itertools

chain(*イテレータブル) この関数は、すべてのイテレータをリンクする新しいイテレータを作成します。返されたイテレータは、イテレータ1からアイテムの生成を開始し、イテレータ1が使い切られたことを認識した後、イテレータ2からアイテムを生成します。

from itertools import chain
test = chain('AB', 'CDE', 'F')
for el in test:
 print el
-------------result---------------------
A
B
C
D
E
F

combinations(iterable, r) は、iterable の長さ r のすべての部分シーケンスを返すイテレータを作成します。

test = itertools.combinations([1,2,3,4], 2)
for i in test:
 print(i)
-------------------------------------------
(1, 2)
(1, 3)
(1, 4)
(2, 3)
(2, 4)
(3, 4)

combinations_with_replacement(iterable, r) イテレータの要素のうち、1つの要素に連続した繰り返しを持たせることができる要素の連続したr長の組み合わせを返します。

test = itertools.combinations_with_replacement([1,2,3], 2)
for i in test:
 print(i)
------------------------------------------------------
(1, 1)
(1, 2)
(1, 3)
(2, 2)
(2, 3)
(3, 3)

islice() 関数は、入力イテレータからインデックスで選択された要素を返すイテレータを返します。

for i in islice(range(10), 5):
 print(i)
for i in islice(range(100), 0, 100, 20):
 print(i)
-----------------result-------------------------
0
1
2
3
4
---
0
20
40
60
80

tee()は、並列処理で複数のアルゴリズムに同じデータセットを提供するために使用できるイテレータを返します。新しいイテレータは、元のイテレータが消費されるときに使用される値を生成しないので、teeは新しいイテレータを返した後に使用すべきではありません。

r = islice(count(), 5)
r1, r2 = tee(r)
print(list(r1))
print(list(r2))
-------------------
[0, 1, 2, 3, 4]
[0, 1, 2, 3, 4]

count(start=0, step=1) 常に新しい値を生成

cycle() は、与えられた引数の内容を無限に繰り返すイテレータを返します。

for i in zip(range(5), cycle(['a','b','c'])):
 print(i)
-----------------------------------------
(0, 'a')
(1, 'b')
(2, 'c')
(3, 'a')
(4, 'b')

repeat() 関数は、アクセスするたびに同じ値を生成するイテレータを返します。

for i in repeat('handsome',5):
 print(i)
--------------------------------
handsome
handsome
handsome
handsome
handsome
for i in map(lambda x,y: (x,y,x*y), repeat(2), range(10)):
 print(f'{i[0]}*{i[1]}={i[2]}')
--------------------------------------------
2*0=0
2*1=2
2*2=4
2*3=6
2*4=8
2*5=10
2*6=12
2*7=14
2*8=16
2*9=18

dropwhile(function, iterable) 条件を満たさないイテレータを返します。

test = dropwhile(lambda x:x<2, [-1,0,1,3,2,0,1])
print(list(test))
---------------------------------------------
[3, 2, 0, 1]

takewhile(functin, iterable) は、以下の条件を満たすイテレータを返します。

test = takewhile(lambda x:x>=2, [2,3,4,-1,5])
print(list(test))
------------------------------------------------------
[2, 3, 4]

filterfalse() は、テスト条件が真にならない要素だけを含むイテレータを返します。

test = filterfalse(lambda x:x%2, [1,2,3,4])
print(list(test))
-----------------------------------------
[2,4]

compress(data, selectors) 真値のデータを返します

test = compress(range(10), cycle([False,True,False]))
print(list(test))
-----------------------------------------------------
[1, 4, 7]

groupby() はイテレータを返し、 共通のキーによって整理された集合の値を生成します。

a = cycle(islice(count(), 3))
b = islice(count(), 7)
c = list(zip(a, b))
#  
for k,g in groupby(c, lambda c:c[0]):
 print(k, list(g))
#  
c.sort()
for k,g in groupby(c, lambda c:c[0]):
 print(k, list(g))
----------------------------------------
#  
0 [(0, 0)]
1 [(1, 1)]
2 [(2, 2)]
0 [(0, 3)]
1 [(1, 4)]
2 [(2, 5)]
0 [(0, 6)]
#  
0 [(0, 0), (0, 3), (0, 6)]
1 [(1, 1), (1, 4)]
2 [(2, 2), (2, 5)]

accumulate() は入力イテレータを処理し、n 番目と n+1 番目の要素を加算して返します。

print(list(accumulate(range(1,6,2))))
print(list(accumulate('abc')))
print(list(accumulate('abc', lambda a,b: a+b+a)))
------------------------------
[1, 4, 9]
['a', 'ab', 'abc']
['a', 'aba', 'abacaba']

product() が生成する値はタプルで、最初のタプルには各イテレータの最初の値が含まれ、product に渡された最後のイテレータが優先されます。

a= [1,2,3,4]
b= ['a','b']
test = product(a,b)
print(list(test))
# 反復子 repeat の反復回数を指定する
test = product(range(3), repeat=2)
print(list(test))
----------------------------
[(1, 'a'), (1, 'b'), (2, 'a'), (2, 'b'), (3, 'a'), (3, 'b'), (4, 'a'), (4, 'b')]
[(0, 0), (0, 1), (0, 2), (1, 0), (1, 1), (1, 2), (2, 0), (2, 1), (2, 2)]

permutations() 与えられた配列を並べます

def show(iterable):
 first = None
 for i, item in enumerate(iterable, 1):
 if first != item[0]:
 if first is not None:
 print()
 first = item[0]
 print(''.join(item), end=' ')
 print()
show(permutations('abcd'))
# r個々の順列の長さと数を制限するパラメータ
show(permutations('abcd', r=2))
------------------------------------------
abcd abdc acbd acdb adbc adcb
bacd badc bcad bcda bdac bdca
cabd cadb cbad cbda cdab cdba
dabc dacb dbac dbca dcab dcba
# r個々の順列の長さと数を制限するパラメータ
ab ac ad
ba bc bd
ca cb cd
da db dc

combinations() は、指定されたシーケンスを組み合わせ、入力メンバは一意であり、返される結果は重複しません。

def show(iterable):
 first = None
 for i, item in enumerate(iterable, 1):
 if first != item[0]:
 if first is not None:
 print()
 first = item[0]
 print(''.join(item), end=' ')
 print()
show(combinations('abcd', r=2)) # r 
--------------------------------------------
ab ac ad
bc bd
cd

combinations_with_replacement() 与えられた配列を組み合わせ、個々の要素を繰り返すことができます。

def show(iterable):
 first = None
 for i, item in enumerate(iterable, 1):
 if first != item[0]:
 if first is not None:
 print()
 first = item[0]
 print(''.join(item), end=' ')
 print()
show(combinations_with_replacement('abcd', r=2)) # r 
---------------------------------------------------------
aa ab ac ad
bb bc bd
cc cd
dd