Python模块 - itertools循环器模块
http://blog.csdn.net/pipisorry/article/details/45171451
迭代工具库itertools
和collections库一样，还有一个库叫itertools，对某些问题真能高效地解决。itertools模块包含创建有效迭代器的函数，可以用各种方式对数据进行循环操作，此模块中的所有函数返回的迭代器都可以与for循环语句以及其他包含迭代器（如生成器和生成器表达式）的函数联合使用。
循环器是对象的容器，包含有多个对象。通过调用循环器的next()方法 (__next__()方法，在Python 3.x中)，循环器将依次返回一个对象。直到所有的对象遍历穷尽，循环器将举出StopIteration错误。
标准库中的itertools包提供了更加灵活的生成循环器的工具。这些工具的输入大都是已有的循环器。另一方面，这些工具完全可以自行使用Python实现，该包只是提供了一种比较标准、高效的实现方式。这也符合Python“只有且最好只有解决方案”的理念。
itertools的工具都可以自行实现，itertools只是提供了更加成形的解决方案。
皮皮blog
无穷循环器
count([n])
创建一个迭代器，生成从n开始的连续整数，如果忽略n，则从0开始计算（注意：此迭代器不支持长整数），如果超出了sys.maxint，计数器将溢出并继续从-sys.maxint-1开始计算。
count(5, 2) #从5开始的整数循环器，每次增加2，即5, 7, 9, 11, 13, 15 ...
cycle(iterable)
创建一个迭代器，对iterable中的元素反复执行循环操作，内部会生成iterable中的元素的一个副本，此副本用于返回循环中的重复项。
cycle("abc") #重复序列的元素，既a, b, c, a, b, c ...
使用for或者__next__()调用里面的元素。
示例：实现只输出3次
print_cnts = itertools.count(3, -1) #全局变量，如在ope_config中定义
if_print = ope_config.print_cnts.__next__() > 0 #py3
if_print = ope_config.print_cnts.next() > 0 #py2
with time_block("backward_in_optimize", if_print):
self.loss.backward()
repeat(object [,times])
创建一个迭代器，重复生成object，times（如果已提供）指定重复计数，如果未提供times，将无止尽返回该对象。
def repeat(object, times=None): if times is None: while True: yield object else: for i in xrange(times): yield objectrepeat(1.2)#重复1.2，构成无穷循环器，即1.2, 1.2, 1.2, ...
皮皮blog
函数式工具
函数式编程是将函数本身作为处理对象的编程范式。在Python中，函数也是对象，因此可以轻松的进行一些函数式的处理，比如map(), filter(), reduce()函数。
itertools包含类似的工具。这些函数接收函数作为参数，并将结果返回为一个循环器。
imap(function, iter1, iter2, iter3, ..., iterN)
创建一个迭代器，生成项function(i1, i2, ..., iN)，其中i1，i2...iN分别来自迭代器iter1，iter2 ... iterN，如果function为None，则返回(i1, i2, ..., iN)形式的元组，只要提供的一个迭代器不再生成值，迭代就会停止。
该函数与map()函数功能相似，只不过返回的不是序列，而是一个循环器。函数pow(内置的乘方函数)作为第一个参数，依次作用于后面两个列表的每个元素，并收集函数结果，组成返回的循环器。
[python] view plaincopy
- >>> from itertools import *
- >>> d = imap(pow, (2,3,10), (5,2,3))
- >>> for i in d: print i
- 32
- 9
- 1000
- ####
- >>> d = imap(pow, (2,3,10), (5,2))
- >>> for i in d: print i
- 32
- 9
- ####
- >>> d = imap(None, (2,3,10), (5,2))
- >>> for i in d : print i
- (2, 5)
- (3, 2)
starmap(func [, iterable]):
创建一个迭代器，生成值func(*item),其中item来自iterable，只有当iterable生成的项适用于这种调用函数的方式时，此函数才有效。
[python] view plaincopy
- def starmap(function, iterable):
- # starmap(pow, [(2,5), (3,2), (10,3)]) --> 32 9 1000
- for args in iterable:
- yield function(*args)
starmap(pow, [(1, 1), (2, 2), (3, 3)])pow将依次作用于表的每个tuple。
ifilter(predicate, iterable):
创建一个迭代器，仅生成iterable中predicate(item)为True的项，如果predicate为None，将返回iterable中所有计算为True的项。
[python] view plaincopy
- ifilter(lambda x: x%2, range(10)) --> 1 3 5 7 9
ifilter函数与filter()函数类似，只是返回的是一个循环器。
ifilter(lambda x: x > 5, [2, 3, 5, 6, 7]
将lambda函数依次作用于每个元素，如果函数返回True，则收集原来的元素。6, 7
ifilterfalse(predicate, iterable):
创建一个迭代器，仅生成iterable中predicate(item)为False的项，如果predicate为None，则返回iterable中所有计算为False的项。
[python] view plaincopy
- ifilterfalse(lambda x: x%2, range(10)) --> 0 2 4 6 8
ifilterfalse(lambda x: x > 5, [2, 3, 5, 6, 7])
与上面类似，但收集返回False的元素。2, 3, 5
takewhile(predicate [, iterable]):
创建一个迭代器，生成iterable中predicate(item)为True的项，只要predicate计算为False，迭代就会立即停止。
[python] view plaincopy
- def takewhile(predicate, iterable):
- # takewhile(lambda x: x<5, [1,4,6,4,1]) --> 1 4
- for x in iterable:
- if predicate(x):
- yield x
- else:
- break
takewhile(lambda x: x < 5, [1, 3, 6, 7, 1])
当函数返回True时，收集元素到循环器。一旦函数返回False，则停止。1, 3
dropwhile(predicate, iterable):
创建一个迭代器，只要函数predicate(item)为True，就丢弃iterable中的项，如果predicate返回False，就会生成iterable中的项和所有后续项。
[python] view plaincopy
- def dropwhile(predicate, iterable):
- # dropwhile(lambda x: x<5, [1,4,6,4,1]) --> 6 4 1
- iterable = iter(iterable)
- for x in iterable:
- if not predicate(x):
- yield x
- break
- for x in iterable:
- yield x
dropwhile(lambda x: x < 5, [1, 3, 6, 7, 1])
当函数返回False时，跳过元素。一旦函数返回True，则开始收集剩下的所有元素到循环器。6, 7, 1
皮皮blog
组合工具
我们可以通过组合原有循环器，来获得新的循环器。
chain链接可遍历对象(iter1, iter2, ..., iterN)
给出一组迭代器(iter1, iter2, ..., iterN)，此函数创建一个新迭代器来将所有的迭代器链接起来，返回的迭代器从iter1开始生成项，知道iter1被用完，然后从iter2生成项，这一过程会持续到iterN中所有的项都被用完。
from itertools import chain test = chain('AB', 'CDE', 'F') for el in test: print el A B C D E F chain.from_iterable(iterables)
一个备用链构造函数，其中的iterables是一个迭代变量，生成迭代序列，此操作的结果与以下生成器代码片段生成的结果相同：
>>> def f(iterables): for x in iterables: for y in x: yield y >>> test = f('ABCDEF')
>>> test.next()
'A' >>> from itertools import chain
>>> test = chain.from_iterable('ABCDEF')
>>> test.next()
'A' Flattening lists扁平列表的不同实现方式
>>> a = [[1, 2], [3, 4], [5, 6]]
>>> list(itertools.chain.from_iterable(a))
[1, 2, 3, 4, 5, 6]>>> sum(a, [])
[1, 2, 3, 4, 5, 6]>>> [x for l in a for x in l]
[1, 2, 3, 4, 5, 6]>>> a = [[[1, 2], [3, 4]], [[5, 6], [7, 8]]]
>>> [x for l1 in a for l2 in l1 for x in l2]
[1, 2, 3, 4, 5, 6, 7, 8]处理更复杂列表的flatten实现：
flatten = lambda x: [y for l in x for y in flatten(l)] if type(x) in [tuple, list, np.ndarray] else [x] a = [[1, 2], 5, [6], (7, 8), (9)] print(flatten(a)) [1, 2, 5, 6, 7, 8, 9] Note:1. sum(iterable, start=None):
Return the sum of an iterable of numbers (NOT strings) plus the value of parameter 'start' (which defaults to 0). When the iterable is empty, return start.
2. 列表解析等要慢1.5倍
3. according to Python's documentation on sum,itertools.chain.from_iterable is the preferred method for this.
[在itertools中链和chain.from_iterable之间的区别是什么？]
product笛卡尔积(iter1, iter2, ... iterN, [repeat=1])
创建一个迭代器，生成表示item1，item2等中的项目的笛卡尔积的元组，repeat是一个关键字参数，指定重复生成序列的次数。
def product(*args, **kwds):
pools = map(tuple, args) * kwds.get('repeat', 1)
result = [[]]
for pool in pools:
result = [x+[y] for x in result for y in pool]
for prod in result:
yield tuple(prod)
示例
product('ABCD', 'xy') --> Ax Ay Bx By Cx Cy Dx Dy
product(range(2), repeat=3) --> 000 001 010 011 100 101 110 111
itertools.product(*a)itertools.product(list_a,list_b)
product("abc", [1, 2])# 多个循环器集合的笛卡尔积。相当于嵌套循环
for m, n in product("abc", [1, 2]):print m, n
Permutations排列 (itertools.permutations)
>>> for p in itertools.permutations([1, 2, 3, 4]):
... print ''.join(str(x) for x in p)permutations(iterable [,r]):
创建一个迭代器，返回iterable中所有长度为r的项目序列，如果省略了r，那么序列的长度与iterable中的项目数量相同：
def permutations(iterable, r=None):
# permutations('ABCD', 2) --> AB AC AD BA BC BD CA CB CD DA DB DC
# permutations(range(3)) --> 012 021 102 120 201 210
pool = tuple(iterable)
n = len(pool)
r = n if r is None else r
if r > n:
return
indices = range(n)
cycles = range(n, n-r, -1)
yield tuple(pool[i] for i in indices[:r])
while n:
for i in reversed(range(r)):
cycles[i] -= 1
if cycles[i] == 0:
indices[i:] = indices[i+1:] + indices[i:i+1]
cycles[i] = n - i
else:
j = cycles[i]
indices[i], indices[-j] = indices[-j], indices[i]
yield tuple(pool[i] for i in indices[:r])
break
else:
return
permutations("abc", 2)# 从"abcd"中挑选两个元素，比如ab, bc, ... 将所有结果排序，返回为新的循环器。
注意，上面的组合分顺序，即ab, ba都返回。
combinations组合(iterable, r)
创建一个迭代器，返回iterable中所有长度为r的子序列，返回的子序列中的项按输入iterable中的顺序排序:
[python] view plaincopy
- >>> from itertools import combinations
- >>> test = combinations([1,2,3,4], 2)
- >>> for el in test:
- print el
- (1, 2)
- (1, 3)
- (1, 4)
- (2, 3)
- (2, 4)
- (3, 4)
其中一个用例是查找所有组合，他能告诉你在一个组中元素的所有不能的组合方式
from itertools import combinations
teams = ["Packers", "49ers", "Ravens", "Patriots"]
for game in combinations(teams, 2):
print game
>>> ('Packers', '49ers')
>>> ('Packers', 'Ravens')
>>> ('Packers', 'Patriots')
>>> ('49ers', 'Ravens')
>>> ('49ers', 'Patriots')
>>> ('Ravens', 'Patriots')
combinations("abc", 2)# 从"abcd"中挑选两个元素，比如ab, bc, ... 将所有结果排序，返回为新的循环器。
注意，上面的组合不分顺序，即ab, ba的话，只返回一个ab。
combinations_with_replacement("abc", 2) # 与上面类似，但允许两次选出的元素重复。即多了aa, bb, cc
Note: 返回的对象转换成其它python基本类型只能转换一次，如combinations(teams, 2)只能转换成list(a)一次，否则迭代完了。
groupby根据给定的KEY分组(iterable [,key])
创建一个迭代器，对iterable生成的连续项进行分组，在分组过程中会查找重复项。
如果iterable在多次连续迭代中生成了同一项，则会定义一个组，如果将此函数应用一个分类列表，那么分组将定义该列表中的所有唯一项，key（如果已提供）是一个函数，应用于每一项，如果此函数存在返回值，该值将用于后续项而不是该项本身进行比较，此函数返回的迭代器生成元素(key, group)，其中key是分组的键值，group是迭代器，生成组成该组的所有项。
将key函数作用于原循环器的各个元素。根据key函数结果，将拥有相同函数结果的元素分到一个新的循环器。每个新的循环器以函数返回结果为标签。
这就好像一群人的身高作为循环器。我们可以使用这样一个key函数: 如果身高大于180，返回"tall"；如果身高底于160，返回"short";中间的返回"middle"。最终，所有身高将分为三个循环器，即"tall", "short", "middle"。
def height_class(h):if h > 180:return "tall"elif h < 160:return "short"else:return "middle"friends = [191, 158, 159, 165, 170, 177, 181, 182, 190]friends = sorted(friends, key = height_class)for m, n in groupby(friends, key = height_class):print(m)print(list(n))注意，groupby的功能类似于UNIX中的uniq命令。分组之前需要使用sorted()对原循环器的元素，根据key函数进行排序，让同组元素先在位置上靠拢。
>>> fromoperatorimportitemgetter
>>> importitertools
>>> with open("contactlenses.csv","r") as infile:
... data = [line.strip().split(",")forline in infile]
...
>>> data = data[1:]
>>> defprint_data(rows):
... print"".join(" ".join("{: <16}".format(s)fors in row) forrowin rows)
...
>>> print_data(data)
young myope no normal soft
young myope yes reduced none
young myope yes normal hard
pre-presbyopic myope no reduced none
pre-presbyopic hypermetrope no normal soft
pre-presbyopic hypermetrope yes normal none
presbyopic myope yes normal hard
presbyopic hypermetrope yes reduced none
presbyopic hypermetrope yes normal none
...
>>> data.sort(key=itemgetter(-1))
>>> forvalue, groupinitertools.groupby(data,lambdar: r[-1]):
... print"-----------"
... print"Group: "+value
... print_data(group)
...
-----------
Group: hard
young myope yes normal hard
young hypermetrope yes normal hard
-----------
Group: none
young myope no reduced none
young myope yes reduced none
-----------
Group: soft
young myope no normal soft
young hypermetrope no normal soft
...
皮皮blog
其它工具
compress
compress("ABCD", [1, 1, 1, 0]) # 根据[1, 1, 1, 0]的真假值情况，选择第一个参数"ABCD"中的元素。A, B, C
islice(iterable, [start, ] stop [, step]):
创建一个迭代器，生成项的方式类似于切片返回值： iterable[start : stop : step]，将跳过前start个项，迭代在stop所指定的位置停止，step指定用于跳过项的步幅。与切片不同，负值不会用于任何start，stop和step，如果省略了start，迭代将从0开始，如果省略了step，步幅将采用1.
[python] view plaincopy
- View Code
- def islice(iterable, *args):
- # 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
- s = slice(*args)
- it = iter(xrange(s.start or 0, s.stop or sys.maxint, s.step or 1))
- nexti = next(it)
- for i, element in enumerate(iterable):
- if i == nexti:
- yield element
- nexti = next(it)
- #If start is None, then iteration starts at zero. If step is None, then the step defaults to one.
- #Changed in version 2.5: accept None values for default start and step.
islice()# 类似于slice()函数，只是返回的是一个循环器
izip(iter1, iter2, ... iterN):
izip() # py2中类似于zip()函数，只是返回的是一个循环器；py3中只有zip()。zip函数参考[python函数： 内置函数]
创建一个迭代器，生成元组(i1, i2, ... iN)，其中i1，i2 ... iN 分别来自迭代器iter1，iter2 ... iterN，只要提供的某个迭代器不再生成值，迭代就会停止，此函数生成的值与内置的zip()函数相同。
[python] view plaincopy
- def izip(*iterables):
- # izip('ABCD', 'xy') --> Ax By
- iterables = map(iter, iterables)
- while iterables:
- yield tuple(map(next, iterables))
izip_longest(iter1, iter2, ... iterN, [fillvalue=None]):
(py3中只有zip_longest())与izip()相同，但是迭代过程会持续到所有输入迭代变量iter1,iter2等都耗尽为止。
如果没有使用fillvalue关键字参数指定不同的值，则使用None来填充已经使用的迭代变量的值。
- def izip_longest(*args, **kwds):
- # izip_longest('ABCD', 'xy', fillvalue='-') --> Ax By C- D-
- fillvalue = kwds.get('fillvalue')
- def sentinel(counter = ([fillvalue]*(len(args)-1)).pop):
- yield counter() # yields the fillvalue, or raises IndexError
- fillers = repeat(fillvalue)
- iters = [chain(it, sentinel(), fillers) for it in args]
- try:
- for tup in izip(*iters):
- yield tup
- except IndexError:
- pass
使用ziplongest可以实现机器学习中batch数据的生成：
list(zip_longest(*[iter(train_data_words)] * batch_size))首先生成batch_size个相同地址的整个数据的迭代器列表，再解构变成zip_longest的多个参数。
tee(iterable [, n]):
从iterable创建n个独立的迭代器，创建的迭代器以n元组的形式返回，n的默认值为2，此函数适用于任何可迭代的对象，但是，为了克隆原始迭代器，生成的项会被缓存，并在所有新创建的迭代器中使用，一定要注意，不要在调用tee()之后使用原始迭代器iterable，否则缓存机制可能无法正确工作。
[python] view plaincopy
- def tee(iterable, n=2):
- it = iter(iterable)
- deques = [collections.deque() for i in range(n)]
- def gen(mydeque):
- while True:
- if not mydeque: # when the local deque is empty
- newval = next(it) # fetch a new value and
- for d in deques: # load it to all the deques
- d.append(newval)
- yield mydeque.popleft()
- return tuple(gen(d) for d in deques)
#Once tee() has made a split, the original iterable should not be used anywhere else; otherwise, the iterable could get advanced without the tee objects being informed.
#This itertool may require significant auxiliary storage (depending on how much temporary data needs to be stored).
In general, if one iterator uses most or all of the data before another iterator starts, it is
from:Python模块 - itertools循环器模块_皮皮blog-CSDN博客
ref:30 Python Language Features and Tricks You May Not Know About
http://www.cnblogs.com/cython/articles/2169009.html
Python标准库13 循环器 (itertools)
Python模块 - itertools循环器模块相关推荐
- python自带intertool模块找不到_介绍Python中内置的itertools模块
Python的内建模块itertools提供了非常有用的用于操作迭代对象的函数. 首先,我们看看itertools提供的几个"无限"迭代器: >>> import ...
- Python的内建模块itertools
Python的内建模块itertools提供了非常有用的用于操作迭代对象的函数. 首先,我们看看itertools提供的几个"无限"迭代器: import itertools na ...
- python 彩票排列组合_对福彩3D号码进行排列组合为例学习Python的itertools模块的用法...
这里我们以对福彩3D号码进行排列组合为例学习Python的itertools模块的用法.首先我们选择心仪的号码.比如我们选择4,5,7,8 第一种我们只要组六的组合.代码如下 import itert ...
- python之堆heapq模块
python之堆heapq模块 堆是一种特殊的树形结构,通常我们所说的堆的数据结构指的是完全二叉树,并且根节点的值小于等于该节点所有子节点的值. 堆是非线性的树形的数据结构,有两种堆,最大堆与最小堆. ...
- Python学习笔记011_模块_标准库_第三方库的安装
容器 -> 数据的封装 函数 -> 语句的封装 类 -> 方法和属性的封装 模块 -> 模块就是程序 , 保存每个.py文件 # 创建了一个hello.py的文件,它的内容如下 ...
- python里的collections模块
python里的collections模块 collections模块里提供了一些特殊功能的容器: namedtuple deque ChainMap Counter OrderedDict defa ...
- 四十六 常用内建模块 itertools
Python的内建模块itertools提供了非常有用的用于操作迭代对象的函数. 首先,我们看看itertools提供的几个"无限"迭代器: >>> import ...
- python 模块 导入机制 模块搜索 Python包 发布python模块或程序
python 模块 python模块:以.py结尾的代码文件. 顶层文件: 程序执行入口 模块文件1 模块文件2 模块文件3 在python中一 ...
- python基础之heapq模块（堆模块）
堆是一种数据结构,本质上是一种二叉树.在python中可以使用heapq模块实现,heapq可以实现一个简单的优先级队列. 一.堆的性质 堆分为小根堆与大根堆,小根堆的第一个元素可以理解为数值最小的元 ...
- python argparse模块_Python argparse模块应用实例解析
这篇文章主要介绍了Python argparse模块应用实例解析,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 简介 argparse是python ...
最新文章
- 最新！中国天气网api接口调用，key获取方式，数据请求秘钥获取，城市id获取方法
- C++基础算法学习——完美立方
- 不仅性能秒杀Hadoop，现在连分布式集群功能也开源了
- 超1亿人选择朋友圈三天可见，背后的原因值得深思
- JavaScript基本概念（下）
- mysql改了排序规则不生效_Mysql数据库表排序规则不一致导致联表查询，索引不起作用问题...
- excel的mysql语言,Mysql中文乱码及导出sql语句和Excel的相关解决方法
- MySql 从查询结果中更新数据
- 关于设计RPC框架的几个问题
- html5 3D微信头像,这组3D动物肖像设计，让微信头像惊艳整个朋友圈
- 速读-NFA的GPU加速器
- JAVA排序:快速排序算法
- Eclipse安装SVN插件和svn连接器
- HTML页面楷体gb2312字体,楷体gb2312
- SQL Express几个版本的区别
- 杜立特尔（Doolittle）分解法（LU分解法）
- java web象棋教程_【Java学习笔记】实战——网络象棋
- The eighth of Word-Day
- 中南网络教育计算机基础在线作业二,《计算机应用基础》2(G)在线作业答案
- 软件测试笔记——3.多种多样的测试类型