Python中itertools模块用法详解

By admin in 4858.com on 2019年4月8日
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一, iter二, …,
iterN),此函数创造一个新迭代器来将有所的迭代器链接起来,再次回到的迭代器从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_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'

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

创立3个迭代器,生成从n起初的总是整数,借使忽略n,则从0初阶总括(注意:此迭代器不援救长整数),固然超出了sys.maxint,计数器将溢出并一连从-sys.maxint-壹初叶估量。

cycle(iterable):

始建3个迭代器,对iterable中的成分反复实践循环操作,内部会生成iterable中的成分的2个副本,此副本用于重临循环中的重复项。

dropwhile(predicate, iterable):

始建3个迭代器,只要函数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在屡次老是迭代中生成了同一项,则会定义3个组,要是将此函数应用二个分拣列表,那么分组将定义该列表中的全体唯1项,key(若是已提供)是多少个函数,应用于每1项,假如此函数存在再次来到值,该值将用未来续项而不是该项自己实行比较,此函数再次回到的迭代器生成成分(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):
始建3个迭代器,仅生成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)
始建1个迭代器,生成项function(i1, i二, …,
iN),在那之中i一,i2…iN各自来自迭代器iter一,iter2 …
iterN,假使function为None,则赶回(i壹, i二, …,
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]):
成立三个迭代器,生成项的章程接近于切片重返值: 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):
4858.com ,创造贰个迭代器,生成元组(i一, i二, … iN),个中i一,i二 … 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()相同,不过迭代进度会随处到独具输入迭代变量iter一,iter二等都耗尽停止,固然未有选取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]):

始建叁个迭代器,重临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]):

始建一个迭代器,生成代表item一,item二等中的项指标笛Carl积的元组,repeat是3个关键字参数,钦点重复生成系列的次数。

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

  再次来到二个迭代类别的累加值系列(未有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*)

  连接八个迭代类别为叁个迭代连串,适用于供给三番五次遍历八个体系场景。

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

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

组成

整体,全部了然

Infiniti迭代器

迭代器         参数         结果                                                例子
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中模块是个什概念?能够用简易的例证表明?

叁个模块正是一个文书,导入文本就导入了相应的模块,能够利用模块里定义的类,函数,变量等音信。若是模块很多,能够用包来治本,就是把公文放进3个文本夹里,再添加叁个__init__.py文件。
 

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

 itertools.chain(\iterables*)

  连接多少个迭代连串为三个迭代体系,适用于供给连接遍历多少个连串场景。

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

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

Python中itertools模块用法详解。  通过1个迭代体系来创制 itertools.chain 的对象。

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

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

  通过一个迭代种类来创建 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:
这里的“不重复”是指迭代连串中的对象不会选拔频仍,但并不代表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开首盘算(注意:此迭代器不援救长整数)

1经过量了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中的成分的三个副本,此副本用于重临循环中的重复项。

定义

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的行列长度能够不等,当中任意叁个迭代终结,整个迭代即终结。

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

创办3个迭代器,重复生成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')]

第①有个别

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

  生成2个计数迭代器,能够内定起先点和步进,然而从未终点,能够一贯迭代下去。

  壹般要求格外其余的迭代器一起使用,例如作为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)

将多少个迭代器作为参数, 但只回去单个迭代器, 它发生负有参数迭代器的始末,
就象是他们是出自于3个纯净的体系.

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)

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

  1般须求相称其余迭代器一起使用,例如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
进行预见,扬弃第3个断言为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)

提供三个抉择列表,对原始数据开始展览筛选

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
进行预见,放弃第二个断言为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.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)

创办1个迭代器,只要函数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:
再次回到值为几个迭代器且重临的是一个有五个要素的元组,第3个要素为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])

归来3个发生根据key举办分组后的值集合的迭代器.

假若iterable在反复一而再迭代中生成了一致项,则会定义3个组,借使将此函数应用3个分拣列表,那么分组将定义该列表中的全数唯一项,key(假使已提供)是三个函数,应用于每壹项,假设此函数存在再次来到值,该值将用今后续项而不是该项本身实行比较,此函数重返的迭代器生成成分(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']

另3个例子

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:
再次来到值为四个迭代器且重回的是一个有多个成分的元组,第1个因素为key值,第1个因素为分组对象的迭代器

>>> 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, 则迭代到终极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.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,
则迭代到结尾叁个

  参数 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:
这里的“不重复”是指迭代类别中的对象不会选择频仍,但并不意味着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(函数相反 , 重临一个暗含这个测试函数再次回到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:
这里的“不重复”是指迭代种类中的对象不会利用频仍,但并不意味壹律的值不会选用频仍。

  注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: 重回值是多个迭代器

>>> 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,步幅将动用一.

归来体系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])

  重返2个迭代器,重复传入的目的。重复的次数为 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一, i贰, …,
iN)形式的元组,只要提供的一个迭代器不再生成值,迭代就会终止。

即:重回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 。

  1经未有传来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)

创办一个迭代器,生成值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
的参数封装在迭代器中的每二个目的中。

  注1:
迭代器中的每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.takewhile(predicate, iterable)

  与 dropwhile() 相反,对迭代器中的对象根据 predicate
进行预感,输出第多少个断言为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])

回到一些基于单个原始输入的独自迭代器(暗许为2).
它和Unix上的tee工具有点语义相似,
相当于说它们都重新读取输入设备中的值并将值写入到三个命名文件和规范输出中

从iterable创设n个独立的迭代器,创立的迭代器以n元组的款式重返,n的暗中认可值为二,此函数适用于其余可迭代的目标,不过,为了克隆原始迭代器,生成的项会被缓存,并在具有新创设的迭代器中行使,一定要留心,不要在调用tee()之后选取原始迭代器iterable,不然缓存机制也许无法正确工作。

把二个迭代器分为n个迭代器, 重返3个元组.暗许是五个

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
进行预知,输出第八个断言为False以前的兼具目的。

  注1: 当出现第3个断言为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)

  将二个迭代器复制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次,再次回到多个有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)

回去三个联结了多个迭代器为三个元组的迭代器. 它好像于内置函数zip(),
只是它回到的是三个迭代器而不是四个列表

始建3个迭代器,生成元组(i一, i二, … iN),在那之中i一,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

其三片段

itertools.product(*iterables[, repeat])

笛Carl积

创造三个迭代器,生成代表item1,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])

排列

创制三个迭代器,重回iterable中具备长度为r的品种类别,就算简单了r,那么连串的尺寸与iterable中的项目数量同样:
重回p中4意取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地图
Copyright @ 2010-2019 美高梅手机版4858 版权所有