介绍

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