python迭代器Itertools

https://docs.python.org/3.6/library/itertools.html

一无限迭代器：

Iterator	Arguments	Results	Example
count()	start, [step]	start, start+step, start+2*step, ...	count(10) --> 10 11 12 13 14 ...
cycle()	p	p0, p1, ... plast, p0, p1, ...	cycle('ABCD') --> A B C D A B C D ...
repeat()	elem [,n]	elem, elem, elem, ... endlessly or up to n times	repeat(10, 3) --> 10 10 10

• itertools.count（arg1,arg2）:arg1:开始位置，arg2：步长

 #相当于for i in range(,)

 #创建迭代器，从10开始步长为2，无结束

 >>> import itertools
 >>> n = itertools.count(,)
 >>> print(type(n))
 <class 'itertools.count'>
 >>> for i in n:
     print(i)

itertools.count()

• itertools.cycle(itertable)

 生成一个无限循环可迭代参数的迭代器
 >>> itertools.cycle('ABCDE')
 <itertools.cycle object at 0x00000000033576C8>
 >>> for i in itertools.cycle('ABCDE'):
     print(i)

 #ABCDEABCDE.......

itertools.cycle()

• itertools.repeat(arg1,arg2):arg1:要重复的参数，arg2:重复多少遍

 >>> s = itertools.repeat('ABC',)
 >>> s
 repeat('ABC', )
 >>> for i in s:
     print(i)
 #ABC
 #ABC
 #ABC

itertools.repeat()

二处理输入序列迭代器

迭代器	参数	结果	例
accumulate()	p [，func]	p0，p0 + p1，p0 + p1 + p2，...	accumulate([1,2,3,4,5]) --> 1 3 610 15
chain()	p，q，...	p0，p1，... plast，q0，q1，...	chain('ABC', 'DEF') --> A B C D EF
chain.from_iterable()	迭代	p0，p1，... plast，q0，q1，...	chain.from_iterable(['ABC','DEF']) --> A B C D E F
compress()	数据，选择器	（d [0]如果s [0]），（d [1]如果s [1]），......	compress('ABCDEF', [1,0,1,0,1,1])--> A C E
dropwhile()	pred，seq	seq [n]，seq [n + 1]，当pred失败时开始	dropwhile(lambda x: x<5,[1,4,6,4,1]) --> 6 4 1
filterfalse()	pred，seq	seq的元素，其中pred（elem）是假的	filterfalse(lambda x: x%2,range(10)) --> 0 2 4 6 8
groupby()	可迭代的[，关键]	按键值（v）分组的子迭代器
islice()	seq，[start，] stop [，step]	来自seq [start：stop：step]的元素	islice('ABCDEFG', 2, None) --> CD E F G
starmap()	func，seq	func（* seq [0]），func（* seq [1]），...	starmap(pow, [(2,5), (3,2),(10,3)]) --> 32 9 1000
takewhile()	pred，seq	seq [0]，seq [1]，直到pred失败	takewhile(lambda x: x<5,[1,4,6,4,1]) --> 1 4
tee()	它，n	it1，it2，... itn将一个迭代器拆分为n
zip_longest()	p，q，...	（p [0]，q [0]），（p [1]，q [1]），...	zip_longest('ABCD', 'xy',fillvalue='-') --> Ax By C- D-

• itertools.accumulate(terable ,func )

　　　　创建一个迭代器，返回累积的总和，或其他二进制函数的累计结果（通过可选的func参数指定 ）。如果提供了func，它应该是两个参数的函数。输入可迭代的 元素可以是可以被接受为func的参数的任何类型,如果输入iterable为空，则输出iterable也将为空。

 >>> import operator
 >>> n=itertools.accumulate([,,,])
 >>> for i in n:
 ...     print(i)#   

 >>> n=itertools.accumulate([,,,],func=operator.mul)
 >>> for i in n:
 ...     print(i) #   

itertools.accumulate()

• itertools.chain(*iterable)

 将俩个可迭代对象缝合起来，生成一个迭代器
 >>> n=itertools.chain('abc','def')
 >>> for i in n:
 ...     print(i)
 ...
 a
 b
 c
 d
 e
 f

itertools.chain()

• classmethod chain.from_iterable（iterable ）对于一个可迭代的数据生成一个迭代器

 >>> for i in itertools.chain.from_iterable(["abc","def"]):
 ...     print(i)
 ...
 a
 b
 c
 d
 e
 f

• itertools.compress(data, selectors) ：选择那些字符作为迭代器内容

 #选择那些字符输出
 >>> for i in itertools.compress("ABCDEFG",[,,,,,,]):
 ...     print(i)
 ...
 A
 C
 D
 E

itertools.compress()

• itertools.dropwhile(pred,seq)：当不满足pred条件时，截取后面的数据做为迭代器内容

 dropwhile(lambda x: x<, [,,,,]) -->   

• itertools.groupby(iterable,key)

　　返回一个产生按照key进行分组后的值集合的迭代器.

　　如果iterable在多次连续迭代中生成了同一项，则会定义一个组，如果将此函数应用一个分类列表，那么分组将定义该列表中的所有唯一项，key（如果已提供）是一个函数，应用于每一项，如果此函数存在返回值，该值将用于后续项而不是该项本身进行比较，此函数返回的迭代器生成元素(key, group)，其中key是分组的键值，group是迭代器，生成组成该组的所有项。

 >>> for key, group in itertools.groupby('AAABBBCCAAA'):
 ...     print(key, list(group))
 ...
 A ['A', 'A', 'A']
 B ['B', 'B', 'B']
 C ['C', 'C']
 A ['A', 'A', 'A']

itertools.group()

• itertools.starmap(func，seq)

 starmap(pow, [(,), (,), (,)]) -->   

• itertools.tee(iterable,n)

 >>> for i in itertools.tee([,,],):
 ...     for x in i:
 ...             print(x)
 ...

三：组合迭代器

product()	p, q, … [repeat=1]	cartesian product, equivalent to a nested for-loop
permutations()	p[, r]	r-length tuples, all possible orderings, no repeated elements
combinations()	p, r	r-length tuples, in sorted order, no repeated elements
combinations_with_replacement()	p, r	r-length tuples, in sorted order, with repeated elements
product('ABCD', repeat=2)		AA AB AC AD BA BB BC BD CA CB CC CD DA DB DC DD
permutations('ABCD', 2)		AB AC AD BA BC BD CA CB CD DA DB DC
combinations('ABCD', 2)		AB AC AD BC BD CD
combinations_with_replacement('ABCD', 2)		AA AB AC AD BB BC BD CC CD DD

• itertools.product(*iterables[, repeat])　笛卡尔积

  　　创建一个迭代器，生成表示item1，item2等中的项目的笛卡尔积的元组，repeat是一个关键字参数，指定重复生成序列的次数

 b=('a','b'.'c'),a=(,,),c=('d','e','f')
 >>> c=itertools.product(a,b,c)
 >>> for i in c:
 ...     print(i)
 (, 'a', 'd')
 (, 'a', 'e')
 (, 'a', 'f')
 (, 'b', 'd')
 (, 'b', 'e')
 (, 'b', 'f')
 (, 'c', 'd')
 (, 'c', 'e')
 (, 'c', 'f')
 (, 'a', 'd')
 (, 'a', 'e')
 (, 'a', 'f')
 (, 'b', 'd')
 (, 'b', 'e')
 (, 'b', 'f')
 (, 'c', 'd')
 (, 'c', 'e')
 (, 'c', 'f')
 (, 'a', 'd')
 (, 'a', 'e')
 (, 'a', 'f')
 (, 'b', 'd')
 (, 'b', 'e')
 (, 'b', 'f')
 (, 'c', 'd')
 (, 'c', 'e')
 (, 'c', 'f')

• itertools.permutation(iterable[, r])，按指定每个元素长度，返回所有有重复的排列，但不允许一个元素中有相同要的子元素

 >>> a = [, , , ]
 >>> s = [i for i in itertools.permutations(a,)] # 从序列a中选出3个元素进行组合排列
 >>> s
 [(, , ), (, , ), (, , ), (, , ), (, , ), (, , ), (, , ), (, , ), (, , ), (, , ), (, , ), (, , ), (, , ), (, , ), (, , ), (, , ), (, , ), (, , ), (, , ), (, , ), (, , ), (, , ), (, , ), (, , )]

 >>> from itertools import permutations
 >>> print permutations(['','',''])
 <itertools.permutations object at 0x02A45210>
 >>>
 >>> print list(permutations(['','','']))
 [('', '', ''), ('', '', ''), ('', '', ''), ('', '', ''), ('', '', ''), ('', '', '')]
 >>>
 >>> print list(permutations(['','',''],))
 [('', ''), ('', ''), ('', ''), ('', ''), ('', ''), ('', '')]
 >>>
 >>> print list(permutations('abc',))
 [('a', 'b', 'c'), ('a', 'c', 'b'), ('b', 'a', 'c'), ('b', 'c', 'a'), ('c', 'a', 'b'), ('c', 'b', 'a')]

• itertools.combinations(iterable, r) 按指定长度，返回所有无重复组合，且每个元素中的子元素不能重复（如AA不可以）

 >>> a = [, , , ]
 >>> s = [i for i in itertools.combinations(a,)] # 从序列a中选出2个不重复的元素
 >>> s
 [(, ), (, ), (, ), (, ), (, ), (, )]

•  itertools.combinations(iterable,r)：和上面的一样，只是允许每个元素中的子元素可以相同（AA可以）

 >>> from itertools import combinations_with_replacement
 >>>
 >>> print list(combinations_with_replacement('',))
 [('', ''), ('', ''), ('', ''), ('', ''), ('', ''), ('', ''), ('', ''), ('', ''), ('', ''), ('', ''), ('', ''), ('', ''), ('', ''), ('', ''), ('', '')]
 >>>
 >>> A = [,,,,]
 >>> print list(combinations(A,))
 [(, ), (, ), (, ), (, ), (, ), (, ), (, ), (, ), (, ), (, )]