标签：cto function int 接收 col 连接 play 无限循环 false
Python 内置的 itertools 模块包含了一系列用来产生不同类型迭代器的函数或类，这些函数的返回都是一个迭代器，我们可以通过 for 循环来遍历取值，也可以使用 next() 来取值。
itertools模块提供了一下三种类型的迭代器
1.count(firstval=0,step=1)：
接收两个参数，创建一个以firstval为起始，step为步长的无限序列，默认下这两个参数分别为0,1
import itertools #什么都没传，默认参数 nums=itertools.count() for i in nums: if i >6: break print(i) #count()传入两个参数，起始值，和步长 nums=itertools.count(2,3) for i in nums: if i>10: break print(‘i‘,i)
2.cycle(iterable)：
创建一个迭代器，返回iterable中所有元素并保存一个副本，当取玩iterable中所有元素，返回副本中所有元素，无限重复
#cycle()用于对itertools中的元素反复循环 import itertools cycle_strings=itertools.cycle(‘ABC‘) k=0 for i in cycle_strings: k+=1 if k>7: break print(i) #输出 # A # B # C # A # B # C # A
3.repeat(object[,times])：
创建一个迭代器，不断重复object，若设置了times，则将object重复times次，否则无限循环重复
#反复生成object，若给定times,则重复次数为times，否则为无限次 import itertools for item in itertools.repeat(‘hello world‘,3): print(item) # 输出 # hello world # hello world # hello world
1.accumulate(iterable[,func])：
生成一个迭代器，若没有指定func这默认将iterable中各个部分进行累加
from itertools import accumulate import operator a=[1,2,3,4,5] print(list(accumulate(a))) #输出[1, 3, 6, 10, 15]， print(list(accumulate(a,operator.mul))) #输出[1, 2, 6, 24, 120]
2.chain(iter1,iter2,...)：
可以将多个iter1，iter2...中的元素进行连接输出
from itertools import chain for item in chain([1,2,3],[‘a‘,‘b‘,‘c‘,‘d‘]): print(item) # 1 # 2 # 3 # a # b # c # d
3.compress(data,selectors)：
创建一个迭代器，返回经selectors进行真值测试后为True相应位置的值，若输入两个参数长短不一，那么在按照短的进行输出。
from itertools import compress list(compress("ABCDE",[1,-1,1,0,1,1,1,1])) # [‘A‘, ‘B‘, ‘C‘, ‘E‘]
4.dropwhile(predicate,iterable)：
创建一个迭代器，若predicate为true，丢弃iterable中相应位置的元素，这相当于一个元素筛选过程。
from itertools import dropwhile list(dropwhile(lambda x :x<5,[1,3,6,2,1,6])) # [6, 2, 1, 6]
5.filterfalse(predicate,iterable)：
只返回iterable中predicate为False的元素，如果predicate为None，返回真值测试为false的元素。
from itertools import filterfalse print(list(filterfalse(None,range(1,10)))) #[] print(list(filterfalse(lambda x: x%2,range(1,10)))) #[2, 4, 6, 8]
6.groupby(iterable,key=None)：
返回iterable中连续的键和组，key 是一个计算元素键值函数。如果未指定或为 None，key 缺省为恒等函数（identity function），返回元素不变。一般来说，iterable 需用同一个键值函数预先排序。
from itertools import groupby for key,value_iter in groupby(‘aaabbbbaaccd‘): print(key,":",list(value_iter)) print(‘-------------------------------‘) data=[‘a‘,‘bb‘,‘ccc‘,‘dd‘,‘eeee‘,‘f‘] for key,value_iter in groupby(data,len): print(key,":",list(value_iter)) # a : [‘a‘, ‘a‘, ‘a‘] # b : [‘b‘, ‘b‘, ‘b‘, ‘b‘] # a : [‘a‘, ‘a‘] # c : [‘c‘, ‘c‘] # d : [‘d‘] # ------------------------------- # 1 : [‘a‘] # 2 : [‘bb‘] # 3 : [‘ccc‘] # 2 : [‘dd‘] # 4 : [‘eeee‘] # 1 : [‘f‘]
7.islice(iterable,stop)或islice(iterable,start,stop[,step])：
相当于切片
from itertools import islice print(list(islice([10,6,2,8,1,3,9],5)))#选择前5个元素，包括第五个 #[10, 6, 2, 8, 1] print(list(islice([10,6,2,8,1,3,9],1,5))) # [6, 2, 8, 1]
8.startmap(func,iterable)：
创建一个迭代器，使用从可迭代对象中获取的参数来计算该函数。当参数对应的形参已从一个单独可迭代对象组合为元组时（数据已被“预组对”）可用此函数代替 map()。
from itertools import starmap list(starmap(pow,[(2,5),[3,2],[10,3]])) # [32, 9, 1000]
9.takewhile(predicate,iterable)：
创建一个迭代器，只要 predicate 为真就从可迭代对象中返回元素
from itertools import takewhile list(takewhile(lambda x:x<5,[1,2,3,6,2,1])) # [1, 2, 3]
10.tee(iterable,n=2)：
从一个可迭代对象中返回 n 个独立的迭代器
from itertools import tee iter1 = tee(‘abcde‘) for key,item in enumerate(iter1): print(list(item)) # [‘a‘, ‘b‘, ‘c‘, ‘d‘, ‘e‘] # [‘a‘, ‘b‘, ‘c‘, ‘d‘, ‘e‘]
11.zip_longest(*iterables,fillvalue=None)：
创建一个迭代器，从每个可迭代对象中收集元素。如果可迭代对象的长度未对齐，将根据 fillvalue 填充缺失值。迭代持续到耗光最长的可迭代对象。
from itertools import zip_longest list(zip_longest(‘a‘,‘bbbb‘,‘dabcfd‘,fillvalue=‘-‘)) # 输出： # [(‘a‘, ‘b‘, ‘d‘), # (‘-‘, ‘b‘, ‘a‘), # (‘-‘, ‘b‘, ‘b‘), # (‘-‘, ‘b‘, ‘c‘), # (‘-‘, ‘-‘, ‘f‘), # (‘-‘, ‘-‘, ‘d‘)]
1.product(*iterables,repeat=1)：
可迭代对象输入的笛卡儿积。用于求解多个可迭代对象的笛卡尔积。与嵌套for循环等价。其中，repeat 是一个关键字参数，用于指定重复生成序列的次数。
from itertools import product for item in product(‘ab‘,‘c‘): print(item) # (‘a‘, ‘c‘) # (‘b‘, ‘c‘) print(list(product(‘ab‘,‘c‘,repeat=2))) # [(‘a‘, ‘c‘, ‘a‘, ‘c‘), (‘a‘, ‘c‘, ‘b‘, ‘c‘), (‘b‘, ‘c‘, ‘a‘, ‘c‘), (‘b‘, ‘c‘, ‘b‘, ‘c‘)]
2.permutations(iterable,r=None)：
连续返回由 iterable 元素生成长度为 r 的排列。
如果 r 未指定或为 None ，r 默认设置为 iterable 的长度，这种情况下，生成所有全长排列。
排列依字典序发出。因此，如果 iterable 是已排序的，排列元组将有序地产出。
即使元素的值相同，不同位置的元素也被认为是不同的。如果元素值都不同，每个排列中的元素值不会重复。
from itertools import permutations print(list(permutations(‘ABC‘,2))) # [(‘A‘, ‘B‘), (‘A‘, ‘C‘), (‘B‘, ‘A‘), (‘B‘, ‘C‘), (‘C‘, ‘A‘), (‘C‘, ‘B‘)] list(permutations(‘ABC‘)) # [(‘A‘, ‘B‘, ‘C‘), # (‘A‘, ‘C‘, ‘B‘), # (‘B‘, ‘A‘, ‘C‘), # (‘B‘, ‘C‘, ‘A‘), # (‘C‘, ‘A‘, ‘B‘), # (‘C‘, ‘B‘, ‘A‘)]
3.combinations(iterable,r)：
返回由输入 iterable 中元素组成长度为 r 的子序列。
组合按照字典序返回。所以如果输入 iterable 是有序的，生成的组合元组也是有序的。
即使元素的值相同，不同位置的元素也被认为是不同的。如果元素各自不同，那么每个组合中没有重复元素。
from itertools import combinations,permutations print("permutations：",list(permutations(‘ABC‘,2))) print("combinations：",list(combinations("ABC",2))) # permutations： [(‘A‘, ‘B‘), (‘A‘, ‘C‘), (‘B‘, ‘A‘), (‘B‘, ‘C‘), (‘C‘, ‘A‘), (‘C‘, ‘B‘)] # combinations： [(‘A‘, ‘B‘), (‘A‘, ‘C‘), (‘B‘, ‘C‘)]
4.combinations_with_replacement(iterable, r)：
返回由输入 iterable 中元素组成的长度为 r 的子序列，允许每个元素可重复出现。
组合按照字典序返回。所以如果输入 iterable 是有序的，生成的组合元组也是有序的。
不同位置的元素是不同的，即使它们的值相同。因此如果输入中的元素都是不同的话，返回的组合中元素也都会不同。
from itertools import combinations_with_replacement,permutations print(‘permutations：‘,list(permutations(‘ABC‘,2))) print(‘combinations_with_replacement：‘,list(combinations_with_replacement("ABC",2))) # permutations： [(‘A‘, ‘B‘), (‘A‘, ‘C‘), (‘B‘, ‘A‘), (‘B‘, ‘C‘), (‘C‘, ‘A‘), (‘C‘, ‘B‘)] # combinations_with_replacement： [(‘A‘, ‘A‘), (‘A‘, ‘B‘), (‘A‘, ‘C‘), (‘B‘, ‘B‘), (‘B‘, ‘C‘), (‘C‘, ‘C‘)]
标签：cto function int 接收 col 连接 play 无限循环 false
原文地址：https://www.cnblogs.com/2019zjp/p/13231686.html
