用于过滤的生成器函数
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返回真值时产出对应的元素，然后立刻停止，不再继续检查
1 def vowel(c):
2 return c.lower() in 'aeiou'
3
4
5 print(list(filter(vowel, 'Aardvark')))
6 # ['A', 'a', 'a']
7 import itertools
8
9 print(list(itertools.filterfalse(vowel, 'Aardvark')))
10 # ['r', 'd', 'v', 'r', 'k']
11 print(list(itertools.dropwhile(vowel, 'Aardvark')))
12 # ['r', 'd', 'v', 'a', 'r', 'k']
13 print(list(itertools.takewhile(vowel, 'Aardvark')))
14 # ['A', 'a']
15 print(list(itertools.islice('Aardvark', 4)))
16 # ['A', 'a', 'r', 'd']
17 print(list(itertools.islice('Aardvark', 4, 7)))
18 # ['v', 'a', 'r']
19 print(list(itertools.islice('Aardvark', 1, 7, 2)))
20 # ['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
1 sample = [5, 4, 2, 8, 7, 6, 3, 0, 9, 1] 2 3 import itertools 4 5 print(list(itertools.accumulate(sample))) 6 # [5, 9, 11, 19, 26, 32, 35, 35, 44, 45] 7 print(list(itertools.accumulate(sample, min))) 8 # [5, 4, 2, 2, 2, 2, 2, 0, 0, 0] 9 print(list(itertools.accumulate(sample, max))) 10 # [5, 5, 5, 8, 8, 8, 8, 8, 9, 9] 11 12 import operator 13 print(list(itertools.accumulate(sample, operator.mul))) 14 # [5, 20, 40, 320, 2240, 13440, 40320, 0, 0, 0] 15 print(list(itertools.accumulate(range(1, 11), operator.mul))) 16 # [1, 2, 6, 24, 120, 720, 5040, 40320, 362880, 3628800]accumulate生成器函数
1 print(list(enumerate('albatroz', 1)))
2 # [(1, 'a'), (2, 'l'), (3, 'b'), (4, 'a'), (5, 't'), (6, 'r'), (7, 'o'), (8, 'z')]
3 import operator
4
5 print(list(map(operator.mul, range(11), range(11))))
6 # [0, 1, 4, 9, 16, 25, 36, 49, 64, 81, 100]
7 print(list(map(operator.mul, range(11), [2, 4, 8])))
8 # [0, 4, 16]
9 print(list(map(lambda a, b: (a, b), range(11), [2, 4, 8])))
10 # [(0, 2), (1, 4), (2, 8)]
11 import itertools
12
13 print(list(itertools.starmap(operator.mul, enumerate('albatroz', 1))))
14 # ['a', 'll', 'bbb', 'aaaa', 'ttttt', 'rrrrrr', 'ooooooo', 'zzzzzzzz']
15 sample = [5, 4, 2, 8, 7, 6, 3, 0, 9, 1]
16
17 print(list(itertools.starmap(lambda a, b: b/a, enumerate(itertools.accumulate(sample), 1))))
18 # [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填充