函數(shù)式編程指引?

迭代器?

我會(huì)從 Python 的一個(gè)語(yǔ)言特性， 編寫函數(shù)式風(fēng)格程序的重要基石開(kāi)始說(shuō)起：迭代器。

迭代器是一個(gè)表示數(shù)據(jù)流的對(duì)象；這個(gè)對(duì)象每次只返回一個(gè)元素。Python 迭代器必須支持 __next__() 方法；這個(gè)方法不接受參數(shù)，并總是返回?cái)?shù)據(jù)流中的下一個(gè)元素。如果數(shù)據(jù)流中沒(méi)有元素，__next__() 會(huì)拋出 StopIteration 異常。迭代器未必是有限的；完全有理由構(gòu)造一個(gè)輸出無(wú)限數(shù)據(jù)流的迭代器。

內(nèi)置的 iter() 函數(shù)接受任意對(duì)象并試圖返回一個(gè)迭代器來(lái)輸出對(duì)象的內(nèi)容或元素，并會(huì)在對(duì)象不支持迭代的時(shí)候拋出 TypeError 異常。Python 有幾種內(nèi)置數(shù)據(jù)類型支持迭代，最常見(jiàn)的就是列表和字典。如果一個(gè)對(duì)象能生成迭代器，那么它就會(huì)被稱作 iterable。

你可以手動(dòng)試驗(yàn)迭代器的接口。

>>> L = [1, 2, 3]
>>> it = iter(L)
>>> it  
<...iterator object at ...>
>>> it.__next__()  # same as next(it)
1
>>> next(it)
2
>>> next(it)
3
>>> next(it)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
StopIteration
>>>

Python 有不少要求使用可迭代的對(duì)象的地方，其中最重要的就是 for 表達(dá)式。在表達(dá)式 for X in Y，Y 要么自身是一個(gè)迭代器，要么能夠由 iter() 創(chuàng)建一個(gè)迭代器。以下兩種表達(dá)是等價(jià)的:

for i in iter(obj):
    print(i)

for i in obj:
    print(i)

可以用 list() 或 tuple() 這樣的構(gòu)造函數(shù)把迭代器具體化成列表或元組:

>>> L = [1, 2, 3]
>>> iterator = iter(L)
>>> t = tuple(iterator)
>>> t
(1, 2, 3)

序列的解壓操作也支持迭代器：如果你知道一個(gè)迭代器能夠返回 N 個(gè)元素，你可以把他們解壓到有 N 個(gè)元素的元組:

>>> L = [1, 2, 3]
>>> iterator = iter(L)
>>> a, b, c = iterator
>>> a, b, c
(1, 2, 3)

像 max() 和 min() 這樣的內(nèi)置函數(shù)可以接受單個(gè)迭代器參數(shù)，然后返回其中最大或者最小的元素。"in" 和 "not in" 操作也支持迭代器：如果能夠在迭代器 iterator 返回的數(shù)據(jù)流中找到 X 的話，則``X in iterator`` 為真。很顯然，如果迭代器是無(wú)限的，這么做你就會(huì)遇到問(wèn)題；max() 和 min() 永遠(yuǎn)也不會(huì)返回；如果元素 X 也不出現(xiàn)在數(shù)據(jù)流中，"in" 和 "not in" 操作同樣也永遠(yuǎn)不會(huì)返回。

注意你只能在迭代器中順序前進(jìn)；沒(méi)有獲取前一個(gè)元素的方法，除非重置迭代器，或者重新復(fù)制一份。迭代器對(duì)象可以提供這些額外的功能，但迭代器協(xié)議只明確了 __next__() 方法。函數(shù)可能因此而耗盡迭代器的輸出，如果你要對(duì)同樣的數(shù)據(jù)流做不同的操作，你必須重新創(chuàng)建一個(gè)迭代器。

>>> m = {'Jan': 1, 'Feb': 2, 'Mar': 3, 'Apr': 4, 'May': 5, 'Jun': 6,
...      'Jul': 7, 'Aug': 8, 'Sep': 9, 'Oct': 10, 'Nov': 11, 'Dec': 12}
>>> for key in m:
...     print(key, m[key])
Jan 1
Feb 2
Mar 3
Apr 4
May 5
Jun 6
Jul 7
Aug 8
Sep 9
Oct 10
Nov 11
Dec 12

>>> L = [('Italy', 'Rome'), ('France', 'Paris'), ('US', 'Washington DC')]
>>> dict(iter(L))
{'Italy': 'Rome', 'France': 'Paris', 'US': 'Washington DC'}

for line in file:
    # do something for each line
    ...

S = {2, 3, 5, 7, 11, 13}
for i in S:
    print(i)

生成器表達(dá)式和列表推導(dǎo)式?

迭代器的輸出有兩個(gè)很常見(jiàn)的使用方式，1) 對(duì)每一個(gè)元素執(zhí)行操作，2) 選擇一個(gè)符合條件的元素子集。比如，給定一個(gè)字符串列表，你可能想去掉每個(gè)字符串尾部的空白字符，或是選出所有包含給定子串的字符串。

列表推導(dǎo)式和生成器表達(dá)時(shí)（簡(jiǎn)寫："listcomps" 和 "genexps"）讓這些操作更加簡(jiǎn)明，這個(gè)形式借鑒自函數(shù)式程序語(yǔ)言 Haskell（https://www.haskell.org/）。你可以用以下代碼去掉一個(gè)字符串流中的所有空白字符:

line_list = ['  line 1\n', 'line 2  \n', ...]

# Generator expression -- returns iterator
stripped_iter = (line.strip() for line in line_list)

# List comprehension -- returns list
stripped_list = [line.strip() for line in line_list]

你可以加上條件語(yǔ)句 "if" 來(lái)選取特定的元素:

stripped_list = [line.strip() for line in line_list
                 if line != ""]

通過(guò)列表推導(dǎo)式，你會(huì)獲得一個(gè) Python 列表；stripped_list 就是一個(gè)包含所有結(jié)果行的列表，并不是迭代器。 生成器表達(dá)式會(huì)返回一個(gè)迭代器，它在必要的時(shí)候計(jì)算結(jié)果，避免一次性生成所有的值。 這意味著，如果迭代器返回一個(gè)無(wú)限數(shù)據(jù)流或者大量的數(shù)據(jù)，列表推導(dǎo)式就不太好用了。 這種情況下生成器表達(dá)式會(huì)更受青睞。

生成器表達(dá)式兩邊使用圓括號(hào) ("()") ，而列表推導(dǎo)式則使用方括號(hào) ("[]")。生成器表達(dá)式的形式為:

( expression for expr in sequence1
             if condition1
             for expr2 in sequence2
             if condition2
             for expr3 in sequence3 ...
             if condition3
             for exprN in sequenceN
             if conditionN )

再次說(shuō)明，列表推導(dǎo)式只有兩邊的括號(hào)不一樣（方括號(hào)而不是圓括號(hào)）。

這些生成用于輸出的元素會(huì)成為 expression 的后繼值。其中 if 語(yǔ)句是可選的；如果給定的話 expression 只會(huì)在符合條件時(shí)計(jì)算并加入到結(jié)果中。

生成器表達(dá)式總是寫在圓括號(hào)里面，不過(guò)也可以算上調(diào)用函數(shù)時(shí)用的括號(hào)。如果你想即時(shí)創(chuàng)建一個(gè)傳遞給函數(shù)的迭代器，可以這么寫:

obj_total = sum(obj.count for obj in list_all_objects())

其中 for...in 語(yǔ)句包含了將要遍歷的序列。這些序列并不必須同樣長(zhǎng)，因?yàn)樗鼈儠?huì)從左往右開(kāi)始遍歷，而 不是 同時(shí)執(zhí)行。對(duì)每個(gè) sequence1 中的元素，sequence2 會(huì)從頭開(kāi)始遍歷。sequence3 會(huì)對(duì)每個(gè) sequence1 和 sequence2 的元素對(duì)開(kāi)始遍歷。

換句話說(shuō)，列表推導(dǎo)式器是和下面的 Python 代碼等價(jià):

for expr1 in sequence1:
    if not (condition1):
        continue   # Skip this element
    for expr2 in sequence2:
        if not (condition2):
            continue   # Skip this element
        ...
        for exprN in sequenceN:
            if not (conditionN):
                continue   # Skip this element

            # Output the value of
            # the expression.

這說(shuō)明，如果有多個(gè) for...in 語(yǔ)句而沒(méi)有 if 語(yǔ)句，輸出結(jié)果的長(zhǎng)度就是所有序列長(zhǎng)度的乘積。如果你的兩個(gè)列表長(zhǎng)度為3，那么輸出的列表長(zhǎng)度就是9:

>>> seq1 = 'abc'
>>> seq2 = (1, 2, 3)
>>> [(x, y) for x in seq1 for y in seq2]  
[('a', 1), ('a', 2), ('a', 3),
 ('b', 1), ('b', 2), ('b', 3),
 ('c', 1), ('c', 2), ('c', 3)]

為了不讓 Python 語(yǔ)法變得含糊，如果 expression 會(huì)生成元組，那這個(gè)元組必須要用括號(hào)括起來(lái)。下面第一個(gè)列表推導(dǎo)式語(yǔ)法錯(cuò)誤，第二個(gè)則是正確的:

# Syntax error
[x, y for x in seq1 for y in seq2]
# Correct
[(x, y) for x in seq1 for y in seq2]

生成器?

生成器是一類用來(lái)簡(jiǎn)化編寫迭代器工作的特殊函數(shù)。普通的函數(shù)計(jì)算并返回一個(gè)值，而生成器返回一個(gè)能返回?cái)?shù)據(jù)流的迭代器。

毫無(wú)疑問(wèn)，你已經(jīng)對(duì)如何在 Python 和 C 中調(diào)用普通函數(shù)很熟悉了，這時(shí)候函數(shù)會(huì)獲得一個(gè)創(chuàng)建局部變量的私有命名空間。當(dāng)函數(shù)到達(dá) return 表達(dá)式時(shí)，局部變量會(huì)被銷毀然后把返回給調(diào)用者。之后調(diào)用同樣的函數(shù)時(shí)會(huì)創(chuàng)建一個(gè)新的私有命名空間和一組全新的局部變量。但是，如果在退出一個(gè)函數(shù)時(shí)不扔掉局部變量會(huì)如何呢？如果稍后你能夠從退出函數(shù)的地方重新恢復(fù)又如何呢？這就是生成器所提供的；他們可以被看成可恢復(fù)的函數(shù)。

這里有簡(jiǎn)單的生成器函數(shù)示例:

>>> def generate_ints(N):
...    for i in range(N):
...        yield i

任何包含了 yield 關(guān)鍵字的函數(shù)都是生成器函數(shù)；Python 的 bytecode 編譯器會(huì)在編譯的時(shí)候檢測(cè)到并因此而特殊處理。

當(dāng)你調(diào)用一個(gè)生成器函數(shù)，它并不會(huì)返回單獨(dú)的值，而是返回一個(gè)支持生成器協(xié)議的生成器對(duì)象。當(dāng)執(zhí)行 yield 表達(dá)式時(shí)，生成器會(huì)輸出 i 的值，就像 return 表達(dá)式一樣。yield 和 return 最大的區(qū)別在于，到達(dá) yield 的時(shí)候生成器的執(zhí)行狀態(tài)會(huì)掛起并保留局部變量。在下一次調(diào)用生成器 __next__() 方法的時(shí)候，函數(shù)會(huì)恢復(fù)執(zhí)行。

這里有一個(gè) generate_ints() 生成器的示例:

>>> gen = generate_ints(3)
>>> gen  
<generator object generate_ints at ...>
>>> next(gen)
0
>>> next(gen)
1
>>> next(gen)
2
>>> next(gen)
Traceback (most recent call last):
  File "stdin", line 1, in <module>
  File "stdin", line 2, in generate_ints
StopIteration

同樣，你可以寫出 for i in generate_ints(5)，或者 a, b, c = generate_ints(3)。

在生成器函數(shù)里面，return value 會(huì)觸發(fā)從 __next__() 方法拋出 StopIteration(value) 異常。一旦拋出這個(gè)異常，或者函數(shù)結(jié)束，處理數(shù)據(jù)的過(guò)程就會(huì)停止，生成器也不會(huì)再生成新的值。

你可以手動(dòng)編寫自己的類來(lái)達(dá)到生成器的效果，把生成器的所有局部變量作為實(shí)例的成員變量存儲(chǔ)起來(lái)。比如，可以這么返回一個(gè)整數(shù)列表：把 self.count 設(shè)為0，然后通過(guò) count`()。然而，對(duì)于一個(gè)中等復(fù)雜程度的生成器，寫出一個(gè)相應(yīng)的類可能會(huì)相當(dāng)繁雜。

包含在 Python 庫(kù)中的測(cè)試套件 Lib/test/test_generators.py 里有很多非常有趣的例子。這里是一個(gè)用生成器實(shí)現(xiàn)樹(shù)的遞歸中序遍歷示例。:

# A recursive generator that generates Tree leaves in in-order.
def inorder(t):
    if t:
        for x in inorder(t.left):
            yield x

        yield t.label

        for x in inorder(t.right):
            yield x

另外兩個(gè) test_generators.py 中的例子給出了 N 皇后問(wèn)題（在 NxN 的棋盤上放置 N 個(gè)皇后，任何一個(gè)都不能吃掉另一個(gè)），以及馬的遍歷路線（在NxN 的棋盤上給馬找出一條不重復(fù)的走過(guò)所有格子的路線）的解。

val = (yield i)

def counter(maximum):
    i = 0
    while i < maximum:
        val = (yield i)
        # If value provided, change counter
        if val is not None:
            i = val
        else:
            i += 1

>>> it = counter(10)  
>>> next(it)  
0
>>> next(it)  
1
>>> it.send(8)  
8
>>> next(it)  
9
>>> next(it)  
Traceback (most recent call last):
  File "t.py", line 15, in <module>
    it.next()
StopIteration

內(nèi)置函數(shù)?

我們可以看看迭代器常常用到的函數(shù)的更多細(xì)節(jié)。

Python 內(nèi)置的兩個(gè)函數(shù) map() 和 filter() 復(fù)制了生成器表達(dá)式的兩個(gè)特性:

map(f, iterA, iterB, ...) 返回一個(gè)遍歷序列的迭代器

f(iterA[0], iterB[0]), f(iterA[1], iterB[1]), f(iterA[2], iterB[2]), ....

>>>

>>> def upper(s):
...     return s.upper()

>>>

>>> list(map(upper, ['sentence', 'fragment']))
['SENTENCE', 'FRAGMENT']
>>> [upper(s) for s in ['sentence', 'fragment']]
['SENTENCE', 'FRAGMENT']

你當(dāng)然也可以用列表推導(dǎo)式達(dá)到同樣的效果。

filter(predicate, iter) 返回一個(gè)遍歷序列中滿足指定條件的元素的迭代器，和列表推導(dǎo)式的功能相似。 predicate （謂詞）是一個(gè)在特定條件下返回真值的函數(shù)；要使用函數(shù) filter()，謂詞函數(shù)必須只能接受一個(gè)參數(shù)。

>>> def is_even(x):
...     return (x % 2) == 0

>>> list(filter(is_even, range(10)))
[0, 2, 4, 6, 8]

這也可以寫成列表推導(dǎo)式:

>>> list(x for x in range(10) if is_even(x))
[0, 2, 4, 6, 8]

enumerate(iter, start=0) 計(jì)數(shù)可迭代對(duì)象中的元素，然后返回包含每個(gè)計(jì)數(shù)（從 start 開(kāi)始）和元素兩個(gè)值的元組。:

>>> for item in enumerate(['subject', 'verb', 'object']):
...     print(item)
(0, 'subject')
(1, 'verb')
(2, 'object')

enumerate() 常常用于遍歷列表并記錄達(dá)到特定條件時(shí)的下標(biāo):

f = open('data.txt', 'r')
for i, line in enumerate(f):
    if line.strip() == '':
        print('Blank line at line #%i' % i)

sorted(iterable, key=None, reverse=False) 會(huì)將 iterable 中的元素收集到一個(gè)列表中，然后排序并返回結(jié)果。其中 key 和 reverse 參數(shù)會(huì)傳遞給所創(chuàng)建列表的 sort() 方法。:

>>> import random
>>> # Generate 8 random numbers between [0, 10000)
>>> rand_list = random.sample(range(10000), 8)
>>> rand_list  
[769, 7953, 9828, 6431, 8442, 9878, 6213, 2207]
>>> sorted(rand_list)  
[769, 2207, 6213, 6431, 7953, 8442, 9828, 9878]
>>> sorted(rand_list, reverse=True)  
[9878, 9828, 8442, 7953, 6431, 6213, 2207, 769]

（對(duì)排序更詳細(xì)的討論可參見(jiàn) 排序指南。）

內(nèi)置函數(shù) any(iter) 和 all(iter) 會(huì)查看一個(gè)可迭代對(duì)象內(nèi)容的邏輯值。any() 在可迭代對(duì)象中任意一個(gè)元素為真時(shí)返回 True，而 all() 在所有元素為真時(shí)返回 True:

>>> any([0, 1, 0])
True
>>> any([0, 0, 0])
False
>>> any([1, 1, 1])
True
>>> all([0, 1, 0])
False
>>> all([0, 0, 0])
False
>>> all([1, 1, 1])
True

zip(iterA, iterB, ...) 從每個(gè)可迭代對(duì)象中選取單個(gè)元素組成列表并返回:

zip(['a', 'b', 'c'], (1, 2, 3)) =>
  ('a', 1), ('b', 2), ('c', 3)

它并不會(huì)在內(nèi)存創(chuàng)建一個(gè)列表并因此在返回前而耗盡輸入的迭代器；相反，只有在被請(qǐng)求的時(shí)候元組才會(huì)創(chuàng)建并返回。（這種行為的技術(shù)術(shù)語(yǔ)叫惰性計(jì)算，參見(jiàn) lazy evaluation.）

這個(gè)迭代器設(shè)計(jì)用于長(zhǎng)度相同的可迭代對(duì)象。如果可迭代對(duì)象的長(zhǎng)度不一致，返回的數(shù)據(jù)流的長(zhǎng)度會(huì)和最短的可迭代對(duì)象相同

zip(['a', 'b'], (1, 2, 3)) =>
  ('a', 1), ('b', 2)

然而，你應(yīng)該避免這種情況，因?yàn)樗袕母L(zhǎng)的迭代器中取出的元素都會(huì)被丟棄。這意味著之后你也無(wú)法冒著跳過(guò)被丟棄元素的風(fēng)險(xiǎn)來(lái)繼續(xù)使用這個(gè)迭代器。

itertools 模塊?

itertools 模塊包含很多常用的迭代器以及用來(lái)組合迭代器的函數(shù)。本節(jié)會(huì)用些小的例子來(lái)介紹這個(gè)模塊的內(nèi)容。

這個(gè)模塊里的函數(shù)大致可以分為幾類：

• 從已有的迭代器創(chuàng)建新的迭代器的函數(shù)。

• 接受迭代器元素作為參數(shù)的函數(shù)。

• 選取部分迭代器輸出的函數(shù)。

• 給迭代器輸出分組的函數(shù)。

itertools.count() =>
  0, 1, 2, 3, 4, 5, 6, 7, 8, 9, ...
itertools.count(10) =>
  10, 11, 12, 13, 14, 15, 16, 17, 18, 19, ...
itertools.count(10, 5) =>
  10, 15, 20, 25, 30, 35, 40, 45, 50, 55, ...

itertools.cycle([1, 2, 3, 4, 5]) =>
  1, 2, 3, 4, 5, 1, 2, 3, 4, 5, ...

itertools.repeat('abc') =>
  abc, abc, abc, abc, abc, abc, abc, abc, abc, abc, ...
itertools.repeat('abc', 5) =>
  abc, abc, abc, abc, abc

itertools.chain(['a', 'b', 'c'], (1, 2, 3)) =>
  a, b, c, 1, 2, 3

itertools.islice(range(10), 8) =>
  0, 1, 2, 3, 4, 5, 6, 7
itertools.islice(range(10), 2, 8) =>
  2, 3, 4, 5, 6, 7
itertools.islice(range(10), 2, 8, 2) =>
  2, 4, 6

itertools.tee( itertools.count() ) =>
   iterA, iterB

where iterA ->
   0, 1, 2, 3, 4, 5, 6, 7, 8, 9, ...

and   iterB ->
   0, 1, 2, 3, 4, 5, 6, 7, 8, 9, ...

itertools.starmap(os.path.join,
                  [('/bin', 'python'), ('/usr', 'bin', 'java'),
                   ('/usr', 'bin', 'perl'), ('/usr', 'bin', 'ruby')])
=>
  /bin/python, /usr/bin/java, /usr/bin/perl, /usr/bin/ruby

itertools.filterfalse(is_even, itertools.count()) =>
  1, 3, 5, 7, 9, 11, 13, 15, ...

def less_than_10(x):
    return x < 10

itertools.takewhile(less_than_10, itertools.count()) =>
  0, 1, 2, 3, 4, 5, 6, 7, 8, 9

itertools.takewhile(is_even, itertools.count()) =>
  0

itertools.dropwhile(less_than_10, itertools.count()) =>
  10, 11, 12, 13, 14, 15, 16, 17, 18, 19, ...

itertools.dropwhile(is_even, itertools.count()) =>
  1, 2, 3, 4, 5, 6, 7, 8, 9, 10, ...

itertools.compress([1, 2, 3, 4, 5], [True, True, False, False, True]) =>
   1, 2, 5

itertools.combinations([1, 2, 3, 4, 5], 2) =>
  (1, 2), (1, 3), (1, 4), (1, 5),
  (2, 3), (2, 4), (2, 5),
  (3, 4), (3, 5),
  (4, 5)

itertools.combinations([1, 2, 3, 4, 5], 3) =>
  (1, 2, 3), (1, 2, 4), (1, 2, 5), (1, 3, 4), (1, 3, 5), (1, 4, 5),
  (2, 3, 4), (2, 3, 5), (2, 4, 5),
  (3, 4, 5)

itertools.permutations([1, 2, 3, 4, 5], 2) =>
  (1, 2), (1, 3), (1, 4), (1, 5),
  (2, 1), (2, 3), (2, 4), (2, 5),
  (3, 1), (3, 2), (3, 4), (3, 5),
  (4, 1), (4, 2), (4, 3), (4, 5),
  (5, 1), (5, 2), (5, 3), (5, 4)

itertools.permutations([1, 2, 3, 4, 5]) =>
  (1, 2, 3, 4, 5), (1, 2, 3, 5, 4), (1, 2, 4, 3, 5),
  ...
  (5, 4, 3, 2, 1)

itertools.permutations('aba', 3) =>
  ('a', 'b', 'a'), ('a', 'a', 'b'), ('b', 'a', 'a'),
  ('b', 'a', 'a'), ('a', 'a', 'b'), ('a', 'b', 'a')

itertools.combinations_with_replacement([1, 2, 3, 4, 5], 2) =>
  (1, 1), (1, 2), (1, 3), (1, 4), (1, 5),
  (2, 2), (2, 3), (2, 4), (2, 5),
  (3, 3), (3, 4), (3, 5),
  (4, 4), (4, 5),
  (5, 5)

city_list = [('Decatur', 'AL'), ('Huntsville', 'AL'), ('Selma', 'AL'),
             ('Anchorage', 'AK'), ('Nome', 'AK'),
             ('Flagstaff', 'AZ'), ('Phoenix', 'AZ'), ('Tucson', 'AZ'),
             ...
            ]

def get_state(city_state):
    return city_state[1]

itertools.groupby(city_list, get_state) =>
  ('AL', iterator-1),
  ('AK', iterator-2),
  ('AZ', iterator-3), ...

where
iterator-1 =>
  ('Decatur', 'AL'), ('Huntsville', 'AL'), ('Selma', 'AL')
iterator-2 =>
  ('Anchorage', 'AK'), ('Nome', 'AK')
iterator-3 =>
  ('Flagstaff', 'AZ'), ('Phoenix', 'AZ'), ('Tucson', 'AZ')

functools 模塊?

Python 2.5 中的 functools 模塊包含了一些高階函數(shù)。 高階函數(shù) 接受一個(gè)或多個(gè)函數(shù)作為輸入，返回新的函數(shù)。 這個(gè)模塊中最有用的工具是 functools.partial() 函數(shù)。

對(duì)于用函數(shù)式風(fēng)格編寫的程序，有時(shí)你會(huì)希望通過(guò)給定部分參數(shù)，將已有的函數(shù)構(gòu)變形稱新的函數(shù)。考慮一個(gè) Python 函數(shù) f(a, b, c)；你希望創(chuàng)建一個(gè)和 f(1, b, c) 等價(jià)的新函數(shù) g(b, c)；也就是說(shuō)你給定了 f() 的一個(gè)參數(shù)的值。這就是所謂的“部分函數(shù)應(yīng)用”。

partial() 接受參數(shù) (function, arg1, arg2, ..., kwarg1=value1, kwarg2=value2)。它會(huì)返回一個(gè)可調(diào)用的對(duì)象，所以你能夠直接調(diào)用這個(gè)結(jié)果以使用給定參數(shù)的 function。

這里有一個(gè)很小但很現(xiàn)實(shí)的例子:

import functools

def log(message, subsystem):
    """Write the contents of 'message' to the specified subsystem."""
    print('%s: %s' % (subsystem, message))
    ...

server_log = functools.partial(log, subsystem='server')
server_log('Unable to open socket')

functools.reduce(func, iter, [initial_value]) 持續(xù)地在可迭代對(duì)象的所有元素上執(zhí)行操作，因此它不能夠用在無(wú)限的可迭代對(duì)象上。func 必須是一個(gè)接受兩個(gè)元素并返回一個(gè)值的函數(shù)。functools.reduce() 接受迭代器返回的前兩個(gè)元素 A 和 B 并計(jì)算 func(A, B) 。然后它會(huì)請(qǐng)求第三個(gè)元素，C，計(jì)算 func(func(A, B), C)，然后把這個(gè)結(jié)果再和第四個(gè)元素組合并返回，如此繼續(xù)下去直到消耗整個(gè)可迭代對(duì)象。如果輸入的可迭代對(duì)象完全不返回任何值，TypeError 異常就會(huì)拋出。如果提供了初值(initial value)，它會(huì)被用作起始值，也就是先計(jì)算 func(initial_value, A) 。:

>>> import operator, functools
>>> functools.reduce(operator.concat, ['A', 'BB', 'C'])
'ABBC'
>>> functools.reduce(operator.concat, [])
Traceback (most recent call last):
  ...
TypeError: reduce() of empty sequence with no initial value
>>> functools.reduce(operator.mul, [1, 2, 3], 1)
6
>>> functools.reduce(operator.mul, [], 1)
1

如果你在 functools.reduce() 中使用 operator.add()，你就會(huì)把可迭代對(duì)象中的所有元素加起來(lái).這種情況非常常見(jiàn), 所以 Python 有一個(gè)特殊的內(nèi)置函數(shù) sum():

>>> import functools, operator
>>> functools.reduce(operator.add, [1, 2, 3, 4], 0)
10
>>> sum([1, 2, 3, 4])
10
>>> sum([])
0

不過(guò), 對(duì)于很多使用 functools.reduce() 的情形, 使用明顯的 for 循環(huán)會(huì)更清晰:

import functools
# Instead of:
product = functools.reduce(operator.mul, [1, 2, 3], 1)

# You can write:
product = 1
for i in [1, 2, 3]:
    product *= i

一個(gè)相關(guān)的函數(shù)是 itertools.accumulate(iterable, func=operator.add) 。它執(zhí)行同樣的計(jì)算, 不過(guò)相對(duì)于只返回最終結(jié)果，accumulate() 會(huì)返回一個(gè)迭代器來(lái)輸出所有中間結(jié)果:

itertools.accumulate([1, 2, 3, 4, 5]) =>
  1, 3, 6, 10, 15

itertools.accumulate([1, 2, 3, 4, 5], operator.mul) =>
  1, 2, 6, 24, 120

小函數(shù)和 lambda 表達(dá)式?

編寫函數(shù)式風(fēng)格程序時(shí)，你會(huì)經(jīng)常需要很小的函數(shù)，作為謂詞函數(shù)或者以某種方式來(lái)組合元素。

如果合適的 Python 內(nèi)置的或者其他模塊中的函數(shù)，你就一點(diǎn)也不需要定義新的函數(shù):

stripped_lines = [line.strip() for line in lines]
existing_files = filter(os.path.exists, file_list)

如果不存在你需要的函數(shù)，你就必須自己編寫。一個(gè)編寫小函數(shù)的方式是使用 lambda 表達(dá)式。lambda 接受一組參數(shù)以及組合這些參數(shù)的表達(dá)式，它會(huì)創(chuàng)建一個(gè)返回表達(dá)式值的匿名函數(shù):

adder = lambda x, y: x+y

print_assign = lambda name, value: name + '=' + str(value)

另一種替代方案就是通常的使用 def 語(yǔ)句來(lái)定義函數(shù):

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

def print_assign(name, value):
    return name + '=' + str(value)

哪一種更受青睞呢？這是一個(gè)風(fēng)格問(wèn)題；我通常的做法是避免使用 lambda。

我這么偏好的一個(gè)原因是，lambda 能夠定義的函數(shù)非常受限。函數(shù)的結(jié)果必須能夠作為單獨(dú)的表達(dá)式來(lái)計(jì)算，這意味著你不能使用多路 if... elif... else 比較，或者 try... except 語(yǔ)句。如果你嘗試在 lambda 語(yǔ)句中做太多事情，你最終會(huì)把表達(dá)式過(guò)于復(fù)雜以至于難以閱讀。你能快速的說(shuō)出下面的代碼做了什么事情嗎？:

import functools
total = functools.reduce(lambda a, b: (0, a[1] + b[1]), items)[1]

你可以弄明白，不過(guò)要花上時(shí)間來(lái)理清表達(dá)式來(lái)搞清楚發(fā)生了什么。使用一個(gè)簡(jiǎn)短的嵌套的 def 語(yǔ)句可以讓情況變得更好:

import functools
def combine(a, b):
    return 0, a[1] + b[1]

total = functools.reduce(combine, items)[1]

如果我僅僅使用一個(gè) for 循環(huán)會(huì)更好:

total = 0
for a, b in items:
    total += b

或者使用內(nèi)置的 sum() 和一個(gè)生成器表達(dá)式:

total = sum(b for a, b in items)

許多使用 functools.reduce() 的情形可以更清晰地寫成 for 循環(huán)的形式。

Fredrik Lundh 曾經(jīng)建議以下一組規(guī)則來(lái)重構(gòu) lambda 的使用:

1. 寫一個(gè) lambda 函數(shù)。

2. 寫一句注釋來(lái)說(shuō)明這個(gè) lambda 究竟干了什么。

3. 研究一會(huì)這個(gè)注釋，然后想出一個(gè)抓住注釋本質(zhì)的名字。

4. 用這個(gè)名字，把這個(gè) lambda 改寫成 def 語(yǔ)句。

5. 把注釋去掉。

我非常喜歡這些規(guī)則，不過(guò)你完全有權(quán)利爭(zhēng)辯這種消除 lambda 的風(fēng)格是不是更好。

修訂記錄和致謝?

作者要感謝以下人員對(duì)本文各種草稿給予的建議，更正和協(xié)助：Ian Bicking,Nick Coghlan, Nick Efford, Raymond Hettinger, Jim Jewett, Mike Krell,Leandro Lameiro, Jussi Salmela, Collin Winter, Blake Winton。

0.1 版: 2006 年 6 月 30 日發(fā)布。

0.11 版: 2006 年 7 月 1 日發(fā)布。 修正拼寫錯(cuò)誤。

0.2 版: 2006 年 7 月 10 日發(fā)布。 將 genexp 與 listcomp 兩節(jié)合二為一。 修正拼寫錯(cuò)誤。

0.21 版: 加入了 tutor 郵件列表中建議的更多參考文件。

0.30 版: 添加了有關(guān) functional 模塊的小節(jié)，由 Collin Winter 撰寫；添加了有關(guān) operator 模塊的簡(jiǎn)短小節(jié)；其他少量修改。

參考文獻(xiàn)?