第1章 準(zhǔn)備工作
第2章 Python語法基礎(chǔ)，IPython和Jupyter
第3章 Python的數(shù)據(jù)結(jié)構(gòu)、函數(shù)和文件
第4章 NumPy基礎(chǔ)：數(shù)組和矢量計算
第5章 pandas入門
第6章 數(shù)據(jù)加載、存儲與文件格式
第7章 數(shù)據(jù)清洗和準(zhǔn)備
第8章 數(shù)據(jù)規(guī)整：聚合、合并和重塑
第9章 繪圖和可視化
第10章 數(shù)據(jù)聚合與分組運算
第11章 時間序列
第12章 pandas高級應(yīng)用
第13章 Python建模庫介紹
第14章 數(shù)據(jù)分析案例
附錄A NumPy高級應(yīng)用
附錄B 更多關(guān)于IPython的內(nèi)容（完）

本章討論Python的內(nèi)置功能，這些功能本書會用到很多。雖然擴展庫，比如pandas和Numpy，使處理大數(shù)據(jù)集很方便，但它們是和Python的內(nèi)置數(shù)據(jù)處理工具一同使用的。

我們會從Python最基礎(chǔ)的數(shù)據(jù)結(jié)構(gòu)開始：元組、列表、字典和集合。然后會討論創(chuàng)建你自己的、可重復(fù)使用的Python函數(shù)。最后，會學(xué)習(xí)Python的文件對象，以及如何與本地硬盤交互。

3.1 數(shù)據(jù)結(jié)構(gòu)和序列

Python的數(shù)據(jù)結(jié)構(gòu)簡單而強大。通曉它們才能成為熟練的Python程序員。

元組

元組是一個固定長度，不可改變的Python序列對象。創(chuàng)建元組的最簡單方式，是用逗號分隔一列值：

In [1]: tup = 4, 5, 6

In [2]: tup
Out[2]: (4, 5, 6)

當(dāng)用復(fù)雜的表達(dá)式定義元組，最好將值放到圓括號內(nèi)，如下所示：

In [3]: nested_tup = (4, 5, 6), (7, 8)

In [4]: nested_tup
Out[4]: ((4, 5, 6), (7, 8))

用tuple可以將任意序列或迭代器轉(zhuǎn)換成元組：

In [5]: tuple([4, 0, 2])
Out[5]: (4, 0, 2)

In [6]: tup = tuple('string')

In [7]: tup
Out[7]: ('s', 't', 'r', 'i', 'n', 'g')

可以用方括號訪問元組中的元素。和C、C++、JAVA等語言一樣，序列是從0開始的：

In [8]: tup[0]
Out[8]: 's'

元組中存儲的對象可能是可變對象。一旦創(chuàng)建了元組，元組中的對象就不能修改了：

In [9]: tup = tuple(['foo', [1, 2], True])

In [10]: tup[2] = False
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-10-c7308343b841> in <module>()
----> 1 tup[2] = False
TypeError: 'tuple' object does not support item assignment

如果元組中的某個對象是可變的，比如列表，可以在原位進(jìn)行修改：

In [11]: tup[1].append(3)

In [12]: tup
Out[12]: ('foo', [1, 2, 3], True)

可以用加號運算符將元組串聯(lián)起來：

In [13]: (4, None, 'foo') + (6, 0) + ('bar',)
Out[13]: (4, None, 'foo', 6, 0, 'bar')

元組乘以一個整數(shù)，像列表一樣，會將幾個元組的復(fù)制串聯(lián)起來：

In [14]: ('foo', 'bar') * 4
Out[14]: ('foo', 'bar', 'foo', 'bar', 'foo', 'bar', 'foo', 'bar')

對象本身并沒有被復(fù)制，只是引用了它。

拆分元組

如果你想將元組賦值給類似元組的變量，Python會試圖拆分等號右邊的值：

In [15]: tup = (4, 5, 6)

In [16]: a, b, c = tup

In [17]: b
Out[17]: 5

即使含有元組的元組也會被拆分：

In [18]: tup = 4, 5, (6, 7)

In [19]: a, b, (c, d) = tup

In [20]: d
Out[20]: 7

使用這個功能，你可以很容易地替換變量的名字，其它語言可能是這樣：

tmp = a
a = b
b = tmp

但是在Python中，替換可以這樣做：

In [21]: a, b = 1, 2

In [22]: a
Out[22]: 1

In [23]: b
Out[23]: 2

In [24]: b, a = a, b

In [25]: a
Out[25]: 2

In [26]: b
Out[26]: 1

變量拆分常用來迭代元組或列表序列：

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

In [28]: for a, b, c in seq:
   ....:     print('a={0}, b={1}, c={2}'.format(a, b, c))
a=1, b=2, c=3
a=4, b=5, c=6
a=7, b=8, c=9

另一個常見用法是從函數(shù)返回多個值。后面會詳解。

Python最近新增了更多高級的元組拆分功能，允許從元組的開頭“摘取”幾個元素。它使用了特殊的語法*rest，這也用在函數(shù)簽名中以抓取任意長度列表的位置參數(shù)：

In [29]: values = 1, 2, 3, 4, 5

In [30]: a, b, *rest = values

In [31]: a, b
Out[31]: (1, 2)

In [32]: rest
Out[32]: [3, 4, 5]

rest的部分是想要舍棄的部分，rest的名字不重要。作為慣用寫法，許多Python程序員會將不需要的變量使用下劃線：

In [33]: a, b, *_ = values

tuple方法

因為元組的大小和內(nèi)容不能修改，它的實例方法都很輕量。其中一個很有用的就是count（也適用于列表），它可以統(tǒng)計某個值得出現(xiàn)頻率：

In [34]: a = (1, 2, 2, 2, 3, 4, 2)

In [35]: a.count(2)
Out[35]: 4

列表

與元組對比，列表的長度可變、內(nèi)容可以被修改。你可以用方括號定義，或用list函數(shù)：

In [36]: a_list = [2, 3, 7, None]

In [37]: tup = ('foo', 'bar', 'baz')

In [38]: b_list = list(tup)

In [39]: b_list
Out[39]: ['foo', 'bar', 'baz']

In [40]: b_list[1] = 'peekaboo'

In [41]: b_list
Out[41]: ['foo', 'peekaboo', 'baz']

列表和元組的語義接近，在許多函數(shù)中可以交叉使用。

list函數(shù)常用來在數(shù)據(jù)處理中實體化迭代器或生成器：

In [42]: gen = range(10)

In [43]: gen
Out[43]: range(0, 10)

In [44]: list(gen)
Out[44]: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

添加和刪除元素

可以用append在列表末尾添加元素：

In [45]: b_list.append('dwarf')

In [46]: b_list
Out[46]: ['foo', 'peekaboo', 'baz', 'dwarf']

insert可以在特定的位置插入元素：

In [47]: b_list.insert(1, 'red')

In [48]: b_list
Out[48]: ['foo', 'red', 'peekaboo', 'baz', 'dwarf']

插入的序號必須在0和列表長度之間。

警告：與append相比，insert耗費的計算量大，因為對后續(xù)元素的引用必須在內(nèi)部遷移，以便為新元素提供空間。如果要在序列的頭部和尾部插入元素，你可能需要使用collections.deque，一個雙尾部隊列。

insert的逆運算是pop，它移除并返回指定位置的元素：

In [49]: b_list.pop(2)
Out[49]: 'peekaboo'

In [50]: b_list
Out[50]: ['foo', 'red', 'baz', 'dwarf']

可以用remove去除某個值，remove會先尋找第一個值并除去：

In [51]: b_list.append('foo')

In [52]: b_list
Out[52]: ['foo', 'red', 'baz', 'dwarf', 'foo']

In [53]: b_list.remove('foo')

In [54]: b_list
Out[54]: ['red', 'baz', 'dwarf', 'foo']

如果不考慮性能，使用append和remove，可以把Python的列表當(dāng)做完美的“多重集”數(shù)據(jù)結(jié)構(gòu)。

用in可以檢查列表是否包含某個值：

In [55]: 'dwarf' in b_list
Out[55]: True

否定in可以再加一個not：

In [56]: 'dwarf' not in b_list
Out[56]: False

在列表中檢查是否存在某個值遠(yuǎn)比字典和集合速度慢，因為Python是線性搜索列表中的值，但在字典和集合中，在同樣的時間內(nèi)還可以檢查其它項（基于哈希表）。

串聯(lián)和組合列表

與元組類似，可以用加號將兩個列表串聯(lián)起來：

In [57]: [4, None, 'foo'] + [7, 8, (2, 3)]
Out[57]: [4, None, 'foo', 7, 8, (2, 3)]

如果已經(jīng)定義了一個列表，用extend方法可以追加多個元素：

In [58]: x = [4, None, 'foo']

In [59]: x.extend([7, 8, (2, 3)])

In [60]: x
Out[60]: [4, None, 'foo', 7, 8, (2, 3)]

通過加法將列表串聯(lián)的計算量較大，因為要新建一個列表，并且要復(fù)制對象。用extend追加元素，尤其是到一個大列表中，更為可取。因此：

everything = []
for chunk in list_of_lists:
    everything.extend(chunk)

要比串聯(lián)方法快：

everything = []
for chunk in list_of_lists:
    everything = everything + chunk

排序

你可以用sort函數(shù)將一個列表原地排序（不創(chuàng)建新的對象）：

In [61]: a = [7, 2, 5, 1, 3]

In [62]: a.sort()

In [63]: a
Out[63]: [1, 2, 3, 5, 7]

sort有一些選項，有時會很好用。其中之一是二級排序key，可以用這個key進(jìn)行排序。例如，我們可以按長度對字符串進(jìn)行排序：

In [64]: b = ['saw', 'small', 'He', 'foxes', 'six']

In [65]: b.sort(key=len)

In [66]: b
Out[66]: ['He', 'saw', 'six', 'small', 'foxes']

稍后，我們會學(xué)習(xí)sorted函數(shù)，它可以產(chǎn)生一個排好序的序列副本。

二分搜索和維護(hù)已排序的列表

bisect模塊支持二分查找，和向已排序的列表插入值。bisect.bisect可以找到插入值后仍保證排序的位置，bisect.insort是向這個位置插入值：

In [67]: import bisect

In [68]: c = [1, 2, 2, 2, 3, 4, 7]

In [69]: bisect.bisect(c, 2)
Out[69]: 4

In [70]: bisect.bisect(c, 5)
Out[70]: 6

In [71]: bisect.insort(c, 6)

In [72]: c
Out[72]: [1, 2, 2, 2, 3, 4, 6, 7]

注意：bisect模塊不會檢查列表是否已排好序，進(jìn)行檢查的話會耗費大量計算。因此，對未排序的列表使用bisect不會產(chǎn)生錯誤，但結(jié)果不一定正確。

切片

用切邊可以選取大多數(shù)序列類型的一部分，切片的基本形式是在方括號中使用start:stop：

In [73]: seq = [7, 2, 3, 7, 5, 6, 0, 1]

In [74]: seq[1:5]
Out[74]: [2, 3, 7, 5]

切片也可以被序列賦值：

In [75]: seq[3:4] = [6, 3]

In [76]: seq
Out[76]: [7, 2, 3, 6, 3, 5, 6, 0, 1]

切片的起始元素是包括的，不包含結(jié)束元素。因此，結(jié)果中包含的元素個數(shù)是stop - start。

start或stop都可以被省略，省略之后，分別默認(rèn)序列的開頭和結(jié)尾：

In [77]: seq[:5]
Out[77]: [7, 2, 3, 6, 3]

In [78]: seq[3:]
Out[78]: [6, 3, 5, 6, 0, 1]

負(fù)數(shù)表明從后向前切片：

In [79]: seq[-4:]
Out[79]: [5, 6, 0, 1]

In [80]: seq[-6:-2]
Out[80]: [6, 3, 5, 6]

需要一段時間來熟悉使用切片，尤其是當(dāng)你之前學(xué)的是R或MATLAB。圖3-1展示了正整數(shù)和負(fù)整數(shù)的切片。在圖中，指數(shù)標(biāo)示在邊緣以表明切片是在哪里開始哪里結(jié)束的。

圖3-1 Python切片演示

在第二個冒號后面使用step，可以隔一個取一個元素：

In [81]: seq[::2]
Out[81]: [7, 3, 3, 6, 1]

一個聰明的方法是使用-1，它可以將列表或元組顛倒過來：

In [82]: seq[::-1]
Out[82]: [1, 0, 6, 5, 3, 6, 3, 2, 7]

序列函數(shù)

Python有一些有用的序列函數(shù)。

enumerate函數(shù)

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

i = 0
for value in collection:
   # do something with value
   i += 1

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

for i, value in enumerate(collection):
   # do something with value

當(dāng)你索引數(shù)據(jù)時，使用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函數(shù)

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

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函數(shù)可以接受和sort相同的參數(shù)。

zip函數(shù)

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可以處理任意多的序列，元素的個數(shù)取決于最短的序列：

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

In [94]: list(zip(seq1, seq2, seq3))
Out[94]: [('foo', 'one', False), ('bar', 'two', True)]

zip的常見用法之一是同時迭代多個序列，可能結(jié)合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可以被用來解壓序列。也可以當(dāng)作把行的列表轉(zhuǎn)換為列的列表。這個方法看起來有點神奇：

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函數(shù)

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

In [100]: list(reversed(range(10)))
Out[100]: [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]

要記住reversed是一個生成器（后面詳細(xì)介紹），只有實體化（即列表或for循環(huán)）之后才能創(chuàng)建翻轉(zhuǎn)的序列。

字典

字典可能是Python最為重要的數(shù)據(jù)結(jié)構(gòu)。它更為常見的名字是哈希映射或關(guān)聯(lián)數(shù)組。它是鍵值對的大小可變集合，鍵和值都是Python對象。創(chuàng)建字典的方法之一是使用尖括號，用冒號分隔鍵和值：

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]}

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

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關(guān)鍵字或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的鍵的舊的值都會被舍棄。

用序列創(chuàng)建字典

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

mapping = {}
for key, value in zip(key_list, value_list):
    mapping[key] = value

因為字典本質(zhì)上是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，另一種構(gòu)建字典的優(yōu)雅方式。

默認(rèn)值

下面的邏輯很常見：

if key in some_dict:
    value = some_dict[key]
else:
    value = default_value

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

value = some_dict.get(key, default_value)

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

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循環(huán)可以改寫為：

for word in words:
    letter = word[0]
    by_letter.setdefault(letter, []).append(word)

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

from collections import defaultdict
by_letter = defaultdict(list)
for word in words:
    by_letter[word[0]].append(word)

有效的鍵類型

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

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'

要用列表當(dāng)做鍵，一種方法是將列表轉(zhuǎn)化為元組，只要內(nèi)部元素可以被哈希，它也就可以被哈希：

In [130]: d = {}

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

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

集合

集合是無序的不可重復(fù)的元素的集合。你可以把它當(dāng)做字典，但是只有鍵沒有值。可以用兩種方式創(chuàng)建集合：通過set函數(shù)或使用尖括號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}

集合支持合并、交集、差分和對稱差等數(shù)學(xué)集合運算。考慮兩個示例集合：

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

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

合并是取兩個集合中不重復(fù)的元素。可以用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的集合操作

所有邏輯集合操作都有另外的原地實現(xiàn)方法，可以直接用結(jié)果替代集合的內(nèi)容。對于大的集合，這么做效率更高：

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}

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

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

集合的內(nèi)容相同時，集合才對等：

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

列表、集合和字典推導(dǎo)式

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

[expr for val in collection if condition]

它等同于下面的for循環(huán);

result = []
for val in collection:
    if condition:
        result.append(expr)

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

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']

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

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

集合的推導(dǎo)式與列表很像，只不過用的是尖括號：

set_comp = {expr for value in collection if condition}

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

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

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

map函數(shù)可以進(jìn)一步簡化：

In [158]: set(map(len, strings))
Out[158]: {1, 2, 3, 4, 6}

作為一個字典推導(dǎo)式的例子，我們可以創(chuàng)建一個字符串的查找映射表以確定它在列表中的位置：

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}

嵌套列表推導(dǎo)式

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

In [161]: all_data = [['John', 'Emily', 'Michael', 'Mary', 'Steven'],
   .....:             ['Maria', 'Juan', 'Javier', 'Natalia', 'Pilar']]

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

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)

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

In [162]: result = [name for names in all_data for name in names
   .....:           if name.count('e') >= 2]

In [163]: result
Out[163]: ['Steven']

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

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表達(dá)式的順序是與嵌套for循環(huán)的順序一樣（而不是列表推導(dǎo)式的順序）：

flattened = []

for tup in some_tuples:
    for x in tup:
        flattened.append(x)

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

In [167]: [[x for x in tup] for tup in some_tuples]
Out[167]: [[1, 2, 3], [4, 5, 6], [7, 8, 9]]

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

3.2 函數(shù)

函數(shù)是Python中最主要也是最重要的代碼組織和復(fù)用手段。作為最重要的原則，如果你要重復(fù)使用相同或非常類似的代碼，就需要寫一個函數(shù)。通過給函數(shù)起一個名字，還可以提高代碼的可讀性。

函數(shù)使用def關(guān)鍵字聲明，用return關(guān)鍵字返回值：

def my_function(x, y, z=1.5):
    if z > 1:
        return z * (x + y)
    else:
        return z / (x + y)

同時擁有多條return語句也是可以的。如果到達(dá)函數(shù)末尾時沒有遇到任何一條return語句，則返回None。

函數(shù)可以有一些位置參數(shù)（positional）和一些關(guān)鍵字參數(shù)（keyword）。關(guān)鍵字參數(shù)通常用于指定默認(rèn)值或可選參數(shù)。在上面的函數(shù)中，x和y是位置參數(shù)，而z則是關(guān)鍵字參數(shù)。也就是說，該函數(shù)可以下面這兩種方式進(jìn)行調(diào)用：

my_function(5, 6, z=0.7)
my_function(3.14, 7, 3.5)
my_function(10, 20)

函數(shù)參數(shù)的主要限制在于：關(guān)鍵字參數(shù)必須位于位置參數(shù)（如果有的話）之后。你可以任何順序指定關(guān)鍵字參數(shù)。也就是說，你不用死記硬背函數(shù)參數(shù)的順序，只要記得它們的名字就可以了。

筆記：也可以用關(guān)鍵字傳遞位置參數(shù)。前面的例子，也可以寫為：

my_function(x=5, y=6, z=7)
my_function(y=6, x=5, z=7)

這種寫法可以提高可讀性。

命名空間、作用域，和局部函數(shù)

函數(shù)可以訪問兩種不同作用域中的變量：全局（global）和局部（local）。Python有一種更科學(xué)的用于描述變量作用域的名稱，即命名空間（namespace）。任何在函數(shù)中賦值的變量默認(rèn)都是被分配到局部命名空間（local namespace）中的。局部命名空間是在函數(shù)被調(diào)用時創(chuàng)建的，函數(shù)參數(shù)會立即填入該命名空間。在函數(shù)執(zhí)行完畢之后，局部命名空間就會被銷毀（會有一些例外的情況，具體請參見后面介紹閉包的那一節(jié)）。看看下面這個函數(shù)：

def func():
    a = []
    for i in range(5):
        a.append(i)

調(diào)用func()之后，首先會創(chuàng)建出空列表a，然后添加5個元素，最后a會在該函數(shù)退出的時候被銷毀。假如我們像下面這樣定義a：

a = []
def func():
    for i in range(5):
        a.append(i)

雖然可以在函數(shù)中對全局變量進(jìn)行賦值操作，但是那些變量必須用global關(guān)鍵字聲明成全局的才行：

In [168]: a = None

In [169]: def bind_a_variable():
   .....:     global a
   .....:     a = []
   .....: bind_a_variable()
   .....:

In [170]: print(a)
[]

注意：我常常建議人們不要頻繁使用global關(guān)鍵字。因為全局變量一般是用于存放系統(tǒng)的某些狀態(tài)的。如果你發(fā)現(xiàn)自己用了很多，那可能就說明得要來點兒面向?qū)ο缶幊塘耍词褂妙悾?/p>

返回多個值

在我第一次用Python編程時（之前已經(jīng)習(xí)慣了Java和C++），最喜歡的一個功能是：函數(shù)可以返回多個值。下面是一個簡單的例子：

def f():
    a = 5
    b = 6
    c = 7
    return a, b, c

a, b, c = f()

在數(shù)據(jù)分析和其他科學(xué)計算應(yīng)用中，你會發(fā)現(xiàn)自己常常這么干。該函數(shù)其實只返回了一個對象，也就是一個元組，最后該元組會被拆包到各個結(jié)果變量中。在上面的例子中，我們還可以這樣寫：

return_value = f()

這里的return_value將會是一個含有3個返回值的三元元組。此外，還有一種非常具有吸引力的多值返回方式——返回字典：

def f():
    a = 5
    b = 6
    c = 7
    return {'a' : a, 'b' : b, 'c' : c}

取決于工作內(nèi)容，第二種方法可能很有用。

函數(shù)也是對象

由于Python函數(shù)都是對象，因此，在其他語言中較難表達(dá)的一些設(shè)計思想在Python中就要簡單很多了。假設(shè)我們有下面這樣一個字符串?dāng)?shù)組，希望對其進(jìn)行一些數(shù)據(jù)清理工作并執(zhí)行一堆轉(zhuǎn)換：

In [171]: states = ['   Alabama ', 'Georgia!', 'Georgia', 'georgia', 'FlOrIda',
   .....:           'south   carolina##', 'West virginia?']

不管是誰，只要處理過由用戶提交的調(diào)查數(shù)據(jù)，就能明白這種亂七八糟的數(shù)據(jù)是怎么一回事。為了得到一組能用于分析工作的格式統(tǒng)一的字符串，需要做很多事情：去除空白符、刪除各種標(biāo)點符號、正確的大寫格式等。做法之一是使用內(nèi)建的字符串方法和正則表達(dá)式re模塊：

import re

def clean_strings(strings):
    result = []
    for value in strings:
        value = value.strip()
        value = re.sub('[!#?]', '', value)
        value = value.title()
        result.append(value)
    return result

結(jié)果如下所示：

In [173]: clean_strings(states)
Out[173]: 
['Alabama',
 'Georgia',
 'Georgia',
 'Georgia',
 'Florida',
 'South   Carolina',
 'West Virginia']

其實還有另外一種不錯的辦法：將需要在一組給定字符串上執(zhí)行的所有運算做成一個列表：

def remove_punctuation(value):
    return re.sub('[!#?]', '', value)

clean_ops = [str.strip, remove_punctuation, str.title]

def clean_strings(strings, ops):
    result = []
    for value in strings:
        for function in ops:
            value = function(value)
        result.append(value)
    return result

然后我們就有了：

In [175]: clean_strings(states, clean_ops)
Out[175]: 
['Alabama',
 'Georgia',
 'Georgia',
 'Georgia',
 'Florida',
 'South   Carolina',
 'West Virginia']

這種多函數(shù)模式使你能在很高的層次上輕松修改字符串的轉(zhuǎn)換方式。此時的clean_strings也更具可復(fù)用性！

還可以將函數(shù)用作其他函數(shù)的參數(shù)，比如內(nèi)置的map函數(shù)，它用于在一組數(shù)據(jù)上應(yīng)用一個函數(shù)：

In [176]: for x in map(remove_punctuation, states):
   .....:     print(x)
Alabama 
Georgia
Georgia
georgia
FlOrIda
south   carolina
West virginia

匿名（lambda）函數(shù)

Python支持一種被稱為匿名的、或lambda函數(shù)。它僅由單條語句組成，該語句的結(jié)果就是返回值。它是通過lambda關(guān)鍵字定義的，這個關(guān)鍵字沒有別的含義，僅僅是說“我們正在聲明的是一個匿名函數(shù)”。

def short_function(x):
    return x * 2

equiv_anon = lambda x: x * 2

本書其余部分一般將其稱為lambda函數(shù)。它們在數(shù)據(jù)分析工作中非常方便，因為你會發(fā)現(xiàn)很多數(shù)據(jù)轉(zhuǎn)換函數(shù)都以函數(shù)作為參數(shù)的。直接傳入lambda函數(shù)比編寫完整函數(shù)聲明要少輸入很多字（也更清晰），甚至比將lambda函數(shù)賦值給一個變量還要少輸入很多字。看看下面這個簡單得有些傻的例子：

def apply_to_list(some_list, f):
    return [f(x) for x in some_list]

ints = [4, 0, 1, 5, 6]
apply_to_list(ints, lambda x: x * 2)

雖然你可以直接編寫[x *2for x in ints]，但是這里我們可以非常輕松地傳入一個自定義運算給apply_to_list函數(shù)。

再來看另外一個例子。假設(shè)有一組字符串，你想要根據(jù)各字符串不同字母的數(shù)量對其進(jìn)行排序：

In [177]: strings = ['foo', 'card', 'bar', 'aaaa', 'abab']

這里，我們可以傳入一個lambda函數(shù)到列表的sort方法：

In [178]: strings.sort(key=lambda x: len(set(list(x))))

In [179]: strings
Out[179]: ['aaaa', 'foo', 'abab', 'bar', 'card']

筆記：lambda函數(shù)之所以會被稱為匿名函數(shù)，與def聲明的函數(shù)不同，原因之一就是這種函數(shù)對象本身是沒有提供名稱name屬性。

柯里化：部分參數(shù)應(yīng)用

柯里化（currying）是一個有趣的計算機科學(xué)術(shù)語，它指的是通過“部分參數(shù)應(yīng)用”（partial argument application）從現(xiàn)有函數(shù)派生出新函數(shù)的技術(shù)。例如，假設(shè)我們有一個執(zhí)行兩數(shù)相加的簡單函數(shù)：

def add_numbers(x, y):
    return x + y

通過這個函數(shù)，我們可以派生出一個新的只有一個參數(shù)的函數(shù)——add_five，它用于對其參數(shù)加5：

add_five = lambda y: add_numbers(5, y)

add_numbers的第二個參數(shù)稱為“柯里化的”（curried）。這里沒什么特別花哨的東西，因為我們其實就只是定義了一個可以調(diào)用現(xiàn)有函數(shù)的新函數(shù)而已。內(nèi)置的functools模塊可以用partial函數(shù)將此過程簡化：

from functools import partial
add_five = partial(add_numbers, 5)

生成器

能以一種一致的方式對序列進(jìn)行迭代（比如列表中的對象或文件中的行）是Python的一個重要特點。這是通過一種叫做迭代器協(xié)議（iterator protocol，它是一種使對象可迭代的通用方式）的方式實現(xiàn)的，一個原生的使對象可迭代的方法。比如說，對字典進(jìn)行迭代可以得到其所有的鍵：

In [180]: some_dict = {'a': 1, 'b': 2, 'c': 3}

In [181]: for key in some_dict:
   .....:     print(key)
a
b
c

當(dāng)你編寫for key in some_dict時，Python解釋器首先會嘗試從some_dict創(chuàng)建一個迭代器：

In [182]: dict_iterator = iter(some_dict)

In [183]: dict_iterator
Out[183]: <dict_keyiterator at 0x7fbbd5a9f908>

迭代器是一種特殊對象，它可以在諸如for循環(huán)之類的上下文中向Python解釋器輸送對象。大部分能接受列表之類的對象的方法也都可以接受任何可迭代對象。比如min、max、sum等內(nèi)置方法以及l(fā)ist、tuple等類型構(gòu)造器：

In [184]: list(dict_iterator)
Out[184]: ['a', 'b', 'c']

生成器（generator）是構(gòu)造新的可迭代對象的一種簡單方式。一般的函數(shù)執(zhí)行之后只會返回單個值，而生成器則是以延遲的方式返回一個值序列，即每返回一個值之后暫停，直到下一個值被請求時再繼續(xù)。要創(chuàng)建一個生成器，只需將函數(shù)中的return替換為yeild即可：

def squares(n=10):
    print('Generating squares from 1 to {0}'.format(n ** 2))
    for i in range(1, n + 1):
        yield i ** 2

調(diào)用該生成器時，沒有任何代碼會被立即執(zhí)行：

In [186]: gen = squares()

In [187]: gen
Out[187]: <generator object squares at 0x7fbbd5ab4570>

直到你從該生成器中請求元素時，它才會開始執(zhí)行其代碼：

In [188]: for x in gen:
   .....:     print(x, end=' ')
Generating squares from 1 to 100
1 4 9 16 25 36 49 64 81 100

生成器表達(dá)式

另一種更簡潔的構(gòu)造生成器的方法是使用生成器表達(dá)式（generator expression）。這是一種類似于列表、字典、集合推導(dǎo)式的生成器。其創(chuàng)建方式為，把列表推導(dǎo)式兩端的方括號改成圓括號：

In [189]: gen = (x ** 2 for x in range(100))

In [190]: gen
Out[190]: <generator object <genexpr> at 0x7fbbd5ab29e8>

它跟下面這個冗長得多的生成器是完全等價的：

def _make_gen():
    for x in range(100):
        yield x ** 2
gen = _make_gen()

生成器表達(dá)式也可以取代列表推導(dǎo)式，作為函數(shù)參數(shù)：

In [191]: sum(x ** 2 for x in range(100))
Out[191]: 328350

In [192]: dict((i, i **2) for i in range(5))
Out[192]: {0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

itertools模塊

標(biāo)準(zhǔn)庫itertools模塊中有一組用于許多常見數(shù)據(jù)算法的生成器。例如，groupby可以接受任何序列和一個函數(shù)。它根據(jù)函數(shù)的返回值對序列中的連續(xù)元素進(jìn)行分組。下面是一個例子：

In [193]: import itertools

In [194]: first_letter = lambda x: x[0]

In [195]: names = ['Alan', 'Adam', 'Wes', 'Will', 'Albert', 'Steven']

In [196]: for letter, names in itertools.groupby(names, first_letter):
   .....:     print(letter, list(names)) # names is a generator
A ['Alan', 'Adam']
W ['Wes', 'Will']
A ['Albert']
S ['Steven']

表3-2中列出了一些我經(jīng)常用到的itertools函數(shù)。建議參閱Python官方文檔，進(jìn)一步學(xué)習(xí)。

表3-2 一些有用的itertools函數(shù)

錯誤和異常處理

優(yōu)雅地處理Python的錯誤和異常是構(gòu)建健壯程序的重要部分。在數(shù)據(jù)分析中，許多函數(shù)函數(shù)只用于部分輸入。例如，Python的float函數(shù)可以將字符串轉(zhuǎn)換成浮點數(shù)，但輸入有誤時，有ValueError錯誤：

In [197]: float('1.2345')
Out[197]: 1.2345

In [198]: float('something')
---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-198-439904410854> in <module>()
----> 1 float('something')
ValueError: could not convert string to float: 'something'

假如想優(yōu)雅地處理float的錯誤，讓它返回輸入值。我們可以寫一個函數(shù)，在try/except中調(diào)用float：

def attempt_float(x):
    try:
        return float(x)
    except:
        return x

當(dāng)float(x)拋出異常時，才會執(zhí)行except的部分：

In [200]: attempt_float('1.2345')
Out[200]: 1.2345

In [201]: attempt_float('something')
Out[201]: 'something'

你可能注意到float拋出的異常不僅是ValueError：

In [202]: float((1, 2))
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-202-842079ebb635> in <module>()
----> 1 float((1, 2))
TypeError: float() argument must be a string or a number, not 'tuple'

你可能只想處理ValueError，TypeError錯誤（輸入不是字符串或數(shù)值）可能是合理的bug。可以寫一個異常類型：

def attempt_float(x):
    try:
        return float(x)
    except ValueError:
        return x

然后有：

In [204]: attempt_float((1, 2))
---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-204-9bdfd730cead> in <module>()
----> 1 attempt_float((1, 2))
<ipython-input-203-3e06b8379b6b> in attempt_float(x)
      1 def attempt_float(x):
      2     try:
----> 3         return float(x)
      4     except ValueError:
      5         return x
TypeError: float() argument must be a string or a number, not 'tuple'

可以用元組包含多個異常：

def attempt_float(x):
    try:
        return float(x)
    except (TypeError, ValueError):
        return x

某些情況下，你可能不想抑制異常，你想無論try部分的代碼是否成功，都執(zhí)行一段代碼。可以使用finally：

f = open(path, 'w')

try:
    write_to_file(f)
finally:
    f.close()

這里，文件處理f總會被關(guān)閉。相似的，你可以用else讓只在try部分成功的情況下，才執(zhí)行代碼：

f = open(path, 'w')

try:
    write_to_file(f)
except:
    print('Failed')
else:
    print('Succeeded')
finally:
    f.close()

IPython的異常

如果是在%run一個腳本或一條語句時拋出異常，IPython默認(rèn)會打印完整的調(diào)用棧（traceback），在棧的每個點都會有幾行上下文：

In [10]: %run examples/ipython_bug.py
---------------------------------------------------------------------------
AssertionError                            Traceback (most recent call last)
/home/wesm/code/pydata-book/examples/ipython_bug.py in <module>()
     13     throws_an_exception()
     14
---> 15 calling_things()

/home/wesm/code/pydata-book/examples/ipython_bug.py in calling_things()
     11 def calling_things():
     12     works_fine()
---> 13     throws_an_exception()
     14
     15 calling_things()

/home/wesm/code/pydata-book/examples/ipython_bug.py in throws_an_exception()
      7     a = 5
      8     b = 6
----> 9     assert(a + b == 10)
     10
     11 def calling_things():

AssertionError:

自身就帶有文本是相對于Python標(biāo)準(zhǔn)解釋器的極大優(yōu)點。你可以用魔術(shù)命令%xmode，從Plain（與Python標(biāo)準(zhǔn)解釋器相同）到Verbose（帶有函數(shù)的參數(shù)值）控制文本顯示的數(shù)量。后面可以看到，發(fā)生錯誤之后，（用%debug或%pdb magics）可以進(jìn)入stack進(jìn)行事后調(diào)試。

3.3 文件和操作系統(tǒng)

本書的代碼示例大多使用諸如pandas.read_csv之類的高級工具將磁盤上的數(shù)據(jù)文件讀入Python數(shù)據(jù)結(jié)構(gòu)。但我們還是需要了解一些有關(guān)Python文件處理方面的基礎(chǔ)知識。好在它本來就很簡單，這也是Python在文本和文件處理方面的如此流行的原因之一。

為了打開一個文件以便讀寫，可以使用內(nèi)置的open函數(shù)以及一個相對或絕對的文件路徑：

In [207]: path = 'examples/segismundo.txt'

In [208]: f = open(path)

默認(rèn)情況下，文件是以只讀模式（'r'）打開的。然后，我們就可以像處理列表那樣來處理這個文件句柄f了，比如對行進(jìn)行迭代：

for line in f:
    pass

從文件中取出的行都帶有完整的行結(jié)束符（EOL），因此你常常會看到下面這樣的代碼（得到一組沒有EOL的行）：

In [209]: lines = [x.rstrip() for x in open(path)]

In [210]: lines
Out[210]: 
['Sue?a el rico en su riqueza,',
 'que más cuidados le ofrece;',
 '',
 'sue?a el pobre que padece',
 'su miseria y su pobreza;',
 '',
 'sue?a el que a medrar empieza,',
 'sue?a el que afana y pretende,',
 'sue?a el que agravia y ofende,',
 '',
 'y en el mundo, en conclusión,',
 'todos sue?an lo que son,',
 'aunque ninguno lo entiende.',
 '']

如果使用open創(chuàng)建文件對象，一定要用close關(guān)閉它。關(guān)閉文件可以返回操作系統(tǒng)資源：

In [211]: f.close()

用with語句可以可以更容易地清理打開的文件：

In [212]: with open(path) as f:
   .....:     lines = [x.rstrip() for x in f]

這樣可以在退出代碼塊時，自動關(guān)閉文件。

如果輸入f =open(path,'w')，就會有一個新文件被創(chuàng)建在examples/segismundo.txt，并覆蓋掉該位置原來的任何數(shù)據(jù)。另外有一個x文件模式，它可以創(chuàng)建可寫的文件，但是如果文件路徑存在，就無法創(chuàng)建。表3-3列出了所有的讀/寫模式。

表3-3 Python的文件模式

對于可讀文件，一些常用的方法是read、seek和tell。read會從文件返回字符。字符的內(nèi)容是由文件的編碼決定的（如UTF-8），如果是二進(jìn)制模式打開的就是原始字節(jié)：

In [213]: f = open(path)

In [214]: f.read(10)
Out[214]: 'Sue?a el r'

In [215]: f2 = open(path, 'rb')  # Binary mode

In [216]: f2.read(10)
Out[216]: b'Sue\xc3\xb1a el '

read模式會將文件句柄的位置提前，提前的數(shù)量是讀取的字節(jié)數(shù)。tell可以給出當(dāng)前的位置：

In [217]: f.tell()
Out[217]: 11

In [218]: f2.tell()
Out[218]: 10

盡管我們從文件讀取了10個字符，位置卻是11，這是因為用默認(rèn)的編碼用了這么多字節(jié)才解碼了這10個字符。你可以用sys模塊檢查默認(rèn)的編碼：

In [219]: import sys

In [220]: sys.getdefaultencoding()
Out[220]: 'utf-8'

seek將文件位置更改為文件中的指定字節(jié)：

In [221]: f.seek(3)
Out[221]: 3

In [222]: f.read(1)
Out[222]: '?'

最后，關(guān)閉文件：

In [223]: f.close()

In [224]: f2.close()

向文件寫入，可以使用文件的write或writelines方法。例如，我們可以創(chuàng)建一個無空行版的prof_mod.py：

In [225]: with open('tmp.txt', 'w') as handle:
   .....:     handle.writelines(x for x in open(path) if len(x) > 1)

In [226]: with open('tmp.txt') as f:
   .....:     lines = f.readlines()

In [227]: lines
Out[227]: 
['Sue?a el rico en su riqueza,\n',
 'que más cuidados le ofrece;\n',
 'sue?a el pobre que padece\n',
 'su miseria y su pobreza;\n',
 'sue?a el que a medrar empieza,\n',
 'sue?a el que afana y pretende,\n',
 'sue?a el que agravia y ofende,\n',
 'y en el mundo, en conclusión,\n',
 'todos sue?an lo que son,\n',
 'aunque ninguno lo entiende.\n']

表3-4列出了一些最常用的文件方法。

表3-4 Python重要的文件方法或?qū)傩?/div>

文件的字節(jié)和Unicode

Python文件的默認(rèn)操作是“文本模式”，也就是說，你需要處理Python的字符串（即Unicode）。它與“二進(jìn)制模式”相對，文件模式加一個b。我們來看上一節(jié)的文件（UTF-8編碼、包含非ASCII字符）：

In [230]: with open(path) as f:
   .....:     chars = f.read(10)

In [231]: chars
Out[231]: 'Sue?a el r'

UTF-8是長度可變的Unicode編碼，所以當(dāng)我從文件請求一定數(shù)量的字符時，Python會從文件讀取足夠多（可能少至10或多至40字節(jié)）的字節(jié)進(jìn)行解碼。如果以“rb”模式打開文件，則讀取確切的請求字節(jié)數(shù)：

In [232]: with open(path, 'rb') as f:
   .....:     data = f.read(10)

In [233]: data
Out[233]: b'Sue\xc3\xb1a el '

取決于文本的編碼，你可以將字節(jié)解碼為str對象，但只有當(dāng)每個編碼的Unicode字符都完全成形時才能這么做：

In [234]: data.decode('utf8')
Out[234]: 'Sue?a el '

In [235]: data[:4].decode('utf8')
---------------------------------------------------------------------------
UnicodeDecodeError                        Traceback (most recent call last)
<ipython-input-235-300e0af10bb7> in <module>()
----> 1 data[:4].decode('utf8')
UnicodeDecodeError: 'utf-8' codec can't decode byte 0xc3 in position 3: unexpecte
d end of data

文本模式結(jié)合了open的編碼選項，提供了一種更方便的方法將Unicode轉(zhuǎn)換為另一種編碼：

In [236]: sink_path = 'sink.txt'

In [237]: with open(path) as source:
   .....:     with open(sink_path, 'xt', encoding='iso-8859-1') as sink:
   .....:         sink.write(source.read())

In [238]: with open(sink_path, encoding='iso-8859-1') as f:
   .....:     print(f.read(10))
Sue?a el r

注意，不要在二進(jìn)制模式中使用seek。如果文件位置位于定義Unicode字符的字節(jié)的中間位置，讀取后面會產(chǎn)生錯誤：

In [240]: f = open(path)

In [241]: f.read(5)
Out[241]: 'Sue?a'

In [242]: f.seek(4)
Out[242]: 4

In [243]: f.read(1)
---------------------------------------------------------------------------
UnicodeDecodeError                        Traceback (most recent call last)
<ipython-input-243-7841103e33f5> in <module>()
----> 1 f.read(1)
/miniconda/envs/book-env/lib/python3.6/codecs.py in decode(self, input, final)
    319         # decode input (taking the buffer into account)
    320         data = self.buffer + input
--> 321         (result, consumed) = self._buffer_decode(data, self.errors, final
)
    322         # keep undecoded input until the next call
    323         self.buffer = data[consumed:]
UnicodeDecodeError: 'utf-8' codec can't decode byte 0xb1 in position 0: invalid s
tart byte

In [244]: f.close()

如果你經(jīng)常要對非ASCII字符文本進(jìn)行數(shù)據(jù)分析，通曉Python的Unicode功能是非常重要的。更多內(nèi)容，參閱Python官方文檔。

3.4 結(jié)論

我們已經(jīng)學(xué)過了Python的基礎(chǔ)、環(huán)境和語法，接下來學(xué)習(xí)NumPy和Python的面向數(shù)組計算。

---

第1章 準(zhǔn)備工作
第2章 Python語法基礎(chǔ)，IPython和Jupyter
第3章 Python的數(shù)據(jù)結(jié)構(gòu)、函數(shù)和文件
第4章 NumPy基礎(chǔ)：數(shù)組和矢量計算
第5章 pandas入門
第6章 數(shù)據(jù)加載、存儲與文件格式
第7章 數(shù)據(jù)清洗和準(zhǔn)備
第8章 數(shù)據(jù)規(guī)整：聚合、合并和重塑
第9章 繪圖和可視化
第10章 數(shù)據(jù)聚合與分組運算
第11章 時間序列
第12章 pandas高級應(yīng)用
第13章 Python建模庫介紹
第14章 數(shù)據(jù)分析案例
附錄A NumPy高級應(yīng)用
附錄B 更多關(guān)于IPython的內(nèi)容（完）

---