Python Language
Moduł Itertools

Składnia

• import itertools

Grupowanie elementów z iterowalnego obiektu za pomocą funkcji

Zacznij od iterowalnego, który musi być zgrupowany

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

Wygeneruj zgrupowany generator, grupując według drugiego elementu w każdej krotce:

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

Pogrupowane są tylko grupy kolejnych elementów. Przed wywołaniem groupby może być konieczne sortowanie według tego samego klucza. Na przykład (ostatni element został zmieniony)

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

Grupa zwrócona przez groupby to iterator, który będzie nieprawidłowy przed następną iteracją. Np. Poniższe elementy nie będą działać, jeśli chcesz, aby grupy były sortowane według klucza. Grupa 5 jest pusta poniżej, ponieważ po pobraniu grupy 2 unieważnia 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 []

Aby poprawnie wykonać sortowanie, przed sortowaniem utwórz listę z iteratora

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

Weź kawałek generatora

Itertools „islice” pozwala pokroić generator:

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

Zwykle nie można pokroić generatora:

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

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

Da

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

Działa to jednak:

import itertools

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

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

Zauważ, że podobnie jak zwykły plasterek, możesz także użyć argumentów start , stop i step :

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

itertools.product

Ta funkcja pozwala iterować po kartezjańskim produkcie listy iteracji.

Na przykład,

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

jest równa

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

Podobnie jak wszystkie funkcje Pythona, które akceptują zmienną liczbę argumentów, możemy przekazać listę do itertools.product do rozpakowania za pomocą operatora *.

A zatem,

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

daje takie same wyniki jak oba poprzednie przykłady.

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

Wprowadzenie:

Ta prosta funkcja generuje nieskończoną serię liczb. Na przykład...

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

Pamiętaj, że musimy się zepsuć lub wydrukuje się na zawsze!

Wynik:

0
1
2
3
4
5
6
7
8
9
10

Argumenty:

count() przyjmuje dwa argumenty, start i step :

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

Wynik:

10
14
18
22

itertools.takewhile

itertools.takewhile umożliwia pobieranie przedmiotów z sekwencji, dopóki warunek nie stanie się 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)
  

Daje to wyniki [0, 2, 4, 12, 18] .

Zauważ, że pierwszą liczbą, która narusza predykat (tj. Funkcja zwracająca wartość logiczną) jest is_even 13 . Gdy takewhile napotka wartość, która powoduje takewhile False dla danego predykatu, wybucha.

Dane wyjściowe wytworzone przez takewhile są podobne do danych wyjściowych wygenerowanych z poniższego kodu.

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

Uwaga: takewhile wyników uzyskanych przez takewhile i dropwhile tworzy oryginalny iterowalny.

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

itertools.dropwhile

itertools.dropwhile umożliwia pobieranie przedmiotów z sekwencji po tym, jak warunek najpierw stanie się 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)
  

Daje to wyniki [13, 14, 22, 23, 44] .

( Ten przykład jest taki sam jak przykład dla takewhile ale z użyciem dropwhile ).

Zauważ, że pierwszą liczbą, która narusza predykat (tj. Funkcja zwracająca wartość logiczną) jest is_even 13 . Wszystkie elementy wcześniej są odrzucane.

Dane wyjściowe generowane przez dropwhile są podobne do danych wyjściowych wygenerowanych z poniższego kodu.

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 wyników uzyskanych przez takewhile i dropwhile daje pierwotną iterowalność.

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

Kompresowanie dwóch iteratorów, dopóki nie zostaną wyczerpane

Podobnie do wbudowanej funkcji zip() , itertools.zip_longest będzie kontynuował iterację poza końcem krótszej z dwóch iteracji.

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)

Opcjonalny argument fillvalue można przekazać (domyślnie na '' ) w następujący sposób:

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)

W Pythonie 2.6 i 2.7 ta funkcja nazywa się itertools.izip_longest .

Metoda kombinacji w module Itertools

itertools.combinations zwróci generator sekwencji k- kombinacji listy.

Innymi słowy: zwróci generator krotek wszystkich możliwych kombinacji K-mądrych listy danych wejściowych.

Na przykład:

Jeśli masz listę:

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

Wynik:

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

Powyższe wyjście jest generatorem przekonwertowanym na listę krotek wszystkich możliwych kombinacji par listy wejściowej a

Możesz również znaleźć wszystkie 3 kombinacje:

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

Wynik:

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

Łączenie wielu iteratorów razem

Użyj itertools.chain aby utworzyć pojedynczy generator, który będzie generował wartości z kilku generatorów w sekwencji.

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

Prowadzi do:

'1 2 3 4 x y z'

Jako alternatywny konstruktor możesz użyć metody classmethod chain.from_iterable która jako pojedynczy parametr przyjmuje iterowalną chain.from_iterable . Aby uzyskać taki sam wynik jak powyżej:

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

chain może przyjmować dowolną liczbę argumentów, chain.from_iterable jest jedynym sposobem na połączenie nieskończonej liczby iterowalnych.

itertools.repeat

Powtórz coś n razy:

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

Uzyskaj łączną sumę liczb w iterowalnym

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

Przełączaj się między elementami w iteratorze

cycle jest nieskończonym iteratorem.

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

Dlatego należy zachować granice podczas korzystania z tego, aby uniknąć nieskończonej pętli. Przykład:

>>> # 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 zwraca generator z kolejnymi permutacjami długości r elementów w iteracji.

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

jeśli lista a zawiera zduplikowane elementy, wynikowe permutacje będą miały zduplikowane elementy, możesz użyć set aby uzyskać unikalne permutacje:

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