【翻譯】《利用Python進行數據分析·第2版》第3章（中）Python的數據結構、函數和文件

06-28

來自專欄 Python程序員

作者：SeanCheney Python愛好者社區專欄作者
簡書專欄：https://www.jianshu.com/u/130f76596b02

前文傳送門：

【翻譯】《利用Python進行數據分析·第2版》第1章準備工作

【翻譯】《利用Python進行數據分析·第2版》第2章（上）Python語法基礎，IPython和Jupyter

【翻譯】《利用Python進行數據分析·第2版》第2章（中）Python語法基礎，IPython和Jupyter

【翻譯】《利用Python進行數據分析·第2版》第2章（下）Python語法基礎，IPython和Jupyter

【翻譯】《利用Python進行數據分析·第2版》第3章（上）Python的數據結構、函數和文件

序列函數

Python有一些有用的序列函數。

enumerate函數

迭代一個序列時，你可能想跟蹤當前項的序號。手動的方法可能是下面這樣：

i = 0

for value in collection:

# do something with value

i += 1

因為這麼做很常見，Python內建了一個enumerate函數，可以返回(i, value)元組序列：

for i, value in enumerate(collection):

# do something with value

當你索引數據時，使用enumerate的一個好方法是計算序列（唯一的）dict映射到位置的值：

In [83]: some_list = [foo, bar, baz]

In [84]: mapping = {}

In [85]: for i, v in enumerate(some_list):

....: mapping[v] = i

In [86]: mapping

Out[86]: {bar: 1, baz: 2, foo: 0}

sorted函數

sorted函數可以從任意序列的元素返回一個新的排好序的列表：

In [87]: sorted([7, 1, 2, 6, 0, 3, 2])

Out[87]: [0, 1, 2, 2, 3, 6, 7]

In [88]: sorted(horse race)

Out[88]: [ , a, c, e, e, h, o, r, r, s]

sorted函數可以接受和sort相同的參數。

zip函數

zip可以將多個列表、元組或其它序列成對組合成一個元組列表：

In [89]: seq1 = [foo, bar, baz]

In [90]: seq2 = [one, two, three]

In [91]: zipped = zip(seq1, seq2)

In [92]: list(zipped)

Out[92]: [(foo, one), (bar, two), (baz, three)]

zip可以處理任意多的序列，元素的個數取決於最短的序列：

In [93]: seq3 = [False, True]

In [94]: list(zip(seq1, seq2, seq3))

Out[94]: [(foo, one, False), (bar, two, True)]

zip的常見用法之一是同時迭代多個序列，可能結合enumerate使用：

In [95]: for i, (a, b) in enumerate(zip(seq1, seq2)):

....: print({0}: {1}, {2}.format(i, a, b))

....:

0: foo, one

1: bar, two

2: baz, three

給出一個「被壓縮的」序列，zip可以被用來解壓序列。也可以當作把行的列錶轉換為列的列表。這個方法看起來有點神奇：

In [96]: pitchers = [(Nolan, Ryan), (Roger, Clemens),

....: (Schilling, Curt)]

In [97]: first_names, last_names = zip(*pitchers)

In [98]: first_names

Out[98]: (Nolan, Roger, Schilling)

In [99]: last_names

Out[99]: (Ryan, Clemens, Curt)

reversed函數

reversed可以從後向前迭代一個序列：

In [100]: list(reversed(range(10)))

Out[100]: [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

要記住reversed是一個生成器（後面詳細介紹），只有實體化（即列表或for循環）之後才能創建翻轉的序列。

字典

字典可能是Python最為重要的數據結構。它更為常見的名字是哈希映射或關聯數組。它是鍵值對的大小可變集合，鍵和值都是Python對象。創建字典的方法之一是使用尖括弧，用冒號分隔鍵和值：

In [101]: empty_dict = {}

In [102]: d1 = {a : some value, b : [1, 2, 3, 4]}

In [103]: d1

Out[103]: {a: some value, b: [1, 2, 3, 4]}

你可以像訪問列表或元組中的元素一樣，訪問、插入或設定字典中的元素：

In [104]: d1[7] = an integer

In [105]: d1

Out[105]: {a: some value, b: [1, 2, 3, 4], 7: an integer}

In [106]: d1[b]

Out[106]: [1, 2, 3, 4]

你可以用檢查列表和元組是否包含某個值得方法，檢查字典中是否包含某個鍵：

In [107]: b in d1

Out[107]: True

可以用del關鍵字或pop方法（返回值得同時刪除鍵）刪除值：

In [107]: b in d1

Out[107]: True

可以用del關鍵字或pop方法（返回值得同時刪除鍵）刪除值：

In [108]: d1[5] = some value

In [109]: d1

Out[109]:

{a: some value,

b: [1, 2, 3, 4],

7: an integer,

5: some value}

In [110]: d1[dummy] = another value

In [111]: d1

Out[111]:

{a: some value,

b: [1, 2, 3, 4],

7: an integer,

5: some value,

dummy: another value}

In [112]: del d1[5]

In [113]: d1

Out[113]:

{a: some value,

b: [1, 2, 3, 4],

7: an integer,

dummy: another value}

In [114]: ret = d1.pop(dummy)

In [115]: ret

Out[115]: another value

In [116]: d1

Out[116]: {a: some value, b: [1, 2, 3, 4], 7: an integer}

keys和values是字典的鍵和值的迭代器方法。雖然鍵值對沒有順序，這兩個方法可以用相同的順序輸出鍵和值：

In [117]: list(d1.keys())

Out[117]: [a, b, 7]

In [118]: list(d1.values())

Out[118]: [some value, [1, 2, 3, 4], an integer]

用update方法可以將一個字典與另一個融合：

In [119]: d1.update({b : foo, c : 12})

In [120]: d1

Out[120]: {a: some value, b: foo, 7: an integer, c: 12}

update方法是原地改變字典，因此任何傳遞給update的鍵的舊的值都會被捨棄。

用序列創建字典

常常，你可能想將兩個序列配對組合成字典。下面是一種寫法：

mapping = {}

for key, value in zip(key_list, value_list):

mapping[key] = value

因為字典本質上是2元元組的集合，dict可以接受2元元組的列表：

In [121]: mapping = dict(zip(range(5), reversed(range(5))))

In [122]: mapping

Out[122]: {0: 4, 1: 3, 2: 2, 3: 1, 4: 0}

後面會談到dict comprehensions，另一種構建字典的優雅方式。

默認值

下面的邏輯很常見：

if key in some_dict:

value = some_dict[key]

else:

value = default_value

因此，dict的方法get和pop可以取默認值進行返回，上面的if-else語句可以簡寫成下面：

value = some_dict.get(key, default_value)

get默認會返回None，如果不存在鍵，pop會拋出一個例外。關於設定值，常見的情況是在字典的值是屬於其它集合，如列表。例如，你可以通過首字母，將一個列表中的單詞分類：

In [123]: words = [apple, bat, bar, atom, book]

In [124]: by_letter = {}

In [125]: for word in words:

.....: letter = word[0]

.....: if letter not in by_letter:

.....: by_letter[letter] = [word]

.....: else:

.....: by_letter[letter].append(word)

.....:

In [126]: by_letter

Out[126]: {a: [apple, atom], b: [bat, bar, book]}

setdefault方法就正是干這個的。前面的for循環可以改寫為：

for word in words:

letter = word[0]

by_letter.setdefault(letter, []).append(word)

collections模塊有一個很有用的類，defaultdict，它可以進一步簡化上面。傳遞類型或函數以生成每個位置的默認值：

from collections import defaultdict

by_letter = defaultdict(list)

for word in words:

by_letter[word[0]].append(word)

有效的鍵類型

字典的值可以是任意Python對象，而鍵通常是不可變的標量類型（整數、浮點型、字元串）或元組（元組中的對象必須是不可變的）。這被稱為「可哈希性」。可以用hash函數檢測一個對象是否是可哈希的（可被用作字典的鍵）：

In [127]: hash(string)

Out[127]: 5023931463650008331

In [128]: hash((1, 2, (2, 3)))

Out[128]: 1097636502276347782

In [129]: hash((1, 2, [2, 3])) # fails because lists are mutable

---------------------------------------------------------------------------

TypeError Traceback (most recent call last)

<ipython-input-129-800cd14ba8be> in <module>()

----> 1 hash((1, 2, [2, 3])) # fails because lists are mutable

TypeError: unhashable type: list

要用列表當做鍵，一種方法是將列錶轉化為元組，只要內部元素可以被哈希，它也就可以被哈希：

In [130]: d = {}

In [131]: d[tuple([1, 2, 3])] = 5

In [132]: d

Out[132]: {(1, 2, 3): 5}

集合

集合是無序的不可重複的元素的集合。你可以把它當做字典，但是只有鍵沒有值。可以用兩種方式創建集合：通過set函數或使用尖括弧set語句：

In [133]: set([2, 2, 2, 1, 3, 3])

Out[133]: {1, 2, 3}

In [134]: {2, 2, 2, 1, 3, 3}

Out[134]: {1, 2, 3}

集合支持合併、交集、差分和對稱差等數學集合運算。考慮兩個示例集合：

In [135]: a = {1, 2, 3, 4, 5}

In [136]: b = {3, 4, 5, 6, 7, 8}

合併是取兩個集合中不重複的元素。可以用union方法，或者|運算符：

In [137]: a.union(b)

Out[137]: {1, 2, 3, 4, 5, 6, 7, 8}

In [138]: a | b

Out[138]: {1, 2, 3, 4, 5, 6, 7, 8}

交集的元素包含在兩個集合中。可以用intersection或&運算符：

In [139]: a.intersection(b)

Out[139]: {3, 4, 5}

In [140]: a & b

Out[140]: {3, 4, 5}

表3-1列出了常用的集合方法。

表3-1 Python的集合操作

所有邏輯集合操作都有另外原地實現方法，它可以直接用結果替代集合的內容。對於大的集合，這麼做效率更高：

In [141]: c = a.copy()

In [142]: c |= b

In [143]: c

Out[143]: {1, 2, 3, 4, 5, 6, 7, 8}

In [144]: d = a.copy()

In [145]: d &= b

In [146]: d

Out[146]: {3, 4, 5}

與字典類似，集合元素通常都是不可變的。要獲得類似列表的元素，必須轉換成元組：

In [147]: my_data = [1, 2, 3, 4]

In [148]: my_set = {tuple(my_data)}

In [149]: my_set

Out[149]: {(1, 2, 3, 4)}

你還可以檢測一個集合是否是另一個集合的子集或父集：

In [150]: a_set = {1, 2, 3, 4, 5}

In [151]: {1, 2, 3}.issubset(a_set)

Out[151]: True

In [152]: a_set.issuperset({1, 2, 3})

Out[152]: True

集合的內容相同時，集合才對等：

In [153]: {1, 2, 3} == {3, 2, 1}

Out[153]: True

列表、集合和字典推導式

列表推導式是Python最受喜愛的特性之一。它允許用戶方便的從一個集合過濾元素，形成列表，在傳遞參數的過程中還可以修改元素。形式如下：

[expr for val in collection if condition]

它等同於下面的for循環;

result = []

for val in collection:

if condition:

result.append(expr)

filter條件可以被忽略，只留下表達式就行。例如，給定一個字元串列表，我們可以過濾出長度在2及以下的字元串，並將其轉換成大寫：

In [154]: strings = [a, as, bat, car, dove, python]

In [155]: [x.upper() for x in strings if len(x) > 2]

Out[155]: [BAT, CAR, DOVE, PYTHON]

用相似的方法，還可以推導集合和字典。字典的推導式如下所示：

dict_comp = {key-expr : value-expr for value in collection if condition}

集合的推導式與列表很像，只不過用的是尖括弧：

set_comp = {expr for value in collection if condition}

與列表推導式類似，集合與字典的推導也很方便，而且使代碼的讀寫都很容易。來看前面的字元串列表。假如我們只想要字元串的長度，用集合推導式的方法非常方便：

In [156]: unique_lengths = {len(x) for x in strings}

In [157]: unique_lengths

Out[157]: {1, 2, 3, 4, 6}

map函數可以進一步簡化：

In [158]: set(map(len, strings))

Out[158]: {1, 2, 3, 4, 6}

作為一個字典推導式的例子，我們可以創建一個字元串的查找映射表以確定它在列表中的位置：

In [159]: loc_mapping = {val : index for index, val in enumerate(strings)}

In [160]: loc_mapping

Out[160]: {a: 0, as: 1, bat: 2, car: 3, dove: 4, python: 5}

嵌套列表推導式

假設我們有一個包含列表的列表，包含了一些英文名和西班牙名：

In [161]: all_data = [[John, Emily, Michael, Mary, Steven],

.....: [Maria, Juan, Javier, Natalia, Pilar]]

你可能是從一些文件得到的這些名字，然後想按照語言進行分類。現在假設我們想用一個列表包含所有的名字，這些名字中包含兩個或更多的e。可以用for循環來做：

names_of_interest = []

for names in all_data:

enough_es = [name for name in names if name.count(e) >= 2]

names_of_interest.extend(enough_es)

可以用嵌套列表推導式的方法，將這些寫在一起，如下所示：

In [162]: result = [name for names in all_data for name in names

.....: if name.count(e) >= 2]

In [163]: result

Out[163]: [Steven]

嵌套列表推導式看起來有些複雜。列表推導式的for部分是根據嵌套的順序，過濾條件還是放在最後。下面是另一個例子，我們將一個整數元組的列表扁平化成了一個整數列表：

In [164]: some_tuples = [(1, 2, 3), (4, 5, 6), (7, 8, 9)]

In [165]: flattened = [x for tup in some_tuples for x in tup]

In [166]: flattened

Out[166]: [1, 2, 3, 4, 5, 6, 7, 8, 9]

記住，for表達式的順序是與嵌套for循環的順序一樣（而不是列表推導式的順序）：

flattened = []

for tup in some_tuples:

for x in tup:

flattened.append(x)

你可以有任意多級別的嵌套，但是如果你有兩三個以上的嵌套，你就應該考慮下代碼可讀性的問題了。分辨列表推導式的列表推導式中的語法也是很重要的：

In [167]: [[x for x in tup] for tup in some_tuples]

Out[167]: [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

這段代碼產生了一個列表的列表，而不是扁平化的只包含元素的列表。