目錄
學前準備
在正式開始之前，你需要安裝python軟件，準備一款好用的IDE工具。牆裂推薦anaconda + pycharm，網上有很多安裝教程的博客，這裏就不再贅述了。
編寫的方式有兩種：一是在Dos界面寫交互式編碼，一是在IDE工具中進行編碼
交互式編寫代碼
- 使用win+R調出“運行”對話框，輸入cmd，再輸入python即可進入“交互模式”
- IDE方式，我使用的是pycharm，在左下方，找到“python console”即可進入“交互模式”
交互模式的優點是，不需要刻意的使用“print”打印，也能自動打印，方便觀察每一步的結果
>>> print 2 ** 8
256
>>> 2 ** 8
256
>>> lumberjack = 'okay'
>>> lumberjack
'okay'
或者說打開文本編輯器，（使用win+R調出“運行”對話框，輸入notepad回車即可），在文本中輸入以下兩行python語句，保存爲spam.py。然後，我們用“python spam.py”命令運行該文件
### file: spam.py
print 2 ** 100
print 'Spam!'
>>> python spam.py
2 ** 100
'Spam!'
IDE編寫代碼
我們選擇pycharm，即可開始代碼練習，將代碼明確保存爲.py格式，使用菜單欄的“run”→“run...” 運行該代碼
### file: threenames.py
a = 'dead'
b = 'parrot'
c = 'sketch'
print a, b, c
Output:dead parrot sketch
IDE中如果要觀察每一步的結果，則需要Debug
常用內置對象
python內置對象優點
- 內置對象使程序更容易編寫。例如，集合（列表）和搜索表（字典），可以馬上使用
- 內置對象是擴展的組件。例如，堆棧數據結構也許會實現爲管理和定製內置列表的類，而python內置了
- 內置對象往往比定製的數據結構更有效率。python的內置類型優化了用C實現數據結構的算法
- 內置對象是語言的標準的一部分。python借鑑了依靠內置工具的語言Lisp，汲取了C++編程框架的優點
內置對象
| 對象類型 | 例子 常量/創建 |
| 數字 | 1234，3.1415，999L，3+4j，Decimal |
| 字符串 | ‘spam’，“guido's’’ |
| 列表 | [1，[2，‘three’]，4] |
| 字典 | {‘food’：‘spam’，‘taste’：‘yum’} |
| 元組 | （1，‘spam’，4，‘U’） |
| 文件 | myfile=open（‘eggs’，‘r’） |
| 其他類型 | 集合、類型、None、布爾型 |
數字、字符串、元組具有不可變性，即對象創建後不能更改。
字符串、列表、元組都屬於序列，可以對序列進行一些通用的操作，如索引、合併以及分片，同時每個內置對象也有特定的方法調用。
字典是唯一具有映射屬性的對象，沒有左右位置關係，支持鍵值對操作
關於多態的問題
操作符取決於被操作的對象，這就是多態。例如，‘a’+‘b’和1+2，輸出的結果分別是ab和3。操作符是‘+’，由於被操作對象不同，輸出的結果呈現不同的結果。
數字常量
| 數字 | 常量 |
| 1234，-24，0 | 一般整數（C語言長整型） |
| 88888888888888888888L | 長整型數（無限大小） |
| 1.23，3.14e-10，4E210，4.0e+210 | 浮點數（C語言雙精度浮點數） |
| 0177，0x9ff，0xff | 整數的八進制和十六進制數常量 |
| 3+4j，3.0j+4.0j，3j | 複數常量 |
python表達式操作符及程序
| 操作符 | 描述 |
| yield x | 生成器函數發送協議（2.5版新增） |
| lambda args：expression | 生成匿名函數 |
| x if y else z | 三元選擇表達式（2.5版新增） |
| x or y | 邏輯或（只有x爲假，纔會計算y） |
| x and y | 邏輯與（只有x爲真，纔會計算y） |
| not x | 邏輯非 |
| x<y，x<=y，x>y，x>=y，x!=y，x is y，x is not y，x in y，x not in y | 比較操作，值相等操作，對象身份測試，序列成員測試 |
| x | y | 位或 |
| x ^ y | 位異或 |
| x & y | 位與 |
| x << y，x>>y | x左移或右移y位 |
| -x + y，x - y | 加法/合併，減法 |
| x * y，x % y，x / y，x // y | 乘法/重複，餘數/格式化，除法 |
| -x，+x，~x，x**y | 一元減法，識別，按位求補，冪運算 |
| x[i]，x[i:j]，x.attr，x（...） | 索引，分片，點號取屬性運算，函數調用 |
| （...），[...]，{...}，‘...’ | 元組，列表，字典，字符串 |
其他知識點
oct（十進制）、hex（十進制），分別表示八進制和十六進制
int（數字，進制）可以將八進制、十六進制的數字（字符串形式）轉化爲十進制
內置數學工具：math.pi，math.e，math.sin，math.sqrt（），abs（），x**y / pow（x，y），round（2.567，2）
集合：x=set（'abcda'），output ：{'c', 'd', 'b', 'a'}，可以看出集合中的元素是不重複且無序的。
字符串常量和表達式
| 操作符 | 描述 |
| s1 = ' ' | 空字符串 |
| s2 = "spam's" | 雙引號 |
| block = """...""" | 三重引號塊 |
| s3 = r'\temp\spam' | Raw字符串 |
| s4 = u'spam' | Unicode字符串 |
| s1 + s2，s2 * 3 | 合併，重複 |
| s2[i]，s2[i:j]，len(s2) | 索引，分片，求長度 |
| "a %s parrot" % type | 字符串格式化 |
| s2.find('pa') | 搜索 |
| s2.rstrip() | 移除空格 |
| s2.replace('pa'，'xx') | 替換 |
| s1.split(' , ') | 用佔位符分隔 |
| s1.isdigit() | 測試字符串內容是否爲數字，返回bool值 |
| s1.lower() | 轉換爲小寫字母 |
| for x in s2 | 迭代 |
| 'spam' in s2 | 成員關係 |
單雙引號字符串是一樣的，"knight's"也可以表示爲'knight\'s'或者"knight\"s"
用轉義序列代表特殊字節
轉義序列：反斜槓+特殊字節編碼。例如，這裏有五個字符的字符串，其中嵌入了一個換行符'\n'和一個製表符'\t'
>>>s = 'a\nb\tc'
字符串反斜線字符
| 轉義 | 意義 |
| \\ | 反斜線（保留\） |
| \' | 單引號（保留 ' ） |
| \" | 雙引號（保留 " ） |
| \a | 響鈴(BEL) |
| \b | 退格(BS) |
| \f | 換頁(FF) |
| \n | 換行(LF) |
| \r | 返回(CR) |
| \t | 水平製表(HT) |
| \v | 垂直製表(VT) |
| \uhhhh | Unicode 16位的十六進制值 |
| \Uhhhh | Unicode 32位的十六進制值 |
| \xhh | 十六進制值 |
| \000 | 八進制值 |
| \0 | 空字符(NULL) |
字符串抑制轉義
在字符串前面增加‘r’或是加入轉義字符，如下所示
myfile = open（'C：\new\text.dat','w'）
myfile = open（r'C：\new\text.dat','w'） #方法一
myfile = open（'C：\\new\\text.dat','w'） #方法二
索引和分片
偏移量是從0開始的，負偏移看作是從結束處反向計數
>>> S = 'spam'
>>> S[0], S[-2] # 索引
('s', 'a')
>>> S[1:3], S[1:], S[:-1] # 分片
('pa', 'pam', 'spa')
擴展分片：第三個值表示步長
>>> S = 'abcdefghijklmnop'
>>> S[1:10:2]
'bdfhj'
>>> S[::2]
'acegikmo'
>>> S = 'hello'
>>> S[::-1]
'olleh'
>>> S = 'abcedfg'
>>> S[5:1:-1]
'fdec'
字符串的修改
在第4章我們提到過，字符串本身是不支持修改的，我們用如下的方法來進行修改：
>>> S = 'spam'
>>> S[0] = "x"
Raises an error!
>>> S = S + 'SPAM!'
>>> S
'spamSPAM!'
>>> S = S[:4] + 'Burger' + S[-1]
>>> S
'spamBurger!'
>>> S = 'splot'
>>> S = S.replace('pl', 'pamal')
>>> S
'spamalot'
字符串轉列表，列表轉字符串
>>> S = 'spammy'
>>> L = list(S)
>>> L
['s', 'p', 'a', 'm', 'm', 'y']
>>> L[3] = 'x' # Works for lists, not strings
>>> L[4] = 'x'
>>> L
['s', 'p', 'a', 'x', 'x', 'y']
>>> S = ''.join(L)
>>> S
'spaxxy'
字符串方法實例：文本解析
>>> line = 'aaa bbb ccc'
>>> col1 = line[0:3]
>>> col3 = line[8:]
>>> col1
'aaa'
>>> col3
'ccc'
>>> line = 'aaa bbb ccc'
>>> cols = line.split()
>>> cols
['aaa', 'bbb', 'ccc']
>>> line = 'bob,hacker,40'
>>> line.split(',')
['bob', 'hacker', '40']
>>> line = "i'mSPAMaSPAMlumberjack"
>>> line.split("SPAM")
["i'm", 'a', 'lumberjack']
常用列表常量和操作
| 操作 | 解釋 |
| L1 = [] | 空列表 |
| L2 = [0,1,2,3] | 四項：索引爲0到3 |
| L3 = ['abc'，['def'，'ghi']] | 嵌套的子列表 |
| L2[i] | 索引 |
| L3[i][j] | 索引的索引 |
| L2[i:j] | 分片 |
| len(L2) | 求長度 |
| L1 + L2 | 合併 |
| L1 * 3 | 重複 |
| for x in L | 迭代 |
| 3 in L2 | 成員關係 |
| L2.append(4) | 增長 |
| L2.extend([5,6,7]) | 擴展 |
| L2.sort() | 排序 |
| L2.index(1) | 搜索 |
| L2.insert(I,X) | 插入 |
| L2.reverse() | 反轉 |
| del L2[k] | 裁剪索引 |
| del L2[i:j] | 裁剪分片 |
| L2.pop() | 刪除列表末端元素，也可以按索引刪除 |
| L2.remove(2) | 按索引刪除列表中某元素 |
| L2[i:j] = [] | 清空列表 |
| L2[i] = 1 | 索引賦值 |
| L2[i:j] = [4,5,6] | 分片賦值 |
| range(4) | 生成整數列表 |
| xrange(0,4) | 返回一個生成器（在版本3.0中已移除） |
| L4 = [x**2 for x in range(5)] | 列表解析 |
| L3.count('abc') | 對‘123’進行計數 |
常見字典常量和操作
| 操作 | 解釋 |
| D1 = {} | 空字典 |
| D2 = {'spam':2，‘eggs’:3} | 兩項目字典 |
| D3 = {'food':{'ham':1，'egg':2}} | 嵌套的字典 |
| D2['eggs'] | 以鍵進行索引 |
| D3['food']['ham'] | 索引的索引 |
| D2.has_key('eggs') | 成員測試 |
| 'eggs' in D2 | 成員測試 |
| D2.keys() | 鍵列表 |
| D2.values() | 值列表 |
| D2.copy() | 複製 |
| D2.get(key,default) | 獲取key，找不到返回default值 |
| D2.update(D1) | 合併 |
| D2.pop(key) | 按鍵索引刪除元素 |
| len(D1) | 長度（儲存的元素的數目） |
| D2[key] = 42 | 新增/修改鍵 |
| del D2[key] | 刪除鍵 |
| D4 = dict.fromkeys(['a','b']) | 構造字典技術 |
| D5 = dict(zip(keyslist，valslist)) | 構造字典技術 |
| D6 = dict(name='Bob'，age=42) | 構造字典技術 |
字典能用作稀疏數據的存取，這一點在實際生活中是經常用到的。
舉出五種創建字典的方法
{'a'：0，'b'：1}
D = {}
D['a'] = 0
D['b'] = 1
dict('a'=0，'b'=1)
dict(['a'，0]，['b'，1])
dict(zip(['a'，'b']，[0，1]))
常見元組常量和運算
| 運算 | 解釋 |
| () | 空元組 |
| t1 = (0,) | 單個元素的元組（非表達式） |
| t2 = (0，'Ni'，1.2，3) | 四個元素的元組 |
| t2 = 0，'Ni'，1.2，3 | 四個元素的元組 |
| t3 = ('abc',('def','ghi')) | 嵌套元組 |
| t1[i] | 索引 |
| t3[i][j] | 索引的索引 |
| t1[i:j] | 分片 |
| len(t1) | 長度 |
| t1 + t2 | 合併 |
| t2 * 3 | 重複 |
| for x in t2 | 迭代 |
| 'spam' in t2 | 成員關係 |
列表和元組的區別：列表提供可變性，元組提供不可變性。
文件
myfile = open('myfile'，'w')
參數‘w’是指寫入。'r'是指讀取，是默認值，‘a’是在文件尾部追加內容。
>>> D = {'a': 1, 'b': 2}
>>> F = open('datafile.pkl', 'wb')
>>> import pickle
>>> pickle.dump(D, F) # Pickle any object to file
>>> F.close()
>>> F = open('datafile.pkl', 'rb')
>>> E = pickle.load(F) # Load any object from file
>>> E
{'a': 1, 'b': 2}
以上是用pickle模塊來儲存python的原生對象
對象GC與共享引用
python中，類型是在運行過程中自動決定的，而不是通過代碼去聲明。
>>>a = 3
上面的代碼反映了python語言中所有賦值的操作：
- 創建一個對象來代表值3
- 創建一個變量a，如果它還沒有創建的話
- 將變量與新的對象相連接
其中，a代表對象，3代表變量名。類型是屬於對象的，而不是變量
關於對象的垃圾收集，我們給出如下的代碼，每當一個變量名被賦予了一個新的對象，之前那個對象佔用的空間就會被收回。
>>>a = 3
>>>a = 'spam'
共享引用
>>>a = 3
>>>b = a
>>>a = 'spam'
以上代碼，只會改變a的值，b的值是不變的。在第4章，我們所介紹過的，整數是不可變的。
>>>L1 = [ 2，3，4]
>>>L2 = L1
>>>L1 = 24
以上代碼，仍然只改變L1的值，L2的值也是不變的。L1的列表自身也是對象，就像整數和字符串一樣，自身是不會被改變的。
>>>L1 = [ 2，3，4]
>>>L2 = L1
>>>L1[0] = 24
以上代碼，L1和L2的值都被改爲了[24，3，4]。L1列表中的元素是可以被改變的。如果我們不想L2發生改變，我們需要做如下改動
>>>L1 = [ 2，3，4]
>>>L2 = L1[:]
>>>L1[0] = 24
L1[:]是對L1的對象的copy。字典D有兩種的copy方法，分別是copy（）和deepcopy（）
共享引用和相等
>>>L = [ 1，2，3]
>>>M = L
>>>L == M
True
>>>L is M
True
>>>L = [ 1，2，3]
>>>M = [ 1，2，3]
>>>L == M
True
>>>L is M
False
"==操作符"，測試兩個被引用的對象是否有相同的值，"is操作符"是在檢查對象的同一性
>>>X = 42
>>>Y = 42
>>>X == Y
True
>>>X is Y
True
這裏因爲小的整數和字符串會被緩存並複用，所以is告訴我們X和Y是一個相同的對象。我們能查詢python對於一個對象重複的引用次數，如下所示：
>>>import sys
>>>sys.getrefcount(42)
23
學習小結
隨着python的發展，內置的對象操作或許還會擴展更多，也會更易用，我們需要不斷學習，不斷更新自己的知識。
送大家一句雞湯：知識要用起來纔會變成自己的，經驗不在於多，而在於精。