itertools

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

Все функции в этом модуле возвращают итераторы, которые можно использовать в инструкции for и в других функциях, где применяются итераторы, например в функциях-генераторах и в выражениях-генераторах.

accumulate()

itertools.accumulate(iterable[, function])

На каждой итерации возвращает сумму предыду­щих элементов последовательности.

Начальное значение равно 0

Warning

Добавлено в 3.2

list(accumulate([1, 2, 3, 4, 5, 6]))
# [1, 3, 6, 10, 15, 21]

list(accumulate([1, 2, 3, 4, 5, 6], lambda a,b: a*b))
# [1, 2, 6, 24, 120, 720]

chain()

itertools.chain(*iterable)

Возвращает генератор, на каждой итерации возвращает элементы сначала из первой последовательности, затем из второй последовательности и т.д.

list(itertools.chain([1,2,3], [4,5,6], [7,8,9]))
# [1, 2, 3, 4, 5, 6, 7, 8, 9]

chain.from_iterable()

chain.from_iterable(iterable)

Аналогична функции chain(), но прини­мает одну последовательность.

Каждый элемент которой считается отдельной последо­вательностью.

list(itertools.chain.from_iterable(['abc', 'def']))
# ['a', 'b', 'c', 'd', 'e', 'f']

combinations()

itertools.combinations(iterable, n)

Создает итератор, который возвращает все возможные последовательности из n элементов, взятых из итерируемого объекта iterable.

Элементы в возвращаемых последовательностях располагаются в том же порядке, в каком они встречаются в исходном объекте iterable.

list(itertools.combinations([1, 2, 3, 4], 2))
# [[1, 2], [1, 3], [1, 4], [2, 3], [2, 4], [3, 4]]

combinations_with_replacement()

itertools.combinations_with_replacement(iterable, n)

Создает итератор, который возвращает кортеж, содержащий комбинацию из указанного количества элементов.

list(itertools.combinations_with_replacement([1, 2, 3], 2))
[[1, 1], [1, 2], [1, 3], [2, 2], [2, 3], [3, 3]]

compress()

itertools.compress(data, selectors)

Производит фильтрацию последовательности, указанной в первом пара­метре.

Элемент возвращается, только если соответствующий элемент (с таким же индек­сом) из второй последовательности трактуется как истина.

Сравнение заканчивается, когда достигнут конец одной из последовательностей.

list(itertools.compress('абвгде', [1,0,0,0,1,1]))
['а', 'д', 'е']

count()

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

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

Этот итератор не поддерживает длинные целые числа.

По достижении значения sys.maxint счетчик переполнится и итератор продолжит воспроизводить значения, начиная с -sys.maxint - 1

for i in itertools.count():
    if i > 5:
        break
    print(i)

# 0, 1, 2, 3, 4

counter = it.count()
list(next(counter) for _ in range(5))
# [0, 1, 2, 3, 4]

cycle()

itertools.cycle(iterable)

Создает итератор, который в цикле многократно выполняет обход элементов в объекте iterable.

За кулисами создает копию элементов в объекте iterable.

Эта копия затем используется для многократного обхода элементов в цикле.

for i in cycle([1, 2]):
    print(i)
# 1, 2, 1, ...

dropwhile()

itertools.dropwhile(predicate, iterable)

Возвращает объект итератор, который в каждой итерации возвращает элемент последовательности, начиная с элемента, для которого функция, указанная в первом параметре вернет False

list(itertools.dropwhile(lambda x: x > 3, [4, 5, 6, 0, 7, 2, 3]))
# [0, 7, 2, 3]

filterfalse()

itertools.filterfalse(predicate, iterable)

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

Если в первом параметре вместо названия функции указать значение None, то каждый элемент последовательности будет проверен на соответствие значению False.

Если эле­мент в логическом контексте возвращает значение True, то он не будет входить в возвращаемый результат.

list(itertoo1s.filterfalse(lambda x: x > 3, [4, 5, 6, 2, 3]
# [0, 2, 3]

groupby()

itertools.groupby(iterable[, key])

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

Процесс группировки основан на поиске одинаковых элементов.

Например, если итерируемый объект iterable возвращает один и тот же элемент несколько раз подряд, этот элемент образует группу.

Если функция применяется к отсортированному списку, она образует группы по числу уникальных элементов в списке.

В необязательном аргументе key может передаваться функция, которая будет применяться к каждому элементу; в этом случае в сравнивании соседних элементов участвуют возвращаемые значения этой функции, а не значения самих элементов.

Итератор, возвращаемый функцией, воспроизводит кортежи (key, group), где элемент key – это значение ключа для группы, а элемент group – это итератор, который возвращает все элементы, попавшие в группу.

ifilter()

itertools.ifilter(predicate, iterable)

Создает итератор, который воспроизводит только те элементы из объекта iterable, для которых функция predicate(item) возвращает True.

Если в аргументе predicate передать None, все элементы в объекте iterable будут оцениваться как True и будут возвращаться итератором.

ifilterfalse()

itertools.ifilterfalse(predicate, iterable)

Создает итератор, который воспроизводит только те элементы из объекта iterable, для которых функция predicate(item) возвращает False.

Если в аргументе predicate передать None, все элементы в объекте iterable будут оцениваться как False и будут возвращаться итератором.

imap()

itertools.imap(function, iter1, iter2, ..., iterN)

Создает итератор, который воспроизводит элементы function(i1,i2, … iN), где i1, i2,…, iN – это элементы, полученные из итераторов iter1, iter2, …, iterN соответственно.

Если в аргументе function передать None, функция imap() вернет кортежи вида (i1, i2, …, iN).

Итерации прекращаются, когда один из указанных итераторов прекращает воспроизводить значения.

islice()

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

Создает итератор, воспроизводящий элементы, которые вернула бы операция извлечения среза iterable[start:stop:step].

Первые start элементов пропускаются и итерации прекращаются по достижении позиции, указанной в аргументе stop.

В необязательном аргументе step передается шаг выборки элементов.

В отличие от срезов, в аргументах start, stop и step не допускается использовать отрицательные значения.

Если аргумент start опущен, итерации начинаются с 0.

Если аргумент step опущен, по умолчанию используется шаг 1.

islice('ABCDEFG', 2, 5)
# ['C', 'D', 'E']

islice(range(5), 3, None)
# [3, 4]

islice(range(5), 3)
# [0, 1, 2]

izip()

itertools.izip(iter1, iter2, ... iterN)

Создает итератор, который воспроизводит кортежи (i1, i2, …, iN), где значения i1, i2, …, iN извлекаются из итераторов iter1, iter2, …, iterN соответственно.

Итерации останавливаются, когда какой-либо из исходных итераторов прекращает возвращать значения.

Итератор, возвращаемый этой функцией, воспроизводит те же значения, что и встроенная функция zip().

izip_longest()

itertools.izip_longest(iter1, iter2, ..., iterN[, fillvalue=None])

То же, что и функция izip(), за исключением того, что возвращаемый итератор продолжает итерации, пока не будут исчерпаны все значения, воспроизводимые итераторами iter1, iter2 и так далее. В качестве недостающих значений для итераторов, которые оказались исчерпаны раньше всех, используется None, если не было указано иное значение в именованном аргументе fillvalue.

permutations()

itertools.permutations(iterable, n=None)

На каждой итерации возвращает кортеж, содержащий комбинацию из указанного количества элементов.

Если количество элементов не указано, то использу­ется длина последовательности.

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

product()

itertools.product(*iterable[, repeat=1])

На каждой итерации возвращает кортеж, содержащий комбинацию из эле­ментов одной или нескольких последовательностей

list(product('aбвг', repeat=2))
# [('а', 'а')' ('а'' 'б'), ('а', 'в'), ... ('г', 'г')]

repeat()

itertools.repeat(object[, n])

Создает итератор, который многократно воспроизводит объект object.

В необязательном аргументе n передается количество повторений.

Если аргумент n не задан, количество повторений будет бесконечным.

list(repeat(1, 3))
# [1, 1, 1]

starmap()

itertools.starmap(<Функция>, <Последовательность>)

Передает значение в функцию и возраща­ет результат ее выполнения.

Каждый элемент должен быть последовательностью.

При передаче в функцию производится распаковка последова­тельности.

list(starmap(lambda x, y: x + y, [(1,2), [3,4]]))
# [3, 7]

takewhile()

itertools.takewhile(<Функция>, <Последовательность>)

Возвращает итератор, в каждой итерации возвращает элемент последовательности, пока не встретится элемент, для которой функция, указанная в превом параметре вернет значение False

list(takewhile(lambda x: x > 3, [4, 5, 6, 0, 7, 2, 3]))
# [4, 5, 6]

tee()

itertools.tee(uterable, n=2)

Возвращает кортеж, содержащий не­сколько итераторов для последовательности.

Эта функция может принимать любые итерируемые объекты.

При этом, когда оригинальный итератор клонируется, в кэше сохраняется его копия, которая используется во всех далее создаваемых итераторах.

Не используйте оригинальный итератор iterable после вызова функции tee(). В противном случае механизм кэширования будет работать некорректно.

tee([1, 2, 3])
# (<itertoo1s.tee object at Ox00rDB760>, <itertoo1s.tee object at Ox00rDB73B>)

zip_longest()

itertools.zip_longest(*iterables, fillvalue=None])

На каждой итерации возвращает кортеж, содержащий элементы после­довательностей, которые расположены на одинаковом смещении.

Если последователь­ности имеют разное количество элементов, то вместо отсутствующего элемента вставля­ется объект, указанный в параметре fillvalue.

list(itertools.zip_longest((1, 2, 3), [4]))
# [(1, 4), (2, None), (3, None)]