#!/usr/local/bin/python2.7
# coding:utf-8
#
#輸入和raw_input(),raw_input()是個內建的函數。它讀取標準輸入，并將去到的數據復制給指定的變量
#user = raw_input('Enter login name:')
#print 'Your login is:',user

#%d %s %f ? 十進制 ?字符串 ?浮點型
#下面這個例子是打印浮點數，整數型的
#[root@localhost python]# cat a.py
#!/usr/local/bin/python2.7
# coding:utf-8
#輸入和raw_input()
#user = raw_input('Enter login name:')
#print 'Your login is: %d' % (int(user) * 2)
#print 'Your login is: %f' % (int(user) * 2)
#print 'Your login is: %s' % (int(user) * 2)
#print 'Your login is: %f',user
#print 'Your login is: %c',user
#print 'Your login is: %a',user
#print 'Your login is: %s',user
#[root@localhost python]# python a.py
#Enter login name:22
#Your login is: 44
#Your login is: 44.000000
#Your login is: 44
#Your login is: %f 22
#Your login is: %c 22
#Your login is: %a 22
#Your login is: %s 22

#操作符，這類的操作符之前還真沒有認真看過，這回一定要好好做筆記，那么有什么區別了？之前只知道一個/單斜杠是除號，而不知道雙斜杠，單斜杠是傳統除法而雙斜杠是浮點數型的，且對結果進行四舍五入。
#>>> print -2*4 + 3*2
#-2
#>>> print -2*4 + 3**2
#1
#正如上面的例子，我們知道了雙星號跟單個還是有差別的這里我們可以想象到雙星號是乘方的作用了，這里有學到了點新知識，書還是多看點 好，筆記多做的好。

#接下來比較操作符了，比較操作符沒啥新知識，去掉吧

#2.5 變量和賦值，去尼瑪的蛋
#2.6. 數字 python支持五種數字類型，其中有三種是整型類型
#有符號整型 長整型 布爾型 浮點值 復數
#int 002 22
#long 22222222222222222L -2222 0XDECADEDDDAFEAFEAE
#bool True False
#float 3.151111 4.2E-10 ?-90. 6.00223e22 -l.233e-19
#complex 6.23+1.5j ?-1.23-5434j 0+1j 9.6323-56.222j

#2.7 字符串 python字符串被定義為引號直接的字符集合。python支持使用承兌的單引號或雙引號，三引號可以用來包含特色字符。
#2.8 列表和索引
#這節的基礎知識，不管懂不懂都要記錄下來啊。python高性能編程 pdf，可以當成普通的數組，能保存任意數量任何類型的python對象，懂了嗎？這里第一次提到了對象。python一切皆對象的本質體現出來了吧？這個還要class來定義對象嗎？
#可以像數組一樣訪問元素，但是列表和元祖存儲不同類型的對象
#列表和元祖的差別：
#列表用中括號包裹，元素個數和值可以改變
#元祖用小括號報告，不可以更改
#相同點：可以通過切片運算得到子集[] 和[:]
#>>> aList = [1,2,3,4] ?#創建一個列表aList
#>>> aList ? ? ? ?#打印列表aList
#[1, 2, 3, 4]
#>>> aList[2] ? ?#打印第三個元素
#3
#>>> aList[2:] #打印第三個元素之后的所有元素
#[3, 4]
#>>> aList[:2] ? ?#打印前兩個元素即第三個元素之前的元素
#[1, 2]


#>>> aTuple = ('robots',33,42,'try')
#>>> aTuple
#('robots', 33, 42, 'try')
#>>> aTuple[:2]
#('robots', 33)
#>>> aTuple[2]
#42
#>>> aTuple[1] = 1
#Traceback (most recent call last):
# ?File "<stdin>", line 1, in <module>
#TypeError: 'tuple' object does not support item assignment
#


#字典作用是映射數據類型由鍵-值（key-value）對構成
#機會所有類型的python對象都可以用做鍵，
#>>> aDict = {'host':'earth'} ?#創建一個名稱為aDict的字典
#>>> aDict = ['port'] = 80 ? ? ? ?#往字典里面添加一個元素port = 80 這里我添加錯了，多了個等號，天才是怎樣煉成的？
# ?File "<stdin>", line 1
#SyntaxError: can't assign to literal ?#明顯的語法錯誤啊
#>>> aDict ['port'] = 80 ? ? ? ?#再添加一次，成功了吧
#>>> aDict ? ? ? ? ? ? ? ? ? ? ? ?#打印字典
#{'host': 'earth', 'port': 80}
#>>> aDict.keys() ? ? ? ? ? ? ? ?#調用keys方法
#['host', 'port']
#>>> aDict['host']
#'earth' ? ? ? ? ? ? ? ?
#>>> for key in aDict: ? ? ? ?#這里報錯了，不知道為何
#... print key,aDict[key]
# ?File "<stdin>", line 2
# ? ?print key,aDict[key]
# ? ? ? ?^
#IndentationError: expected an indented block
#>>> for key in aDict:
#... print key, aDict[key]
# ?File "<stdin>", line 2
# ? ?print key, aDict[key]
# ? ? ? ?^
#IndentationError: expected an indented block


#接下來就是循環了。基礎不能錯過
#if x < .0:
# ? ?print "x" must be atleast 0!
#else語句
#if expression:
# ? ?if_suite
#else:
# ? ?else_suite
#還支持elif語句，語法如下
#if expression1:
# ? ?if_suite
#elif expression2:
# ? ?elif_suite
#else:
# ? ?else_suite
#while循環
#標準while條件循環語句的語法類似if。
#while expression:
# ? ?while_suite
#語句 while_suite會被連續不斷的循環執行，直接表達式的值編程0或者false。
#[root@localhost python]# cat b.py
#!bin/python
#counter = 0
#while counter < 3:
# ? ? ? ?print 'loop #%d' % (counter)
# ? ? ? ?counter +=1
#[root@localhost python]# python b.py
#loop #0
#loop #1
#loop #2
#基礎知識鞏固之：什么是屬性？屬性是與數據有關的項目。屬性可以是簡單的數據值，也可以是可執行對象，比如函數和方法。python高性能編程、那些對象有用屬性了？類，模塊，文件和復數等對象都擁有屬性使用句點屬性標識符。也就是說對象名稱和屬性名稱直接加一個句號object.attribute
#
#文件和內建函數 open(),file()
#錯誤和異常，沒有特別說明的，坑跳多了也就會了
#函數 python函數使用小括號調用。函數在調用之前必須定義。如果函數中沒有return語句，就會自動返回None對象
#如何定義函數：def function_name([arguments]):
# ? ? ? ? ? ? ? ? ? ?"optional documentation string"
# ? ? ? ? ? ? ? ? ? ?function_suite
#定義一個函數的語法由def關鍵字及緊隨其后的函數名，再加上該函數需要的幾個參數組成。函數參數可以選的，以冒號結尾： 之后代表函數體的代碼組
#def addMe2Me(X):
# ? ?'apply + operation to argument'
# ? ?return (x+x)
#上面函數已經定義了，如何調用了？
#addMe2Me(22.2)
#>>> addMe2Me
#<function addMe2Me at 0x01C9DD30>
#>>> print addMe2Me
#<function addMe2Me at 0x01C9DD30>
#>>> addMe2Me(22.2)
#44.4
#>>> addMe2Me(10)
#20
#>>> addMe2Me('python')
#'pythonpython'
#>>> addMe2Me([-1,'abc'])
#[-1, 'abc', -1, 'abc']
#
#默認參數
#def foo(debug=True):
# ? ?if debug:
# ? ? ? ?print 'in debug mode'
# ? ?print 'done'
#>>> foo()
#in debug mode
#done
#>>> foo(True)
#in debug mode
#done
#>>> foo(False)
#done

無論是python自帶的IDLE編輯器還是最sublime編輯器，各有各自的特點，當然基于xypython的spe也有很多好處

各自有自己的好處，此處省略一萬字

感覺在xypython調試代碼比較人性化，特別是在操作數據庫的時候感覺非常棒滴

有時候感覺IDLE中比較好。

而sublime就感覺比較雞肋了,不過有代碼補全功能，寫代碼還是不錯的，也有報錯提示。python編程pdf。總之寫代碼靠他，調試還是不要用它了

python之數據結構，好幾天沒有堅持了，以后很少掛QQ

python之數據結構，好幾天沒有寫程序了。蛋疼，都是在扯淡

數據結構：數據結構就是通過某種方式（例如對元素進行編號）組織在一起的數據元素的集合，這些數據元素可以是數字或者字符甚至額可以是其他數據結構，python中，最基本的數據結構是序列 。序列中的每個元素被分配一個序號—即元素的位置，也成為索引。

python中有六種內建的序列：暫時學習兩種，列表和元祖
其他序列有：字符串，，unicode字符竄，buffer對象和xrange對象

列表和元祖的區別在于，列表可以修改，而元組不行。

通用序列操作：
所有序列都可以精心某些特定的操作。包括：索引(indxing),分片(sliceing),加(adding),乘(multiplying)以及檢查某個元素是否屬于序列的車呢國有(成員資格)。python筆記？

序列中的所有元素都是有編號的–從0開始遞增。這些元素可以通過編號分別訪問，如下例所示：
>>> greeting = ‘Hello’
>>> greeting[0]
‘H’
>>> greeting[2]
‘l’
>>> greeting[-1]
‘o’

分片：
與使用索引來訪問單個元素類似，可以使用分片操作來訪問一定范圍的元素。分片通過冒號像個的兩個索引來實現：

前面學習了很多知識，都是注釋的，現在就不注釋了，也不會貼什么圖片裝逼，不寫注釋好代碼補全打字速度上去了

第三章 python語法
介紹python一些基本編程風格，之后簡要介紹標識符，變量和關鍵字。
3.1語句和語法
python 語句中有一些基本規則和特殊字符：
井號之后為注釋#
#換行(\n) 是標準 的換行符，（通常一個語句一行）
反斜線 \繼續上一行，跟Linux的很像啊
分號，將兩個語句鏈接在一行中
冒號 將代碼塊的頭和體分開
語句（代碼塊）用縮進方式體現
不同的縮進深度分隔不同的代碼塊
python文件以模塊的形式組織

3.16 模塊

3.2變量賦值
python中等號是主要的賦值操作（其他是增量賦值操作）
賦值并不是直接將一個值賦給一個變量，盡管你可能根據其他語言編程經驗認為應該如此。
在python中，對象是通過引用傳遞的。在賦值的時候，不管這個對象是新建的還是已經存在的都是將該對象的引用（并不是值）賦值給變量。python核心編程、
第四章：對象

所有python對象都擁有三個特性：身份，類型和值
身份： 每個對象都有一個唯一 的身份標識自己，任何對象的身份可以使用內建函數id()來得到。
? ?這個值可以被認為是該對象的內存地址。你極少會用的哦啊這個值，也不用太關心它研究是什么
類型：對象的類型決定了該對象可以保存什么類型的值，可以進行什么樣的操作，以及遵循什么樣的規則。你可以用內建函數type()查看python對象的類型。因為在python中類型也是對象
值：對象表示數據項

對象屬性：
某些python對象屬性，值或相關聯的可執行代碼，比如方法（method），python用句點標記法來訪問屬性。最常用的屬性是函數和方法，含有數據屬性的對象包括：類，類實例，模塊，復數和文件
4.2 標準類型
數字：分為幾個子類型，其中三個是整型
integer整型
boolean 布爾型
long integer 長整型
floating point real number 浮點型
string ? ? 字符串
list 列表
tuple 元組
dictionary 字典
其他內建內型
類型 null對象（none） ?文件 集合/固定集合 函數/方法 模塊 類

標準類型內建函數
cmp(obj1,obj2) 根據比較結果返回整型i：
? ? ? ? ? ? ? ?i < 0 if obj1 <obj2
? ? ? ? ? ? ? ?i > 0 if obj1 >obj2
? ? ? ? ? ? ? ?i == 0 if obj1 == obj2
repr(obj)或者'obj' ? ?返回一個對象的字符串表示
str(obj) ? ?返回對象適合可讀性好的字符串表示
type(obj) ? ?得到一個對象的類型，并返回相應的type對象

type() 是內建的函數2.2后變成"工廠函數"了，那么我們該怎么理解工廠函數了？
>>> type(2)
<type 'int'>
>>> type('hello world!')
<type 'str'>
>>> type(type)
<type 'type'>

多的我就懶得打字了。python web？直接上代碼看cmp()
>>> a,b = 2,11
>>> cmp(a,b)
-1
>>> cmp(b,a)
1
>>> a = 11
>>> cmp(a,b)
0
>>> cmp(b,a)
0

>>> c,d = 'abc','wcx'
>>> cmp(c,d)
-1
>>> cmp(d,c)
1
>>> d = ?'abc'
>>> cmp(c,d)
0

str() repr()操作符
str() repr() 或反引號操作符('')可以方便地以字符串的方式獲取對象的內容。類型，數值屬性等信息

str() 函數得到的字符串可讀性好，而repr()函數得到的字符串通常可以用來重新獲得該對象，通常情況下obj == eval(repr(obj)) 這個等式是成立的。

>>> str(1.22-2j)
'(1.22-2j)'
>>> str(2)
'2'
>>> exit()
[root@localhost ~]# python2.7
Python 2.7.5 (default, Mar 18 2014, 05:37:40)
[GCC 4.1.2 20080704 (Red Hat 4.1.2-54)] on linux2
Type "help", "copyright", "credits" or "license" for more information.
>>> str(2.23-2j)
'(2.23-2j)'
>>> str(2e10)
'20000000000.0'
>>> str([3,1,4,66])
'[3, 1, 4, 66]'
>>> '[2,4,1,55]'
'[2,4,1,55]'

>>> for i in range(1,20):
? ?r = random.randint(1,100)
? ?position = bisect,bisect(l,r)
? ?bisect.insort(l,r)
? ?print '%2d %2d' % (r,position),l



Traceback (most recent call last):
?File "<pyshell#21>", line 3, in <module>
? ?position = bisect,bisect(l,r)
TypeError: 'module' object is not callable

? ?^
>>> for i in range(1, 20):
? ?r = random.randint(1, 100)
? ?position = bisect.bisect(l, r)
? ?bisect.insort(l, r)


? ?接下來第六章了，第五章以后慢慢看，不是以后，現在有時間就看看這里的內容。離開網絡才能認真的學習啊。深有體悟

? ?第六章 序列：字符串，列表和元組
一：序列
1.序列的介紹
序列的定義：成員有序排列，并且可以通過下班偏移量訪問到它的一個或者幾個成員，這類python類型統稱為序列，包括字符串，列表和元組類型

接下來的東西感覺有點亂，不容易接受，好好總結一下。
是不是python講的太多對象了？什么地方譯者都搞個類型出來忽悠我們？
那么我自己來理解吧

序列就序列了，還整個序列類型，這里我噴死那個譯者，字符串后面非得加個類型你拓麻的才爽啊，尼瑪祖傳類型。python有什么用，

序列有哪些了？前面講到的字符串，列表和元組，哥少寫了幾個類型感覺爽多了

序列有著相同的訪問模式：它的每一個元素可以通過制定一個偏移量的方式得到。而多個元素可以通過切片操作的方式得到，切片操作會在接下來的內容中講到。下標偏移量是從0開始到總元素-1結束——之所以要減1，是因為我們從0開始啊。

標準類型操作符
適用于所有序列類型（這里說序列類型還像話）這里他說參考4.5節，批評一句語病（不過其他的操作絕對是完全適用的），初三的學生看了都頭疼。

我真是納悶，這章作者為什么不譯成 序列類型：字符串類型，列表類型和元組類型

序列操作符：
1，成員關系操作符（in, not in）
成員關系才哦啊佐夫是用來判斷一個元素是否屬于一個序列的。對于字符串來說，判斷這個字符是否屬于字符串；對于元組來說，就代表了一個對象是否屬于該對象序列。qpython。in/not in 的操作符返回值一般來講就是True/Flase滿足成員關系就返回True，否則返回Flase操作語法如下
對象 [not] in 序列

? ? ? ?序列操作符
序列操作符 ? ? ? ? ? ? ? ? 作用
seq[ind] ? ? ? ? ? ?活動下標為ind的元素
seq[ind1:ind2] ? ? ? ?活動下標從ind1到ind2間的元素集合
seq*expr ? ? ? ? ? ? 序列從父expre次
seq1+seq2 ? ? ? ? ? ?里那句seq1和seq2
obj in seq ? ? ? ? ? ? 判斷obj元素是否包含在seq中

2.連接操作符(+)
這個操作符允許我們把一個序列和另外一個相同序列的類型做連接。語法如下。
sequence1 + sequence2
該表達式的結果是一個包含sequencel和sequence2 的內容的新序列。

3.重復操作符*
這里前面有講到過的不再寫了，自己多看吧。前四章是基礎，大概把前十章的內容都給說了一遍。

4.切片操作符([],[:],[::])
簡單地講，所謂序列類型就是包含一些序列排列的對象的一個結構。python核心編程第二版。你可以簡單的用方括號加一個下標的方式訪問它的每一個元素，或者通過在方括號中用冒號把開始下標和結束下標分開的方式來訪問一組連續的元素。

看到這里頭疼，讀譯者的文字感覺很累。看其他書去了補充這里遺漏的

5.
6.13 內建函數
標準內建函數
cmp()
>>> list1,list2 = [123,'xy2'],[234,'abc']
>>> cmp(list1,list2)
-1
>>> cmp(list2,list1)
1
>>> list3 = list2 + [567]
>>> list3
[234, 'abc', 567]
>>> cmp(list2,list3]
SyntaxError: invalid syntax
>>> cmp(list2,list3)
-1

len()
對字符串來說，返回字符串長度的個數，對于元組和列表來說，它會返回列表和元組的元素個數。容器中的每個對象被作為一個項來處理
用上面例子和新定義一個字符串list4來舉例

>>> len(list2)
2
>>> len(list3)
3
>>> len(list1)
2
>>> list4 = 'abcdef2d'
>>> len(list4)
8

max() min()
在字符串中作用不大

sorted() 和 reversed()
>>> s = ['They','stamp','them','when',"they'er",'smaill']
>>> for t in reversed(s):
? ?print t,


smaill they'er when them stamp They
>>> sorted(s)
['They', 'smaill', 'stamp', 'them', "they'er", 'when']
>>>

4.元組


接下來元祖了，可能沒有章序，不過以后會好好整，慢慢來

1.如何創建一個元組并給它賦值
這里我建議要用例子上面的橋，數字字母可以亂寫，不過要想想作者為什么這么寫？有什么規律。作者命名的時候并不是亂命名的，而是有規律可言的。學習一定要認真，態度一定要端正

>>> aTuple = (123,'abc',3.21,['inner','tuple'],7-9j)>>> aontherTuple = (None,'something to see here')
>>> print aTuple
(123, 'abc', 3.21, ['inner', 'tuple'], (7-9j))
>>> print anotherTuple
(None, 'something to see here')


>>> a = (None)
>>> print a
None
>>> b = (None,)
>>> print b
(None,)
>>> tuple('bar')
('b', 'a', 'r')

訪問元組中的值
元組切片操作跟列表一樣，用方括號作為切片操作符([]),里面寫上索引或者索引范圍

>>> aTuple[2:4]
(3.21, ['inner', 'tuple'])
>>> aTuple[0:3]
(123, 'abc', 3.21)
>>> aTuple[2][0]

Traceback (most recent call last):
?File "<pyshell#14>", line 1, in <module>
? ?aTuple[2][0]
TypeError: 'float' object has no attribute '__getitem__'
>>> aTuple[3][1]
'tuple'
>>> aTuple[3][2]

Traceback (most recent call last):
?File "<pyshell#16>", line 1, in <module>
? ?aTuple[3][2]
IndexError: list index out of range
>>> aTuple[:2]
(123, 'abc')
>>>

如何更新元組

不可以改變的，可以重新構造一個啦

例如

>>> aTuple = aTuple[0],aTuple[2],aTuple[-1]
>>> aTuple
(123, 3.21, (7-9j))
原來我們定義的aTuple是什么了？下面的啦
>>> aTuple = (123,'abc',3.21,['inner','tuple'],7-9j)
>>> print aTuple
(123, 'abc', 3.21, ['inner', 'tuple'], (7-9j))


就這樣就得到了一個新的元組，感覺有點坑不？