1.pyc簡介
python程序在運行時也有編譯過程，編譯后會產生.pyc文件。這是一種由python虛擬機執行的二進制文件（字節碼），用於保存內存中PyCodeObject，以便加快程序的加載運行。這個文件可以跨平台，但與python版本高度相關（文件名中帶有版本信息），不同版本的.pyc內容不同。
怎么見證.pyc文件的存在呢？
方法1：
在python程序中通過import調用其他程序運行時，python會自動生成一個與被調用的python程序文件相關的.pyc文件出來。linux平台和windows平台都OK，生成的文件保存在__pycache__目錄中。
注意：
被調用的程序如果修改代碼后再次運行，系統會基於時間來檢測pyc的可用性並重新生成最新的pyc文件
方法2：
手動編譯
>>> import py_compile
>>> py_compile.compile("D:/test.py")
>>>
批量編譯只需要輸入對應的目錄名稱即可
以上內容參考自博客 http://blog.csdn.net/carolzhang8406/article/details/6342174
2.python常用的數據類型及其用法
2.1 數字
數字是一類常見的數據類型，可分為整型、長整型(僅僅在2.x版本中存在該類型)和浮點數等常見的幾類。
數字的類型可通過函數type()來確定：
2.2 布爾值
布爾值用來表示true或false，常常用在條件控制語句中作為條件來判斷，系統會根據表達式的內容自動判斷true或false，也可以通過print打印輸出：
>>> print((4+1)<5) False >>>
2.3 字符串
字符串是一類非常常見的數據類型，使用變量、條件判斷等都需要使用它。
字符串常見的操作如下：
2.3.1 strip 去除首尾特殊字符
strip可用於去除字符串中首尾的特殊字符，包括空格、換行符等。
>>> a=" this is for test\n" >>> print(a) this is for test >>> a=a.strip() >>> print(a) this is for test >>>
應用strip方法后直接去除了首部空格和尾部換行符。
2.3.2 split 按指定分隔符分割字符串
分割后的字符串會以列表形式打印輸出
>>> test="Alex Jobs Tim Jack" >>> test1=test.split(" ") >>> print(test1) ['Alex', 'Jobs', 'Tim', 'Jack']
2.3.3 join 按指定分隔符拼接字符串
語法： 'sep'.join(seq)
參數說明
sep：分隔符。可以為空
seq：要連接的元素序列、字符串、元組、字典
上面的語法即：以sep作為分隔符，將seq所有的元素合並成一個新的字符串
返回值：返回一個以分隔符sep連接各個元素后生成的字符串
可以看出join的操作近似於split的逆向操作。
>>> print(test1) ['Alex', 'Jobs', 'Tim', 'Jack'] >>> print(' '.join(test1)) Alex Jobs Tim Jack >>>
直接對字符串對象進行拼接處理時每兩個相鄰的字符之間都會插入分隔符：
>>> print(' '.join("Let'sPython")) L e t ' s P y t h o n >>>
2.3.4 format 格式化替換
>>> message="Hi {name}, Let's {do_something}" >>> messageForJack=message.format(name='Jack',do_something='Python') >>> print(messageForJack) Hi Jack, Let's Python >>>
>>> message="Hi {0}, Let's {1}" >>> print(message.format('Jack','Python')) Hi Jack, Let's Python >>>
>>> message="Hi {1}, Let's {2}" >>> print(message.format('Jack','Python')) Traceback (most recent call last): File "<stdin>", line 1, in <module> IndexError: tuple index out of range >>>
2.3.5 按索引對字符串切片（切分）
>>> message="Let's Python" >>> print(message[6:]) Python >>> print(message[:]) Let's Python >>> print(message[0:4]) Let' >>>
>>> print(message[6:-1]) Pytho >>> print(message[6:-2]) Pyth >>> print(message[-2:]) on >>>
2.3.6 center 字符串居中並均勻填充至指定長度
>>> message="Let's Python" >>> test=message.center(20,'*') >>> print(test) ****Let's Python**** >>> print(message.center(20,'*')) ****Let's Python****
>>> print(message.center(20,)) Let's Python >>> print(len(message.center(20,))) 20 >>>
2.3.7 find 查找字符串中指定的字符
>>> message="Let's Python" >>> print(message.find('t')) 2 >>>
#!/usr/bin/env python # -*- coding:utf-8 -*- message="Let's Python" counter=0 flag=0 while(message.find('t')) > 0: counter+=1 index=message.find('t') flag=index+1 message=message[flag:] print(counter)
2.3.8 判斷字符串的格式或內容
先列舉部分，有待完善：
isalnum 判斷字符串是否有字母和數字組成
startswith 判斷是否以某個字符開頭
endswith 判斷是否以某個字符結束
upper 所有字母轉換成大寫
lower 所有字母轉換成小寫
示例：
>>> test='23edtg9v%' >>> print(test.isalnum()) False >>> print(test.startswith('6')) False >>> print(test.endswith('v%')) True >>> print(test.upper()) 23EDTG9V% >>> print(test.upper().lower()) 23edtg9v% >>>
2.4 列表list
列表是有序、長度和內容可靈活變化的集合，它由不同的元素按照特定的順序組合構成，也是python的一種非常典型的數據類型。
2.4.1 創建列表
列表的創建方法如下：
>>> list1 = []
>>> list2 = [1,2,3]
方括號表示創建一個列表，可創建一個為空的列表后續賦值，亦可創建時直接賦值。
2.4.2 訪問獲取列表的元素與切片處理
訪問獲取列表的單個元素可直接通過索引下標來進行，需要注意的是索引下標從0開始。但對於末尾的元素，下標可逆向用負數來標識。
>>> list2[2] 3 >>> list2[1] 2 >>> list2[0] 1 >>> list2[-1] 3 >>> list2[-2] 2
需要一次性訪問獲取列表的多個連續元素時，需要通過切片操作來進行。
切片的要點如下：
- 通過起始索引和結束索引位置來訪問獲取多個元素，獲取的元素包括起始索引對應的元素，但不包括結束索引位置對應的元素
- 訪問的方向只能從左往右，不能逆向
- 結束位置索引省略不寫表示獲取的對象包含最后一個元素
- 獲取整個元素時可省略起始索引和結束索引位置不寫，或者連方括號也省略不寫
- 索引值不可超過相應的范圍，<=len(list)-1
>>> list2[1:2] [2] >>> list2[1:] [2, 3] >>> list2[1:-1] [2] >>> list2[0:2] [1, 2] >>> list2[:] [1, 2, 3] >>> list2 1, 2, 3]
切片操作中可支持連續切片，直到分割為單個字符串為止：
>>> name = ["Jack","Tim","Jessie","Frank","Merry"] >>> name[1:4] ['Tim', 'Jessie', 'Frank'] >>> name[1:4][1] 'Jessie' >>> name[1:4][1][:4] 'Jess' >>> name[1:4][1][:4][1] 'e' >>> name[1:4][1][:4][1][1] Traceback (most recent call last): File "<stdin>", line 1, in <module> IndexError: string index out of range >>>
需要注意的是上面第二步切片后獲取的是列表的單個元素，如果想繼續切片直到分割為單個字符為止，那么在第二步切片時應該使用單個索引小標來訪問獲取到這個元素，之后再繼續切片，否則會得出完全不同的結果：
>>> name[1:4] ['Tim', 'Jessie', 'Frank'] >>> name[1:4][1:2] ['Jessie'] >>> name[1:4][1:2][:] ['Jessie'] >>> name[1:4][1:2][:4] ['Jessie'] >>> name[1:4][1:2][1:2] [] >>> name[1:4][1:2][:] ['Jessie'] >>> name[1:4][1:2][3] Traceback (most recent call last): File "<stdin>", line 1, in <module> IndexError: list index out of range
2.4.3 修改某個元素的值
通過下標重新賦值即可：
>>> name = ["Jack","Tim","Jessie","Frank","Merry"] >>> name[0]="Jim" >>> name ['Jim', 'Tim', 'Jessie', 'Frank', 'Merry'] >>>
2.4.4 插入新元素
調用insert方法即可：
insert（index, newelement） 第一個參數表示計划插入的下標，第二個參數表示計划插入的具體元素
>>> name = ["Jack","Tim","Jessie","Frank","Merry"] >>> name ['Jack', 'Tim', 'Jessie', 'Frank', 'Merry'] >>> name.insert(1,"Jim") >>> name ['Jack', 'Jim', 'Tim', 'Jessie', 'Frank', 'Merry'] >>>
2.4.5 追加元素
通過append方法即可：
append（newelement） 注意append是將元素追加到末尾，不能像insert一樣指定插入的索引位置點
>>> name = ['Jack', 'Jim', 'Tim', 'Jessie', 'Frank', 'Merry'] >>> name.append("Jim2") >>> name ['Jack', 'Jim', 'Tim', 'Jessie', 'Frank', 'Merry', 'Jim2'] >>>
注意：
對於定義的空數組，第一次賦值時一定要使用append方法追加，如果使用定義列表的方法賦值會報“IndexError: list assignment index out of range”的錯誤。
2.4.6 刪除元素
刪除元素的方法很多，大致列舉如下：
remove（element） 傳入的參數是元素的具體內容，且每次只能刪除一個元素
>>> name = ['Jack', 'Jim', 'Tim', 'Jessie', 'Frank', 'Merry', 'Jim2'] >>> name.remove("Jim2") >>> name ['Jack', 'Jim', 'Tim', 'Jessie', 'Frank', 'Merry'] >>>
pop（index） 通過元素的索引下標來進行刪除，每次也只能刪除一個元素，刪除時會顯示刪除的元素內容；如果下標為空則刪除列表的最后一個元素
>>> name = ['Jack', 'Jim', 'Tim', 'Jessie', 'Frank', 'Merry'] >>> name.pop(1) 'Jim' >>> name ['Jack', 'Tim', 'Jessie', 'Frank', 'Merry']
>>> name.pop()
'Merry'
>>> name ['Jack', 'Tim', 'Jessie', 'Frank']
del 可用於刪除內存中的任何數據
>>> name = ['Jack', 'Jim', 'Tim', 'Jessie', 'Frank', 'Merry'] >>> del name >>> print(name) Traceback (most recent call last): File "<stdin>", line 1, in <module> NameError: name 'name' is not defined >>>
2.4.7 步長
一般用於切片處理，表示針對索引分隔多少個元素。步長不能為0，默認為1（此時相當於普通的切片處理）。
>>> name = ['Jack', 'Jim', 'Tim', 'Jessie', 'Frank', 'Merry'] >>> print(name[::]) ['Jack', 'Jim', 'Tim', 'Jessie', 'Frank', 'Merry'] >>> print(name[::3]) ['Jack', 'Jessie'] >>>
2.4.8 判斷某個元素是否在列表中
使用in操作符來判斷某個元素是否在列表中
>>> name = ['Jack', 'Jim', 'Tim', 'Jessie', 'Frank', 'Merry'] >>> >>> 'Alex' in name False >>> 'Alex' not in name True >>>
2.4.9 獲取某個元素在列表中的具體索引位置
使用index方法可獲取某個元素在列表中的具體索引位置，但需要注意的是如果某個元素多次出現，index方法僅返回第一次匹配到的索引位置
>>> name = ['Jack', 'Jim', 'Tim', 'Jessie', 'Frank', 'Merry'] >>> print("The index is: %s" % name.index('Tim')) The index is: 2 >>>
2.4.10 統計某個元素在列表中出現的次數
使用count方法可以統計某個元素在列表中出現的次數
>>> print(name) ['Jack', 'Jim', 'Tim', 'Jessie', 'Frank', 'Merry', 'Jim', 'Jim', 'Jim'] >>> >>> >>> name.count('Tim') 1 >>> name.count('Jim') 4 >>>
2.4.11 合並列表
通過extend方法可將一個列表的元素追加合並到另外一個列表中
list1.extend(list2) 將list2的元素追加合並到list1中
>>> list1=[1,2,3,'Jack','Jim'] >>> list2=[4,5,6,'Jessie','Lucy'] >>> print(list1) [1, 2, 3, 'Jack', 'Jim'] >>> print(list2) [4, 5, 6, 'Jessie', 'Lucy'] >>> list1.extend(list2) >>> print(list1) [1, 2, 3, 'Jack', 'Jim', 4, 5, 6, 'Jessie', 'Lucy'] >>>
2.4.12 列表排序
使用sort方法可對列表的元素進行正向排序
>>> list3=[11,33,66,22,0,56] >>> print(list3) [11, 33, 66, 22, 0, 56] >>> list3.sort() >>> print(list3) [0, 11, 22, 33, 56, 66] >>>
注意2.0版本可以對字符串和數字混合的列表進行排序，3.0不支持
2.4.13 列表反轉
使用reverse方法可以把列表的所有元素倒序反轉排列
>>> list3=[11,33,66,22,0,56] >>> print(list3) [11, 33, 66, 22, 0, 56] >>> list3.reverse() >>> print(list3) [56, 0, 22, 66, 33, 11] >>>
2.4.14 列表的嵌套
可根據需要對列表進行自由嵌套處理，需要注意的是此時如果訪問被嵌套的列表中的元素，則需要通過多層索引逐級（從外到內）來訪問。
>>> list1=['Sichuan','HuBei','GuangDong',['HaiDian','DongCheng','XiCheng'],'Beij ing'] >>> print(list1) ['Sichuan', 'HuBei', 'GuangDong', ['HaiDian', 'DongCheng', 'XiCheng'], 'Beijing' ] >>> print(list1[3][:]) ['HaiDian', 'DongCheng', 'XiCheng'] >>> print(list1[3][0]) HaiDian >>>
2.4.15 列表的淺copy和深copy
對列表進行copy時，存在淺copy和深copy兩種方式：
- 淺copy：
對列表進行淺copy時，新的列表只會copy不屬於嵌套列表中的元素（即列表中第一層元素），屬於嵌套列表中的元素則直接指向它的內存塊地址。這樣copy前后的兩個列表實質是共享同一個被嵌套的列表（內存空間）。在任何一個列表中對被嵌套的元素進行修改后，兩個列表中的數據均會同步變化。被嵌套的列表類似於copy前后兩個列表的軟鏈接。
這個屬於淺copy，可避免被嵌套的列表元素過多而導致copy后占用大量內存資源。
>>> list1=['Sichuan','HuBei','GuangDong',['HaiDian','DongCheng','XiCheng'],'Beijing'] >>> print(list1) ['Sichuan', 'HuBei', 'GuangDong', ['HaiDian', 'DongCheng', 'XiCheng'], 'Beijing'] >>> print(list1[3][:]) ['HaiDian', 'DongCheng', 'XiCheng'] >>> print(list1[3][0]) HaiDian >>> >>> list2=list1.copy() >>> print(list2) ['Sichuan', 'HuBei', 'GuangDong', ['HaiDian', 'DongCheng', 'XiCheng'], 'Beijing']
現在對被嵌套的元素進行更新處理：
>>> list2[3][0]='ChaoYang' >>> print(list2) ['Sichuan', 'HuBei', 'GuangDong', ['ChaoYang', 'DongCheng', 'XiCheng'], 'Beijing'] >>> print(list1) ['Sichuan', 'HuBei', 'GuangDong', ['ChaoYang', 'DongCheng', 'XiCheng'], 'Beijing'] >>>
對比被嵌套的元素更新前后可發現，即便是通過copy后的新列表來對其進行更新處理，這個變化也會立即同步到被copy的源列表中，足以說明被嵌套的列表在兩者中其實是共享的一塊內存空間。可通過id查看內存地址來驗證：
>>> print(id(list1[3])) 7463816 >>> print(id(list2[3])) 7463816 >>>
但是注意，僅僅是被嵌套的列表存在共享關系，其他的第一層元素仍然是獨立的，整個列表的id二者還是不同：
>>> print(id(list1)) 18377864 >>> print(id(list2)) 7284680
- 深copy：
不同於淺copy中的共享內存地址空間機制，深copy是針對被copy的列表生成一份完整獨立的拷貝，包括被嵌套的列表元素。copy后的新列表與原列表二者相互獨立，通過各自專屬的內存空間存放。
需要注意的是使用deepcopy時需要先import copy（淺copy中list.copy等同於copy.copy(list1)）:
>>> import copy >>> list1=['Sichuan','HuBei','GuangDong',['HaiDian','DongCheng','XiCheng'],'Beiing'] >>> print(list1) ['Sichuan', 'HuBei', 'GuangDong', ['HaiDian', 'DongCheng', 'XiCheng'], 'Beijing] >>> list3=copy.deepcopy(list1) >>> print(list3) ['Sichuan', 'HuBei', 'GuangDong', ['HaiDian', 'DongCheng', 'XiCheng'], 'Beijing] >>> list1[3][0]='ChaoYang' #開始更新被嵌套的列表元素 >>> print(list1) ['Sichuan', 'HuBei', 'GuangDong', ['ChaoYang', 'DongCheng', 'XiCheng'], 'Beijin '] >>> print(list3) ['Sichuan', 'HuBei', 'GuangDong', ['HaiDian', 'DongCheng', 'XiCheng'], 'Beijing ] >>> list3[0]='HuNan' #更新新列表的元素 >>> print(list3) ['HuNan', 'HuBei', 'GuangDong', ['HaiDian', 'DongCheng', 'XiCheng'], 'Beijing'] >>> print(list1) ['Sichuan', 'HuBei', 'GuangDong', ['ChaoYang', 'DongCheng', 'XiCheng'], 'Beijing '] >>> list1[0]='ZheJiang' #更新被拷貝的列表的元素 >>> print(list1) ['ZheJiang', 'HuBei', 'GuangDong', ['ChaoYang', 'DongCheng', 'XiCheng'], 'Beijin g'] >>> print(list3) ['HuNan', 'HuBei', 'GuangDong', ['HaiDian', 'DongCheng', 'XiCheng'], 'Beijing'] >>>
通過上述更新過程可發現，執行deepcopy后兩者之間是完全獨立的，可通過id來驗證：
>>> print(id(list1)) 18377864 >>> print(id(list3)) 7307528 >>> >>> print(id(list1[3])) 7463816 >>> print(id(list3[3])) 7463932
2.4.16 列表的遍歷
常用的遍歷列表方法有如下兩種：
方法一：
通過簡單的for循環，逐個打印出列表元素（不能打印索引）：
members = ['Tim', 'Jack', 'Frank', 'July', 'Alex', 'Tim', 'Susan']for i in members: print(i)
輸出結果為：
Tim
Jack
Frank
July
Alex
Tim
Susan
方法二：
通過enumerate函數和for循環，同時逐個打印索引和索引對應的元素：
members = ['Tim', 'Jack', 'Frank', 'July', 'Alex', 'Tim', 'Susan'] for i, j in enumerate(members): print(i, j)
輸出結果為：
0 Tim 1 Jack 2 Frank 3 July 4 Alex 5 Tim 6 Susan
注意：
如果list的元素是由元組（tuple）有規律地嵌套組成，則可以通過簡單的for循環逐個取出每個元組（每個元素）的值，實質上類似於方法一，只不過每次取一個tuple對應的值，實際分解出來是兩個值：
members = [('Tim', 'male'), ( 'Jack', 'male'), ('Frank', 'male'),('Susan', 'female')] print(members) for member, gender in members: print(member, gender)
輸出結果為：
[('Tim', 'male'), ('Jack', 'male'), ('Frank', 'male'), ('Susan', 'female')] Tim male Jack male Frank male Susan female
2.5 元組tuple
元組即其他語言中的數組，元組與列表的區別是，一旦定義后不可更改對元素的指向(並非元素一旦定義就不可更改)，相當於只讀列表。
如何理解一旦定義后就不可更改對元素的指向呢？tuple的每個元素，指向永遠不變。即指向'a'，就不能改成指向'b'，指向一個list，就不能改成指向其他對象，但指向的這個list本身是可變的！這個指向不可改變的好處是代碼更安全，如果可能，能用tuple代替list就盡量用tuple。
元組只支持count和index函數，也可以通過索引來獲取元素。
定義元組的方法如下：
>>> members=('Tim','Jack','Suse','Mar')
>>> print(members)
('Tim', 'Jack', 'Suse', 'Mary')
或者通過tuple關鍵字加雙括號來定義：
>>> Lanauge=tuple(('Python','Java','PHP')) >>> print(Lanauge) ('Python', 'Java', 'PHP') >>>
count和index的使用如下：
>>> print(members.count('Jack')) 1 >>> print(members.index('Jack')) 1 >>> print(members.index('Suse')) 2 >>>
2.6 字典
字典是python中唯一的映射類型，采用鍵值對（key-value）的形式存儲數據。python對key進行哈希函數運算，根據計算的結果決定value的存儲地址，所以字典是無序存儲的，且key必須是可哈希的。可哈希表示key必須是不可變類型，如：數字、字符串、只含不可變類型元素的元組（1,2,3,’abc’）、實現__hash__()方法的自定義對象（因為__hash__()須返回一個整數，否則會出現異常：TypeError: an integer is required）。
由於采用key-value鍵值對存儲，因此在同一個字典中key必須唯一。
2.6.1 字典的定義
字典可通過一對花括號來定義，元素內部通過冒號來連接key和對應的value，元素與元素之間通過逗號隔開，可進行自由嵌套。
>>> dict1={'Name':'Alex','Sex':'Male','Add':'Beijing'}
>>> print(dict1)
{'Name': 'Alex', 'Sex': 'Male', 'Add': 'Beijing'}
>>>
2.6.2 字典的常用操作
訪問、修改、刪除字典的某個元素，都通過key來實現
訪問：
>>> dict1={'Name':'Alex','Sex':'Male','Add':'Beijing'}
>>> print(dict1['Sex'])
Male
>>>
更新修改：
>>> dict1['Name']='Alice' >>> dict1['Sex']='Female' >>> print(dict1) {'Name': 'Alice', 'Sex': 'Female', 'Add': 'Beijing'} >>>
刪除， 可通過del或者調用字典的pop方法來實現
>>> del dict1['Add'] >>> print(dict1) {'Name': 'Alice', 'Sex': 'Female'} >>> dict1.pop('Sex') 'Female' >>> print(dict1) {'Name': 'Alice'} >>>
獲取字典的長度（鍵值對的個數），通過len方法實現：
>>> dict1={'Name':'Alex','Sex':'Male','Add':'Beijing'}
>>> print(len(dict1))
3
>>>
通過sorted方法對所有的key進行排序並以列表形式返回：
>>> dict1={'Name':'Alex','Sex':'Male','Add':'Beijing'}
>>> sorted(dict1)
['Add', 'Age', 'Name', 'Sex']
>>>
2.6.3 字典的常用內置方法
keys --以列表形式返回字典的所有key：
>>> dict1={'Name':'Alex','Sex':'Male','Add':'Beijing'}
>>> dict1.keys()
dict_keys(['Name', 'Sex', 'Add'])
>>>
values --以列表形式返回字典的所有value：
>>> dict1={'Name':'Alex','Sex':'Male','Add':'Beijing'}
>>> dict1.values()
dict_values(['Male', 'Alex', 'Beijing'])
>>>
items --返回一個包含鍵值元組的列表
>>> dict1={'Name':'Alex','Sex':'Male','Add':'Beijing'}
>>> dict1.items()
dict_items([('Sex', 'Male'), ('Name', 'Alex'), ('Add', 'Beijing')])
>>>
get -- dict.get(key,default=None) 返回指定key對應的value，若key不存在則返回默認指定的值（僅僅是返回而已，不會修改原字典），可用於判斷某個key是否在字典中。
>>> dict1={'Name':'Alex','Sex':'Male','Add':'Beijing'}
>>> dict1.get('Age',22)
22
>>> print(dict1)
{'Sex': 'Male', 'Name': 'Alex', 'Add': 'Beijing'}
>>>
setdefault -- dict.setdefault(key,default=None) 若key在字典中存在，則用默認值覆蓋更新原值，否則直接添加鍵值對到原字典中。
>>> dict1={'Name':'Alex','Sex':'Male','Add':'Beijing'}
>>> dict1.setdefault('Age',22)
22
>>> print(dict1)
{'Sex': 'Male', 'Age': 22, 'Name': 'Alex', 'Add': 'Beijing'}
>>>
update -- dict1.update(dict2) 將字典dict2的鍵值對復制添加到字典dict1中
>>> dict1={'Name':'Alex','Sex':'Male','Add':'Beijing'}
>>> dict2={1:'Beijing',2:'Shanghai',3:'Guangzhou'}
>>> dict1.update(dict2)
>>> dict1
{3: 'Guangzhou', 1: 'Beijing', 'Add': 'Beijing', 'Age': 22, 'Sex': 'Male', 'Name': 'Alex', 2: 'Shanghai'}
2.6.4 字典與列表的對比
字典的特殊性在於，內部存放的順序與key存入的順序沒有任何關系，因為它本身就是無序的。
字典與列表對比特點如下：
字典：
查找和插入的速度極快，不會隨着key的增加而變慢
需要占用大量的內存（浪費比較多）
列表：
查找和插入的時間隨着元素的增加而增加
占用空間小，內存浪費少
綜上所述，字典是在用空間換取時間（執行效率）。
3.python常用的運算符
3.1 數據運算
3.2 比較運算
3.3 賦值運算
3.3 邏輯運算
邏輯運算符可以直接使用在if條件判斷中，示例如下：
if 2 > 1 and not 2 > 3: print("2 is the middle between 1 and 3") else: print("Error")
3.4 成員運算
判斷某個元素是否在列表中即使用in操作符來實現。
>>> list1=['Python','PHP','Ruby'] >>> print(list1) ['Python', 'PHP', 'Ruby'] >>> 'Java' in list1 False >>> 'Java' not in list1 True >>>
3.5 身份運算
用於判斷兩個對象的引用關系。
3.6 位運算
按位取反的結果，就是二進制反碼對應的十進制減掉256后的結果。