資料來(lái)源：https://github.com/BrambleXu/pydata-notebook
本章討論P(yáng)ython的內(nèi)置功能，這些功能本書(shū)會(huì)用到很多。雖然擴(kuò)展庫(kù)，比如pandas和Numpy，使處理大數(shù)據(jù)集很方便，但它們是和Python的內(nèi)置數(shù)據(jù)處理工具一同使用的。
我們會(huì)從Python最基礎(chǔ)的數(shù)據(jù)結(jié)構(gòu)開(kāi)始：元組、列表、字典和集合。然后會(huì)討論創(chuàng)建你自己的、可重復(fù)使用的Python函數(shù)。最后，會(huì)學(xué)習(xí)Python的文件對(duì)象，以及如何與本地硬盤(pán)交互。
3.1 數(shù)據(jù)結(jié)構(gòu)和序列
Python的數(shù)據(jù)結(jié)構(gòu)簡(jiǎn)單而強(qiáng)大。通曉它們才能成為熟練的Python程序員
元組
元組是一個(gè)固定長(zhǎng)度，不可改變的Python序列對(duì)象。創(chuàng)建元組的最簡(jiǎn)單方式，是用逗號(hào)分隔一列值：
In [1]: tup = 4, 5, 6
In [2]: tup
Out[2]: (4, 5, 6)
當(dāng)用復(fù)雜的表達(dá)式定義元組，最好將值放到圓括號(hào)內(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')
可以用方括號(hào)訪問(wèn)元組中的元素。和C、C++、JAVA等語(yǔ)言一樣，序列是從0開(kāi)始的：
In [8]: tup[0]
Out[8]: 's'
元組中存儲(chǔ)的對(duì)象可能是可變對(duì)象。一旦創(chuàng)建了元組，元組中的對(duì)象就不能修改了：
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
如果元組中的某個(gè)對(duì)象是可變的，比如列表，可以在原位進(jìn)行修改：
In [11]: tup[1].append(3)
In [12]: tup
Out[12]: ('foo', [1, 2, 3], True)
可以用加號(hào)運(yùn)算符將元組串聯(lián)起來(lái)：
In [13]: (4, None, 'foo') + (6, 0) + ('bar',)
Out[13]: (4, None, 'foo', 6, 0, 'bar')
元組乘以一個(gè)整數(shù)，像列表一樣，會(huì)將幾個(gè)元組的復(fù)制串聯(lián)起來(lái)：
In [14]: ('foo', 'bar') * 4
Out[14]: ('foo', 'bar', 'foo', 'bar', 'foo', 'bar', 'foo', 'bar')
對(duì)象本身并沒(méi)有被復(fù)制，只是引用了它。
拆分元組
如果你想將元組賦值給類(lèi)似元組的變量，Python會(huì)試圖拆分等號(hào)右邊的值：
In [15]: tup = (4, 5, 6)
In [16]: a, b, c = tup
In [17]: b
Out[17]: 5
即使含有元組的元組也會(huì)被拆分：
In [18]: tup = 4, 5, (6, 7)
In [19]: a, b, (c, d) = tup
In [20]: d
Out[20]: 7
使用這個(gè)功能，你可以很容易地替換變量的名字，其它語(yǔ)言可能是這樣：
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
變量拆分常用來(lái)迭代元組或列表序列：
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
另一個(gè)常見(jiàn)用法是從函數(shù)返回多個(gè)值。后面會(huì)詳解。
Python最近新增了更多高級(jí)的元組拆分功能，允許從元組的開(kāi)頭“摘取”幾個(gè)元素。它使用了特殊的語(yǔ)法 *rest，這也用在函數(shù)簽名中以抓取任意長(zhǎng)度列表的位置參數(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的名字不重要。作為慣用寫(xiě)法，許多Python程序員會(huì)將不需要的變量使用下劃線(xiàn)：
In [33]: a, b, *_ = values
tuple方法
因?yàn)樵M的大小和內(nèi)容不能修改，它的實(shí)例方法都很輕量。其中一個(gè)很有用的就是count（也適用于列表），它可以統(tǒng)計(jì)某個(gè)值得出現(xiàn)頻率：
In [34]: a = (1, 2, 2, 2, 3, 4, 2)
In [35]: a.count(2)
Out[35]: 4
列表
與元組對(duì)比，列表的長(zhǎng)度可變、內(nèi)容可以被修改。你可以用方括號(hào)定義，或用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']
列表和元組的語(yǔ)義接近，在許多函數(shù)中可以交叉使用。
list函數(shù)常用來(lái)在數(shù)據(jù)處理中實(shí)體化迭代器或生成器：
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']
插入的序號(hào)必須在0和列表長(zhǎng)度之間。
警告：與append相比，insert耗費(fèi)的計(jì)算量大，因?yàn)閷?duì)后續(xù)元素的引用必須在內(nèi)部遷移，以便為新元素提供空間。如果要在序列的頭部和尾部插入元素，你可能需要使用collections.deque，一個(gè)雙尾部隊(duì)列。
insert的逆運(yùn)算是pop，它移除并返回指定位置的元素：
In [49]: b_list.pop(2)
Out[49]: 'peekaboo'
In [50]: b_list
Out[50]: ['foo', 'red', 'baz', 'dwarf']
可以用remove去除某個(gè)值，remove會(huì)先尋找第一個(gè)值并除去：
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可以檢查列表是否包含某個(gè)值：
In [55]: 'dwarf' in b_list
Out[55]: True
在列表中檢查是否存在某個(gè)值遠(yuǎn)比字典和集合速度慢，因?yàn)镻ython是線(xiàn)性搜索列表中的值，但在字典和集合中，在同樣的時(shí)間內(nèi)還可以檢查其它項(xiàng)（基于哈希表）。
串聯(lián)和組合列表
與元組類(lèi)似，可以用加號(hào)將兩個(gè)列表串聯(lián)起來(lái):
In [57]: [4, None, 'foo'] + [7, 8, (2, 3)]
Out[57]: [4, None, 'foo', 7, 8, (2, 3)]
如果已經(jīng)定義了一個(gè)列表，用extend方法可以追加多個(gè)元素：
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)]
通過(guò)加法將列表串聯(lián)的計(jì)算量較大，因?yàn)橐陆ㄒ粋€(gè)列表，并且要復(fù)制對(duì)象。用extend追加元素，尤其是到一個(gè)大列表中，更為可取。因此：
everything = []
for chunk in list_of_lists:
everything.extend(chunk)
排序
你可以用sort函數(shù)將一個(gè)列表原地排序（不創(chuàng)建新的對(duì)象）：
In [61]: a = [7, 2, 5, 1, 3]
In [62]: a.sort()
In [63]: a
Out[63]: [1, 2, 3, 5, 7]
sort有一些選項(xiàng)，有時(shí)會(huì)很好用。其中之一是二級(jí)排序key，可以用這個(gè)key進(jìn)行排序。例如，我們可以按長(zhǎng)度對(duì)字符串進(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']
sort有一些選項(xiàng)，有時(shí)會(huì)很好用。其中之一是二級(jí)排序key，可以用這個(gè)key進(jìn)行排序。例如，我們可以按長(zhǎng)度對(duì)字符串進(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']
稍后，我們會(huì)學(xué)習(xí)sorted函數(shù)，它可以產(chǎn)生一個(gè)排好序的序列副本。
二分搜索和維護(hù)已排序的列表
bisect模塊支持二分查找，和向已排序的列表插入值。bisect.bisect可以找到插入值后仍保證排序的位置，bisect.insort是向這個(gè)位置插入值：
In [67]: import bisect
In [68]: c = [1, 2, 2, 2, 3, 4, 7]
In [69]: bisect.bisect(c, 2) #其目的在于查找該數(shù)值將會(huì)插入的位置并返回，而不會(huì)插入。
Out[69]: 4
In [70]: bisect.bisect(c, 5)
Out[70]: 6
In [71]: bisect.insort(c, 6) # 其插入的結(jié)果是不會(huì)影響原有的排序。
In [72]: c
Out[72]: [1, 2, 2, 2, 3, 4, 6, 7]
注意：
bisect模塊不會(huì)檢查列表是否已排好序，進(jìn)行檢查的話(huà)會(huì)耗費(fèi)大量計(jì)算。因此，對(duì)未排序的列表使用bisect不會(huì)產(chǎn)生錯(cuò)誤，但結(jié)果不一定正確。
切片
用切邊可以選取大多數(shù)序列類(lèi)型的一部分，切片的基本形式是在方括號(hào)中使用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é)果中包含的元素個(gè)數(shù)是stop - start。
start或stop都可以被省略，省略之后，分別默認(rèn)序列的開(kāi)頭和結(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]
在第二個(gè)冒號(hào)后面使用step，可以隔一個(gè)取一個(gè)元素：
In [81]: seq[::2]
Out[81]: [7, 3, 3, 6, 1]
一個(gè)聰明的方法是使用-1，它可以將列表或元組顛倒過(guò)來(lái)：
In [82]: seq[::-1]
Out[82]: [1, 0, 6, 5, 3, 6, 3, 2, 7]
序列函數(shù)
Python有一些有用的序列函數(shù)。
enumerate函數(shù)
迭代一個(gè)序列時(shí)，你可能想跟蹤當(dāng)前項(xiàng)的序號(hào)。手動(dòng)的方法可能是下面這樣：
i = 0
for value in collection:
# do something with value
i += 1 #x+=y 等價(jià)于x = x + y
因?yàn)檫@么做很常見(jiàn)，Python內(nèi)建了一個(gè)enumerate函數(shù)，可以返回(i, value)元組序列：
for i, value in enumerate(collection):
# do something with value
當(dāng)你索引數(shù)據(jù)時(shí)，使用enumerate``的一個(gè)好方法是計(jì)算序列（唯一的）dict`映射到位置的值：
In [83]: some_list = ['foo', 'bar', 'baz']
In [84]: mapping = {} #mapping對(duì)象將可哈希的值映射為任意對(duì)象。映射是可變對(duì)象。
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ù)可以從任意序列的元素返回一個(gè)新的排好序的列表：
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可以將多個(gè)列表、元組或其它序列成對(duì)組合成一個(gè)元組列表：
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可以處理任意多的序列，元素的個(gè)數(shù)取決于最短的序列：
In [93]: seq3 = [False, True]
In [94]: list(zip(seq1, seq2, seq3))
Out[94]: [('foo', 'one', False), ('bar', 'two', True)]
zip的常見(jiàn)用法之一是同時(shí)迭代多個(gè)序列，可能結(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
給出一個(gè)“被壓縮的”序列，zip可以被用來(lái)解壓序列。也可以當(dāng)作把行的列表轉(zhuǎn)換為列的列表。這個(gè)方法看起來(lái)有點(diǎ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可以從后向前迭代一個(gè)序列：
In [100]: list(reversed(range(10)))
Out[100]: [9, 8, 7, 6, 5, 4, 3, 2, 1, 0]
要記住reversed是一個(gè)生成器（后面詳細(xì)介紹），只有實(shí)體化（即列表或for循環(huán)）之后才能創(chuàng)建翻轉(zhuǎn)的序列。
字典
字典可能是Python最為重要的數(shù)據(jù)結(jié)構(gòu)。它更為常見(jiàn)的名字是哈希映射或關(guān)聯(lián)數(shù)組。它是鍵值對(duì)的大小可變集合，鍵和值都是Python對(duì)象。創(chuàng)建字典的方法之一是使用尖括號(hào)，用冒號(hào)分隔鍵和值：
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]}
你可以像訪問(wèn)列表或元組中的元素一樣，訪問(wèn)、插入或設(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]
你可以用檢查列表和元組是否包含某個(gè)值的方法，檢查字典中是否包含某個(gè)鍵：
In [107]: 'b' in d1
Out[107]: True
可以用del關(guān)鍵字或pop方法（返回值的同時(shí)刪除鍵）刪除值：
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是字典的鍵和值的迭代器方法。雖然鍵值對(duì)沒(méi)有順序，這兩個(gè)方法可以用相同的順序輸出鍵和值：
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方法可以將一個(gè)字典與另一個(gè)融合：
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的鍵的舊的值都會(huì)被舍棄。
用序列創(chuàng)建字典
常常，你可能想將兩個(gè)序列配對(duì)組合成字典。下面是一種寫(xiě)法：
mapping = {}
for key, value in zip(key_list, value_list):
mapping[key] = value
因?yàn)樽值浔举|(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}
后面會(huì)談到dict comprehensions，另一種構(gòu)建字典的優(yōu)雅方式。
默認(rèn)值
下面的邏輯很常見(jiàn)：
if key in some_dict:
value = some_dict[key]
else:
value = default_value #default_value就是默認(rèn)值
因此，dict的方法get和pop可以取默認(rèn)值進(jìn)行返回，上面的if-else語(yǔ)句可以簡(jiǎn)寫(xiě)成下面：
value = some_dict.get(key, default_value)
get默認(rèn)會(huì)返回None，如果不存在鍵，pop會(huì)拋出一個(gè)例外。關(guān)于設(shè)定值，常見(jiàn)的情況是在字典的值是屬于其它集合，如列表。例如，你可以通過(guò)首字母，將一個(gè)列表中的單詞分類(lèi)：
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方法就正是干這個(gè)的。前面的for循環(huán)可以改寫(xiě)為：
for word in words:
letter = word[0]
by_letter.setdefault(letter, []).append(word)
collections模塊有一個(gè)很有用的類(lèi)，defaultdict，它可以進(jìn)一步簡(jiǎn)化上面。傳遞類(lèi)型或函數(shù)以生成每個(gè)位置的默認(rèn)值：
from collections import defaultdict
by_letter = defaultdict(list)
for word in words:
by_letter[word[0]].append(word)
有效的鍵類(lèi)型
字典的值可以是任意Python對(duì)象，而鍵通常是不可變的標(biāo)量類(lèi)型（整數(shù)、浮點(diǎn)型、字符串）或元組（元組中的對(duì)象必須是不可變的）。這被稱(chēng)為“可哈希性”?？梢杂?code>hash函數(shù)檢測(cè)一個(gè)對(duì)象是否是可哈希的（可被用作字典的鍵）：
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}
集合
集合是無(wú)序的不可重復(fù)的元素的集合。你可以把它當(dāng)做字典，但是只有鍵沒(méi)有值?？梢杂脙煞N方式創(chuàng)建集合：通過(guò)set函數(shù)或使用尖括號(hào)set語(yǔ)句：
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}
集合支持合并、交集、差分和對(duì)稱(chēng)差等數(shù)學(xué)集合運(yùn)算。考慮兩個(gè)示例集合：
In [135]: a = {1, 2, 3, 4, 5}
In [136]: b = {3, 4, 5, 6, 7, 8}
合并是取兩個(gè)集合中不重復(fù)的元素。可以用union方法，或者|運(yùn)算符:
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}
交集的元素包含在兩個(gè)集合中?？梢杂胕ntersection或&運(yùn)算符：
In [139]: a.intersection(b)
Out[139]: {3, 4, 5}
In [140]: a & b
Out[140]: {3, 4, 5}
下表列出了常用的集合方法。
列表、集合和字典推導(dǎo)式
列表推導(dǎo)式是Python最受喜愛(ài)的特性之一。它允許用戶(hù)方便的從一個(gè)集合過(guò)濾元素，形成列表，在傳遞參數(shù)的過(guò)程中還可以修改元素。形式如下：
[expr for val in collection if condition]
它等同于下面的for循環(huán);
result = []
for val in collection:
if condition:
result.append(expr)
filter條件可以被忽略，只留下表達(dá)式就行。例如，給定一個(gè)字符串列表，我們可以過(guò)濾出長(zhǎng)度在2及以下的字符串，并將其轉(zhuǎn)換成大寫(xiě)：
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)式
假設(shè)我們有一個(gè)包含列表的列表，包含了一些英文名和西班牙名：
In [161]: all_data = [['John', 'Emily', 'Michael', 'Mary', 'Steven'],
.....: ['Maria', 'Juan', 'Javier', 'Natalia', 'Pilar']]
你可能是從一些文件得到的這些名字，然后想按照語(yǔ)言進(jìn)行分類(lèi)?，F(xiàn)在假設(shè)我們想用一個(gè)列表包含所有的名字，這些名字中包含兩個(gè)或更多的e?？梢杂胒or循環(huán)來(lái)做：
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)式的方法，將這些寫(xiě)在一起，如下所示：
In [162]: result = [name for names in all_data for name in names
.....: if name.count('e') >= 2]
In [163]: result
Out[163]: ['Steven']
