Python模块 - itertools循环器模块

傷城~ 2022-08-07 17:36 259阅读 0赞

http://[blog.csdn.net/pipisorry/article/details/45171451][blog.csdn.net_pipisorry_article_details_45171451]

# 迭代工具库itertools #

和collections库一样，还有一个库叫itertools，对某些问题真能高效地解决。itertools模块包含创建有效迭代器的函数，可以用各种方式对数据进行循环操作，此模块中的所有函数返回的迭代器都可以与for循环语句以及其他包含迭代器（如生成器和生成器表达式）的函数联合使用。

循环器是对象的容器，包含有多个对象。通过调用循环器的next()方法 (\_\_next\_\_()方法，在Python 3.x中)，循环器将依次返回一个对象。直到所有的对象遍历穷尽，循环器将举出StopIteration错误。

标准库中的itertools包提供了更加灵活的生成循环器的工具。这些工具的输入大都是已有的循环器。另一方面，这些工具完全可以自行使用Python实现，该包只是提供了一种比较标准、高效的实现方式。这也符合Python“只有且最好只有解决方案”的理念。

itertools的工具都可以自行实现，itertools只是提供了更加成形的解决方案。

[皮皮blog][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)

with time\_block("backward\_in\_optimize", ope\_config.print\_cnts.\_\_next\_\_() > 0):  
    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 object

repeat(1.2)\#重复1.2，构成无穷循环器，即1.2, 1.2, 1.2, ...

[皮皮blog][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 plain][][copy][view plain]

1.  >>> from itertools import \*  
2.     >>> d = imap(pow, (2,3,10), (5,2,3))  
3.     >>> for i in d: print i  
4.       
5.     32  
6.     9  
7.     1000  
8.       
9.    \#\#\#\#  
10.   >>> d = imap(pow, (2,3,10), (5,2))  
11.   >>> for i in d: print i  
12.     
13.   32  
14.   9  
15.    
16.   \#\#\#\#  
17.   >>> d = imap(None, (2,3,10), (5,2))  
18.   >>> for i in d : print i  
19.     
20.   (2, 5)  
21.   (3, 2)

### starmap(func \[, iterable\]): ###

创建一个迭代器，生成值func(\*item),其中item来自iterable，只有当iterable生成的项适用于这种调用函数的方式时，此函数才有效。

\[python\] [view plain][][copy][view plain]

1.  def starmap(function, iterable):  
2.      \# starmap(pow, \[(2,5), (3,2), (10,3)\]) --> 32 9 1000  
3.      for args in iterable:  
4.          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 plain][][copy][view plain]

1.  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 plain][][copy][view plain]

1.  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 plain][][copy][view plain]

1.  def takewhile(predicate, iterable):  
2.      \# takewhile(lambda x: x<5, \[1,4,6,4,1\]) --> 1 4  
3.      for x in iterable:  
4.          if predicate(x):  
5.              yield x  
6.          else:  
7.              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 plain][][copy][view plain]

1.  def dropwhile(predicate, iterable):  
2.      \# dropwhile(lambda x: x<5, \[1,4,6,4,1\]) --> 6 4 1  
3.      iterable = iter(iterable)  
4.      for x in iterable:  
5.          if not predicate(x):  
6.              yield x  
7.              break  
8.      for x in iterable:  
9.          yield x

dropwhile(lambda x: x < 5, \[1, 3, 6, 7, 1\])

当函数返回False时，跳过元素。一旦函数返回True，则开始收集剩下的所有元素到循环器。6, 7, 1  
[皮皮blog][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之间的区别是什么？][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 plain][][copy][view plain]

1.  >>> from itertools import combinations  
2.  >>> test = combinations(\[1,2,3,4\], 2)  
3.  >>> for el in test:  
4.      print el  
5.    
6.  (1, 2)  
7.  (1, 3)  
8.  (1, 4)  
9.  (2, 3)  
10. (2, 4)  
11. (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][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 plain][][copy][view plain]

1.  View Code   
2.    
3.   def islice(iterable, \*args):  
4.        \# islice('ABCDEFG', 2) --> A B  
5.        \# islice('ABCDEFG', 2, 4) --> C D  
6.        \# islice('ABCDEFG', 2, None) --> C D E F G  
7.        \# islice('ABCDEFG', 0, None, 2) --> A C E G  
8.        s = slice(\*args)  
9.        it = iter(xrange(s.start or 0, s.stop or sys.maxint, s.step or 1))  
10.       nexti = next(it)  
11.       for i, element in enumerate(iterable):  
12.          if i == nexti:  
13.              yield element  
14.              nexti = next(it)  
15.    
16.  \#If start is None, then iteration starts at zero. If step is None, then the step defaults to one.  
17.  \#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函数： 内置函数][python_]\]

创建一个迭代器，生成元组(i1, i2, ... iN)，其中i1，i2 ... iN 分别来自迭代器iter1，iter2 ... iterN，只要提供的某个迭代器不再生成值，迭代就会停止，此函数生成的值与内置的zip()函数相同。

**\[python\]** [view plain][][copy][view plain]

1.  def izip(\*iterables):  
2.        \# izip('ABCD', 'xy') --> Ax By  
3.        iterables = map(iter, iterables)  
4.        while iterables:  
5.            yield tuple(map(next, iterables))

**izip\_longest(iter1, iter2, ... iterN, \[fillvalue=None\]):**

(py3中只有zip\_longest())与izip()相同，但是迭代过程会持续到所有输入迭代变量iter1,iter2等都耗尽为止。

如果没有使用fillvalue关键字参数指定不同的值，则使用None来填充已经使用的迭代变量的值。

1.    def izip\_longest(\*args, \*\*kwds):  
2.         \# izip\_longest('ABCD', 'xy', fillvalue='-') --> Ax By C- D-  
3.         fillvalue = kwds.get('fillvalue')  
4.         def sentinel(counter = (\[fillvalue\]\*(len(args)-1)).pop):  
5.             yield counter()         \# yields the fillvalue, or raises IndexError  
6.         fillers = repeat(fillvalue)  
7.         iters = \[chain(it, sentinel(), fillers) for it in args\]  
8.         try:  
9.             for tup in izip(\*iters):  
10.               yield tup  
11.       except IndexError:  
12.           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 plain][][copy][view plain]

1.  def tee(iterable, n=2):  
2.      it = iter(iterable)  
3.      deques = \[collections.deque() for i in range(n)\]  
4.      def gen(mydeque):  
5.          while True:  
6.              if not mydeque:             \# when the local deque is empty  
7.                  newval = next(it)       \# fetch a new value and  
8.                  for d in deques:        \# load it to all the deques  
9.                      d.append(newval)  
10.             yield mydeque.popleft()  
11.     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:[http://blog.csdn.net/pipisorry/article/details/45171451][blog.csdn.net_pipisorry_article_details_45171451]

ref:30 Python Language Features and Tricks You May Not Know About

http://www.cnblogs.com/cython/articles/2169009.html

[Python标准库13 循环器 (itertools)][Python_13 _ _itertools]

[blog.csdn.net_pipisorry_article_details_45171451]: http://blog.csdn.net/pipisorry/article/details/45171451
[blog]: http://blog.csdn.net/pipisorry
[view plain]: http://blog.csdn.net/iamaiearner/article/details/9311687#
[documentation]: http://docs.python.org/2.7/library/functions.html#sum
[itertools_chain.from_iterable]: http://codego.net/555149/
[python_]: https://youzipi.blog.csdn.net/article/details/44755423
[Python_13 _ _itertools]: http://www.cnblogs.com/vamei/p/3174796.html