Шпаргалка по модулю itertools

Модуль itertools позволяет создавать свои собственные итераторы. Умело комбинируя его функции, можно облегчить написание итеративных алгоритмов и решить любые комбинаторные задачи в несколько строк легко читаемого кода.

Бесконечные итераторы

Итераторы, которые завершаются на самой короткой последовательности

Комбинаторные итераторы

Бесконечные итераторы

Бесконечные итераторы никогда не завершаются сами. Они хорошо подойдут для задач, в которых количество итераций заранее неизвестно, или бесконечно.

repeat()

itertools.repeat(object[, times]

Возвращает объект object times раз или бесконечно

for i in repeat(1, 2):
    print(i)
# 1
# 1

cycle()

itertools.cycle(iterable)

Создает итератор, возвращающий элементы из последовательности iterable и сохраняющий их копии. При исчерпании последовательности, начинает возвращать копии.

a = cycle((9, 3, 7))
for i in cycle((9, 3, 7)):
    print(i)
# 9
# 3
# 7
# 9
# 3
# 7
...

Требует дополнительную память для хранения копий.

count()

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

Создает бесконечный итератор, возвращающий числа, начиная со start с шагом step.

count(-2, 3)
# -2
# 1
# 4
...

Итераторы, которые завершаются на самой короткой последовательности

Самый распространенный и разнообразный тип итераторов.

accumulate()

itertools.accumulate(iterable[, func, *, initial=None])

Создает итератор, возвращающий кумулятивные суммы или аккумулированные результаты функции func, принимающей два аргумента. Опциональный аргумент initial добавляет значение перед последовательностью iterable.

accumulate([1, 2, 3, 4])
# 1
# 3
# 6
# 10

accumulate([1, 2, 3, 4], func=operator.mul)
# 1
# 2
# 6
# 24

accumulate([1, 2, 3, 4], initial=-10)
# -2
# -1
# 1
# 4
# 8

chain()

itertools.chain(*iterables)

Склеивает несколько последовательностей в один итератор.

chain(('a', 'b'), ('c', 'd'))
# a
# b
# c
# d

Имеет метод для склеивания последовательностей, объединенных в одну последовательность.

chain.from_iterable(iterable)

chain.from_iterable([('a', 'b'), ('c', 'd')])
# a
# b
# c
# d

compress()

itertools.compress(data, selectors)

Создает итератор из элементов последовательности data, которым соответствуют элементы с истинным значением из последовательности selectors.

a = compress(('A', 'B', 'C', 'D', 'E', 'F'),
             (True, False, 1, 0, None, 'str'))

dropwhile()

itertools.dropwhile(predicate, iterable)

Создает итератор, пропускающий элементы последовательности iterable, пока условие predicate не выполнено.

a = dropwhile(lambda x: x > 0, (8, 3, 1, 0, 7, 2))
# 0
# 7
# 2

filterfalse()

itertools.filterfalse(predicate, iterable)

Создает итератор, возвращающий только те элементы последовательности iterable, для которых условие predicate не выполняется.

filterfalse(lambda x: x > 0, (3, 0, -9, 2))
# 0
# -9

groupby()

itertools.groupby(iterable, key=None)

Создает итератор, возвращающий итераторы для каждой группы итератора iterable. Функция key должна принимать одно значение и возвращать его ключ. Аналог GROUP BY в SQL. Данные должны быть отсортированы, иначе группы будут разбиты на более мелкие.

for k, g in groupby((3, 4, 0, -1), key=lambda x: x > 0):
    print(k, [i for i in g])
# True [3, 4]
# False [0, -1]

islice()

itertools.islice(iterable, stop)
itertools.islice(iterable, start, stop[, step])

Создает итератор, возвращающий итератор среза последовательности. Можно задать начало, конец и шаг последовательности.

islice((0, 1, 2, 3, 4, 5, 6), 2)
# 0
# 1

a = islice((0, 1, 2, 3, 4, 5, 6, 7, 8), 2, 7, 2)
# 2
# 4
# 6

pairwise()

itertools.pairwise(iterable)

Создает итератор, последовательно возвращающий кортежи из перекрывающихся пар соседних значений.

pairwise(('a', 'b', 'c', 'd'))
('a', 'b')
('b', 'c')
('c', 'd')

starmap()

itertools.starmap(function, iterable)

Аналог функции map(). Создает итератор, возвращающий результаты выполнения функции function на группах параметров, записанных в одну последовательность iterable. Обычно такие последовательности создаются функциями zip() или itertools.zip_longest.

starmap(operator.mul, ((1, 2), (3, 4)))
# 2
# 12

takewhile()

itertools.takewhile(predicate, iterable)

Создает итератор, который возвращает значения из последовательности iterable, пока условие predicate выполняется.

takewhile(lambda x: x > 0, (8, 3, 1, 0, 7, 2))
# 8
# 3
# 1

tee()

itertools.tee(iterable, n=2)

Возвращает кортеж из n независимых итераторов по одной и той же последовательности iterable

a = tee((1, 2), 2)
a[0]
# 1
# 2
a[1]
# 1
# 2

zip_longest()

itertools.zip_longest(*iterables, fillvalue=None)

Поэлементно склеивает последовательности *iterables в кортежи. В отличие от стандартной функции zip(), после исчерпания одной из последовательностей продолжает работу, заменяя её элементы на значение по умолчанию (fillvalue).

zip_longest((1, 2, 3), ('A', 'B'))
# (1, 'A', 'q')
# (2, 'B', 'p')
# (3, None, None)

zip_longest((1, 2, 3), ('A', 'B'), fillvalue='_')
# (1, 'A')
# (2, 'B')
# (3, '_')

Комбинаторные итераторы

Комбинаторные итераторы возвращают комбинации элементов последовательностей.

product()

itertools.product(*iterables, repeat=1)

Возвращает прямое произведение множеств. Грубо эквивалентно вложенному циклу ((x,y) for x in A for y in B). Параметр repeat определяет количество повторов каждой последовательности

a = product(('a', 'b'), ('-', '+'))
# ('a', '-')
# ('a', '+')
# ('b', '-')
# ('b', '+')

product(('a', 'b'), repeat=2)
# ('a', 'a')
# ('a', 'b')
# ('b', 'a')
# ('b', 'b')

При запуске полностью считывает последовательность, поэтому не работает с бесконечными итераторами.

permutations()

itertools.permutations(iterable, r=None)

Возвращает все возможные перестановки в виде кортежей длины r последовательности iterable. При r == None длина перестановок равна длине исходной последовательности.

permutations(("a", "b", "c"), 2)
# ('a', 'b')
# ('a', 'c')
# ('b', 'a')
# ('b', 'c')
# ('c', 'a')
# ('c', 'b')

permutations(("a", "b", "c"))
# ('a', 'b', 'c')
# ('a', 'c', 'b')
# ('b', 'a', 'c')
# ('b', 'c', 'a')
# ('c', 'a', 'b')
# ('c', 'b', 'a')

Количество комбинаций: n! / (n-r)! при 0 <= r <= n 0 приr > n.

combinations()

combinations(iterable, r)

Возвращает все возможные кортежи длины r элементов последовательности iterable без перестановки.

combinations((4, 3, 2, 1), 3)
# (4, 3, 2)
# (4, 3, 1)
# (4, 2, 1)
# (3, 2, 1)

Количество комбинаций: n! / r! / (n-r)! при 0 <= r <= n 0 при r > n.

combinations_with_replacement()

combinations_with_replacement(iterable, r)

Возвращает все возможные кортежи длины r элементов последовательности iterable, допуская любое количество повторений.

combinations_with_replacement((1, 2), 3)
# (1, 1, 1)
# (1, 1, 2)
# (1, 2, 2)
# (2, 2, 2)

Количество комбинаций: (n+r-1)! / r! / (n-1)! при n > 0