Python中itertools模块用法详解

itertools functions
accumulate() compress() groupby() starmap()
chain() count() islice() takewhile()
chain.from_iterable() cycle() permutations() tee()
combinations() dropwhile() product() zip_longest()
combinations_with_replacement() filterfalse() repeat()  

Python标准库(3.x): itertools库扫盲,pythonitertools

itertools functions
accumulate() compress() groupby() starmap()
chain() count() islice() takewhile()
chain.from_iterable() cycle() permutations() tee()
combinations() dropwhile() product() zip_longest()
combinations_with_replacement() filterfalse() repeat()  

 

PYTHON-进阶-ITERTOOLS模块,python–itertools

Python中itertools模块用法详解,pythonitertools

正文实例讲述了Python中itertools模块用法,分享给大家供我们参考。具体分析如下:

诚如的话,itertools模块包蕴创建有效迭代器的函数,能够用种种法子对数据开始展览巡回操作,此模块中的所有函数重返的迭代器都可以与for循环语句以及任何富含迭代器(如生成器和生成器表明式)的函数联合利用。

chain(iter1, iter2, …, iterN):

付出壹组迭代器(iter壹, iter2, …,
iterN),此函数创设2个新迭代器来将有着的迭代器链接起来,重返的迭代器从iter1伊始生成项,知道iter一被用完,然后从iter二生成项,这一进度会频频到iterN中有着的项都被用完。

from itertools import chain
test = chain('AB', 'CDE', 'F')
for el in test:
  print el

A
B
C
D
E
F

chain.from_Python中itertools模块用法详解。iterable(iterables):

二个备用链构造函数,在这之中的iterables是1个迭代变量,生成迭代类别,此操作的结果与以下生成器代码片段生成的结果1律:

>>> 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'

combinations(iterable, r):

创设二个迭代器,再次回到iterable中装有长度为r的子种类,重回的子体系中的项按输入iterable中的顺序排序:

>>> 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)

count([n]):

创立1个迭代器,生成从n初阶的连天整数,假设忽略n,则从0开端估量(注意:此迭代器不扶助长整数),要是赶过了sys.maxint,计数器将溢出并持续从-sys.maxint-1初阶推断。

cycle(iterable):

制造3个迭代器,对iterable中的成分反复实践循环操作,内部会生成iterable中的成分的二个别本,此别本用于再次回到循环中的重复项。

dropwhile(predicate, iterable):

始建一个迭代器,只要函数predicate(item)为True,就废弃iterable中的项,如若predicate重返False,就会生成iterable中的项和兼具继续项。

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

groupby(iterable [,key]):

始建三个迭代器,对iterable生成的接连项实行分组,在分组进程中会查找重复项。

假如iterable在屡次连接迭代中生成了同一项,则会定义一个组,如若将此函数应用贰个分拣列表,那么分组将定义该列表中的全部唯壹项,key(如若已提供)是三个函数,应用于每壹项,假设此函数存在重临值,该值将用现在续项而不是该项自身举行相比较,此函数重临的迭代器生成成分(key,
group),个中key是分组的键值,group是迭代器,生成组成该组的具备项。

ifilter(predicate, iterable):
成立二个迭代器,仅生成iterable中predicate(item)为True的项,倘若predicate为None,将回到iterable中兼有总结为True的项。

ifilter(lambda x: x%2, range(10)) --> 1 3 5 7 9

 
ifilterfalse(predicate, iterable):
创设叁个迭代器,仅生成iterable中predicate(item)为False的项,倘诺predicate为None,则赶回iterable中持有总计为False的项。

ifilterfalse(lambda x: x%2, range(10)) --> 0 2 4 6 8

 

imap(function, iter1, iter2, iter3, …,
iterN)
始建多个迭代器,生成项function(i一, i2, …,
iN),个中i一,i2…iN各自来自迭代器iter1,iter贰 …
iterN,假如function为None,则赶回(i一, i2, …,
iN)情势的元组,只要提供的贰个迭代器不再生成值,迭代就会告一段落。

>>> 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)

islice(iterable, [start, ] stop [,
step]):
创造1个迭代器,生成项的方法接近于切丝再次来到值: iterable[start :
stop :
step],将跳过前start个项,迭代在stop所钦赐的岗位截止,step内定用于跳过项的宽窄。与切成条不相同,负值不会用于其他start,stop和step,借使简单了start,迭代将从0初步,假诺轻便了step,步幅将使用1.

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.

izip(iter1, iter2, … iterN):
创建2个迭代器,生成元组(i一, i二, … iN),当中i一,i2 … iN
分别来自迭代器iter壹,iter二 …
iterN,只要提供的某部迭代器不再生成值,迭代就会结束,此函数生成的值与内置的zip()函数相同。

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]):
与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

permutations(iterable [,r]):

创办2个迭代器,再次来到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

product(iter1, iter2, … iterN,
[repeat=1]):

创制叁个迭代器,生成表示item1,item2等中的项目的笛Carl积的元组,repeat是三个主要字参数,钦点重复生成系列的次数。

def product(*args, **kwds):
   # product('ABCD', 'xy') --> Ax Ay Bx By Cx Cy Dx Dy
   # product(range(2), repeat=3) --> 000 001 010 011 100 101 110 111
   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)

repeat(object [,times]):
创建三个迭代器,重复生成object,times(假使已提供)钦定重复计数,假诺未提供times,将无止尽再次回到该目的。

def repeat(object, times=None):
   # repeat(10, 3) --> 10 10 10
   if times is None:
     while True:
       yield object
   else:
     for i in xrange(times):
       yield object

starmap(func [, iterable]):
创办一个迭代器,生成值func(*item),当中item来自iterable,唯有当iterable生成的项适用于那种调用函数的措施时,此函数才使得。

def starmap(function, iterable):
   # starmap(pow, [(2,5), (3,2), (10,3)]) --> 32 9 1000
   for args in iterable:
     yield function(*args)

takewhile(predicate [, iterable]):
创设叁个迭代器,生成iterable中predicate(item)为True的项,只要predicate计算为False,迭代就会立刻停下。

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

tee(iterable [, n]):
从iterable成立n个独立的迭代器,制造的迭代器以n元组的款型重回,n的暗中认可值为二,此函数适用于其它可迭代的目的,不过,为了克隆原始迭代器,生成的项会被缓存,并在具有新创造的迭代器中采纳,一定要留心,不要在调用tee()之后采取原始迭代器iterable,不然缓存机制或许无法正确职业。

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 faster to use list() instead of tee().

深信不疑本文所述对大家Python程序设计的读书有明确的借鉴价值。

 

itertools.accumulate(iterable [, func])

  重临3个迭代体系的累加值种类(未有func的状态下)。

  当内定了func(参数必须为多少个)后,将透过func拓展增多。

  注1: 当未有传到func时,func相当于 operator.add

  **注2: **返回值为迭代器

>>> data = [1,2,3,4]
>>> a = itertools.accumulate(data)
>>> list(a)
[1, 3, 6, 10]
#[1,2,3,4] --> [1, 1+2, (1+2)+3, ((1+2)+3)+4]

>>> b = itertools.accumulate(data, operator.mul)
>>> list(b)
[1, 2, 6, 24]
#[1,2,3,4] --> [1, 1*2, (1*2)*3, ((1*2)*3)*4]

PYTHON-进阶-ITERTOOLS模块小结

那货很有力, 必须调整

文档 链接

pymotw 链接

主导是基于文书档案的翻译和补偿,相当于翻译了

itertools用于高效循环的迭代函数群集

人老是脑瓜疼怎办?

吃药啊!或到诊所检查肺
 

itertools.accumulate(iterable [, func])

  重回四个迭代类别的累加值连串(未有func的情况下)。

  当钦定了func(参数必须为四个)后,将因此func张开增多。

  注1: 当未有传来func时,func相当于
operator.add

  **注2: **重返值为迭代器

>>> data = [1,2,3,4]
>>> a = itertools.accumulate(data)
>>> list(a)
[1, 3, 6, 10]
#[1,2,3,4] --> [1, 1+2, (1+2)+3, ((1+2)+3)+4]

>>> b = itertools.accumulate(data, operator.mul)
>>> list(b)
[1, 2, 6, 24]
#[1,2,3,4] --> [1, 1*2, (1*2)*3, ((1*2)*3)*4]

 itertools.chain(\iterables*)

  连接七个迭代种类为3个迭代系列,适用于需求连接遍历五个类别场景。

  注`: 再次回到值为迭代器

>>> a = [1,2,3,4,5]
>>> b = [6,7,8,9,10]
>>> c = itertools.chain(a,b)
>>> list(c)
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

组成

一体化,全部了然

最为迭代器

迭代器         参数         结果                                                例子
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

拍卖输入系列迭代器

迭代器          参数            结果                                        例子
chain()     p, q, ...           p0, p1, ... plast, q0, q1, ...              chain('ABC', 'DEF') --> A B C D E F
compress()  data, selectors     (d[0] if s[0]), (d[1] if s[1]), ...         compress('ABCDEF', [1,0,1,0,1,1]) --> A C E F
dropwhile() pred, seq           seq[n], seq[n+1], starting when pred fails  dropwhile(lambda x: x<5, [1,4,6,4,1]) --> 6 4 1
groupby()   iterable[, keyfunc] sub-iterators grouped by value of keyfunc(v)
ifilter()   pred, seq           elements of seq where pred(elem) is True    ifilter(lambda x: x%2, range(10)) --> 1 3 5 7 9
ifilterfalse()  pred, seq       elements of seq where pred(elem) is False   ifilterfalse(lambda x: x%2, range(10)) --> 0 2 4 6 8
islice()    seq, [start,] stop [, step] elements from seq[start:stop:step]  islice('ABCDEFG', 2, None) --> C D E F G
imap()      func, p, q, ...     func(p0, q0), func(p1, q1), ...             imap(pow, (2,3,10), (5,2,3)) --> 32 9 1000
starmap()   func, seq           func(*seq[0]), func(*seq[1]), ...           starmap(pow, [(2,5), (3,2), (10,3)]) --> 32 9 1000
tee()       it, n               it1, it2 , ... itn splits one iterator into n
takewhile() pred, seq           seq[0], seq[1], until pred fails            takewhile(lambda x: x<5, [1,4,6,4,1]) --> 1 4
izip()      p, q, ...           (p[0], q[0]), (p[1], q[1]), ...             izip('ABCD', 'xy') --> Ax By
izip_longest()  p, q, ...       (p[0], q[0]), (p[1], q[1]), ...             izip_longest('ABCD', 'xy', fillvalue='-') --> Ax By C- D-

组合生成器

迭代器          参数                        结果
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

在python中模块是个什概念?能够用简易的例证表达?

2个模块就是1个文书,导入文本就导入了相应的模块,能够选拔模块里定义的类,函数,变量等音讯。倘使模块诸多,可以用包来治本,正是把文件放进三个文件夹里,再加多八个__init__.py文件。
 

本文实例讲述了Python中itertools模块用法,分享给大家供大家参考。具体分析如下:
一般的话,i…

 itertools.chain(\iterables*)

  连接多少个迭代连串为3个迭代类别,适用于须要延续遍历五个类别场景。

  注`:再次回到值为迭代器

>>> a = [1,2,3,4,5]
>>> b = [6,7,8,9,10]
>>> c = itertools.chain(a,b)
>>> list(c)
[1, 2, 3, 4, 5, 6, 7, 8, 9, 10]

 itertools.chain.from_iterable(iterable)

  通过一个迭代类别来创建 itertools.chain 的对象。

  类似于将迭代连串中的每八个目的作为 itertools.chain
的参数,因而传出的迭代连串中的每1个目标应当也是可迭代的。

  注1: 重临值为迭代器

>>> a = itertools.chain.from_iterable(['abc', 'def', 'hjk'])
>>> list(a)
['a', 'b', 'c', 'd', 'e', 'f', 'h', 'j', 'k']
>>>
>>> b = itertools.chain.from_iterable([1,2,3])
>>> list(b)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'int' object is not iterable

首先有个别

 itertools.chain.from_iterable(iterable)

  通过3个迭代体系来创建 itertools.chain 的对象。

  类似于将迭代种类中的每三个对象作为 itertools.chain
的参数,由此传出的迭代体系中的每1个对象应该也是可迭代的。

  注1: 再次来到值为迭代器

>>> a = itertools.chain.from_iterable(['abc', 'def', 'hjk'])
>>> list(a)
['a', 'b', 'c', 'd', 'e', 'f', 'h', 'j', 'k']
>>>
>>> b = itertools.chain.from_iterable([1,2,3])
>>> list(b)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'int' object is not iterable

 itertools.combinations(iterable, r)

  将迭代连串中的对象开始展览“不另行的”构成并重返全数结成的元组列表,每种组合的要素个数为r

  注1:
这里的“不重复”是指迭代体系中的对象不会动用频繁,但并不意味着一如既往的值不会使用频繁。

  注2: 重返的整合顺序信赖传入的迭代连串中的顺序。

  注3: 重返值为迭代器。

>>> a = itertools.combinations('ABC',2)
>>> list(a)
[('A', 'B'), ('A', 'C'), ('B', 'C')]
>>>
>>> b = itertools.combinations('CBA',2)
>>> list(b)
[('C', 'B'), ('C', 'A'), ('B', 'A')]
>>>
>>> c = itertools.combinations('AAC',2)
>>> list(c)
[('A', 'A'), ('A', 'C'), ('A', 'C')]

itertools.count(start=0, step=1)

创制贰个迭代器,生成从n早先的连年整数,固然忽略n,则从0初叶估摸(注意:此迭代器不辅助长整数)

假使抢先了sys.maxint,计数器将溢出并承袭从-sys.maxint-一初步企图。

定义

def count(start=0, step=1):
    # count(10) --> 10 11 12 13 14 ...
    # count(2.5, 0.5) -> 2.5 3.0 3.5 ...
    n = start
    while True:
        yield n
        n += step

等同于(start + step * i for i in count())

使用

from itertools import *

for i in izip(count(1), ['a', 'b', 'c']):
    print i

(1, 'a')
(2, 'b')
(3, 'c')

 itertools.combinations(iterable, r)

  将迭代体系中的对象开始展览“不另行的”结缘并回到全部结成的元组列表,各样组合的要素个数为r

  注1:
这里的“不重复”是指迭代类别中的对象不会动用频仍,但并不表示一如既往的值不会选择频仍。

  注2: 重临的结合顺序依赖传入的迭代类别中的顺序。

  注3: 再次回到值为迭代器。

>>> a = itertools.combinations('ABC',2)
>>> list(a)
[('A', 'B'), ('A', 'C'), ('B', 'C')]
>>>
>>> b = itertools.combinations('CBA',2)
>>> list(b)
[('C', 'B'), ('C', 'A'), ('B', 'A')]
>>>
>>> c = itertools.combinations('AAC',2)
>>> list(c)
[('A', 'A'), ('A', 'C'), ('A', 'C')]

itertools.combinations_with_replacement(iterable, r)

  将迭代类别中的对象举办“可另行的”组合并再次回到全部结成的元组列表,种种组合的要素个数为r

  注1: itertools.combinations
的绝无仅有差别就是因素得以重复使用。

  注2: 重临的重组顺序注重传入的迭代系列中的顺序。

  注3: 再次回到值为迭代器

>>> a = itertools.combinations_with_replacement('ABC', 2)
>>> list(a)
[('A', 'A'), ('A', 'B'), ('A', 'C'), ('B', 'B'), ('B', 'C'), ('C', 'C')]

itertools.cycle(iterable)

创设三个迭代器,对iterable中的成分反复施行循环操作,内部会生成iterable中的成分的2个别本,此别本用于重返循环中的重复项。

定义

def cycle(iterable):
    # cycle('ABCD') --> A B C D A B C D A B C D ...
    saved = []
    for element in iterable:
        yield element
        saved.append(element)
    while saved:
        for element in saved:
            yield element

使用

from itertools import *

i = 0
for item in cycle(['a', 'b', 'c']):
    i += 1
    if i == 10:
        break
    print (i, item)

(1, 'a')
(2, 'b')
(3, 'c')
(4, 'a')
(5, 'b')
(6, 'c')
(7, 'a')
(8, 'b')
(9, 'c')

itertools.combinations_with_replacement(iterable, r)

  将迭代系列中的对象开始展览“可重新的”组合并赶回全部结成的元组列表,每种组合的成分个数为r

  注1:
itertools.combinations
的绝无仅有差别正是因素得以重复使用。

  注2: 重回的组合顺序依赖传入的迭代种类中的顺序。

  注3: 重回值为迭代器

>>> a = itertools.combinations_with_replacement('ABC', 2)
>>> list(a)
[('A', 'A'), ('A', 'B'), ('A', 'C'), ('B', 'B'), ('B', 'C'), ('C', 'C')]

 itertools.compress(data, selectors)

  对 data 中的数据进行过滤,只保留 selectors 中对应位置为
True 的对象。

  dataselectors的系列长度能够不等,在那之中任性3个迭代终结,整个迭代即终结。

  注1: 再次来到值为迭代器

>>> a = itertools.compress('ABCDE', [1,1,0,0,0])
>>> list(a)
['A', 'B']
>>>
>>> b = itertools.compress('ABCDE', [1,1])
>>> list(b)
['A', 'B']
>>>
>>> c = itertools.compress('ABC', [1,1,0,0,1])
>>> list(c)
['A', 'B']

itertools.repeat(object[, times])

创设八个迭代器,重复生成object,times(倘使已提供)内定重复计数,假诺未提供times,将无止尽重临该目标。

定义

def repeat(object, times=None):
    # repeat(10, 3) --> 10 10 10
    if times is None:
        while True:
            yield object
    else:
        for i in xrange(times):
            yield object

使用

from itertools import *

for i in repeat('over-and-over', 5):
    print i

over-and-over
over-and-over
over-and-over
over-and-over
over-and-over

 itertools.compress(data, selectors)

  对 data
中的数据进行过滤,只保留 selectors 中对应地方为 True 的对象。

  dataselectors的连串长度能够不等,其中任性多少个迭代终结,整个迭代即终结。

  注1: 重返值为迭代器

>>> a = itertools.compress('ABCDE', [1,1,0,0,0])
>>> list(a)
['A', 'B']
>>>
>>> b = itertools.compress('ABCDE', [1,1])
>>> list(b)
['A', 'B']
>>>
>>> c = itertools.compress('ABC', [1,1,0,0,1])
>>> list(c)
['A', 'B']

 itertools.count(start=0, step=1)

  生成一个计数迭代器,能够钦赐开首点和步进,可是从未极限,能够直接迭代下去。

  一般要求格外别的的迭代器一齐使用,举个例子作为map(),
zip()
的参数等。

>>> a = itertools.count(start=1, step=2)
>>> next(a)
1
>>> next(a)
3
>>> next(a)
5
>>> next(a)
7
>>> next(a)
9
>>> next(a)
11
>>> next(a)
13
>>> 
>>> b = itertools.count(start=100, step=1)
>>> list(zip(b, 'ABCDE'))
[(100, 'A'), (101, 'B'), (102, 'C'), (103, 'D'), (104, 'E')]

第3片段

 itertools.count(start=0, step=1)

  生成贰个计数迭代器,能够钦定起首点和步进,不过尚未极限,可以一向迭代下去。

  一般须要合营别的的迭代器一同行使,比方作为map(), zip()的参数等。

>>> a = itertools.count(start=1, step=2)
>>> next(a)
1
>>> next(a)
3
>>> next(a)
5
>>> next(a)
7
>>> next(a)
9
>>> next(a)
11
>>> next(a)
13
>>> 
>>> b = itertools.count(start=100, step=1)
>>> list(zip(b, 'ABCDE'))
[(100, 'A'), (101, 'B'), (102, 'C'), (103, 'D'), (104, 'E')]

 itertools.cycle(iterable)

  生成一个循环迭代器,循环遍历传入迭代器中的对象,未有截至。

  一般须要十二分其余迭代器一同使用,举个例子map(), zip() 的参数等

>>> a = itertools.cycle('ABC')
>>> next(a)
'A'
>>> next(a)
'B'
>>> next(a)
'C'
>>> next(a)
'A'
>>> next(a)
'B'
>>> next(a)
'C'
>>> next(a)
'A'
>>> 
>>> b = itertools.cycle(range(1,4))
>>> list(zip('ABCDEFG', b))
[('A', 1), ('B', 2), ('C', 3), ('D', 1), ('E', 2), ('F', 3), ('G', 1)]

itertools.chain(*iterables)

将八个迭代器作为参数, 但只回去单个迭代器, 它产生负有参数迭代器的剧情,
就就像是他们是出自于三个纯粹的种类.

def chain(*iterables):
    # chain('ABC', 'DEF') --> A B C D E F
    for it in iterables:
        for element in it:
            yield element

使用

from itertools import *

for i in chain([1, 2, 3], ['a', 'b', 'c']):
    print i
1
2
3
a
b
c


from itertools import chain, imap
def flatmap(f, items):
    return chain.from_iterable(imap(f, items))
>>> list(flatmap(os.listdir, dirs))
>>> ['settings.py', 'wsgi.py', 'templates', 'app.py',
     'templates', 'index.html, 'config.json']

 itertools.cycle(iterable)

  生成三个循环迭代器,循环遍历传入迭代器中的对象,未有终止。

  一般要求协作别的迭代器一同利用,比方map(), zip()
的参数等

>>> a = itertools.cycle('ABC')
>>> next(a)
'A'
>>> next(a)
'B'
>>> next(a)
'C'
>>> next(a)
'A'
>>> next(a)
'B'
>>> next(a)
'C'
>>> next(a)
'A'
>>> 
>>> b = itertools.cycle(range(1,4))
>>> list(zip('ABCDEFG', b))
[('A', 1), ('B', 2), ('C', 3), ('D', 1), ('E', 2), ('F', 3), ('G', 1)]

 itertools.dropwhile(predicate, iterable)

  对迭代器中的对象根据 predicate
进行预见,抛弃第一个断言为False事先的有所目的。

  也得以了解为从第三个断言为False的目的开头出口。

  注1:
当出现第多个断言为False的靶子后,之后的对象不再实行预知。

  注2: predicate 代表的函数只好有贰个参数。

  注3: 重返值为迭代器

>>> a = itertools.dropwhile(lambda x: x<5, [3,4,5,6,5,4,3])
>>> list(a)
[5, 6, 5, 4, 3]

itertools.compress(data, selectors)

提供2个精选列表,对原有数据举行筛选

def compress(data, selectors):
    # compress('ABCDEF', [1,0,1,0,1,1]) --> A C E F
    return (d for d, s in izip(data, selectors) if s)

 itertools.dropwhile(predicate, iterable)

  对迭代器中的对象遵照 predicate
实行预见,抛弃第3个断言为False此前的装有目标。

  也能够清楚为从第三个断言为False的对象起始出口。

  注1: 当出现第一个断言为False的靶子后,之后的靶子不再进行预感。

  注2: predicate
代表的函数只好有2个参数。

  注3: 重返值为迭代器

>>> a = itertools.dropwhile(lambda x: x<5, [3,4,5,6,5,4,3])
>>> list(a)
[5, 6, 5, 4, 3]

 itertools.filterfalse(predicate, iterable)

  过滤掉迭代器中遵守 predicate 断言为 True 的对象。

  如果 predicate 传入None, 则过滤掉值为 True
的对象。

  注1: 重返值为迭代器

>>> a = itertools.filterfalse(lambda x: x%2==0, range(10))
>>> list(a)
[1, 3, 5, 7, 9]
>>> 
>>> b = itertools.filterfalse(None, [1,0,1,0,1,0])
>>> list(b)
[0, 0, 0]

itertools.dropwhile(predicate, iterable)

制造贰个迭代器,只要函数predicate(item)为True,就扬弃iterable中的项,若是predicate重临False,就会生成iterable中的项和具备继续项。

即:在尺度为false之后的第二次, 再次回到迭代器中剩下来的项.

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

使用

from itertools import *

def should_drop(x):
    print 'Testing:', x
    return (x<1)

for i in dropwhile(should_drop, [ -1, 0, 1, 2, 3, 4, 1, -2 ]):
    print 'Yielding:', i

Testing: -1
Testing: 0
Testing: 1
Yielding: 1
Yielding: 2
Yielding: 3
Yielding: 4
Yielding: 1
Yielding: -2

 itertools.filterfalse(predicate, iterable)

  过滤掉迭代器中依据 predicate 断言为
True
的对象。

  如果 predicate
传入None,
则过滤掉值为 True 的对象。

  注1: 再次来到值为迭代器

>>> a = itertools.filterfalse(lambda x: x%2==0, range(10))
>>> list(a)
[1, 3, 5, 7, 9]
>>> 
>>> b = itertools.filterfalse(None, [1,0,1,0,1,0])
>>> list(b)
[0, 0, 0]

 itertools.groupby(iterable, key=None)

  对迭代类别中的对象遵照key进行分组,借使key为None则依照目的自己的值进行分组。

  注1:
假如迭代体系中key值相等的靶子中间间隔了其余的key值,则不会分在贰个组。

  注2:
再次回到值为一个迭代器且重临的是多个有多个因素的元组,第一个要素为key值,第二个成分为分组对象的迭代器

>>> data = ['abc-0', 'def-0', 'xyz-1', 'tty-1', 'kkk-2']
>>> a = itertools.groupby(data, lambda x:x[-1])
>>> [(k, list(g)) for k, g in a]
[('0', ['abc-0', 'def-0']), ('1', ['xyz-1', 'tty-1']), ('2', ['kkk-2'])]
>>> 
>>> 
>>> b = itertools.groupby('AAABBBCC')
>>> [(k, list(g)) for k, g in b]
[('A', ['A', 'A', 'A']), ('B', ['B', 'B', 'B']), ('C', ['C', 'C'])]

itertools.groupby(iterable[, key])

重返三个发出依据key进行分组后的值集合的迭代器.

万一iterable在一连一连迭代中生成了同样项,则会定义1个组,假使将此函数应用一个分类列表,那么分组将概念该列表中的全部唯一项,key(即便已提供)是叁个函数,应用于每1项,如若此函数存在再次回到值,该值将用来后续项而不是该项自己实行相比,此函数再次来到的迭代器生成成分(key,
group),当中key是分组的键值,group是迭代器,生成组成该组的装有项。

即:遵照keyfunc函数对队列每一个成分实践后的结果分组(每种分组是一个迭代器),
再次回到那些分组的迭代器

等价于

class groupby(object):
    # [k for k, g in groupby('AAAABBBCCDAABBB')] --> A B C D A B
    # [list(g) for k, g in groupby('AAAABBBCCD')] --> AAAA BBB CC D
    def __init__(self, iterable, key=None):
        if key is None:
            key = lambda x: x
        self.keyfunc = key
        self.it = iter(iterable)
        self.tgtkey = self.currkey = self.currvalue = object()
    def __iter__(self):
        return self
    def next(self):
        while self.currkey == self.tgtkey:
            self.currvalue = next(self.it)    # Exit on StopIteration
            self.currkey = self.keyfunc(self.currvalue)
        self.tgtkey = self.currkey
        return (self.currkey, self._grouper(self.tgtkey))
    def _grouper(self, tgtkey):
        while self.currkey == tgtkey:
            yield self.currvalue
            self.currvalue = next(self.it)    # Exit on StopIteration
            self.currkey = self.keyfunc(self.currvalue)

应用

from itertools import groupby
qs = [{'date' : 1},{'date' : 2}]
[(name, list(group)) for name, group in itertools.groupby(qs, lambda p:p['date'])]

Out[77]: [(1, [{'date': 1}]), (2, [{'date': 2}])]


>>> from itertools import *
>>> a = ['aa', 'ab', 'abc', 'bcd', 'abcde']
>>> for i, k in groupby(a, len):
...     print i, list(k)
...
2 ['aa', 'ab']
3 ['abc', 'bcd']
5 ['abcde']

另2个例证

from itertools import *
from operator import itemgetter

d = dict(a=1, b=2, c=1, d=2, e=1, f=2, g=3)
di = sorted(d.iteritems(), key=itemgetter(1))
for k, g in groupby(di, key=itemgetter(1)):
    print k, map(itemgetter(0), g)


1 ['a', 'c', 'e']
2 ['b', 'd', 'f']
3 ['g']

 itertools.groupby(iterable, key=None)

  对迭代系列中的对象依照key进行分组,即使key为None则依据目标自己的值实行分组。

  注1:
假如迭代连串中key值相等的目的中间间隔了任何的key值,则不会分在一个组。

  注2:
重返值为一个迭代器且重回的是三个有七个要素的元组,第三个成分为key值,第二个因素为分组对象的迭代器

>>> data = ['abc-0', 'def-0', 'xyz-1', 'tty-1', 'kkk-2']
>>> a = itertools.groupby(data, lambda x:x[-1])
>>> [(k, list(g)) for k, g in a]
[('0', ['abc-0', 'def-0']), ('1', ['xyz-1', 'tty-1']), ('2', ['kkk-2'])]
>>> 
>>> 
>>> b = itertools.groupby('AAABBBCC')
>>> [(k, list(g)) for k, g in b]
[('A', ['A', 'A', 'A']), ('B', ['B', 'B', 'B']), ('C', ['C', 'C'])]

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

  对迭代连串进行分片,类似 slice(),然则本函数中 start, stop,
step
都不能够为负数。

  参数 start 如果为 None, 则 start = 0

  参数 stop 如果为 None, 则迭代到最终二个

  参数 step 如果为 None, 则 step = 1

  **注1: 再次回到值为2个迭代器*


>>> data = 'ABCDEFG'
>>> a = itertools.islice(data, 3)
>>> list(a)
['A', 'B', 'C']
>>> 
>>> b = itertools.islice(data, 1, 5, 2)
>>> list(b)
['B', 'D']
>>> 
>>> c = itertools.islice(data, None, 3)
>>> list(c)
['A', 'B', 'C']
>>> 
>>> d = itertools.islice(data, 3, None)
>>> list(d)
['D', 'E', 'F', 'G']

itertools.ifilter(predicate, iterable)

回去的是迭代器类似于针对列表的放置函数 filter() ,
它只囊括当测试函数重回true时的项. 它分裂于 dropwhile()

始建三个迭代器,仅生成iterable中predicate(item)为True的项,假设predicate为None,将回到iterable中保有计算为True的项

对函数func实行回来真的元素的迭代器

def ifilter(predicate, iterable):
    # ifilter(lambda x: x%2, range(10)) --> 1 3 5 7 9
    if predicate is None:
        predicate = bool
    for x in iterable:
        if predicate(x):
            yield x

使用

from itertools import *

def check_item(x):
    print 'Testing:', x
    return (x<1)

for i in ifilter(check_item, [ -1, 0, 1, 2, 3, 4, 1, -2 ]):
    print 'Yielding:', i

Testing: -1
Yielding: -1
Testing: 0
Yielding: 0
Testing: 1
Testing: 2
Testing: 3
Testing: 4
Testing: 1
Testing: -2
Yielding: -2

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

  对迭代种类进行分片,类似 slice(),但是本函数中
start, stop,
step
都不可能为负数。

  参数 start 如果为
None, 则
start = 0

  参数 stop 如果为
None,
则迭代到最后1个

  参数 step 如果为
None, 则
step = 1

  **注1: 再次来到值为一个迭代器*


>>> data = 'ABCDEFG'
>>> a = itertools.islice(data, 3)
>>> list(a)
['A', 'B', 'C']
>>> 
>>> b = itertools.islice(data, 1, 5, 2)
>>> list(b)
['B', 'D']
>>> 
>>> c = itertools.islice(data, None, 3)
>>> list(c)
['A', 'B', 'C']
>>> 
>>> d = itertools.islice(data, 3, None)
>>> list(d)
['D', 'E', 'F', 'G']

itertools.permutations(iterable, r=None)

  将迭代连串中的对象开始展览“不另行的”排列组合并赶回全数结成的元组列表,各个组合的因素个数为r

  如果rNone,则长度为迭代种类的长度。

  注1:
这里的“不重复”是指迭代连串中的对象不会选用频仍,但并不意味着一致的值不会动用频仍。

  注2: 再次回到的结合顺序依赖传入的迭代种类中的顺序。

  注3: 再次回到值为迭代器。

>>> a = itertools.permutations('ABC', 2)
>>> list(a)
[('A', 'B'), ('A', 'C'), ('B', 'A'), ('B', 'C'), ('C', 'A'), ('C', 'B')]
>>> 
>>> b = itertools.permutations('ABC')
>>> list(b)
[('A', 'B', 'C'), ('A', 'C', 'B'), ('B', 'A', 'C'), ('B', 'C', 'A'), ('C', 'A', 'B'), ('C', 'B', 'A')]

itertools.ifilterfalse(predicate, iterable)

和ifilter(函数相反 , 再次回到贰个包蕴那1个测试函数重回false的项的迭代器)

成立二个迭代器,仅生成iterable中predicate(item)为False的项,假如predicate为None,则赶回iterable中具备计算为False的项
对函数func实践重临假的成分的迭代器

def ifilterfalse(predicate, iterable):
    # ifilterfalse(lambda x: x%2, range(10)) --> 0 2 4 6 8
    if predicate is None:
        predicate = bool
    for x in iterable:
        if not predicate(x):
            yield x

使用

from itertools import *

def check_item(x):
    print 'Testing:', x
    return (x<1)

for i in ifilterfalse(check_item, [ -1, 0, 1, 2, 3, 4, 1, -2 ]):
    print 'Yielding:', i

Testing: -1
Testing: 0
Testing: 1
Yielding: 1
Testing: 2
Yielding: 2
Testing: 3
Yielding: 3
Testing: 4
Yielding: 4
Testing: 1
Yielding: 1
Testing: -2

itertools.permutations(iterable, r=None)

  将迭代种类中的对象举办“不另行的”排列组合并重回全数结成的元组列表,每种组合的要素个数为r

  如果rNone,则长度为迭代系列的长短。

  注1:
这里的“不重复”是指迭代系列中的对象不会动用频繁,但并不意味1如既往的值不会选取频仍。

  注2: 再次来到的咬合顺序信赖传入的迭代体系中的顺序。

  注3: 重临值为迭代器。

>>> a = itertools.permutations('ABC', 2)
>>> list(a)
[('A', 'B'), ('A', 'C'), ('B', 'A'), ('B', 'C'), ('C', 'A'), ('C', 'B')]
>>> 
>>> b = itertools.permutations('ABC')
>>> list(b)
[('A', 'B', 'C'), ('A', 'C', 'B'), ('B', 'A', 'C'), ('B', 'C', 'A'), ('C', 'A', 'B'), ('C', 'B', 'A')]

itertools.product(\iterables, repeat=1*)

  再次回到多少个迭代类别的笛Carl乘积,repeat值也便是把传播的迭代器参数重复的次数。

  注1: 重临值是2个迭代器

>>> a = itertools.product('ABCD', 'xy')
>>> list(a)
[('A', 'x'), ('A', 'y'), ('B', 'x'), ('B', 'y'), ('C', 'x'), ('C', 'y'), ('D', 'x'), ('D', 'y')]
>>> 
>>> b = itertools.product(range(2), repeat=3)
>>> list(b)
[(0, 0, 0), (0, 0, 1), (0, 1, 0), (0, 1, 1), (1, 0, 0), (1, 0, 1), (1, 1, 0), (1, 1, 1)]
# 相当于 itertools.product(range(2), range(2), range(2))

itertools.islice(iterable, stop)

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

回去的迭代器是回到了输入迭代器依据目录来挑选的项

创立多个迭代器,生成项的秘技接近于切成条再次来到值: iterable[start : stop :
step],将跳过前start个项,迭代在stop所钦命的岗位截至,step钦定用于跳过项的增长幅度。
与切块不相同,负值不会用于别的start,stop和step,
如果省略了start,迭代将从0开端,假使轻便了step,步幅将选取1.

回去连串seq的从start开首到stop甘休的小幅为step的因素的迭代器

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)

使用

from itertools import *

print 'Stop at 5:'
for i in islice(count(), 5):
    print i

print 'Start at 5, Stop at 10:'
for i in islice(count(), 5, 10):
    print i

print 'By tens to 100:'
for i in islice(count(), 0, 100, 10):
    print i

Stop at 5:
0
1
2
3
4
Start at 5, Stop at 10:
5
6
7
8
9
By tens to 100:
0
10
20
30
40
50
60
70
80
90

itertools.product(\iterables, repeat=1*)

  重回四个迭代连串的笛Carl乘积,repeat值也正是把传播的迭代器参数重复的次数。

亚洲必赢官网 ,  注1: 再次来到值是三个迭代器

>>> a = itertools.product('ABCD', 'xy')
>>> list(a)
[('A', 'x'), ('A', 'y'), ('B', 'x'), ('B', 'y'), ('C', 'x'), ('C', 'y'), ('D', 'x'), ('D', 'y')]
>>> 
>>> b = itertools.product(range(2), repeat=3)
>>> list(b)
[(0, 0, 0), (0, 0, 1), (0, 1, 0), (0, 1, 1), (1, 0, 0), (1, 0, 1), (1, 1, 0), (1, 1, 1)]
# 相当于 itertools.product(range(2), range(2), range(2))

itertools.repeat(object [, times])

  再次回到二个迭代器,重复传入的对象。重复的次数为 times 。

  如果未有传到times参数,则最为重复。***


>>> a = itertools.repeat('hello', 3)
>>> list(a)
['hello', 'hello', 'hello']
>>> 
>>> b = itertools.repeat('test')
>>> list(map(lambda x, y: x + y, b, 'ABCD'))
['testA', 'testB', 'testC', 'testD']

itertools.imap(function, *iterables)

开创贰个迭代器,生成项function(i1, i二, …,
iN),个中i一,i贰…iN个别来自迭代器iter壹,iter2 …
iterN,假如function为None,则赶回(i一, i2, …,
iN)情势的元组,只要提供的3个迭代器不再生成值,迭代就会告1段落。

即:再次来到叁个迭代器, 它是调用了二个其值在输入迭代器上的函数, 重返结果.
它相仿于内置函数 map() ,
只是前者在自由输入迭代器甘休后就终止(而不是插入None值来补全全数的输入).

归来类别每种成分被func施行后重回值的行列的迭代器

def imap(function, *iterables):
    # imap(pow, (2,3,10), (5,2,3)) --> 32 9 1000
    iterables = map(iter, iterables)
    while True:
        args = [next(it) for it in iterables]
        if function is None:
            yield tuple(args)
        else:
            yield function(*args)

使用

from itertools import *

print 'Doubles:'
for i in imap(lambda x:2*x, xrange(5)):
    print i

print 'Multiples:'
for i in imap(lambda x,y:(x, y, x*y), xrange(5), xrange(5,10)):
    print '%d * %d = %d' % i

Doubles:
0
2
4
6
8
Multiples:
0 * 5 = 0
1 * 6 = 6
2 * 7 = 14
3 * 8 = 24
4 * 9 = 36

itertools.repeat(object [, times])

  重返贰个迭代器,重复传入的目标。重复的次数为 times 。

  倘诺未有传到times参数,则最为重复。***


>>> a = itertools.repeat('hello', 3)
>>> list(a)
['hello', 'hello', 'hello']
>>> 
>>> b = itertools.repeat('test')
>>> list(map(lambda x, y: x + y, b, 'ABCD'))
['testA', 'testB', 'testC', 'testD']

itertools.starmap(function, iterable)

  和 map() 类似。可是此地 function
的参数封装在迭代器中的各样对象中。

  注1:
迭代器中的每二个目的也亟须是可迭代的,哪怕函数只有贰个参数。

>>> a = itertools.starmap(lambda x,y: x**y, [(2,1), (2,2), (2,3)])
>>> list(a)
[2, 4, 8]
>>> 
>>> b = itertools.starmap(lambda x: x*x, [(1,),(2,),(3,)])
>>> list(b)
[1, 4, 9]

itertools.starmap(function, iterable)

开创3个迭代器,生成值func(*item),个中item来自iterable,只有当iterable生成的项适用于那种调用函数的法丑时,此函数才使得。

对队列seq的各类成分作为func的参数列表施行, 重返推行结果的迭代器

def starmap(function, iterable):
    # starmap(pow, [(2,5), (3,2), (10,3)]) --> 32 9 1000
    for args in iterable:
        yield function(*args)

使用

from itertools import *

values = [(0, 5), (1, 6), (2, 7), (3, 8), (4, 9)]
for i in starmap(lambda x,y:(x, y, x*y), values):
    print '%d * %d = %d' % i

0 * 5 = 0
1 * 6 = 6
2 * 7 = 14
3 * 8 = 24
4 * 9 = 36

itertools.starmap(function, iterable)

  和 map()
类似。然则那里 function
的参数封装在迭代器中的每3个对象中。

  注1:
迭代器中的每3个目标也务必是可迭代的,哪怕函数唯有叁个参数。

>>> a = itertools.starmap(lambda x,y: x**y, [(2,1), (2,2), (2,3)])
>>> list(a)
[2, 4, 8]
>>> 
>>> b = itertools.starmap(lambda x: x*x, [(1,),(2,),(3,)])
>>> list(b)
[1, 4, 9]

itertools.takewhile(predicate, iterable)

  与 dropwhile() 相反,对迭代器中的对象遵照 predicate
进行预知,输出第二个断言为False从前的保有目的。

  注1: 当出现第五个断言为False的目的后,迭代即结束。

  注2: predicate 代表的函数只可以有1个参数。

  注3: 重返值为迭代器

>>> a = itertools.takewhile(lambda x: x<5, [3,4,5,6,5,4,3])
>>> list(a)
[3, 4]

itertools.tee(iterable[, n=2])

回到一些依照单个原始输入的单独迭代器(默感觉二).
它和Unix上的tee工具有点语义相似,
也等于说它们都再次读取输入设备中的值并将值写入到三个命名文件和正规输出中

从iterable创造n个单身的迭代器,创设的迭代器以n元组的款型重返,n的暗中同意值为2,此函数适用于其余可迭代的目标,不过,为了克隆原始迭代器,生成的项会被缓存,并在装有新创制的迭代器中使用,一定要注意,不要在调用tee()之后接纳原始迭代器iterable,不然缓存机制恐怕无法正确工作。

把三个迭代器分为n个迭代器, 重回一个元组.默许是四个

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)

使用

from itertools import *

r = islice(count(), 5)
i1, i2 = tee(r)

for i in i1:
    print 'i1:', i
for i in i2:
    print 'i2:', i

i1: 0
i1: 1
i1: 2
i1: 3
i1: 4
i2: 0
i2: 1
i2: 2
i2: 3
i2: 4

itertools.takewhile(predicate, iterable)

  与 dropwhile()
相反,对迭代器中的对象依照 predicate
进行预感,输出第3个断言为False从前的有所目标。

  注1: 当出现第二个断言为False的靶子后,迭代即甘休。

  注2: predicate
代表的函数只好有一个参数。

  注3: 再次回到值为迭代器

>>> a = itertools.takewhile(lambda x: x<5, [3,4,5,6,5,4,3])
>>> list(a)
[3, 4]

itertools.tee(iterable, n=2)

  将3个迭代器复制n次,重回一个有n个迭代器的元组。n默认为2

>>> a = itertools.tee('ABC')
>>> [list(x) for x in a]
[['A', 'B', 'C'], ['A', 'B', 'C']]
>>> 
>>> b = itertools.tee(range(5), 3)
>>> [list(x) for x in b]
[[0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4]]

itertools.takewhile(predicate, iterable)

和dropwhile相反

创建贰个迭代器,生成iterable中predicate(item)为True的项,只要predicate计算为False,迭代就会应声截至。

即:从体系的头早先, 直到实行函数func失利.

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

使用

from itertools import *

def should_take(x):
    print 'Testing:', x
    return (x<2)

for i in takewhile(should_take, [ -1, 0, 1, 2, 3, 4, 1, -2 ]):
    print 'Yielding:', i

Testing: -1
Yielding: -1
Testing: 0
Yielding: 0
Testing: 1
Yielding: 1
Testing: 2

itertools.tee(iterable, n=2)

  将三个迭代器复制n次,再次来到2个有n个迭代器的元组。n默认为2

>>> a = itertools.tee('ABC')
>>> [list(x) for x in a]
[['A', 'B', 'C'], ['A', 'B', 'C']]
>>> 
>>> b = itertools.tee(range(5), 3)
>>> [list(x) for x in b]
[[0, 1, 2, 3, 4], [0, 1, 2, 3, 4], [0, 1, 2, 3, 4]]

itertools.zip_longest(\iterables, fillvalue=None*)

  类似于 zip()。然而那里依照最长的迭代类别举办李包裹装,缺少的成分用
fillvalue 的值举办填写。

  注1: fillvalue 默认为None,
并且假若是None,填充的正是None

>>> a = itertools.zip_longest('ABC', 'xy', fillvalue='*')
>>> list(a)
[('A', 'x'), ('B', 'y'), ('C', '*')]
>>>
>>> b = itertools.zip_longest('ABC', 'xy')
>>> list(b)
[('A', 'x'), ('B', 'y'), ('C', None)]

 

):
itertools库扫盲,pythonitertools itertools functions accumulate()
compress() groupby() starmap() chain() count() islice() takewhile()
chain.from_iterable(…

itertools.izip(*iterables)

回到七个联结了五个迭代器为3个元组的迭代器. 它相仿于内置函数zip(),
只是它回到的是二个迭代器而不是贰个列表

始建一个迭代器,生成元组(i1, i二, … iN),个中i1,i贰 … iN
分别来自迭代器iter一,iter二 …
iterN,只要提供的某部迭代器不再生成值,迭代就会结束,此函数生成的值与内置的zip()函数同样。

izip(iter1, iter2, ... iterN):
返回:(it1[0],it2 [0], it3[0], ..), (it1[1], it2[1], it3[1], ..)...

def izip(*iterables):
    # izip('ABCD', 'xy') --> Ax By
    iterators = map(iter, iterables)
    while iterators:
        yield tuple(map(next, iterators))

使用

from itertools import *

for i in izip([1, 2, 3], ['a', 'b', 'c']):
    print i
(1, 'a')
(2, 'b')
(3, 'c')

itertools.zip_longest(\iterables, fillvalue=None*)

  类似于 zip()。可是此地依据最长的迭代系列举行包装,缺乏的因素用
fillvalue
的值进行填写。

  注1: fillvalue
默认为None,
并且假使是None,填充的就是None

>>> a = itertools.zip_longest('ABC', 'xy', fillvalue='*')
>>> list(a)
[('A', 'x'), ('B', 'y'), ('C', '*')]
>>>
>>> b = itertools.zip_longest('ABC', 'xy')
>>> list(b)
[('A', 'x'), ('B', 'y'), ('C', None)]

 

itertools.izip_longest(*iterables[, fillvalue])

与izip()同样,但是迭代进度会频频到具备输入迭代变量iter一,iter二等都耗尽截至,要是未有接纳fillvalue关键字参数钦命分裂的值,则接纳None来填充已经应用的迭代变量的值。

class ZipExhausted(Exception):
    pass

def izip_longest(*args, **kwds):
    # izip_longest('ABCD', 'xy', fillvalue='-') --> Ax By C- D-
    fillvalue = kwds.get('fillvalue')
    counter = [len(args) - 1]
    def sentinel():
        if not counter[0]:
            raise ZipExhausted
        counter[0] -= 1
        yield fillvalue
    fillers = repeat(fillvalue)
    iterators = [chain(it, sentinel(), fillers) for it in args]
    try:
        while iterators:
            yield tuple(map(next, iterators))
    except ZipExhausted:
        pass

其3部分

itertools.product(*iterables[, repeat])

笛Carl积

创建1个迭代器,生成代表item一,item二等中的项目标笛Carl积的元组,repeat是八个重中之重字参数,内定重复生成类别的次数。

def product(*args, **kwds):
    # product('ABCD', 'xy') --> Ax Ay Bx By Cx Cy Dx Dy
    # product(range(2), repeat=3) --> 000 001 010 011 100 101 110 111
    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)

例子

import itertools
a = (1, 2, 3)
b = ('A', 'B', 'C')
c = itertools.product(a,b)
for elem in c:
    print elem

(1, 'A')
(1, 'B')
(1, 'C')
(2, 'A')
(2, 'B')
(2, 'C')
(3, 'A')
(3, 'B')
(3, 'C')

itertools.permutations(iterable[, r])

排列

成立3个迭代器,重返iterable中具备长度为r的门类连串,固然轻易了r,那么连串的长短与iterable中的项目数量一样:
重返p中随便取r个要素做排列的元组的迭代器

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
也可以用product实现

def permutations(iterable, r=None):
    pool = tuple(iterable)
    n = len(pool)
    r = n if r is None else r
    for indices in product(range(n), repeat=r):
        if len(set(indices)) == r:
            yield tuple(pool[i] for i in indices)

itertools.combinations(iterable, r)

创造一个迭代器,重返iterable中保有长度为r的子种类,重回的子类别中的项按输入iterable中的顺序排序
(不带重复)

def combinations(iterable, r):
    # combinations('ABCD', 2) --> AB AC AD BC BD CD
    # combinations(range(4), 3) --> 012 013 023 123
    pool = tuple(iterable)
    n = len(pool)
    if r > n:
        return
    indices = range(r)
    yield tuple(pool[i] for i in indices)
    while True:
        for i in reversed(range(r)):
            if indices[i] != i + n - r:
                break
        else:
            return
        indices[i] += 1
        for j in range(i+1, r):
            indices[j] = indices[j-1] + 1
        yield tuple(pool[i] for i in indices)

#或者
def combinations(iterable, r):
    pool = tuple(iterable)
    n = len(pool)
    for indices in permutations(range(n), r):
        if sorted(indices) == list(indices):
            yield tuple(pool[i] for i in indices)

itertools.combinations_with_replacement(iterable, r)

成立一个迭代器,重回iterable中有所长度为r的子系列,再次回到的子种类中的项按输入iterable中的顺序排序
(带重复)

def combinations_with_replacement(iterable, r):
    # combinations_with_replacement('ABC', 2) --> AA AB AC BB BC CC
    pool = tuple(iterable)
    n = len(pool)
    if not n and r:
        return
    indices = [0] * r
    yield tuple(pool[i] for i in indices)
    while True:
        for i in reversed(range(r)):
            if indices[i] != n - 1:
                break
        else:
            return
        indices[i:] = [indices[i] + 1] * (r - i)
        yield tuple(pool[i] for i in indices)
或者
def combinations_with_replacement(iterable, r):
    pool = tuple(iterable)
    n = len(pool)
    for indices in product(range(n), repeat=r):
        if sorted(indices) == list(indices):
            yield tuple(pool[i] for i in indices)

第陆局地

扩展

使用现成扩大功效

def take(n, iterable):
    "Return first n items of the iterable as a list"
    return list(islice(iterable, n))

def tabulate(function, start=0):
    "Return function(0), function(1), ..."
    return imap(function, count(start))

def consume(iterator, n):
    "Advance the iterator n-steps ahead. If n is none, consume entirely."
    # Use functions that consume iterators at C speed.
    if n is None:
        # feed the entire iterator into a zero-length deque
        collections.deque(iterator, maxlen=0)
    else:
        # advance to the empty slice starting at position n
        next(islice(iterator, n, n), None)

def nth(iterable, n, default=None):
    "Returns the nth item or a default value"
    return next(islice(iterable, n, None), default)

def quantify(iterable, pred=bool):
    "Count how many times the predicate is true"
    return sum(imap(pred, iterable))

def padnone(iterable):
    """Returns the sequence elements and then returns None indefinitely.

    Useful for emulating the behavior of the built-in map() function.
    """
    return chain(iterable, repeat(None))

def ncycles(iterable, n):
    "Returns the sequence elements n times"
    return chain.from_iterable(repeat(tuple(iterable), n))

def dotproduct(vec1, vec2):
    return sum(imap(operator.mul, vec1, vec2))

def flatten(listOfLists):
    "Flatten one level of nesting"
    return chain.from_iterable(listOfLists)

def repeatfunc(func, times=None, *args):
    """Repeat calls to func with specified arguments.

    Example:  repeatfunc(random.random)
    """
    if times is None:
        return starmap(func, 
网站地图xml地图