Python itertools模块

itertools模块包含创建高效迭代器的函数，这些函数的返回值不是list，而是iterator（可迭代对象）,可以用各种方式对数据执行循环操作

count(),    repeat(),    cycle(),    chain(),    chain.from_iterable(),    islice()

compress(),    filterflase(),    dropwhile(),    takewhile(),    accumulate(),    groupby(),    starmap(),    tee(),    zip_longest()

product(),    permutations(),    combinations(),    combinations_with_replacement()

工具函数

                主要用于为模块中其他函数提供输入

count(start=0, step=1)可以从开始点产生无限数字序列，setp参数控制数字的间隔

for in itertools.cout(15,2):
    if n<20:
        pass
    else:
        break

repeat(object[, times])创建一个反复返回object的迭代器。times可指定返回的次数

>>> ns = itertools.repeat('A', 3)
>>> for n in ns:
...     print(n)
...

>>> for n in range(7):
...     print(next(itertools.repeat('yes ')))
...

cycle(iterable)    轮式迭代，重复再iterable上轮转

              使迭代器从iterable返回元素并保存每个元素的副本。当iterable耗尽时，从保存的副本返回元素。重复无限。

                     可为负载平衡或资源分配创建轮式迭代

>>> res1=[]
>>> res2=[]
>>> res3=[]
>>> resources=itertools.cycle([res1,res2,res3])
>>> for n in range(30):
...     res = next(resources)
...     res.append(n)
...
>>> res1
[0, 3, 6, 9, 12, 15, 18, 21, 24, 27]
>>> res2
[1, 4, 7, 10, 13, 16, 19, 22, 25, 28]
>>> res3
[2, 5, 8, 11, 14, 17, 20, 23, 26, 29]

chain(*iterable)将一组迭代对象串联起来，形成一个更大的迭代器

>>> for c in itertools.chain('ABC', 'XYZ'):
...     print(c)
'A' 'B' 'C' 'X' 'Y' 

chain.from_iterable(iterables) chain()的替代构造函数， iterables为生成iterable序列的迭代变量

    # chain.from_iterable(['ABC', 'DEF']) --> A B C D E F

islice(iterable,start, stop[, step])

islice(iterable,stop)与切片类似，由于使用了生成器，再内存使用上更加高效

                    islice()不支持start,stop,step的负值。

    # islice('ABCDEFG', 2) --> A B
    # islice('ABCDEFG', 2, 4) --> C D
    # islice('ABCDEFG', 2, None) --> C D E F G
    # islice('ABCDEFG', 0, None, 2) --> A C E G

数据处理函数

             接受输入数据并转化元素，或者以某种方式过滤内容

             通常接受一个函数对象作为参数

compress(data, selectors)   创建迭代器，用于过滤data中的元素，只返回在selectors中具有对应元素为True的元素             

    # compress('ABCDEF', [1,0,1,0,1,1]) --> A C E F

            selectors的布尔值，可以是可转化为布尔值的东西，可以为表达式

filterflase(data,selectors)    和compress类似，返回的是selectors对应为False的值

dropwhile(predicate, iterable) 创建迭代器，接受一个输入函数predicate和一个iterable，对于每个iterable中元素应用于函数

            迭代器不会产生任何输出，直到predicate首次返回为假，因此它可能有一个冗长的启动时间。

    # dropwhile(lambda x: x<5, [1,4,6,4,1]) --> 6 4 1

takewhile(predicate,iterable)与dropwhile类似，但是会返回元素直到predicate首次为False

    # takewhile(lambda x: x<5, [1,4,6,4,1]) --> 1 4

accumulate(iterable[,func])创建的迭代对象返回iterable依次累加的值，或者其他通过func指定的二元函数的结果

            func为接受两个参数的函数，第一个参数为上一次accumuulate生成的值，第二个为iterable的下一个值

                iterable的元素是可以作为func参数的任何类型               

            如果输入iterable为空，则输出的迭代对象也为空

# accumulate([1,2,3,4,5]) --> 1 3 6 10 15
# accumulate([1,2,3,4,5],lambda x,y:x*y) -->1 2 6 24 120

groupby(iterable, key=None)创建一个迭代器，对iterable生成的连续项进行分组

            返回的迭代器生成元素（key,group),key为分组的键值，group为迭代器，生成组成该组的所有项

            如果iterable在多次连续迭代中生成了同一项，则会定义一个组

            key为一个函数，应用于每一项，如果此函数存在返回值，则后续项与该值进行比较，而不是与该项本身比较

            key默认为标识函数，并不更改元素

            每当key函数的值发生变化时（通常需要使用相同的键函数对数据进行排序），它会生成一个断点或新的组。

            这种行为不同于SQL的GROUP BY，它集合了公共元素，而不考虑它们的输入顺序。

    # [k for k, g in groupby('AAAABBBCCDAABBB')] --> A B C D A B
    # [k for k, g in groupby('AAAABBBCCD')] -->     A B C D 

    # [list(g) for k, g in groupby('AAAABBBCCD')] --> AAAA BBB CC D

             通常需要使用相同的键函数对数据进行排序

data = sorted(data, key=keyfunc)
for k, g in groupby(data, keyfunc):

            返回的group本身是一个迭代器，它与groupby()共享底层的可迭代器。

            因为源是共享的，所以会导致先前的组不再可见，如果以后需要该数据，则应将其存储为列表：

groups = []
uniquekeys = []
data = sorted(data, key=keyfunc)
for k, g in groupby(data, keyfunc):
    groups.append(list(g))      # Store group iterator as a list
    uniquekeys.append(k)

starmap(func,iterable) 创建一个迭代器，生成值为func(*item),item来自iterable

        # starmap(pow, [(2,5), (3,2), (10,3)]) --> 32 9 1000

            与map()的区别在于function(a,b),function(*c),starmap的func参数函数可以接受任意个数参数

            但是只有当iterable生成的项是用于这种调用函数的方式是，此函数才有效    

            

tee(iterable， n=2) 从单个iterable中创建n个独立的迭代器。

            创建的迭代器以n元组的形式返回

            为了克隆原始迭代器，生成项会被还承诺，并在所有新创建的迭代器中使用

            调用tee()拆分后，不要在任何其他地方使用试迭代器iterable

            通常，如果一个迭代器在另一个迭代器开始之前使用大多数或所有数据，则不应使用tee(),而应该使用list()会更快

zip_longest(*iterables, fillvalue=None) 创建一个迭代器，聚合来自每个迭代器的元素。

            如果迭代的长度不均匀，则缺少的值将被填充fillvalue。

            迭代继续，直到最长可迭代被耗尽。

 # zip_longest('ABCD', 'xy', fillvalue='-') --> Ax By C- D-

组合生成器

     

product(*iterables, repeat=1) 创建迭代器，生成iterables位置参数中项的笛卡尔积的元组，repeat指定重复生成序列的次数   

            大致等同于生成器表达式中的嵌套for循环，product(A, B)等同于( (x,y) for x in A for y in B)

    # product('ABCD', 'xy') 
    ('A','x') ('A','y') ...--> Ax Ay Bx By Cx Cy Dx Dy
    # product(range(2), repeat=3) 
    (0,0,0) (0,0,1) ...--> 000 001 010 011 100 101 110 111

permutations(iterable, r=None)  创建迭代器，返回一个iterable中所有长度为r的项的序列    

            如果忽略r，则r默认为iterable的长度

            元素根据它们的位置被视为唯一的而不是它们的值。

            因此，如果输入元素是唯一的，则在每个排列中将不存在重复值。

    # permutations('ABCD', 2) 
    ('A','B') ('A', 'C') ... --> AB AC AD BA BC BD CA CB CD DA DB DC
    # permutations(range(3)) --> 012 021 102 120 201 210

combinations(iterable, r) 与permutations()类似，但是返回的子序列中的项按照iterable中的顺序排列

    # combinations('ABCD', 2) 
    ('A','B') ('A','C') ...--> AB AC AD BC BD CD
    # combinations(range(4), 3) 
    (0,1,2) (0,1,3) ...--> 012 013 023 123

combinations_with_replacement(iterable,r) 与combinations()类似，但是允许单个元素重复一次以上

    # combinations_with_replacement('ABC', 2) --> AA AB AC BB BC CC