python 的幾種數據類型

列表 
列表是 Python  的主力數據類型。當提到 「 列表 」 時，您腦海中可
能會閃現「 必須進一步聲明大小的數組，只能包含同一類對象
「  等想法。千萬別這麼想。列表比那要酷得多。  
☞ Python  中的列表相似 Perl  5  中的數組。在 Perl  5  
中，存儲數組的變量老是以字符 @ 開頭；在 Python  
中，變量可隨意命名，Python  僅在內部對數據類型
進行跟蹤。 
☞ Python  中的列表更像 Java   中的數組（儘管能夠
把列表當作生命中所須要的一切來使用)。一個更好
的比喻多是  ArrayList  類，該類能夠容納任何對
象，並可在添加新元素時進行動態拓展。 
建立列表 
列表建立很是輕鬆：使用中括號包裹一系列以逗號分割的值即
可。 
>>>  a_list = ['a',  'b', 'mpilgrim', 'z', 'example']  ① 
>>>  a_list 
['a',  'b', 'mpilgrim', 'z', 'example'] 
>>>  a_list[0]                                         ② 
'a'  
>>>  a_list[4]                                         ③ 
'example'  
>>>  a_list[ ‐1]                                       ④ 
'example'  
>>> a_list[ ‐3]                                       ⑤ 
'mpilgrim' 
1.   首先，建立一個包含 5 個元素的列表。要注意的是它們保持
了最初的順序。這並非偶然的。列表是元素的有序集合。  
2.   列表可當作以零爲基點的數組使用。非空列表的首個元素始
終是  a_list[0]  。  
3.   該 5 元素列表的最後一個元素是 a_list[4] ，由於列表（索
引）老是以零爲基點的。  
4.   使用負索引值可從列表的尾部向前計數訪問元素。任何非空
列表的最後一個元素老是 a_list[ ‐1] 。  
5.   若是負數令你混淆，可將其視爲以下方式： a_list[ ‐n] == 
a_list[len(a_list)  ‐  n] 。所以在此列表中， a_list[ ‐3] == 
a_list[5 ‐  3] == a_list[2] 。 
列表切片 
a_list[0] 是列表的第一個元素。  
定義列表後，可從其中獲取任何部分做爲新列表。該技術稱爲
對列表進行 切片 。 
>>>  a_list 
['a',  'b', 'mpilgrim', 'z', 'example'] 
>>>  a_list[1:3]             ① 
['b',  'mpilgrim'] 
>>>  a_list[1: ‐1]           ② 
['b',  'mpilgrim', 'z'] 
>>>  a_list[0:3]             ③ 
['a',  'b', 'mpilgrim'] 
>>>  a_list[:3]             ④ 
['a',  'b', 'mpilgrim'] 
>>>  a_list[3:]             ⑤ 
['z',  'example'] 
>>> a_list[:]                ⑥ 
['a',  'b', 'mpilgrim', 'z', 'example'] 
1.   經過指定兩個索引值，能夠從列表中獲取稱做「 切片」 的某個
部分。返回值是一個新列表，它包含列表(??切片)中全部元素，
按順序從第一個切片索引開始（本例中爲 a_list[1] ），截止但
不包含第二個切片索引（本例中的 a_list[3] ）。  
2.   若是切片索引之一或二者均爲負數，切片操做仍可進行。如
果有幫助的話，您能夠這麼思考：自左向右讀取列表，第一個
切片索引指明瞭想要的第一個元素，第二個切片索引指明瞭第
一個不想要的元素。返回值是二者之間的任何值。 between.   
3.   列表是以零爲起點的，所以 a_list[0:3] 返回列表的頭三個
元素，從 a_list[0]  開始，截止到但不包括 a_list[3]  。  
4.   若是左切片索引爲零，能夠將其留空而將零隱去。所以 
a_list[:3] 與 a_list[0:3] 是徹底相同的，由於起點 0  被隱去
了。  
5.   一樣，若是右切片索引爲列表的長度，也能夠將其留空。因
此 a_list[3:] 與 a_list[3:5] 是徹底相同的，由於該列表有五
個元素。此處有個好玩的對稱現象。在這個五元素列表中， 
a_list[:3] 返回頭三個元素，而 a_list[3:] 返回最後兩個元
素。事實上，不管列表的長度是多少,  a_list[:n] 將返回頭 n 個
元素，而 a_list[ n:] 返回其他部分。  
6.   若是兩個切片索引都留空，那麼將包括列表全部的元素。但
該返回值與最初的 a_list 變量並不同。它是一個新列表，只
不過剛好擁有徹底相同的元素而已。a_list[:]  是對列表進行復
制的一條捷徑。 
向列表中新增項 
有四種方法可用於向列表中增長元素。 
>>>  a_list = ['a']  
>>>  a_list = a_list + [2.0,  3]    ① 
>>>  a_list                        ② 
['a',  2.0, 3] 
>>>  a_list.append(True)           ③ 
>>>  a_list 
['a',  2.0, 3, True]  
>>>  a_list.extend(['four', 'Ω'])   ④ 
>>>  a_list 
['a',  2.0, 3, True,  'four',  'Ω'] 
>>>  a_list.insert(0,  'Ω')          ⑤ 
>>> a_list 
['Ω', 'a', 2.0, 3, True,  'four',  'Ω'] 
1.   + 運算符鏈接列表以建立一個新列表。列表可包含任何數量
的元素；沒有大小限制（除了可用內存的限制）。然而，若是
內存是個問題，那就必須知道在進行鏈接操做時，將在內存中
建立第二個列表。在該狀況下，新列表將會當即被賦值給已有
變量 a_list 。所以，實際上該行代碼包含兩個步驟 —  鏈接而後
賦值 —  當處理大型列表時，該操做可能（暫時）消耗大量內
存。  
2.   列表可包含任何數據類型的元素，單個列表中的元素無須全
爲同一類型。下面的列表中包含一個字符串、一個浮點數和一
個整數。  
3.   append() 方法向列表的尾部添加一個新的元素。（如今列表
中有 四種 不一樣數據類型！）  
4.   列表是以類的形式實現的。「 建立」 列表其實是將一個類實
例化。所以，列表有多種方法能夠操做。extend() 方法只接受
一個列表做爲參數，並將該參數的每一個元素都添加到原有的列
表中。  
5.   insert() 方法將單個元素插入到列表中。第一個參數是列表
中將被頂離原位的第一個元素的位置索引。列表中的元素並不
必定要是惟一的；好比說：現有兩個各自獨立的元素，其值均
爲 'Ω':，第一個元素 a_list[0]  以及最後一個元素 a_list[6]  。 
☞a_list.insert(0, value ) 就像是 Perl  中的 
unshift()  函數。它將一個元素添加到列表的頭
部，全部其它的元素都被頂理原先的位置以騰出空
間。 
讓咱們進一步看看  append() 和 extend() 的區別。 
>>>  a_list = ['a',  'b', 'c'] 
>>>  a_list.extend(['d', 'e', 'f'])   ① 
>>>  a_list 
['a',  'b', 'c', 'd', 'e', 'f'] 
>>>  len(a_list)                     ② 
6 
>>>  a_list[ ‐1] 
'f'  
>>>  a_list.append(['g', 'h', 'i'])   ③ 
>>>  a_list 
['a',  'b', 'c', 'd', 'e', 'f', ['g',  'h', 'i']]  
>>>  len(a_list)                     ④ 
7 
>>> a_list[ ‐1] 
['g',  'h', 'i'] 
1.   extend() 方法只接受一個參數，而該參數老是一個列表，並
將列表 a_list 中全部的元素都添加到該列表中。  
2.   若是開始有個 3 元素列表，而後將它與另外一個 3 元素列表進
行 extend  操做，結果是將得到一個 6 元素列表。  
3.   另外一方面， append() 方法只接受一個參數，但能夠是任何數
據類型。在此，對一個 3 元素列表調用 append() 方法。  
4.   若是開始的時候有個 6 元素列表，而後將一個列表 append
［添加］上去，結果就會……獲得一個 7 元素列表。爲何是 7 
個？由於最後一個元素（剛剛 append［添加］ 的元素） 自己
是個列表 。列表可包含任何類型的數據，包括其它列表。這可
能是你所須要的結果，也許不是。但若是這就是你想要的，那
這就是你所獲得的。 
在列表中檢索值 
>>>  a_list = ['a',  'b', 'new', 'mpilgrim', 'new'] 
>>>  a_list.count('new')        ① 
2 
>>>  'new'  in a_list           ② 
True 
>>>  'c'  in a_list 
False  
>>>  a_list.index('mpilgrim')  ③ 
3 
>>>  a_list.index('new')        ④ 
2 
>>>  a_list.index('c')          ⑤ 
Traceback  (innermost last): 
  File  "<interactive input>", line 1, in ?ValueError:  
list.index(x):  x not  in list 
1.   如你所指望，  count()  方法返回了列表中某個特定值出現的
次數。  
2.   若是你想知道的是某個值是否出如今列表中， in 運算符將會
比使用 count()  方法要略快一些。in 運算符老是返回 True 或 
False ；它不會告訴你該值出如今什麼位置。  
3.   若是想知道某個值在列表中的精確位置，可調用 index()  方
法。儘管能夠經過第二個參數（以 0  爲基點的）索引值來指定
起點，經過第三個參數（以 0  基點的）索引來指定搜索終點，
但缺省狀況下它將搜索整個列表，  
4.   index()  方法將查找某值在列表中的第一次出現。在該狀況
下，'new'  在列表中出現了兩次，分別爲 a_list[2]  和 
a_list[4] ，但 index()  方法將只返回第一次出現的位置索引
值。  
5.   可能 出乎 您的預期，若是在列表中沒有找到該值，index()  
方法將會引起一個例外。 
等等，什麼？是這樣的：若是沒有在列表中找到該值， index()  
方法將會引起一個例外。這是 Python  語言最顯著不一樣之處，其
它多數語言將會返回一些無效的索引值（像是 ‐1）。固然，一
開始這一點看起來比較討厭，但我想您會逐漸欣賞它。這意味
着您的程序將會在問題的源頭處崩潰，而不是以後奇怪地、默
默地崩潰。請記住， ‐1 是合法的列表索引值。若是 index()  方
法返回 ‐1，可能會致使調整過程變得不那麼有趣！  
從列表中刪除元素 
列表永遠不會有縫隙。  
列表能夠自動拓展或者收縮。您已經看到了拓展部分。也有幾
種方法可從列表中刪除元素。 
>>>  a_list = ['a',  'b', 'new', 'mpilgrim', 'new'] 
>>>  a_list[1]  
'b'  
>>>  del  a_list[1]           ① 
>>>  a_list 
['a',  'new', 'mpilgrim', 'new'] 
>>> a_list[1]              ② 
'new'  
1.   可以使用  del  語句從列表中刪除某個特定元素。  
2.   刪除索引  1 以後再訪問索引 1 將 不會 致使錯誤。被刪除元素
以後的全部元素將移動它們的位置以「 填補」 被刪除元素所產生
的「 縫隙」 。 
不知道位置索引？這不成問題，您能夠經過值而不是索引刪除
元素。 
>>>  a_list.remove('new')  ① 
>>>  a_list 
['a',  'mpilgrim', 'new'] 
>>>  a_list.remove('new')  ② 
>>>  a_list 
['a',  'mpilgrim'] 
>>>  a_list.remove('new') 
Traceback  (most  recent call last): 
  File  "<stdin>", line 1, in <module> 
ValueError:  list.remove(x): x not  in list 
1.   還能夠經過  remove() 方法從列表中刪除某個元素。remove() 
方法接受一個 value 參數，並刪除列表中該值的第一次出現。同
樣，被刪除元素以後的全部元素將會將索引位置下移，以「 填補
縫隙」 。列表永遠不會有「 縫隙」 。  
2.   您能夠盡情地調用 remove() 方法，但若是試圖刪除列表中不
存在的元素，它將引起一個例外。 
R EMOVING I TEMS FROM  A  LIST :  BONUS 
R OUND 
另外一有趣的列表方法是 pop()  。pop()  方法是從列表刪除元素的
另外一方法，但有點變化。 
>>>  a_list = ['a',  'b', 'new', 'mpilgrim'] 
>>>  a_list.pop()     ① 
'mpilgrim' 
>>>  a_list 
['a',  'b', 'new'] 
>>>  a_list.pop(1)  ② 
'b'  
>>>  a_list 
['a',  'new'] 
>>>  a_list.pop()  
'new'  
>>>  a_list.pop()  
'a'  
>>>  a_list.pop()     ③ 
Traceback  (most  recent call last): 
  File  "<stdin>", line 1, in <module> 
IndexError:  pop  from empty  list 
1.   若是不帶參數調用，  pop()  列表方法將刪除列表中最後的元
素，並返回所刪除的值。  
2.   能夠從列表中 pop ［彈出］任何元素。只需傳給 pop()  方法
一個位置索引值。它將刪除該元素，將其後全部元素移位以「 填
補縫隙」, 而後返回它刪除的值。  
3.   對空列表調用 pop()  將會引起一個例外。 
☞不帶參數調用的 pop()  列表方法就像 Perl  中的 
pop()  函數。它從列表中刪除最後一個元素並返回
所刪除元素的值。Perl  還有另外一個函數  shift() ，
可用於刪除第一個元素並返回其值；在 Python  
中，該函數至關於 a_list.pop(0)  。 
布爾上下文環境中的列表 
空列表爲假；其它全部列表爲真。  
能夠在 if 這樣的 布爾類型上下文環境中 使用列表。 
>>>  def  is_it_true(anything): 
...    if anything:  
...      print("yes, it's true") 
...    else:  
...      print("no, it's false")  
...  
>>>  is_it_true([])              ① 
no,  it's false  
>>>  is_it_true(['a'])          ② 
yes, it's true 
>>> is_it_true([False])        ③ 
yes, it's true 
1.   在布爾類型上下文環境中，空列表爲假值。  
2.   任何至少包含一個上元素的列表爲真值。  
3.   任何至少包含一個上元素的列表爲真值。元素的值無關緊
要。 
⁂  
元組 
元素 是不可變的列表。一旦建立以後，用任何方法都不能夠修
改元素。 
>>>  a_tuple  = ("a",  "b", "mpilgrim", "z", "example")  ① 
>>>  a_tuple  
('a',  'b', 'mpilgrim', 'z', 'example') 
>>>  a_tuple[0]                                        ② 
'a'  
>>>  a_tuple[‐1]                                       ③ 
'example'  
>>> a_tuple[1:3]                                        ④ 
('b',  'mpilgrim') 
1.   元組的定義方式和列表相同，除了整個元素的集合都用圓括
號，而不是方括號閉合。  
2.   和列表同樣，元組的元素都有肯定的順序。元組的索引也是
以零爲基點的，和列表同樣，所以非空元組的第一個元素老是 
a_tuple[0] 。  
3.   負的索引從元組的尾部開始計數，這和列表也是同樣的。  
4.   和列表同樣，元組也能夠進行切片操做。對列表切片能夠得
到新的列表；對元組切片能夠獲得新的元組。 
元組和列表的主要區別是元組不能進行修改。用技術術語來
說，元組是 不可變動 的。從實踐的角度來講，沒有可用於修改
元組的方法。列表有像 append()、 extend()、 insert()、
remove() 和 pop()  這樣的方法。這些方法，元組都沒有。能夠
對元組進行切片操做（由於該方法建立一個新的元組），能夠
檢查元組是否包含了特定的值（由於該操做不修改元組），還
能夠……就那麼多了。 
# continued  from the  previous example  
>>>  a_tuple  
('a',  'b', 'mpilgrim', 'z', 'example') 
>>>  a_tuple.append("new")               ① 
Traceback  (innermost last): 
  File  "<interactive  input>",  line  1,  in  ?AttributeError:  
'tuple'  object has  no attribute  'append' 
>>>  a_tuple.remove("z")                 ② 
Traceback  (innermost last): 
  File  "<interactive  input>",  line  1,  in  ?AttributeError:  
'tuple'  object has  no attribute  'remove' 
>>>  a_tuple.index("example")             ③ 
4 
>>> "z"  in a_tuple                       ④ 
True 
1.   沒法向元組添加元素。元組沒有  append() 或 extend() 方
法。  
2.   不能從元組中刪除元素。元組沒有 remove() 或 pop()  方法。  
3.   能夠 在元組中查找元素，因爲該操做不改變元組。  
4.   還可使用 in 運算符檢查某元素是否存在於元組中。 
那麼元組有什麼好處呢？ 
•   元組的速度比列表更快。若是定義了一系列常量值，而所需
作的僅是對它進行遍歷，那麼請使用元組替代列表。  
•   對不須要改變的數據進行「 寫保護」 將使得代碼更加安全。使
用元組替代列表就像是有一條隱含的 assert 語句顯示該數據是
常量，特別的想法（及特別的功能）必須重寫。（？？）  
•   一些元組可用做字典鍵（特別是包含字符串、數值和其它元
組這樣的不可變數據的元組）。列表永遠不能當作字典鍵使
用，由於列表不是不可變的。 
☞元組可轉換成列表，反之亦然。內建
的 tuple()  函數接受一個列表參數，並返回
一個包含一樣元素的元組，而 list() 函數
接受一個元組參數並返回一個列表。從效
果上看， tuple()  凍結列表，而 list() 融
化元組。 
布爾上下文環境中的元組 
能夠在 if 這樣的 布爾類型上下文環境中 使用元組。 
>>>  def  is_it_true(anything): 
...    if anything:  
...      print("yes, it's true") 
...    else:  
...      print("no, it's false")  
...  
>>>  is_it_true(())              ① 
no,  it's false  
>>>  is_it_true(('a',  'b'))       ② 
yes, it's true 
>>>  is_it_true((False,))        ③ 
yes, it's true 
>>>  type((False))               ④ 
<class 'bool'>  
>>> type((False,))  
<class 'tuple'> 
1.   在布爾類型上下文環境中，空元組爲假值。  
2.   任何至少包含一個上元素的元組爲真值。  
3.   任何至少包含一個上元素的元組爲真值。元素的值無關緊
要。不過此處的逗號起什麼做用呢？  
4.   爲建立單元素元組，須要在值以後加上一個逗號。沒有逗
號，Python  會假定這只是一對額外的圓括號，雖然沒有害處，
但並不建立元組。 
同時賦多個值 
如下是一種很酷的編程捷徑：在 Python  中，可以使用元組來一次
賦多值。 
>>>  v = ('a',  2, True)  
>>>  (x,  y, z) = v        ① 
>>>  x 
'a'  
>>>  y 
2 
>>> z 
True 
1.   v 是一個三元素的元組，而 (x,  y, z) 是包含三個變量的元
組。將其中一個賦值給另外一個將會把 v 中的每一個值按順序賦值
給每個變量。 
該特性有多種用途。假設須要將某個名稱指定某個特定範圍的
值。可使用內建的 range()  函數進行多變量賦值以快速地進
行連續變量賦值。 
>>>  (MONDAY, TUESDAY, WEDNESDAY, THURSDAY,  FRIDAY,  
SATURDAY,  SUNDAY)  = range(7)  ① 
>>>  MONDAY                                                                
② 
0 
>>>  TUESDAY  
1 
>>> SUNDAY 
6 
1.   內建的  range()  函數構造了一個整數序列。（從技術上來
說， range()  函數返回的既不是列表也不是元組，而是一個 迭
代器，但稍後您將學到它們的區別。） MONDAY、 TUESDAY 、 
WEDNESDAY 、 THURSDAY、 FRIDAY、 SATURDAY 和 SUNDAY 是您所定
義的變量。（本例來自於 calendar 模塊，該短小而有趣的模塊
打印日曆，有點像 UNIX 程序 cal  。該 calendar 模塊爲星期數
定義了整數常量。  
2.   如今，每一個變量都有其值了： MONDAY 爲 0 ， TUESDAY  爲 1，
如此類推。 
還可使用多變量賦值建立返回多值的函數，只需返回一個包
含全部值的元組。調用者可將返回值視爲一個簡單的元組，或
將其賦值給不一樣的變量。許多標準 Python  類庫這麼幹，包括在
下一章將學到的 os 模塊。  
⁂  
集合 
集合set 是裝有獨特值的無序「 袋子」 。一個簡單的集合能夠包含
任何數據類型的值。若是有兩個集合，則能夠執行像聯合、交
集以及集合求差等標準集合運算。  
建立集合 
重中之重。建立集合很是簡單。 
>>>  a_set  = {1}       ① 
>>>  a_set  
{1}  
>>>  type(a_set)      ② 
<class 'set'> 
>>>  a_set  = {1,  2}  ③ 
>>> a_set  
{1, 2} 
1.   要建立只包含一個值的集合，僅需將該值放置於花括號之
間。（{}）。  
2.   實際上，集合以 類 的形式實現，但目前還無須考慮這一點。  
3.   要建立多值集合，請將值用逗號分開，並用花括號將全部值
包裹起來。 
還能夠 列表 爲基礎建立集合。 
>>>  a_list = ['a',  'b', 'mpilgrim', True,  False, 42]  
>>>  a_set  = set(a_list)                            ① 
>>>  a_set                                          ② 
{'a',  False, 'b', True,  'mpilgrim', 42}  
>>> a_list                                        ③ 
['a',  'b', 'mpilgrim', True,  False, 42]  
1.   要從列表建立集合，可以使用  set()  函數。（懂得如何實現集
合的學究可能指出這實際上並非調用某個函數，而是對某個
類進行實例化。我保證在本書稍後的地方將會學到其中的區
別。目前而言，僅需知道 set()  行爲與函數相似，以及它返回
一個集合。）  
2.   正如我以前提到的，簡單的集合能夠包括任何數據類型的
值。並且，如我以前所提到的，集合是 無序的。該集合並不記
得用於建立它的列表中元素的最初順序。若是向集合中添加元
素，它也不會記得添加的順序。  
3.   初始的列表並不會發生變化。 
尚未任何值？沒有問題。能夠建立一個空的集合。 
>>>  a_set  = set()     ① 
>>>  a_set              ② 
set()  
>>>  type(a_set)      ③ 
<class 'set'> 
>>>  len(a_set)        ④ 
0 
>>>  not_sure = {}    ⑤ 
>>> type(not_sure)  
<class 'dict'>  
1.   要建立空集合，可不帶參數調用  set()  。  
2.   打印出來的空集合表現形式看起來有點兒怪。也許，您指望
看到一個  {} 吧 ？該符號表示一個空的字典，而不是一個空的集
合。本章稍後您將學到關於字典的內容。  
3.   儘管打印出的形式奇怪，這 確實是 一個集合……  
4.   …… 同時該集合沒有任何成員。  
5.   因爲從 Python  2 沿襲而來歷史的古怪規定，不能使用兩個花
括號來建立空集合。該操做實際建立一個空字典，而不是一個
空集合。 
修改集合 
有兩種方法可向現有集合中添加值： add()  方法和 update() 方
法。 
>>>  a_set  = {1,  2} 
>>>  a_set.add(4)   ① 
>>>  a_set  
{1,  2, 4} 
>>>  len(a_set)    ② 
3 
>>>  a_set.add(1)   ③ 
>>>  a_set  
{1,  2, 4} 
>>> len(a_set)    ④ 
3 
1.   add()  方法接受單個能夠是任何數據類型的參數，並將該值
添加到集合之中。  
2.   該集合如今有三個成員了。  
3.   集合是裝 惟一值 的袋子。若是試圖添加一個集合中已有的
值，將不會發生任何事情。將不會引起一個錯誤；只是一條空
操做。  
4.   該集合 仍然 只有三個成員。 
>>>  a_set  = {1,  2, 3} 
>>>  a_set  
{1,  2, 3} 
>>>  a_set.update({2,  4, 6})                         ① 
>>>  a_set                                          ② 
{1,  2, 3, 4, 6} 
>>>  a_set.update({3,  6, 9},  {1,  2, 3, 5, 8, 13})  ③ 
>>>  a_set  
{1,  2, 3, 4, 5, 6, 8, 9, 13}  
>>>  a_set.update([10, 20,  30])                    ④ 
>>> a_set  
{1, 2, 3, 4, 5, 6, 8, 9, 10,  13,  20,  30}  
1.   update() 方法僅接受一個集合做爲參數，並將其全部成員添
加到初始列表中。其行爲方式就像是對參數集合中的每一個成員
調用 add()  方法。  
2.   因爲集合不能包含重複的值，所以重複的值將會被忽略。  
3.   實際上，能夠帶任何數量的參數調用 update() 方法。若是調
用時傳遞了兩個集合， update() 將會被每一個集合中的每一個成員
添加到初始的集合當中（丟棄重複值）。  
4.   update() 方法還可接受一些其它數據類型的對象做爲參數，
包括列表。若是調用時傳入列表，update() 將會把列表中全部
的元素添加到初始集合中。 
從集合中刪除元素 
有三種方法能夠用來從集合中刪除某個值。前兩種，discard()  
和 remove() 有細微的差別。 
>>>  a_set  = {1,  3, 6, 10,  15,  21,  28,  36,  45}  
>>>  a_set  
{1,  3, 36,  6, 10,  45,  15,  21,  28}  
>>>  a_set.discard(10)                        ① 
>>>  a_set  
{1,  3, 36,  6, 45,  15,  21,  28}  
>>>  a_set.discard(10)                        ② 
>>>  a_set  
{1,  3, 36,  6, 45,  15,  21,  28}  
>>>  a_set.remove(21)                           ③ 
>>>  a_set  
{1,  3, 36,  6, 45,  15,  28}  
>>>  a_set.remove(21)                           ④ 
Traceback  (most  recent call last): 
  File  "<stdin>", line 1, in <module> 
KeyError:  21 
1.   discard()  接受一個單值做爲參數，並從集合中刪除該值。  
2.   若是針對一個集合中不存在的值調用 discard()  方法，它不
進行任何操做。不產生錯誤；只是一條空指令。  
3.   remove() 方法也接受一個單值做爲參數，也從集合中將其刪
除。  
4.   區別在這裏：若是該值不在集合中，remove() 方法引起一個 
KeyError 例外。 
就像列表，集合也有個 pop()  方法。 
>>>  a_set  = {1,  3, 6, 10,  15,  21,  28,  36,  45}  
>>>  a_set.pop()                                 ① 
1 
>>>  a_set.pop() 
3 
>>>  a_set.pop() 
36 
>>>  a_set  
{6,  10,  45,  15,  21,  28}  
>>>  a_set.clear()                              ② 
>>>  a_set  
set()  
>>>  a_set.pop()                                 ③ 
Traceback  (most  recent call last): 
  File  "<stdin>", line 1, in <module> 
KeyError:  'pop from an empty  set' 
1.   pop()  方法從集合中刪除某個值，並返回該值。然而，因爲
集合是無序的，並無「 最後一個」 值的概念，所以沒法控制刪
除的是哪個值。它基本上是隨機的。  
2.   clear()  方法刪除集合中 全部 的值，留下一個空集合。它等
價於 a_set  = set() ，該語句建立一個新的空集合，並用之覆蓋 
a_set  變量的以前的值。  
3.   試圖從空集合中彈出某值將會引起 KeyError 例外。 
常見集合操做 
Python  的 集合 類型支持幾種常見的運算。 
>>>  a_set  = {2,  4, 5, 9, 12,  21,  30,  51,  76,  127, 195} 
>>>  30 in a_set                                                      
① 
True 
>>>  31 in a_set  
False  
>>>  b_set  = {1,  2, 3, 5, 6, 8, 9, 12,  15,  17,  18,  21}  
>>>  a_set.union(b_set)                                               
② 
{1,  2, 195, 4, 5, 6, 8, 12,  76,  15,  17,  18,  3, 21,  30,  
51,  9, 127} 
>>>  a_set.intersection(b_set)                                        
③ 
{9,  2, 12,  5, 21}  
>>>  a_set.difference(b_set)                                          
④ 
{195,  4, 76,  51,  30,  127} 
>>> a_set.symmetric_difference(b_set)                               
⑤ 
{1, 3, 4, 6, 8, 76,  15,  17,  18,  195, 127, 30,  51}  
1.   要檢測某值是不是集合的成員，可以使用  in 運算符。其工做原
理和列表的同樣。  
2.   union()  方法返回一個新集合，其中裝着 在兩個 集合中出現
的元素。  
3.   intersection()  方法返回一個新集合，其中裝着 同時 在兩個
集合中出現的全部元素。  
4.   difference()  方法返回的新集合中，裝着全部在 a_set  出現
但未在 b_set  中的元素。  
5.   symmetric_difference() 方法返回一個新集合，其中裝着所
有 只在其中一個 集合中出現的元素。 
這三種方法是對稱的。 
# continued  from the  previous example  
>>>  b_set.symmetric_difference(a_set)                                     
① 
{3,  1, 195, 4, 6, 8, 76,  15,  17,  18,  51,  30,  127} 
>>>  b_set.symmetric_difference(a_set) == 
a_set.symmetric_difference(b_set)  ② 
True 
>>>  b_set.union(a_set)  == a_set.union(b_set)                               
③ 
True 
>>>  b_set.intersection(a_set)  == 
a_set.intersection(b_set)                    ④ 
True 
>>> b_set.difference(a_set)  == a_set.difference(b_set)                     
⑤ 
False  
1.   a_set  與 b_set  的對稱差分 看起來 和b_set  與 a_set  的對稱
差分不一樣，但請記住：集合是無序的。任何兩個包含全部一樣
值（無一遺漏）的集合可認爲是相等的。  
2.   而這正是這裏發生的事情。不要被 Python  Shell 對這些集合
的輸出形式所愚弄了。它們包含相同的值，所以是相等的。  
3.   對兩個集合的 Union［並集］操做也是對稱的。  
4.   對兩個集合的 Intersection ［交集］操做也是對稱的。  
5.   對兩個集合的 Difference［求差］操做不是對稱的。這是有意
義的；它相似於從一個數中減去另外一個數。操做數的順序會導
致結果不一樣。 
最後，有幾個您可能會問到的問題。 
>>>  a_set  = {1,  2, 3} 
>>>  b_set  = {1,  2, 3, 4} 
>>>  a_set.issubset(b_set)    ① 
True 
>>>  b_set.issuperset(a_set)   ② 
True 
>>>  a_set.add(5)              ③ 
>>>  a_set.issubset(b_set) 
False  
>>> b_set.issuperset(a_set)  
False  
1.   a_set  是 b_set  的 子集 —  全部 a_set  的成員均爲 b_set  的成
員。  
2.   一樣的問題反過來講， b_set  是 a_set  的 超集，由於 a_set  
的全部成員均爲 b_set  的成員。  
3.   一旦向 a_set  添加一個未在 b_set  中出現的值，兩項測試均
返回 False  。 
布爾上下文環境中的集合 
可在 if 這樣的 布爾類型上下文環境中 使用集合。 
>>>  def  is_it_true(anything): 
...    if anything:  
...      print("yes, it's true") 
...    else:  
...      print("no, it's false")  
...  
>>>  is_it_true(set())          ① 
no,  it's false  
>>>  is_it_true({'a'})          ② 
yes, it's true 
>>> is_it_true({False})        ③ 
yes, it's true 
1.   在布爾類型上下文環境中，空集合爲假值。  
2.   任何至少包含一個上元素的集合爲真值。  
3.   任何至少包含一個上元素的集合爲真值。元素的值無關緊
要。 
⁂  
字典 
字典 是鍵值對的無序集合。向字典添加一個鍵的同時，必須爲
該鍵增添一個值。（以後可隨時修改該值。） Python  的字典爲
經過鍵獲取值進行了優化，而不是反過來。  
☞Python  中的字典與 Perl  5  中的 hash  [ 散列] 相似。
在 Perl  5  中，散列存儲的變量老是以一個 % 符開
頭。在 Python  中，變量能夠隨意命名，而 Python  
內部跟蹤其數據類型。 
建立字典 
建立字典很是簡單。其語法與 集合 的相似，但應當指定鍵值對
而不是值。有了字典後，能夠經過鍵來查找值。 
>>>  a_dict = {'server': 'db.diveintopython3.org',  
'database': 'mysql'}  ① 
>>>  a_dict 
{'server':  'db.diveintopython3.org',   'database':  'mysql'} 
>>>  a_dict['server']                                                     
② 
'db.diveintopython3.org' 
>>>  a_dict['database']                                                   
③ 
'mysql'  
>>>  a_dict['db.diveintopython3.org']                                     
④ 
Traceback  (most  recent call last): 
  File  "<stdin>", line 1, in <module> 
KeyError:  'db.diveintopython3.org' 
1.   首先，經過將兩個字典項指定給  a_dict 變量建立了一個新字
典。每一個字典項都是一組鍵值對，整個字典項集合都被大括號
包裹在內。  
2.   'server' 爲鍵，經過 a_dict['server']  引用的關聯值爲 
'db.diveintopython3.org' 。  
3.   'database' 爲鍵，經過 a_dict['database']  引用的關聯值爲 
'mysql'  。  
4.   能夠經過鍵獲取值，但不能經過值獲取鍵。所以 
a_dict['server']  爲 'db.diveintopython3.org'，而 
a_dict['db.diveintopython3.org']  會引起例外，由於 
'db.diveintopython3.org' 並非鍵。 
修改字典 
字典沒有預約義的大小限制。能夠隨時向字典中添加新的鍵值
對，或者修改現有鍵所關聯的值。繼續前面的例子： 
>>>  a_dict 
{'server':  'db.diveintopython3.org',   'database':  'mysql'} 
>>>  a_dict['database']  = 'blog'  ① 
>>>  a_dict 
{'server': 'db.diveintopython3.org',  'database': 'blog'}  
>>>  a_dict['user']  = 'mark'      ② 
>>>  a_dict                        ③ 
{'server': 'db.diveintopython3.org',  'user':  'mark',  
'database': 'blog'}  
>>>  a_dict['user']  = 'dora'      ④ 
>>>  a_dict 
{'server': 'db.diveintopython3.org',  'user':  'dora',  
'database': 'blog'}  
>>>  a_dict['User']  = 'mark'      ⑤ 
>>> a_dict 
{'User': 'mark',  'server':  'db.diveintopython3.org',  
'user':  'dora',  'database': 'blog'}  
1.   在字典中不容許有重複的鍵。對現有的鍵賦值將會覆蓋舊
值。  
2.   可隨時添加新的鍵值對。該語法與修改現有值相同。  
3.   新字典項（鍵爲 'user'，值爲 'mark'）出如今中間。事實
上，在第一個例子中字典項按順序出現是個巧合；如今它們不
按順序出現一樣也是個巧合。  
4.   對既有字典鍵進行賦值只會用新值替代舊值。  
5.   該操做會將  user 鍵的值改回 "mark"  嗎？不會！仔細看看該
鍵——有個大寫的  U 出如今 "User" 中。字典鍵是區分大小寫
的，所以該語句建立了一組新的鍵值對，而不是覆蓋既有的字
典項。對你來講它們多是同樣的，但對於 Python  而言它們是
徹底不一樣的。 
混合值字典 
字典並不是只能用於字符串。字典的值能夠是任何數據類型，包
括整數、布爾值、任何對象，甚至是其它的字典。並且就算在
同一字典中，全部的值也無須是同一類型，您可根據須要混合
匹配。字典的鍵要嚴格得多，能夠是字符串、整數和其它一些
類型。在同一字典中也可混合、匹配使用不一樣數據類型的鍵。  
實際上，您已經在 your  first  Python  program  見過一個將非字符
串用做鍵的字典了。 
SUFFIXES = {1000: ['KB', 'MB',  'GB',  'TB',  'PB',  'EB',  
'ZB',  'YB'], 
             1024:  ['KiB',  'MiB', 'GiB', 'TiB', 'PiB', 
'EiB', 'ZiB', 'YiB']}  
讓咱們在交互式 shell  中剖析一下： 
>>>  SUFFIXES = {1000: ['KB', 'MB',  'GB',  'TB',  'PB',  
'EB',  'ZB',  'YB'], 
...                1024:   ['KiB',   'MiB',  'GiB',  'TiB',  'PiB', 
'EiB', 'ZiB', 'YiB']}  
>>>  len(SUFFIXES)      ① 
2 
>>>  1000 in SUFFIXES    ② 
True 
>>>  SUFFIXES[1000]       ③ 
['KB', 'MB',  'GB',  'TB',  'PB',  'EB',  'ZB',  'YB']  
>>>  SUFFIXES[1024]       ④ 
['KiB',  'MiB', 'GiB', 'TiB', 'PiB', 'EiB', 'ZiB', 'YiB'] 
>>> SUFFIXES[1000][3]  ⑤ 
'TB' 
1.   相似 列表 和 集合 ，len()  函數將返回字典中鍵的數量。  
2.   並且像列表和集合同樣，可以使用  in 運算符以測試某個特定的
鍵是否在字典中。  
3.   1000 是 字典 SUFFIXES 的一個鍵；其值爲一個 8  元素列表
（確切地說，是 8  個字符串）。  
4.   一樣， 1024 是字典 SUFFIXES 的鍵；其值也是一個 8  元素列
表。  
5.   因爲 SUFFIXES[1000]  是列表，能夠經過它們的 0  基點索引來
獲取列表中的單個元素。 
布爾上下文環境中的字典 
空字典爲假值；全部其它字典爲真值。  
能夠在 if 這樣的 布爾類型上下文環境中 使用字典。 
>>>  def  is_it_true(anything): 
...    if anything:  
...      print("yes, it's true") 
...    else:  
...      print("no, it's false")  
...  
>>>  is_it_true({})              ① 
no,  it's false  
>>> is_it_true({'a':  1})         ② 
yes, it's true 
1.   在布爾類型上下文環境中，空字典爲假值。  
2.   至少包含一個鍵值對的字典爲真值。 
⁂  
NONE  
None 是 Python  的一個特殊常量。它是一個 空 值。None 與 
False  不一樣。None 不是 0  。None 不是空字符串。將 None 與任何
非  None 的東西進行比較將老是返回 False  。  
None 是惟一的空值。它有着本身的數據類型（NoneType）。可
將  None 賦值給任何變量，但不能建立其它 NoneType 對象。所
有值爲  None 變量是相等的。 
>>>  type(None) 
<class 'NoneType'> 
>>>  None == False  
False  
>>>  None == 0 
False  
>>>  None == '' 
False  
>>>  None == None 
True 
>>>  x = None 
>>>  x == None 
True 
>>>  y = None 
>>>  x == y 
True 
布爾上下文環境中的  NONE  
在 布爾類型上下文環境中， None 爲假值，而 not  None 爲真
值。 
>>>  def  is_it_true(anything): 
...    if anything:  
...      print("yes, it's true") 
...    else:  
...      print("no, it's false")  
...  
>>>  is_it_true(None)  
no,  it's false  
>>>  is_it_true(not  None)  
yes, it's true