itertools 该模块主要包含一些生成迭代器的函数。先导入Python的交互式解释器 itertools 然后输入模块[e for e in dir(itertools) if not e.startswith('_')]命令可以看到模块中包含的所有属性和函数：

>>>[eforeindir(itertools)ifnote.startswith('_')]
['accumulate','chain','combinations','combinations_with_replacement','compress','count','cycle',
'dropwhile','filterfalse','groupby','islice','permutations','product','repeat','starmap','takewhile',
'tee','zip_longest']

从以上输出结果可以看出，itertools 生成迭代器可以使用模块中的许多函数。

先看 itertools 模块中三个生成迭代器的函数：

count(start, [step])：生成 start, start+step, start+2*step... 迭代器，其中 step 默认为 1。比如使用 count(10) 生成的迭代器包括：10， 11 , 12 , 13, 14..。

cycle(p)：对序列 p 生成循环 p0, p1,..., p0, p1,... 迭代器。例如使用 cycle('ABCD') 生成的迭代器包括：A,B,C,D,A,B,C,D,..。

repeat(elem [,n])：生成个 elem 如果指定参数，元素重复的迭代器 n，则只生成 n 个 elem 元素。例如使用 repeat(10, 3) 生成的法代器包括：10， 10, 10。

以下程序演示了使用上述三个函数生成迭代器的方法：

importitertoolsasit
#count(10,3)生成10、13、16……迭代器
foreinit.count(10,3):
print(e)
#用于跳出循环
ife>20:
break
print('---------')
my_counter=0
#cycle用于迭代序列生成循环
foreinit.cycle(['Python','Kotlin','Swift']):
print(e)
#用于跳出循环
my_counter+=1
ifmy_counter>7:
break
print('---------')
#repeat用于生成n元素重复的迭代器
foreinit.repeat('Python',3):
print(e)

在 itertools 模块中还有一些常用的迭代函数，如下所示：

accumulate(p[,func])：根据序列默认生成 p 元素积累的迭代器，p0， p0+p1, p0+p1+p2...如果指定了序列 func 函数，则用 func 计算下一个元素值的函数。

chain(p, q, ...)：将多个序列中的元素“链”在一起，生成一个新的序列。

compress(data, selectors)：根据 selectors 序列的值对 data 过滤序列元素。如果 selector[0] 如果是真的，保留它 data[0]；如果 selector[1] 如果是真的，保留它 data[1]...依此类推。

dropwhile(pred, seq)：使用 pred 函数对 seq 过滤序列，从 seq 第一次使用 pred 函数计算为 False 从元素开始，保留从元素到序列结束的所有元素。

takewhile(pred, seq)：该函数与上一个函数正好相反。使用 pred 函数对 seq 过滤序列，从 seq 第一次使用 pred 函数计算为 False 从元素开始，去除从元素到序列结束的所有元素。

filterfalse(pred, seq)：使用 pred 函数对 seq 过滤和保留序列 seq 中使用 pred 计算为 True 元素。例如 filterfalse(lambda x:x%2, range(10)，得到 0, 2, 4, 6, 8。

islice(seq, [start,] stop [, step])：其功能与序列相似 slice 实际上，方法是返回 seq[start:stop:step] 的结果。

starmap(func, seq)：使用 func 对 seq 计算序列的每个元素，并将计算结果作为新的序列元素。使用时 func 支持序列解包计算序列元素。例如 seq 序列元素的长度为 3，那么 func 它可以是一个接收三个参数的函数，它将根据这三个参数计算新序列的元素。

zip_longest(p,q,...)：将 p、q 按索引等序列中的元素合并成元组，这些元素将作为新序列的元素。

以上函数的测试程序如下：

importitertoolsasit
#默认情况下，下一个元素的值是通过累加来计算的
foreinit.accumulate(range(6)):
print(e,end=',')#0,1,3,6,10,15
print('\n---------')
#用x*y计算迭代器下一个元素的值
foreinit.accumulate(range(1,6),lambdax,y:x*y):
print(e,end=',')#1,2,6,24,120
print('\n---------')
#将两个序列“链”放在一起，生成新的迭代器
foreinit.chain(['a','b'],['Kotlin','Swift']):
print(e,end=',')#'a','b','Kotlin','Swift'
print('\n---------')
#第一个序列的元素按照第二个序列进行筛选，
#因为第二个序列只有中间两个元素（True），因此，前一个序列只保留中间两个元素
foreinit.compress(['a','b','Kotlin','Swift'],[0，1，1，0]):
print(e,end=',')#只有:'b','Kotlin'
print('\n---------')
#从长度不小于4的元素开始到获取序列结束的所有元素
foreinit.dropwhile(lambdax:len(x)<4,['a','b','Kotlin','x','y']):
print(e,end=',')#只有:'Kotlin','x','y'
print('\n---------')
#从长度不小于4的元素开始到结束，删除序列中的所有元素
foreinit.takewhile(lambdax:len(x)<4,['a','b','Kotlin','x','y']):
print(e,end=',')#只有:'a','b'
print('\n---------')
#只保留序列中长度不小于4的元素
foreinit.filterfalse(lambdax:len(x)<4,['a','b','Kotlin','x','y']):
print(e,end=',')#只有:'Kotlin'
print('\n---------')
#使用pow函数计算原序列元素，并将计算结果作为新序列元素
foreinit.starmap(pow,(2，5)，(3，2)，(10，3)):
print(e,end=',')#32,9,1000
print('\n---------')
#将'ABCD'、'xy'元素按索引合并成元组，这些元素作为新序列的元素
#使用长度不足的序列元素'-'字符代替
foreinit.zip_longest('ABCD','xy',fillvalue='-'):
print(e,end=',')#('A','x'),('B','y'),('C','-'),('D','-')

在操作上述程序时，可以看到以下输出结果：

1、3、6、10、15
---------
1,2,6,24,120,
---------
a,b,Kotlin,Swift,
---------
b,Kotlin,
---------
Kotlin,x,y,
---------
a,b,
---------
Kotlin,
---------
32,9,1000,
---------
('A','x'),('B','y'),('C','-'),('D','-'),

在 itertools 还有一些工具函数用于在模块中生成排列组合：

product(p, q, ...[repeat= 1)]：用序列 p 、q ... 排列组合中的元素相当于嵌套循环组合。

permutations(p[, r])：从序列 p 中取出 r 将排列的元素作为新迭代器的元素组成全排列。

combinations(p, r)：从序列 p 中取出 r 一个元素组成全组合，元素不允许重复，组合得到的元素作为新迭代器的元素。

combinations with_replacement(p, r)，从序列 p 中取出 r 一个元素组成一个完整的组合，允许重复元素，并将组合得到的元素作为新迭代器的元素。

上面演示了以下程序 4 个函数的用法：

importitertoolsasit
#使用两个序列进行排列组合
foreinit.product('AB','CD'):
print(''.join(e),end=',')#AC,AD,BC,BD,
print('\n---------')
#全排列使用一个序列，重复两次
foreinit.product('AB',repeat=2):
print(''.join(e),end=',')#AA,AB,BA,BB,
print('\n---------')
#从序列中取出两个元素进行排列
foreinit.permutations('ABCD',2):
print(''.join(e),end=',')#AB,AC,AD,BA,BC,BD,CA,CB,CD,DA,DB,DC,
print('\n---------')
#从序列中提取两个元素进行组合，元素不允许重复
foreinit.combinations('ABCD',2):
print(''.join(e),end=',')#AB,AC,AD,BC,BD,CD,
print('\n---------')
#将两个元素从序列中组合起来，允许元素重复
foreinit.combinations_with_replacement('ABCD',2):
print(''.join(e),end=',')#AA,AB,AC,AD,BB,BC,BD,CC,CD,DD,

上述程序使用字符串 join() 该方法用于将元组的所有元素连接成字符串。在操作程序中，可以看到以下输出结果：

AC,AD,BC,BD,
---------
AA,AB,BA,BB,
---------
AB,AC,AD,BA,BC,BD,CA,CB,CD,DA,DB,DC,
---------
AB,AC,AD,BC,BD,CD,
---------
AA,AB,AC,AD,BB,BC,BD,CC,CD,DD,