Python的 循环器 itertools

在循环对象和函数对象中，咱们了解了循环器(iterator)的功能。循环器是对象的容器，包含有多个对象。经过调用循环器的next()方法 (__next__()方法，在Python 3.x中)，循环器将依次返回一个对象。直到全部的对象遍历穷尽，循环器将举出StopIteration错误。

 

在for i in iterator结构中，循环器每次返回的对象将赋予给i，直到循环结束。使用iter()内置函数，咱们能够将诸如表、字典等容器变为循环器。好比

for i in iter([2, 4, 5, 6]):    
    print(i)

标准库中的itertools包提供了更加灵活的生成循环器的工具。这些工具的输入大都是已有的循环器。另外一方面，这些工具彻底能够自行使用Python实现，该包只是提供了一种比较标准、高效的实现方式。这也符合Python“只有且最好只有解决方案”的理念。

# import the tools
from itertools import *

无穷循环器

count(5, 2)     #从5开始的整数循环器，每次增长2，即5, 7, 9, 11, 13, 15 ...
cycle('abc')    #重复序列的元素，既a, b, c, a, b, c ...
repeat(1.2)     #重复1.2，构成无穷循环器，即1.2, 1.2, 1.2, ...
 
repeat也能够有一个次数限制:
repeat(10, 5)   #重复10，共重复5次

函数式工具

函数式编程是将函数自己做为处理对象的编程范式。在Python中，函数也是对象，所以能够轻松的进行一些函数式的处理，好比map(), filter(), reduce()函数。

itertools包含相似的工具。这些函数接收函数做为参数，并将结果返回为一个循环器。

from itertools import *
rlt = imap(pow, [1, 2, 3], [1, 2, 3])
for num in rlt:    
    print(num)

imap()和map()的区别在于，imap()能够做用于无穷序列，而且，若是两个序列的长度不一致，以短的那个为准。

>>> for x in itertools.imap(lambda x, y: x * y, [10, 20, 30], itertools.count(0)):
...     print x
...
0
40
90

上面显示了imap函数。该函数与map()函数功能类似，只不过返回的不是序列，而是一个循环器。包含元素1, 4, 27，即1**1, 2**2, 3**3的结果。函数pow(内置的乘方函数)做为第一个参数。pow()依次做用于后面两个列表的每一个元素，并收集函数结果，组成返回的循环器。

此外，还能够用下面的函数:

starmap(pow, [(1, 1), (2, 2), (3, 3)])

pow将依次做用于表的每一个tuple。

ifilter函数与filter()函数相似，只是返回的是一个循环器。

ifilter(lambda x: x > 5, [2, 3, 5, 6, 7]

将lambda函数依次做用于每一个元素，若是函数返回True，则收集原来的元素。6, 7

此外，

ifilterfalse(lambda x: x > 5, [2, 3, 5, 6, 7])

与上面相似，但收集返回False的元素。2, 3, 5

 

takewhile(lambda x: x < 5, [1, 3, 6, 7, 1])

当函数返回假时，不在迭代序列。1, 3

 

dropwhile(lambda x: x < 5, [1, 3, 6, 7, 1])

当函数返回假时, 开始迭代序列。6, 7, 1

组合工具

咱们能够经过组合原有循环器，来得到新的循环器。

chain([1, 2, 3], [4, 5, 7])      # 链接两个循环器成为一个。1, 2, 3, 4, 5, 7

for i in chain(dropwhile(lambda s:s>2,[1,2,3,4,5]),takewhile(lambda s:s>3,[4,5,1,2,3,4,5])):
    print i
1
2
3
4
5
4
5

product([1,2], [1, 2])   # 多个循环器集合的笛卡尔积。至关于嵌套循环  

>>> for m, n in product([1,2], [1, 2]):   
...     print m,n
... 
1 1
1 2
2 1
2 2

permutations('abc', 2)   # 从'abcd'中挑选两个元素，好比ab, bc, ... 将全部结果排序，返回为新的循环器。

注意，上面的组合分顺序，即ab, ba都返回。

>>> for i in permutations('abc', 2) :
...     print i
... 
('a', 'b')
('a', 'c')
('b', 'a')
('b', 'c')
('c', 'a')
('c', 'b')

combinations('abc', 2)   # 从'abcd'中挑选两个元素，好比ab, bc, ... 将全部结果排序，返回为新的循环器。

注意，上面的组合不分顺序，即ab, ba的话，只返回一个ab。

 

>>> for i in combinations('abc', 2) :
...     print i
... 
('a', 'b')
('a', 'c')
('b', 'c')

combinations_with_replacement('abc', 2) # 与上面相似，但容许两次选出的元素重复。即多了aa, bb, cc

groupby()

将key函数做用于原循环器的各个元素。根据key函数结果，将拥有相同函数结果的元素分到一个新的循环器。每一个新的循环器以函数返回结果为标签。

这就好像一群人的身高做为循环器。咱们能够使用这样一个key函数: 若是身高大于180，返回"tall"；若是身高底于160，返回"short";中间的返回"middle"。最终，全部身高将分为三个循环器，即"tall", "short", "middle"。

>>> def height_class(h):
...     if h > 180:
...         return "tall"
...     elif h < 160:
...         return "short"
...     else:
...         return "middle"
... 
>>> friends = [191, 158, 159, 165, 170, 177, 181, 182, 190]
>>> friends = sorted(friends, key = height_class)
>>> friends 
[165, 170, 177, 158, 159, 191, 181, 182, 190]
>>> for m, n in groupby(friends, key = height_class):
...     print(m)
...     print(list(n))
... 
middle
[165, 170, 177]
short
[158, 159]
tall
[191, 181, 182, 190]

注意，groupby的功能相似于UNIX中的uniq命令。分组以前须要使用sorted()对原循环器的元素，根据key函数进行排序，让同组元素先在位置上靠拢。

看下面没有排序的错误结果
friends = [191, 158, 159, 165, 170, 177, 181, 182, 190]
>>> for m, n in groupby(friends, key = height_class):
...     print(m)
...     print(list(n))
... 
tall
[191]
short
[158, 159]
middle
[165, 170, 177]
tall
[181, 182, 190]

其它工具

compress('ABCD', [1, 1, 1, 0])  # 根据[1, 1, 1, 0]的真假值状况，选择第一个参数'ABCD'中的元素。A, B, C

islice()                        # 相似于slice()函数，只是返回的是一个循环器

izip()                          # 相似于zip()函数，只是返回的是一个循环器。

总结

itertools的工具均可以自行实现。itertools只是提供了更加成形的解决方案。