介绍
itertools是python内置的模块，提供了若干个用于操作迭代对象的函数，使用简单且功能强大。方便以后使用，特别汇总整理。
使用方法
import itertools
主要方法
- accumulate(iterable[, func])
接收一个可迭代对象，和一个二元运算函数名 [可选]
接收一个参数，默认对可迭代对象中的元素进行累加运算，返回结果仍为可迭代对象
接收两个参数，可迭代对象中的元素按照二元运算函数进行累计运算
import operator
cc = itertools.accumulate([1, 2, 3])
cs = itertools.accumulate([1, 2, 3], operator.mul)
print(list(cc), list(cs))
>>[1, 3, 6] [1, 2, 6]
- chain(*iterables)
可以把若干个迭代对象（这里可以是字符串、列表、字典、集合等一切迭代对象）串联起来，形成一个更大的迭代器
it_a = ['a', 'b']
it_b = range(3)
merge = itertools.chain(it_a, it_b, 'sss')
print(merge, list(merge))
>>
<itertools.chain object at 0x014573B0> ['a', 'b', 0, 1, 2, 's', 's', 's']
- combinations(iterabe, r)
将可迭代对象（序列）中的任意r个元素组成一个元组，最后将所有的组合情况以迭代器返回
cm = itertools.combinations('abc', 2)
print(list(cm))
>>[('a', 'b'), ('a', 'c'), ('b', 'c')]
- combinations_with_replacement(iterable, r)
可以认为是对combinations的扩展，它会额外返回单个元素重复r次的情形
cm = itertools.combinations_with_replacement('abc', 2)
print(list(cm))
>>[('a', 'a'), ('a', 'b'), ('a', 'c'), ('b', 'b'), ('b', 'c'), ('c', 'c')]
- compress(data, selectors)
接受两个可迭代对象
通过判断选择器中的元素的bool值，如果为True，则保留数据的相应元素，否则删除
# 如果是一个由5个空值组成的列表，则空值被视为False
# 注意!!!
# 列表中的第一个元素是空格，并不是什么也没有，特别需要注意
cm = itertools.compress([1, 2, 3, 4, 5], [' ', '', '', '', ''])
print(list(cm))
>>[1]
- count(start=0, step=1)
创建一个无限迭代器（序列）
默认创建一个以0开始，步长为1的自然数序列：0,1,2,3,4...
要注意在程序中设置退出条件，或者ctrl + c强制打断
odd = itertools.count(1, 2)
for i in odd:
if i < 10:
print(i, end=' ')
else:
break
>>1 3 5 7 9
- cycle(iterable)
把一个序列无限重复下去
cs = itertools.cycle([1, 2, 3])
i = 0
for c in cs:
if i != 7:
print(c, end=' ')
i += 1
else:
break
>>1 2 3 1 2 3 1
- dropwhile(predicate, iterable)
第一个参数（可以是函数）只要能返回迭代对象中元素的bool值即可
遍历iterable中的元素，若某个元素判断predicate为True，则丢弃该元素，否则停止判断，并以迭代器的形式返回该元素以及后面的所有元素
cm = itertools.dropwhile(lambda x: x.isupper(), 'aAbc')
for c in cm:
print(c, end='')
>>aAbc
- filterfalse(function_or_None, sequence)
第一个参数为函数名，或者 None
如果为函数，则保留序列中使得函数为False的元素，并返回迭代器
如果为None，则判断序列中的元素，并返回为False的元素
# 列表中只有0 == False，因此结果必定只有0
cm = itertools.filterfalse(None, [1, 0, 2, 3])
for c in cm:
print(c)
>>0
- groupby(iterable, key=None)
从传入的可迭代对象中返回连续的键和组
vehicles = [('Ford', 'Taurus'), ('Dodge', 'Durango'),
('Chevrolet', 'Cobalt'), ('Ford', 'F150'),
('Dodge', 'Charger'), ('Ford', 'GT')]
sorted_vehicles = sorted(vehicles)
for key, group in itertools.groupby(sorted_vehicles, lambda make: make[0]):
for make, model in group:
print('{model} is made by {make}'.format(model=model, make=make))
print("**** END OF GROUP ***\n")
>>
Cobalt is made by Chevrolet
**** END OF GROUP ***
Charger is made by Dodge
Durango is made by Dodge
**** END OF GROUP ***
F150 is made by Ford
GT is made by Ford
Taurus is made by Ford
**** END OF GROUP ***
- islice(iterable, stop)
islice(iterable, start, stop[, step])
工作原理完全类似列表的切片功能，返回的是一个迭代器
s = 'abcdefghijklmnopqrstuvwxyz'
cm = itertools.islice(s, 16)
print(list(cm) == list(s[:16]))
>>True
cm = itertools.islice(s, 16, 18)
print(list(cm) == list(s[16:18]))
>>True
cm = itertools.islice(s, 16, 18, 1)
print(list(cm) == list(s[16:18:1]))
>>True
cm = itertools.islice(s, 16, 18, 3)
print(list(cm) == list(s[16:18:3]))
>>True
cm = itertools.islice(s, 16, None)
print(list(cm) == list(s[16:]))
>>True
- permutations(iterable, r=None)
以迭代器的形式返回可迭代对象的所有的长度为 r 的排列
默认返回全排列
cm = itertools.permutations('abc', 2)
for c in cm:
print(''.join(c), end=' ')
>>ab ac ba bc ca cb
- product(*iterable, repeat=1)
计算多个可迭代对象的笛卡尔积
arrays = [(-1, 1), (-3, 3)]
cm = itertools.product(*arrays)
print(list(cm))
>>[(-1, -3), (-1, 3), (1, -3), (1, 3)]
- repeat(p_object, times=None)
以迭代器的形式按次数返回传入的对象
默认则等价于无限迭代器
cm = itertools.repeat('a', 3)
print(list(cm))
>>['a', 'a', 'a']
# 不传入times参数值时，为无限迭代，要设置退出循环的条件
cm = itertools.repeat('a')
i = 0
for c in cm:
if i > 10:
break
else:
print(c, end=' ')
i += 1
>>a a a a a a a a a a a
- starmap(function, sequence)
序列是由迭代对象（包含的元素个数与传入的函数需要的参数相同）构成的
cm = itertools.starmap(lambda x, y: x + y, ['ab', [2, 3], (1, 1)])
print(list(cm))
>>['ab', 5, 2]
- takewhile(predicate, iterable)
遍历迭代器中的元素，若该元素判断predicate为True，则保留该元素，否则放弃该元素及其后面的所有元素，并以迭代器形式返回所有的保留元素
cm = itertools.takewhile(lambda x: x.isupper(), 'BCCCaAbc')
for c in cm:
print(c, end='')
>>BCCC
# 由于第一个为小写字母，匿名函数判断为False，则放弃所有的元素，cm中没有元素，因此输出为空
cm = itertools.takewhile(lambda x: x.isupper(), 'aBCCCaAbc')
for c in cm:
print(c, end='')
>>
- tee(iterable, n=2)
返回n个独立的迭代器，默认返回两个
data = 'ABCDE'
iter1, iter2 = itertools.tee(data)
for item in iter1:
print(item, end='')
print()
for item in iter2:
print(item, end='')
>>ABCDE
ABCDE
zip_longest(iter1, iter2=None, *some, **kwargs)
zip_longest(*iterable[,fillvalue=None])
返回一个由元组构成的迭代器
简单地说，就是将多个迭代器对应元素重新组成一个元组，直到最长的元组全部配对完成。较短的迭代器元素不足，会由传入的命名关键字参数fillvalue进行填充（替代）
cm = itertools.zip_longest([1, 2, 3], 'abc', (1, 2, 3, 4), fillvalue='_')
print(list(cm))
>>[(1, 'a', 1), (2, 'b', 2), (3, 'c', 3), ('_', '_', 4)]
如有错误，欢迎指正！
最后修改时间：2018-01-23 22:33:34
