标准库中的生成器函数

用于过滤的生成器函数

1、itertools.compress(it, selector_it)

并行处理两个可迭代对象；如果select_it中的元素是真值，产出it中对应的元素

2、itertools.dropwhile(predicate, it)

处理it，跳过predicate的计算结果为真值的元素，然后产出剩下的各个元素

3、filter(predicate, it)

把it中的各个元素传给predicate，如果predicate(item)返回真值，那么产生对应的元素；如果predicate是None，那么只产出真值元素。

4、itertools.filterfalse(predicate, it)

与filter函数的作用类似，不过predicate的逻辑是相反的，predicate返回假值时产生对应的元素

5、itertools.islice(it, stop)或islice(it, start, stop, step=1)

产出的it切片，作用类似于s[: stop]或s[start: stop: step]，不过it可以是任何可迭代的对象，而且这个函数实现的是惰性操作

6、itertools.takewhile(predicate, it)

predicate返回真值时产出对应的元素，然后立刻停止，不再继续检查

def vowel(c):
    return c.lower() in 'aeiou'


print(list(filter(vowel, 'Aardvark')))
# ['A', 'a', 'a']
import itertools

print(list(itertools.filterfalse(vowel, 'Aardvark')))
# ['r', 'd', 'v', 'r', 'k']
print(list(itertools.dropwhile(vowel, 'Aardvark')))
# ['r', 'd', 'v', 'a', 'r', 'k']
print(list(itertools.takewhile(vowel, 'Aardvark')))
# ['A', 'a']
print(list(itertools.islice('Aardvark', 4)))
# ['A', 'a', 'r', 'd']
print(list(itertools.islice('Aardvark', 4, 7)))
# ['v', 'a', 'r']
print(list(itertools.islice('Aardvark', 1, 7, 2)))
# ['a', 'd', 'a']

用于映射的生成器函数

1、itertools.accumulate(it, [func])

默认产出累积的总和，如果提供了func，那么把前两个元素传给它，然后把计算结果和下一个元素传给它，以此类推，最后产出结果

2、enumerate(iterable, start=0)

产生由两个元素组成的元组，结构是(index, item)，其中index从start开始计数，item则从iterable中获取

3、map(func, it1, [it2, ..., itN])

把it中的各个元素传给func，产出结果；如果传入N个可迭代的对象，那么func必须接收N个参数，而且要并行处理各个可迭代对象

4、itertools.starmap(func, it)

把it中的各个元素传给func，产出结果；输入的可迭代对象应该产出可迭代的元素iit，然后以func(*iit)这种形态调用func

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

import itertools

print(list(itertools.accumulate(sample)))
# [5, 9, 11, 19, 26, 32, 35, 35, 44, 45]
print(list(itertools.accumulate(sample, min)))
# [5, 4, 2, 2, 2, 2, 2, 0, 0, 0]
print(list(itertools.accumulate(sample, max)))
# [5, 5, 5, 8, 8, 8, 8, 8, 9, 9]

import operator
print(list(itertools.accumulate(sample, operator.mul)))
# [5, 20, 40, 320, 2240, 13440, 40320, 0, 0, 0]
print(list(itertools.accumulate(range(1, 11), operator.mul)))
# [1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800]

print(list(enumerate('albatroz', 1)))
# [(1, 'a'), (2, 'l'), (3, 'b'), (4, 'a'), (5, 't'), (6, 'r'), (7, 'o'), (8, 'z')]
import operator

print(list(map(operator.mul, range(11), range(11))))
# [0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
print(list(map(operator.mul, range(11), [2, 4, 8])))
# [0, 4, 16]
print(list(map(lambda a, b: (a, b), range(11), [2, 4, 8])))
# [(0, 2), (1, 4), (2, 8)]
import itertools

print(list(itertools.starmap(operator.mul, enumerate('albatroz', 1))))
# ['a', 'll', 'bbb', 'aaaa', 'ttttt', 'rrrrrr', 'ooooooo', 'zzzzzzzz']
sample = [5, 4, 2, 8, 7, 6, 3, 0, 9, 1]

print(list(itertools.starmap(lambda a, b: b/a, enumerate(itertools.accumulate(sample), 1))))
# [5.0, 4.5, 3.6666666666666665, 4.75, 5.2, 5.333333333333333, 5.0, 4.375, 4.888888888888889, 4.5]

合并多个可迭代对象的生成器函数

1、itertools.chain(it1, ..., itN)

先产出it1中的所有元素，然后产生it2中的所有元素，以此类推，无缝连接在一起

2、itertools.chain.from_iterable(it)

产生it生成的各个可迭代对象中的元素，一个接一个，无缝连接在一起；it应该产出可迭代的元素，列入可迭代的对象列表

3、itertools.product(it1, ..., itN, repeat=1)

计算笛卡尔积：从输入的各个可迭代对象中获取元素，产出由N个元素组成的元组，与嵌套的for循环效果一样；repeat指明重复处理多少次输入的可迭代对象

4、zip(it1, ..., itN)

并行从输入的各个可迭代对象中获取元素，产出由N个元素组成的元组，只要有一个可迭代的对象到头了，就默默地停止。

5、itertools.zip_longest(it1, itN, fillvalue=None)

并行从输入的各个可迭代对象中获取元素，产出N个元素组成的元组，等到最长的可迭代对象到头后停止，空缺的值使用fillvalue填充

import itertools
print(list(itertools.chain('ABC', range(2))))
# ['A', 'B', 'C', 0, 1]
print(list(itertools.chain(enumerate('ABC'))))
# [(0, 'A'), (1, 'B'), (2, 'C')]
print(list(itertools.chain.from_iterable(enumerate('ABC'))))
# [0, 'A', 1, 'B', 2, 'C']
print(list(zip('ABC', range(5))))
# [('A', 0), ('B', 1), ('C', 2)]
print(list(zip('ABC', range(5), [10, 20, 30, 40])))
# [('A', 0, 10), ('B', 1, 20), ('C', 2, 30)]
print(list(itertools.zip_longest('ABC', range(5))))
# [('A', 0), ('B', 1), ('C', 2), (None, 3), (None, 4)]
print(list(itertools.zip_longest('ABC', range(5), fillvalue='?')))
# [('A', 0), ('B', 1), ('C', 2), ('?', 3), ('?', 4)]

import itertools

print(list(itertools.product('ABC', range(2))))
# [('A', 0), ('A', 1), ('B', 0), ('B', 1), ('C', 0), ('C', 1)]
suits = 'spades hearts diamonds clubs'.split()

print(list(itertools.product('AK', suits)))
# [('A', 'spades'), ('A', 'hearts'), ('A', 'diamonds'), ('A', 'clubs'), ('K', 'spades'), ('K', 'hearts'), ('K', 'diamonds'), ('K', 'clubs')]
print(list(itertools.product('ABC')))
# [('A',), ('B',), ('C',)]
print(list(itertools.product('ABC', repeat=2)))
# [('A', 'A'), ('A', 'B'), ('A', 'C'), ('B', 'A'), ('B', 'B'), ('B', 'C'), ('C', 'A'), ('C', 'B'), ('C', 'C')]
print(list(itertools.product(range(2), repeat=3)))
# [(0, 0, 0), (0, 0, 1), (0, 1, 0), (0, 1, 1), (1, 0, 0), (1, 0, 1), (1, 1, 0), (1, 1, 1)]
rows = itertools.product(range(2), repeat=3)

for row in rows:
    print(row)
# (0, 0, 0)
# (0, 0, 1)
# (0, 1, 0)
# (0, 1, 1)
# (1, 0, 0)
# (1, 0, 1)
# (1, 1, 0)
# (1, 1, 1)

把输入的各个元素扩展成多个输出元素的生成器函数

1、itertools.combinations(it, out_len)

把it产生的out_len个元素组合在一起，然后产出

2、itertools.combinations_with_replacement(it, out_len)

把it产出的out_len个元素组合在一起，然后产出包含相同元素的组合

3、itertools.count(start=0, step=1)

从start开始不断产出数字，按step指定的步幅增加

4、itertools.cycle(it)

从it中产出各个元素，村粗各个元素的副本，然后按顺序重复不断地产出各个元素

5、itertools.permutations(it, out_len=None)

把out_len个it产出的元素排列到一起，然后产出这些排列；out_len的默认值等于len(list(it))

6、itertools.repeat(item, [times])

重复不断地产出指定的元素，除非提供times，指定次数

import itertools, operator


ct = itertools.count()
print(next(ct))
# 0
print(next(ct), next(ct), next(ct))
# 1 2 3
print(list(itertools.islice(itertools.count(1, .3), 3)))
# [1, 1.3, 1.6]
cy = itertools.cycle('ABC')
print(next(cy))
# A
print(list(itertools.islice(cy, 7)))
# ['B', 'C', 'A', 'B', 'C', 'A', 'B']
rp = itertools.repeat(7)
print(next(rp), next(rp))
# 7 7
print(list(itertools.repeat(8, 4)))
# [8, 8, 8, 8]
print(list(map(operator.mul, range(11), itertools.repeat(5))))
# [0, 5, 10, 15, 20, 25, 30, 35, 40, 45, 50]

import itertools

print(list(itertools.combinations('ABC', 2)))
# [('A', 'B'), ('A', 'C'), ('B', 'C')]
print(list(itertools.combinations_with_replacement('ABC', 2)))
# [('A', 'A'), ('A', 'B'), ('A', 'C'), ('B', 'B'), ('B', 'C'), ('C', 'C')]
print(list(itertools.permutations('ABC', 2)))
# [('A', 'B'), ('A', 'C'), ('B', 'A'), ('B', 'C'), ('C', 'A'), ('C', 'B')]
print(list(itertools.product('ABC',repeat=2)))
# [('A', 'A'), ('A', 'B'), ('A', 'C'), ('B', 'A'), ('B', 'B'), ('B', 'C'), ('C', 'A'), ('C', 'B'), ('C', 'C')]

用于重新排列元素的生成器函数

1、itertools.groupby(it, key=None)

产生由两个元素组成的元素，形式为(key, group)，其中可以是分组标准，group是生成器，用于产出分组里的元素

2、reversed(seq)

从后往前，倒序产出seq中的元素；seq必须是序列，或者是实现了__reversed__特殊方法的对象

3、itertools.tee(it, n=2)

产出一个由n个生成器组成的元组，每个生成器用于单独产出输入的可迭代对象中的元素

import itertools

print(list(itertools.groupby('LLLLAAGGG')))
# [('L', <itertools._grouper object at 0x10dcf2208>), 
# ('A', <itertools._grouper object at 0x10dcf2240>), 
# ('G', <itertools._grouper object at 0x10dcf2198>)]

for char, group in itertools.groupby('LLLLAAGGG'):
    print(char, '-->', list(group))
# L --> ['L', 'L', 'L', 'L']
# A --> ['A', 'A']
# G --> ['G', 'G', 'G']

animals = ['duck', 'eagle', 'rat', 'giraffe', 'bear', 'bat', 'dolphin', 'shark', 'lion']
animals.sort(key=len)
print(animals)
# ['rat', 'bat', 'duck', 'bear', 'lion', 'eagle', 'shark', 'giraffe', 'dolphin']

for length, group in itertools.groupby(animals, len):
    print(length, '-->', list(group))
# 3 --> ['rat', 'bat']
# 4 --> ['duck', 'bear', 'lion']
# 5 --> ['eagle', 'shark']
# 7 --> ['giraffe', 'dolphin']

for length, group in itertools.groupby(reversed(animals), len):
    print(length, '-->', list(group))
# 7 --> ['dolphin', 'giraffe']
# 5 --> ['shark', 'eagle']
# 4 --> ['lion', 'bear', 'duck']
# 3 --> ['bat', 'rat']

import itertools

print(itertools.tee('ABC'))
# (<itertools._tee object at 0x10dd1e8c8>, 
# <itertools._tee object at 0x10dd1e908>)

g1, g2 = itertools.tee('ABC')

print(next(g1))
# A
print(next(g2))
# A
print(next(g2))
# B
print(list(g1))
# ['B', 'C']
print(list(zip(*itertools.tee('ABC'))))
# [('A', 'A'), ('B', 'B'), ('C', 'C')]

yield from

场景：如果生成器函数需要产出另一个生成器生成的值，传统的解决方法是使用嵌套的for循环

def chain(*iterables):
    for it in iterables:
        for i in it:
            yield i


s = 'ABC'
t = tuple(range(3))
print(list(chain(s, t)))
# ['A', 'B', 'C', 0, 1, 2]

def chain_new(*iterables):
    for i in iterables:
        yield from i

s = 'ABC'
t = tuple(range(3))
print(list(chain(s, t)))
# ['A', 'B', 'C', 0, 1, 2]

可以看出yield from i完全替代了内层的for循环。在这个示例中使用yield from是对的，而且代码读起来更顺畅，感觉更像是语法糖。除了代替循环之外，yield from还会创建通道，把内层生成器直接与外层生成器的客户端联系起来。把生成器当成协程使用时，这个通道特别重要，不仅能为客户端生成值，还能使用客户端代码提供的值。

最值得注意的几个函数

islice: 允许对一个无穷生成器进行切片

chain: 将多个生成器链接到一起

takewhile: 给生成器添加一个终止条件

cycle: 通过不断重复将一个有穷生成器变成无穷