Python函数式编程指引

生成器¶

生成器是一类用来简化编写迭代器工作的特殊函数。普通的函数计算并返回一个值，而生成器返回一个能返回数据流的迭代器。

毫无疑问，你已经对如何在 Python 和 C 中调用普通函数很熟悉了，这时候函数会获得一个创建局部变量的私有命名空间。当函数到达 return 表达式时，局部变量会被销毁然后把返回给调用者。之后调用同样的函数时会创建一个新的私有命名空间和一组全新的局部变量。但是，如果在退出一个函数时不扔掉局部变量会如何呢？如果稍后你能够从退出函数的地方重新恢复又如何呢？这就是生成器所提供的；他们可以被看成可恢复的函数。

这里有简单的生成器函数示例:

>>> defgenerate_ints(N):
... foriinrange(N):
... yieldi

任何包含了 yield 关键字的函数都是生成器函数；Python 的 bytecode 编译器会在编译的时候检测到并因此而特殊处理。

当你调用一个生成器函数，它并不会返回单独的值，而是返回一个支持生成器协议的生成器对象。当执行 yield 表达式时，生成器会输出 i 的值，就像 return 表达式一样。yield 和 return 最大的区别在于，到达 yield 的时候生成器的执行状态会挂起并保留局部变量。在下一次调用生成器 __next__() 方法的时候，函数会恢复执行。

这里有一个 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

同样，你可以写出 foriingenerate_ints(5)，或者 a,b,c=generate_ints(3)。

在生成器函数里面，returnvalue 会触发从 __next__() 方法抛出 StopIteration(value) 异常。一旦抛出这个异常，或者函数结束，处理数据的过程就会停止，生成器也不会再生成新的值。

你可以手动编写自己的类来达到生成器的效果，把生成器的所有局部变量作为实例的成员变量存储起来。比如，可以这么返回一个整数列表：把 self.count 设为0，然后通过 count`()。然而，对于一个中等复杂程度的生成器，写出一个相应的类可能会相当繁杂。

包含在 Python 库中的测试套件 Lib/test/test_generators.py 里有很多非常有趣的例子。这里是一个用生成器实现树的递归中序遍历示例。:

# A recursive generator that generates Tree leaves in in-order.
definorder(t):
ift:
forxininorder(t.left):
yieldx
yieldt.label
forxininorder(t.right):
yieldx

另外两个 test_generators.py 中的例子给出了 N 皇后问题（在 NxN 的棋盘上放置 N 个皇后，任何一个都不能吃掉另一个），以及马的遍历路线（在NxN 的棋盘上给马找出一条不重复的走过所有格子的路线）的解。

val=(yieldi)

defcounter(maximum):
i=0
whilei<maximum:
val=(yieldi)
# If value provided, change counter
ifvalisnotNone:
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

内置函数¶

我们可以看看迭代器常常用到的函数的更多细节。

Python 内置的两个函数 map() 和 filter() 复制了生成器表达式的两个特性:

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

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

>>> defupper(s):
... returns.upper()

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

你当然也可以用列表推导式达到同样的效果。

filter(predicate,iter) 返回一个遍历序列中满足指定条件的元素的迭代器，和列表推导式的功能相似。 predicate （谓词）是一个在特定条件下返回真值的函数；要使用函数 filter()，谓词函数必须只能接受一个参数。

>>> defis_even(x):
... return(x%2)==0

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

这也可以写成列表推导式:

>>> list(xforxinrange(10)ifis_even(x))
[0, 2, 4, 6, 8]

enumerate(iter,start=0) 计数可迭代对象中的元素，然后返回包含每个计数（从 start 开始）和元素两个值的元组。:

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

enumerate() 常常用于遍历列表并记录达到特定条件时的下标:

f=open('data.txt','r')
fori,lineinenumerate(f):
ifline.strip()=='':
print('Blank line at line #%i'%i)

sorted(iterable,key=None,reverse=False) 会将 iterable 中的元素收集到一个列表中，然后排序并返回结果。其中 key 和 reverse 参数会传递给所创建列表的 sort() 方法。:

>>> importrandom
>>> # 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]

（对排序更详细的讨论可参见 排序指南。）

内置函数 any(iter) 和 all(iter) 会查看一个可迭代对象内容的逻辑值。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)

它并不会在内存创建一个列表并因此在返回前而耗尽输入的迭代器；相反，只有在被请求的时候元组才会创建并返回。（这种行为的技术术语叫惰性计算，参见 lazy evaluation.）

这个迭代器设计用于长度相同的可迭代对象。如果可迭代对象的长度不一致，返回的数据流的长度会和最短的可迭代对象相同

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

然而，你应该避免这种情况，因为所有从更长的迭代器中取出的元素都会被丢弃。这意味着之后你也无法冒着跳过被丢弃元素的风险来继续使用这个迭代器。

itertools 模块¶

itertools 模块包含很多常用的迭代器以及用来组合迭代器的函数。本节会用些小的例子来介绍这个模块的内容。

这个模块里的函数大致可以分为几类：

• 从已有的迭代器创建新的迭代器的函数。

• 接受迭代器元素作为参数的函数。

• 选取部分迭代器输出的函数。

• 给迭代器输出分组的函数。

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
whereiterA->
0,1,2,3,4,5,6,7,8,9,...
anditerB->
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,...

defless_than_10(x):
returnx<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'),
...
]
defget_state(city_state):
returncity_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')

importfunctools
deflog(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')

>>> importoperator,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

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

importfunctools
# Instead of:
product=functools.reduce(operator.mul,[1,2,3],1)
# You can write:
product=1
foriin[1,2,3]:
product*=i

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

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

adder=lambdax,y:x+y
print_assign=lambdaname,value:name+'='+str(value)

defadder(x,y):
returnx+y
defprint_assign(name,value):
returnname+'='+str(value)

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

importfunctools
defcombine(a,b):
return0,a[1]+b[1]
total=functools.reduce(combine,items)[1]

total=0
fora,binitems:
total+=b

total=sum(bfora,binitems)