Pythonのitertoolsモジュールの使い方を詳しく解説

この記事の例は、Python での itertools モジュールの使用法を説明しており、参考のために共有されています。具体的な分析は次のとおりです。

一般に、itertools モジュールには、さまざまな方法でデータをループするために使用できる有効なイテレータを作成する関数が含まれています。このモジュールのすべての関数によって返されるイテレータは、for ループ ステートメントや他のイテレータと組み合わせて使用​​できます。ジェネレーターやジェネレーター式などの関数を使用します。

chain(iter1, iter2, ..., iterN):

反復子のセット (iter1、iter2、...、iterN) を指定すると、この関数はすべての反復子をリンクする新しい反復子を作成します。返された反復子は、iter1 が使い果たされるまで 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'

組み合わせ(反復可能、r):

反復可能内に長さ r のすべてのサブシーケンスを返す反復子を作成します。返されたサブシーケンス内の項目は、反復可能に入力された順序でソートされます。

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

n から始まる連続する整数を生成する反復子を作成します。n が無視された場合、カウントは 0 から始まります (注: この反復子は長整数をサポートしません)。 sys.maxint-1 で計算を開始します。

サイクル(反復可能):

反復子を作成し、反復可能内の要素に対してループ操作を繰り返し実行します。反復可能内の要素のコピーが、ループ内の重複した項目を返すために使用されます。

dropwhile(述語、反復可能):

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

反復可能によって生成された連続する項目をグループ化するイテレーターを作成し、グループ化プロセス中に重複する項目を見つけます。

イテラブルが複数の連続した反復で同じ項目を生成する場合、グループが定義されます。この関数がカテゴリリストに適用されると、グループ化によってリスト内のすべての一意の項目が定義されます (指定されている場合)。この関数が値を返す場合、この関数によって返される反復子は要素 (キー、グループ) を生成し、キーはグループになります。 . キー値、グループは反復子であり、グループを構成するすべての項目を生成します。

ifilter(述語、反復可能):

predicate(item) が True の iterable 内の項目のみを生成するイテレータを作成します。 predicate が None の場合、True と評価される iterable 内のすべての項目が返されます。

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

ifilterfalse(述語、反復可能):
述語(項目)が False である反復可能項目のみを生成する反復子を作成します。述語が None の場合、False と評価される反復可能項目をすべて返します。

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

imap(関数, iter1, iter2, iter3, ..., iterN)

イテレーターを作成し、項目 function(i1, i2, ..., iN) を生成します。ここで、i1、i2...iN はそれぞれイテレーター iter1、iter2... iterN から来ます。 function が None の場合は、タプルの場合に戻ります。 (i1, 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]):

イテレータを作成します。項目の生成方法はスライスの戻り値と似ています: iterable[start : stop : step]。最初の開始項目はスキップされ、繰り返しは stop で指定された位置で停止し、step はスキップに指定された項目のストライド。スライスとは異なり、開始、停止、ステップに負の値は使用されません。開始を省略した場合は反復は 0 から開始され、ステップを省略した場合はストライドは 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):

イテレータを作成し、タプル (i1、i2、... iN) を生成します。ここで、i1、i2 ... iN は、それぞれイテレータ iter1、iter2 ... iterN から取得されます。ただし、指定されたイテレータの 1 つが値が再度生成されると反復は停止し、この関数によって生成される値は組み込みの 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 が使用されます。変数。

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

创建一个迭代器，生成表示item1，item2等中的项目的笛卡尔积的元组，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的默认值为2，此函数适用于任何可迭代的对象，但是，为了克隆原始迭代器，生成的项会被缓存，并在所有新创建的迭代器中使用，一定要注意，不要在调用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程序设计的学习有一定的借鉴价值。