初入資料分析2

遍歷

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

for a,b,c in seq:

    print("a==",a,"b==",b,"c==",c)

a== 1 b== 2 c== 3
a== 4 b== 5 c== 6
a== 7 b== 8 c== 9

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

兩種形式

元組的拆分功能

Python最近新增了更多高階的元組拆分功能，允許從元組的開頭“摘取”幾個元素。它使用了特殊的語法*rest

，這也用在函式簽名中以抓取任意長度列表的位置引數：

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
In [34]:_

OUT[34]:[3, 4, 5]

tuple方法

因為元組的大小和內容不能修改，它的例項方法都很輕量。其中一個很有用的就是count

（也適用於列表），它可以統計某個值得出現頻率：

a=(1,2,2,3,4,2)

a.count(2)

3

列表

元組列表：

list函式常用來在資料處理中實體化迭代器或生成器：

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

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

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的列表當做完美的“多重集”資料結構。

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

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

在列表中檢查是否存在某個值遠比字典和集合速度慢，因為Python是線性搜尋列表中的值，但在字典和集合中，在同樣的時間內還可以檢查其它項（基於雜湊表）。

串聯和組合列表

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

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

如果已經定義了一個列表，用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)]

排序

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進行排序。例如，我們可以按長度對字串進行排序：

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

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

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

二分搜尋和維護已排序的列表

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模組不會檢查列表是否已排好序，進行檢查的話會耗費大量計算。因此，對未排序的列表使用bisect不會產生錯誤，但結果不一定正確。

切片

用切邊可以選取大多數序列型別的一部分，切片的基本形式是在方括號中使用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]

把seq切片3和4的位置改為6，3

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

start或stop都可以被省略，省略之後，分別預設序列的開頭和結尾：

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

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

在第二個冒號後面使用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]

序列函式

enumerate函式

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

i=0

collection=[1,2,3,4,5]

for value in collection:

    i+=1

    print(i)

1
2
3
4
5

 獲取下標位置

i=0

for i ,value in enumerate(collection):

    collection=[1,2,3,4,5]

    print(i)

0
1
2
3
4

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

與.sort的方法不同，sorted函式不僅可以排序列表，還可以排序字串，sorted函式可以接受和sort相同的引數。

zip函式

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

seq1=['foo','bar','baz']

seq2=['one','two','three']

zipped=zip(seq1,seq2)

zipped

<zip at 0x24f82eb1988>

list(zipped)

[('foo', 'one'), ('bar', 'two'), ('baz', 'three')]

zip可以處理任意多的序列，元素的個數取決於最短的序列（注意： ('baz', 'three')不見了）：

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

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

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

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

seq1=['foo','bar','baz']

seq2=['one','two','three']

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可以被用來解壓序列。也可以當作把行的列表轉換為列的列表。這個方法看起來有點神奇：

pitchers=[('Nolan','Ryan'),('Roer','Clemens'),('Schilling','Curt')]

first_names,last_names=zip(*pitchers)

first_names

('Nolan', 'Roer', 'Schilling')

last_names

('Ryan', 'Clemens', 'Curt')

 reversed函式

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

list(reversed(range(10)))

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

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

字典

字典可能是Python最為重要的資料結構。它更為常見的名字是雜湊對映或關聯陣列。它是鍵值對的大小可變集合，鍵和值都是Python物件。建立字典的方法之一是使用尖括號，用冒號分隔鍵和值：

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

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

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

d1[7]='an integer'

d1

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

d1['b']

[1, 2, 3, 4]

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

'b' in d1

True

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

d1

{'a': 'some value',
 'b': [1, 2, 3, 4],
 7: 'an integer',
 5: 'some value',
 'dummy': 'another value'}

d1['dummy']='some value'

d1

{'a': 'some value',
 'b': [1, 2, 3, 4],
 7: 'an integer',
 5: 'some value',
 'dummy': 'some value'}

del d1[5]

d1

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

ret = d1.pop('dummy')

ret

'some value'

d1

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

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

list(d1.keys())

['a', 'b', 7]

list(d1.values())

['some value', [1, 2, 3, 4], 'an integer']

用update方法可以將一個字典與另一個融合：（update方法是原地改變字典，因此任何傳遞給update的鍵的舊的值都會被捨棄。） 

d1.update({'b':'foo','c':12})

d1

{'a': 'some value', 'b': 'foo', 7: 'an integer', 'c': 12}

 用序列建立字典

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

mapping={}

key_list=[1,2,3]

value_list=[4,5,6]

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

    mapping[key]=value

print(mapping)

{1: 4, 2: 5, 3: 6}

 因為字典本質上是2元元組的集合，dict可以接受2元元組的列表：（後面會談到dict comprehensions，另一種構建字典的優雅方式。）附：reversed是倒序排列

mapping=dict(zip(range(5),reversed(range(5))))

mapping

{0: 4, 1: 3, 2: 2, 3: 1, 4: 0}

預設值

some_dict={'ren':6}

default_value=5

if key in some_dict:

    value=some_dict[key]

else:

    value=default_value

    

print(value)

5

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

value=some_dict.get(value,default_value)

value

5

插入一個分類程式碼

words=['apple','bat','bar','atom','book']

by_letter={}

for word in words:

    letter=word[0]

    if letter not in by_letter:

#         print(by_letter)

        by_letter[letter]=[word]

#         print(by_letter)

    else:

        by_letter[letter].append(word)

        print(by_letter)

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

by_letter

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

setdefault方法就正是幹這個的。前面的for迴圈可以改寫為：

for word in words:

    letter = word[0]

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

by_letter

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

有效的鍵型別

字典的值可以是任意Python物件，而鍵通常是不可變的標量型別（整數、浮點型、字串）或元組（元組中的物件必須是不可變的）。這被稱為“可雜湊性”。可以用hash函式檢測一個物件是否是可雜湊的（可被用作字典的鍵）：【說的蠻複雜的，其實就是判斷他的‘不可變型別’】

hash('string')

-5056716542471840635

hash((1,2,(3,4)))

-2725224101759650258

hash((1,2,[2,3]))

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-19-576218ff90d3> in <module>()
----> 1 hash((1,2,[2,3]))

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語句：

set([2,2,2,1,3,3])

{1, 2, 3}

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

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

a={1,2,3,4,5}

b={3,4,5,6,7,8,}

a.union(b)

{1, 2, 3, 4, 5, 6, 7, 8}

a|b

{1, 2, 3, 4, 5, 6, 7, 8}

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

a.intersection(b)

{3, 4, 5}

a&b

{3, 4, 5}

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

my_data=[1,2,3,4]

my_set={tuple(my_data)}

my_set

{(1, 2, 3, 4)}

列表、集合和字典推導式

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

collection=[1,2,3]

​

# result =

[val for val in collection if val>2]

[3]

是該形式的簡化

collection=[1,2,3]

result = []
for val in collection:
    if val>2:
        result.append(val)
print(result)
[3]

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

strings=['a','as','bat','car','dove','python']

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

['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}

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

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

collection={'ren':5,'wei':6}

dict_comp={'wei':7 for value in collection if 'wei' in collection}

dict_comp

{'wei': 7}

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

set_comp = {expr for value in collection if condition}

collection={'a','ab','cd'}

{x for x in collection if len(x)>1}

{'ab', 'cd'}

與列表推導式類似，集合與字典的推導也很方便，而且使程式碼的讀寫都很容易。來看前面的字串列表。假如我們只想要字串的長度，用集合推導式的方法非常方便：（遍歷集合的長度【注：集合有互已性】）

strings=['a','as','bat','car','dove','python']
unique_lengths={len(x) for x in strings} 

unique_lengths

{1, 2, 3, 4, 6}

簡化寫法：

set(map(len,strings))
{1, 2, 3, 4, 6}

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

loc_mapping={val:index for index,val in enumerate(strings)}

loc_mapping

{'a': 0, 'as': 1, 'bat': 2, 'car': 3, 'dove': 4, 'python': 5}

巢狀列表推導式

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

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

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

all_data = [['John', 'Emily', 'Michael', 'Mary', 'Steven'],

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

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

result

['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)

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

[[x for x in tup] for tup in some_tuples]

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

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

3.2 函式

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

函式使用def關鍵字宣告，用return關鍵字返回值：

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

函式可以有一些位置引數（positional）和一些關鍵字引數（keyword）。關鍵字引數通常用於指定預設值或可選引數。在上面的函式中，x和y是位置引數，而z則是關鍵字引數。也就是說，該函式可以下面這兩種方式進行呼叫：

def my_function(x,y,z=1.5):

    if z>1:

        return z*(x+y)

    else:

        return z/(x+y)

my_function(5,5,1)

0.1

my_function(5,5)

15.0

函式引數的主要限制在於：關鍵字引數必須位於位置引數（如果有的話）之後。你可以任何順序指定關鍵字引數。也就是說，你不用死記硬背函式引數的順序，只要記得它們的名字就可以了。

筆記：也可以用關鍵字傳遞位置引數。前面的例子，也可以寫為：

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

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

名稱空間、作用域，和區域性函式

函式可以訪問兩種不同作用域中的變數：全域性（global）和區域性（local）。Python有一種更科學的用於描述變數作用域的名稱，即名稱空間（namespace）。任何在函式中賦值的變數預設都是被分配到區域性名稱空間（local namespace）中的。區域性名稱空間是在函式被呼叫時建立的，函式引數會立即填入該名稱空間。在函式執行完畢之後，區域性名稱空間就會被銷燬（會有一些例外的情況，具體請參見後面介紹閉包的那一節）。看看下面這個函式：

def func():

    a=[]

    for i in range(5):

        a.append(i)

    return a

func()

[0, 1, 2, 3, 4]

呼叫func()之後，首先會創建出空列表a，然後新增5個元素，最後a會在該函式退出的時候被銷燬。假如我們像下面這樣定義a：

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

雖然可以在函式中對全域性變數進行賦值操作，但是那些變數必須用global關鍵字宣告成全域性的才行：

a=None

def bind_a_variable():

    global a

    a=[]

bind_a_variable()

print(a)

[]

注意：不要頻繁使用global關鍵字。因為全域性變數一般是用於存放系統的某些狀態的。如果你發現自己用了很多，那可能就說明得要來點兒面向物件程式設計了（即使用類）。

返回多個值

函式可以返回多個值。下面是一個簡單的例子：

def f():

    a=5

    b=6

    c=7

    return a,b,c

a,b,c=f()

f()

(5, 6, 7)

在資料分析和其他科學計算應用中，你會發現自己常常這麼幹。該函式其實只返回了一個物件，也就是一個元組，最後該元組會被拆包到各個結果變數中。在上面的例子中，我們還可以這樣寫：

return_value = f()

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

def f():

    a=5

    b=6

    c=7

    return{'a':a,'b':b,'c':c}

f()

{'a': 5, 'b': 6, 'c': 7}

取決於工作內容，第二種方法可能很有用。

函式也是物件

由於Python函式都是物件，因此，在其他語言中較難表達的一些設計思想在Python中就要簡單很多了。假設我們有下面這樣一個字串陣列，希望對其進行一些資料清理工作並執行一堆轉換：

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

不管是誰，只要處理過由使用者提交的調查資料，就能明白這種亂七八糟的資料是怎麼一回事。為了得到一組能用於分析工作的格式統一的字串，需要做很多事情：去除空白符、刪除各種標點符號、正確的大寫格式等。做法之一是使用內建的字串方法和正則表示式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

clean_strings(states)

['Alabama',
 'Georgia',
 'Georgia',
 'Georgia',
 'Florida',
 'South   Carolina',
 'West Virginia']

其實還有另外一種不錯的辦法：將需要在一組給定字串上執行的所有運算做成一個列表（這個不太懂，先拿小本本記下來）：

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

clean_strings(states, clean_ops)

['Alabama',
 'Georgia',
 'Georgia',
 'Georgia',
 'Florida',
 'South   Carolina',
 'West Virginia']

這種多函式模式使你能在很高的層次上輕鬆修改字串的轉換方式。此時的clean_strings也更具可複用性！

還可以將函式用作其他函式的引數，比如內建的map函式，它用於在一組資料上應用一個函式：

for x in map(remove_punctuation,states):

    print(x)

   Alabama 
Georgia
Georgia
georgia
FlOrIda
south   carolina
West virginia

匿名（lambda）函式

Python支援一種被稱為匿名的、或lambda函式。它僅由單條語句組成，該語句的結果就是返回值。它是通過lambda關鍵字定義的，這個關鍵字沒有別的含義，僅僅是說“我們正在宣告的是一個匿名函式”。

def short_function(x):
    return x*2
equiv_anon=lambda x:x*2

本書其餘部分一般將其稱為lambda函式。它們在資料分析工作中非常方便，因為你會發現很多資料轉換函式都以函式作為引數的。直接傳入lambda函式比編寫完整函式宣告要少輸入很多字（也更清晰），甚至比將lambda函式賦值給一個變數還要少輸入很多字。看看下面這個簡單得有些傻的例子：

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)

[8, 0, 2, 10, 12]

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

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

strings=['foo','caard','bar','aaaa','abab']

strings.sort(key=lambda x :len(set(list(x))))

strings

['aaaa', 'foo', 'abab', 'bar', 'caard']

筆記：lambda函式之所以會被稱為匿名函式，與def宣告的函式不同，原因之一就是這種函式物件本身是沒

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

有提供名稱name屬性。

柯里化：部分引數應用

柯里化（currying）是一個有趣的計算機科學術語，它指的是通過“部分引數應用”（partial argument application）從現有函式派生出新函式的技術。例如，假設我們有一個執行兩數相加的簡單函式：

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

通過這個函式，我們可以派生出一個新的只有一個引數的函式——add_five，它用於對其引數加5：

add_five=lambda y:add_numbers(5,y)

add_numbers的第二個引數稱為“柯里化的”（curried）。這裡沒什麼特別花哨的東西，因為我們其實就只是定義了一個可以呼叫現有函式的新函式而已。內建的functools模組可以用partial函式將此過程簡化：

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

生成器

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

for key in some_dict:

    print(key)

a
b
c

當你編寫for key in some_dict時，Python直譯器首先會嘗試從some_dict建立一個迭代器：

迭代器是一種特殊物件，它可以在諸如for迴圈之類的上下文中向Python直譯器輸送物件。大部分能接受列表之類的物件的方法也都可以接受任何可迭代物件。比如min、max、sum等內建方法以及list、tuple等型別構造器：

dict_iterator=iter(some_dict)

dict_iterator

<dict_keyiterator at 0x20c01956f48>

list(dict_iterator)

['a', 'b', 'c']

生成器（generator）是構造新的可迭代物件的一種簡單方式。一般的函式執行之後只會返回單個值，而生成器則是以延遲的方式返回一個值序列，即每返回一個值之後暫停，直到下一個值被請求時再繼續。要建立一個生成器，只需將函式中的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

呼叫該生成器時，沒有任何程式碼會被立即執行

gen=squares()

gen

<generator object squares at 0x0000020C01983EB8>

直到你從該生成器中請求元素時，它才會開始執行其程式碼：

for x in gen:

    print(x,end=" ")

Generating squares from 1 to 100
1 4 9 16 25 36 49 64 81 100 

生成器表示式

另一種更簡潔的構造生成器的方法是使用生成器表示式（generator expression）。這是一種類似於列表、字典、集合推導式的生成器。其建立方式為，把列表推導式兩端的方括號改成圓括號：

gen=(x**2 for x in range(100))

gen

<generator object <genexpr> at 0x0000020C01972F68>

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

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

生成器表示式也可以取代列表推導式，作為函式引數：

sum(x**2 for x in range(100))

328350

dict((i,i **2) for i in range(5))

{0: 0, 1: 1, 2: 4, 3: 9, 4: 16}

itertools模組

標準庫itertools模組中有一組用於許多常見資料演算法的生成器。例如，groupby可以接受任何序列和一個函式。它根據函式的返回值對序列中的連續元素進行分組。下面是一個例子：

import itertools

first_letter=lambda x : x[0]

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

for letter,names in itertools.groupby(names,first_letter):

    print(letter,list(names))

A ['Alan', 'Adam']
W ['Wes', 'Will']
A ['Albert']
S ['Steven']

表3-2中列出了一些我經常用到的itertools函式。建議參閱Python官方文件，進一步學習。

錯誤和異常處理

優雅地處理Python的錯誤和異常是構建健壯程式的重要部分。在資料分析中，許多函式函式只用於部分輸入。例如，Python的float函式可以將字串轉換成浮點數，但輸入有誤時，有ValueError錯誤：

float('1.2345')

1.2345

float('something')

---------------------------------------------------------------------------
ValueError                                Traceback (most recent call last)
<ipython-input-252-2649e4ade0e6> in <module>()
----> 1 float('something')

ValueError: could not convert string to float: 'something'

假如想優雅地處理float的錯誤，讓它返回輸入值。我們可以寫一個函式，在try/except中呼叫float：

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

當float(x)丟擲異常時，才會執行except的部分：

attempt_float('1.2345')

1.2345

attempt_float('something')

'something'

你可能注意到float丟擲的異常不僅是ValueError：

float((1,2))

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-256-a101b3a3d6cd> in <module>()
----> 1 float((1,2))

TypeError: float() argument must be a string or a number, not 'tuple'

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

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

然後有：

attempt_float((1,2))

---------------------------------------------------------------------------
TypeError                                 Traceback (most recent call last)
<ipython-input-258-102527222085> in <module>()
----> 1 attempt_float((1,2))

<ipython-input-257-6209ddecd2b5> 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

attempt_float((1,2))

(1, 2)

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

f=open(path,'w')
try:
    write_to_file(f)
finally:
    f.close()

這裡，檔案處理f總會被關閉。相似的，你可以用else讓只在try部分成功的情況下，才執行程式碼：

f = open(path, 'w')

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

IPython的異常

如果是在%run一個指令碼或一條語句時丟擲異常，IPython預設會列印完整的呼叫棧（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標準直譯器的極大優點。你可以用魔術命令%xmode，從Plain（與Python標準直譯器相同）到Verbose（帶有函式的引數值）控制文字顯示的數量。後面可以看到，發生錯誤之後，（用%debug或%pdb magics）可以進入stack進行事後除錯。

3.3 檔案和作業系統

本書的程式碼示例大多使用諸如pandas.read_csv之類的高階工具將磁碟上的資料檔案讀入Python資料結構。但我們還是需要了解一些有關Python檔案處理方面的基礎知識。好在它本來就很簡單，這也是Python在文字和檔案處理方面的如此流行的原因之一。

為了開啟一個檔案以便讀寫，可以使用內建的open函式以及一個相對或絕對的檔案路徑：

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

In [208]: f = open(path)

預設情況下，檔案是以只讀模式（'r'）開啟的。然後，我們就可以像處理列表那樣來處理這個檔案控制代碼f了，比如對行進行迭代：

for line in f:
    pass

從檔案中取出的行都帶有完整的行結束符（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建立檔案物件，一定要用close關閉它。關閉檔案可以返回作業系統資源：

In [211]: f.close()

用with語句可以可以更容易地清理開啟的檔案：

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

這樣可以在退出程式碼塊時，自動關閉檔案。

如果輸入f =open(path,'w')，就會有一個新檔案被建立在examples/segismundo.txt，並覆蓋掉該位置原來的任何資料。另外有一個x檔案模式，它可以建立可寫的檔案，但是如果檔案路徑存在，就無法建立。表3-3列出了所有的讀/寫模式。

對於可讀檔案，一些常用的方法是read、seek和tell。read會從檔案返回字元。字元的內容是由檔案的編碼決定的（如UTF-8），如果是二進位制模式開啟的就是原始位元組：

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模式會將檔案控制代碼的位置提前，提前的數量是讀取的位元組數。tell可以給出當前的位置：

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

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

儘管我們從檔案讀取了10個字元，位置卻是11，這是因為用預設的編碼用了這麼多位元組才解碼了這10個字元。你可以用sys模組檢查預設的編碼：

In [219]: import sys

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

seek將檔案位置更改為檔案中的指定位元組：

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

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

最後，關閉檔案：

In [223]: f.close()

In [224]: f2.close()

向檔案寫入，可以使用檔案的write或writelines方法。例如，我們可以建立一個無空行版的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']

檔案的位元組和Unicode

Python檔案的預設操作是“文字模式”，也就是說，你需要處理Python的字串（即Unicode）。它與“二進位制模式”相對，檔案模式加一個b。我們來看上一節的檔案（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編碼，所以當我從檔案請求一定數量的字元時，Python會從檔案讀取足夠多（可能少至10或多至40位元組）的位元組進行解碼。如果以“rb”模式開啟檔案，則讀取確切的請求位元組數：

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

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

取決於文字的編碼，你可以將位元組解碼為str物件，但只有當每個編碼的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

文字模式結合了open的編碼選項，提供了一種更方便的方法將Unicode轉換為另一種編碼：

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

注意，不要在二進位制模式中使用seek。如果檔案位置位於定義Unicode字元的位元組的中間位置，讀取後面會產生錯誤：

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()