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

迭代器?

我會從 Python 的一個語言特性， 編寫函數(shù)式風(fēng)格程序的重要基石開始說起：迭代器。

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

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

你可以手動試驗迭代器的接口。

>>> 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 有不少要求使用可迭代的對象的地方，其中最重要的就是 for 表達式。在表達式 for X in Y，Y 要么自身是一個迭代器，要么能夠由 iter() 創(chuàng)建一個迭代器。以下兩種表達是等價的:

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)

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

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

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

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

>>> 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ǎo)式?

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

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

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]

你可以加上條件語句 "if" 來選取特定的元素:

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

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

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

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

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

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

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

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

其中 for...in 語句包含了將要遍歷的序列。這些序列并不必須同樣長，因為它們會從左往右開始遍歷，而 不是 同時執(zhí)行。對每個 sequence1 中的元素，sequence2 會從頭開始遍歷。sequence3 會對每個 sequence1 和 sequence2 的元素對開始遍歷。

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

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.

這說明，如果有多個 for...in 語句而沒有 if 語句，輸出結(jié)果的長度就是所有序列長度的乘積。如果你的兩個列表長度為3，那么輸出的列表長度就是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 語法變得含糊，如果 expression 會生成元組，那這個元組必須要用括號括起來。下面第一個列表推導(dǎo)式語法錯誤，第二個則是正確的:

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

生成器?

生成器是一類用來簡化編寫迭代器工作的特殊函數(shù)。普通的函數(shù)計算并返回一個值，而生成器返回一個能返回數(shù)據(jù)流的迭代器。

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

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

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

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

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

這里有一個 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 會觸發(fā)從 __next__() 方法拋出 StopIteration(value) 異常。一旦拋出這個異常，或者函數(shù)結(jié)束，處理數(shù)據(jù)的過程就會停止，生成器也不會再生成新的值。

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

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

# 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

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

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ù)的更多細節(jié)。

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

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

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)式達到同樣的效果。

filter(predicate, iter) 返回一個遍歷序列中滿足指定條件的元素的迭代器，和列表推導(dǎo)式的功能相似。 predicate （謂詞）是一個在特定條件下返回真值的函數(shù)；要使用函數(shù) filter()，謂詞函數(shù)必須只能接受一個參數(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) 計數(shù)可迭代對象中的元素，然后返回包含每個計數(shù)（從 start 開始）和元素兩個值的元組。:

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

enumerate() 常常用于遍歷列表并記錄達到特定條件時的下標(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) 會將 iterable 中的元素收集到一個列表中，然后排序并返回結(jié)果。其中 key 和 reverse 參數(shù)會傳遞給所創(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]

（對排序更詳細的討論可參見 排序指南。）

內(nèi)置函數(shù) any(iter) 和 all(iter) 會查看一個可迭代對象內(nèi)容的邏輯值。any() 在可迭代對象中任意一個元素為真時返回 True，而 all() 在所有元素為真時返回 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, ...) 從每個可迭代對象中選取單個元素組成列表并返回:

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

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

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

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

然而，你應(yīng)該避免這種情況，因為所有從更長的迭代器中取出的元素都會被丟棄。這意味著之后你也無法冒著跳過被丟棄元素的風(fēng)險來繼續(xù)使用這個迭代器。

itertools 模塊?

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

這個模塊里的函數(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ù) 接受一個或多個函數(shù)作為輸入，返回新的函數(shù)。 這個模塊中最有用的工具是 functools.partial() 函數(shù)。

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

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

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

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ù)地在可迭代對象的所有元素上執(zhí)行操作，因此它不能夠用在無限的可迭代對象上。func 必須是一個接受兩個元素并返回一個值的函數(shù)。functools.reduce() 接受迭代器返回的前兩個元素 A 和 B 并計算 func(A, B) 。然后它會請求第三個元素，C，計算 func(func(A, B), C)，然后把這個結(jié)果再和第四個元素組合并返回，如此繼續(xù)下去直到消耗整個可迭代對象。如果輸入的可迭代對象完全不返回任何值，TypeError 異常就會拋出。如果提供了初值(initial value)，它會被用作起始值，也就是先計算 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()，你就會把可迭代對象中的所有元素加起來.這種情況非常常見, 所以 Python 有一個特殊的內(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

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

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

一個相關(guān)的函數(shù)是 itertools.accumulate(iterable, func=operator.add) 。它執(zhí)行同樣的計算, 不過相對于只返回最終結(jié)果，accumulate() 會返回一個迭代器來輸出所有中間結(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 表達式?

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

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

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

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

adder = lambda x, y: x+y

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

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

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

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

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

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

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

你可以弄明白，不過要花上時間來理清表達式來搞清楚發(fā)生了什么。使用一個簡短的嵌套的 def 語句可以讓情況變得更好:

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

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

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

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

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

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

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

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

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

2. 寫一句注釋來說明這個 lambda 究竟干了什么。

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

4. 用這個名字，把這個 lambda 改寫成 def 語句。

5. 把注釋去掉。

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

修訂記錄和致謝?

作者要感謝以下人員對本文各種草稿給予的建議，更正和協(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ā)布。 修正拼寫錯誤。

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

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

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

參考文獻?