Python Language
Itertools 모듈

통사론

• import itertools

함수를 사용하여 반복 가능한 객체의 항목 그룹화

그룹화 할 필요가있는 iterable로 시작하십시오.

lst = [("a", 5, 6), ("b", 2, 4), ("a", 2, 5), ("c", 2, 6)]

그룹화 된 생성기를 생성하고 각 튜플의 두 번째 요소별로 그룹화합니다.

def testGroupBy(lst):
    groups = itertools.groupby(lst, key=lambda x: x[1])
    for key, group in groups:
        print(key, list(group))

testGroupBy(lst)

# 5 [('a', 5, 6)]
# 2 [('b', 2, 4), ('a', 2, 5), ('c', 2, 6)]

연속 된 요소 그룹 만 그룹화됩니다. 예를 들어 groupby를 호출하기 전에 동일한 키로 정렬해야 할 수도 있습니다 (마지막 요소가 변경됨)

lst = [("a", 5, 6), ("b", 2, 4), ("a", 2, 5), ("c", 5, 6)]
testGroupBy(lst)

# 5 [('a', 5, 6)]
# 2 [('b', 2, 4), ('a', 2, 5)]
# 5 [('c', 5, 6)]

groupby가 반환 한 그룹은 다음 반복 전에 무효화 될 반복자입니다. 예를 들어, 그룹을 키순으로 정렬하려면 다음이 작동하지 않습니다. 그룹 2를 가져 오면 5가 무효화되므로 그룹 5는 비어 있습니다.

lst = [("a", 5, 6), ("b", 2, 4), ("a", 2, 5), ("c", 2, 6)]
groups = itertools.groupby(lst, key=lambda x: x[1])
for key, group in sorted(groups):
    print(key, list(group))

# 2 [('c', 2, 6)]
# 5 []

정렬을 제대로하려면 정렬 전에 반복기에서 목록을 만듭니다.

groups = itertools.groupby(lst, key=lambda x: x[1])
for key, group in sorted((key, list(group)) for key, group in groups):
    print(key, list(group))
      
# 2 [('b', 2, 4), ('a', 2, 5), ('c', 2, 6)]
# 5 [('a', 5, 6)]

발전기 한 조각을 가져 가라.

Itertools "islice"를 사용하면 생성기를 슬라이스 할 수 있습니다.

results = fetch_paged_results()  # returns a generator
limit = 20  # Only want the first 20 results
for data in itertools.islice(results, limit):
    print(data)

일반적으로 생성기는 슬라이스 할 수 없습니다.

def gen():
    n = 0
    while n < 20:
        n += 1
        yield n

for part in gen()[:3]:
    print(part)

줄게

Traceback (most recent call last):
  File "gen.py", line 6, in <module>
    for part in gen()[:3]:
TypeError: 'generator' object is not subscriptable

그러나,이 작품 :

import itertools

def gen():
    n = 0
    while n < 20:
        n += 1
        yield n

for part in itertools.islice(gen(), 3):
    print(part)

일반 슬라이스와 마찬가지로 start , stop 및 step 인수를 사용할 수도 있습니다.

itertools.islice(iterable, 1, 30, 3)

itertools.product

이 함수는 반복 가능한 목록의 데카르트 곱을 반복 할 수있게합니다.

예를 들어,

for x, y in itertools.product(xrange(10), xrange(10)):
    print x, y

~에 해당합니다.

for x in xrange(10):
    for y in xrange(10):
        print x, y

가변 개수의 인수를 허용하는 모든 파이썬 함수와 마찬가지로 * 연산자를 사용하여 언팩하기 위해 itertools.product에 목록을 전달할 수 있습니다.

그러므로,

its = [xrange(10)] * 2
for x,y in itertools.product(*its):
    print x, y

앞의 두 예와 동일한 결과를 산출합니다.

>>> from itertools import product
>>> a=[1,2,3,4]
>>> b=['a','b','c']
>>> product(a,b)
<itertools.product object at 0x0000000002712F78>
>>> for i in product(a,b):
...     print i
...
(1, 'a')
(1, 'b')
(1, 'c')
(2, 'a')
(2, 'b')
(2, 'c')
(3, 'a')
(3, 'b')
(3, 'c')
(4, 'a')
(4, 'b')
(4, 'c')

itertools.count

소개:

이 간단한 함수는 무한 수의 수를 생성합니다. 예를 들면 ...

for number in itertools.count():
    if number > 20:
        break
    print(number)

우리는 끊어야하거나 영원히 인쇄해야합니다!

산출:

0
1
2
3
4
5
6
7
8
9
10

인수 :

count() 는 start 와 step 이라는 두 개의 인수를 취 step .

for number in itertools.count(start=10, step=4):
    print(number)
    if number > 20:
        break

산출:

10
14
18
22

itertools.takewhile

itertools.takewhile을 사용하면 조건이 처음 False 가 될 때까지 시퀀스의 항목을 가져올 수 있습니다.

def is_even(x):
    return x % 2 == 0


lst = [0, 2, 4, 12, 18, 13, 14, 22, 23, 44]
result = list(itertools.takewhile(is_even, lst))

print(result)
  

이것은 [0, 2, 4, 12, 18] 합니다.

술어를 위반하는 첫 번째 숫자 (즉, 부울 값을 반환하는 함수) is_even 은 13 입니다. takewhile 이 주어진 조건 자에 대해 False 를 생성하는 값을 만나면 빠져 나옵니다.

takewhile 에 의해 생성 된 출력 은 아래 코드에서 생성 된 출력과 유사합니다.

def takewhile(predicate, iterable):
    for x in iterable:
        if predicate(x):
            yield x
        else:
            break

주 : takewhile 과 dropwhile 의해 생성 된 결과의 연결은 원래 반복 가능을 생성합니다.

result = list(itertools.takewhile(is_even, lst)) + list(itertools.dropwhile(is_even, lst))

itertools.dropwhile

itertools.dropwhile를 사용하면 조건이 처음 False 가 된 후 시퀀스에서 항목을 가져올 수 있습니다.

def is_even(x):
    return x % 2 == 0


lst = [0, 2, 4, 12, 18, 13, 14, 22, 23, 44]
result = list(itertools.dropwhile(is_even, lst))

print(result)
  

이 출력은 [13, 14, 22, 23, 44] 입니다.

( 이 예제는 takewhile 의 예제와 동일하지만 dropwhile 사용 dropwhile . )

술어를 위반하는 첫 번째 숫자 (즉, 부울 값을 반환하는 함수) is_even 은 13 입니다. 그 전에 모든 요소는 버려집니다.

dropwhile 에 의해 생성 된 출력 은 아래 코드에서 생성 된 출력과 유사합니다.

def dropwhile(predicate, iterable):
    iterable = iter(iterable)
    for x in iterable:
        if not predicate(x):
            yield x
            break
    for x in iterable:
        yield x

takewhile 과 dropwhile 생성 된 결과의 연결은 원래 반복 가능합니다.

result = list(itertools.takewhile(is_even, lst)) + list(itertools.dropwhile(is_even, lst))

두 개의 반복기가 모두 소모 될 때까지 압축합니다.

내장 함수 zip() 과 유사하게 itertools.zip_longest 는 두 개의 반복 가능 시간 중 짧은 기간의 끝을 넘어서 계속 반복됩니다.

from itertools import zip_longest
a = [i for i in range(5)] # Length is 5
b = ['a', 'b', 'c', 'd', 'e', 'f', 'g'] # Length is 7
for i in zip_longest(a, b):
    x, y = i  # Note that zip longest returns the values as a tuple
    print(x, y)

선택적인 fillvalue 인자가 다음과 같이 전달 될 수 있습니다 (기본값은 '' ) :

for i in zip_longest(a, b, fillvalue='Hogwash!'):
    x, y = i  # Note that zip longest returns the values as a tuple
    print(x, y)

Python 2.6 및 2.7에서는이 함수를 itertools.izip_longest 라고합니다.

Itertools 모듈의 조합 방법

itertools.combinations 는 목록의 k- 결합 순서의 생성자를 리턴합니다.

다른 말로하면 : 그것은 입력리스트의 가능한 모든 k-wise 조합의 튜플 생성자를 반환합니다.

예 :

목록이있는 경우 :

a = [1,2,3,4,5]
b = list(itertools.combinations(a, 2))
print b

산출:

[(1, 2), (1, 3), (1, 4), (1, 5), (2, 3), (2, 4), (2, 5), (3, 4), (3, 5), (4, 5)]

위의 출력은 입력리스트 a 의 모든 쌍 쌍 조합의 튜플 목록으로 변환 된 생성자입니다

또한 다음 3 가지 조합을 모두 찾을 수 있습니다.

a = [1,2,3,4,5]
b = list(itertools.combinations(a, 3))
print b

산출:

[(1, 2, 3), (1, 2, 4), (1, 2, 5), (1, 3, 4),
 (1, 3, 5), (1, 4, 5), (2, 3, 4), (2, 3, 5),
 (2, 4, 5), (3, 4, 5)]

여러 개의 반복자 연결하기

itertools.chain 을 사용하여 여러 생성자의 값을 순서대로 생성하는 단일 생성기를 만듭니다.

from itertools import chain
a = (x for x in ['1', '2', '3', '4'])
b = (x for x in ['x', 'y', 'z'])
' '.join(chain(a, b))

결과 :

'1 2 3 4 x y z'

대체 생성자로서, chain.from_iterable 을 사용할 수 있습니다.이 chain.from_iterable 는 하나의 매개 변수로 iterable의 반복 가능을 취합니다. 위와 동일한 결과를 얻으려면 다음과 같이하십시오.

' '.join(chain.from_iterable([a,b])

chain 은 임의의 수의 인수를 취할 수 있지만 chain.from_iterable 은 무한 수의 반복 가능을 연결하는 유일한 방법입니다.

itertools.repeat

n 번 무언가를 반복하십시오 :

>>> import itertools
>>> for i in itertools.repeat('over-and-over', 3):
...    print(i)
over-and-over
over-and-over
over-and-over

반복 가능한 숫자의 누적 합계 가져 오기

>>> import itertools as it
>>> import operator

>>> list(it.accumulate([1,2,3,4,5]))
[1, 3, 6, 10, 15]

>>> list(it.accumulate([1,2,3,4,5], func=operator.mul)) 
[1, 2, 6, 24, 120]

반복자의 요소 순환

cycle 은 무한 반복자입니다.

>>> import itertools as it
>>> it.cycle('ABCD')
A B C D A B C D A B C D ...

따라서 이것을 사용하면 무한 루프를 피하기 위해 경계를 지정하는 데주의해야합니다. 예:

>>> # Iterate over each element in cycle for a fixed range
>>> cycle_iterator = it.cycle('abc123')
>>> [next(cycle_iterator) for i in range(0, 10)]
['a', 'b', 'c', '1', '2', '3', 'a', 'b', 'c', '1']

itertools.permutations

itertools.permutations 는 iterable에 연속 된 r-length 순열을 가진 생성자를 리턴한다.

a = [1,2,3]
list(itertools.permutations(a))
# [(1, 2, 3), (1, 3, 2), (2, 1, 3), (2, 3, 1), (3, 1, 2), (3, 2, 1)]

list(itertools.permutations(a, 2))
[(1, 2), (1, 3), (2, 1), (2, 3), (3, 1), (3, 2)]

리스트 a 중복 요소가있는 경우 결과 순열에 중복 요소가 생기며 set 를 사용하여 고유 순열을 가져올 수 있습니다.

a = [1,2,1]
list(itertools.permutations(a))
# [(1, 2, 1), (1, 1, 2), (2, 1, 1), (2, 1, 1), (1, 1, 2), (1, 2, 1)]

set(itertools.permutations(a))
# {(1, 1, 2), (1, 2, 1), (2, 1, 1)}