itertools — Функции, создающие итераторы для эффективного цикла


Данный модуль реализует ряд стандартных блоков итераторов, вдохновленных конструкциями из APL, Haskell и SML. Каждый из них был переработан в форму, подходящую для Python.

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

Например, SML предоставляет инструмент табуляции: tabulate(f), создающий последовательность f(0), f(1), .... Того же эффекта можно достичь в Python объединив map() и count() в map(f, count()).

Данные инструменты и их встроенные аналоги также хорошо работают с высокоскоростными функциями модуля operator. Например, оператор умножения может быть отображен на два вектора, чтобы сформировать эффективное скалярное произведение: sum(map(operator.mul, vector1, vector2)).

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

Итератор Аргументы Результаты Пример
count() start, [step] start, start+step, start+2*step, … count(10) --> 10 11 12 13 14 ...
cycle() p p0, p1, … plast, p0, p1, … cycle('ABCD') --> A B C D A B C D ...
repeat() elem [,n] elem, elem, elem, … бесконечно или до n раз repeat(10, 3) --> 10 10 10

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

Итератор Аргументы Результаты Пример
accumulate() p [,func] p0, p0+p1, p0+p1+p2, … accumulate([1,2,3,4,5]) --> 1 3 6 10 15
chain() p, q, … p0, p1, … plast, q0, q1, … chain('ABC', 'DEF') --> A B C D E F
chain.from_iterable() iterable p0, p1, … plast, q0, q1, … chain.from_iterable(['ABC', 'DEF']) --> A B C D E F
compress() data, selectors (d[0] if s[0]), (d[1] if s[1]), … compress('ABCDEF', [1,0,1,0,1,1]) --> A C E F
dropwhile() pred, seq seq[n], seq[n+1], начинается, когда pred провалился dropwhile(lambda x: x<5, [1,4,6,4,1]) --> 6 4 1
filterfalse() pred, seq элементы seq, где pred(elem) равно false filterfalse(lambda x: x%2, range(10)) --> 0 2 4 6 8
groupby() iterable[, key] субтераторы, сгруппированные по значению key(v)  
islice() seq, [start,] stop [, step] элементы из seq[start:stop:step] islice('ABCDEFG', 2, None) --> C D E F G
starmap() func, seq func(*seq[0]), func(*seq[1]), … starmap(pow, [(2,5), (3,2), (10,3)]) --> 32 9 1000
takewhile() pred, seq seq[0], seq[1], пока pred не провалится takewhile(lambda x: x<5, [1,4,6,4,1]) --> 1 4
tee() it, n it1, it2, … itn разбивает один итератор на n  
zip_longest() p, q, … (p[0], q[0]), (p[1], q[1]), … zip_longest('ABCD', 'xy', fillvalue='-') --> Ax By C- D-

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

Итератор Аргументы Результаты
product() p, q, … [repeat=1] декартово произведение, эквивалентное вложенному циклу for
permutations() p[, r] кортежи r-длины, все возможные упорядочения, без повторяющихся элементов
combinations() p, r кортежи r-длины, в отсортированном порядке, без повторяющихся элементов
combinations_with_replacement() p, r кортежи r-длины, в отсортированном порядке, с повторяющимися элементами
Примеры Результаты
product('ABCD', repeat=2) AA AB AC AD BA BB BC BD CA CB CC CD DA DB DC DD
permutations('ABCD', 2) AB AC AD BA BC BD CA CB CD DA DB DC
combinations('ABCD', 2) AB AC AD BC BD CD
combinations_with_replacement('ABCD', 2) AA AB AC AD BB BC BD CC CD DD

Функции Itertool

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

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

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

Если указан func, он должен быть функцией двух аргументов. Входные элементы iterable могут быть любого типа, которые могут быть приняты в качестве аргументов для func. (Например, при операции добавления по умолчанию элементы могут быть любого добавляемого типа, включая Decimal или Fraction.)

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

Примерно эквивалентно

def accumulate(iterable, func=operator.add, *, initial=None):
    'Возвращает текущие итоги'
    # accumulate([1,2,3,4,5]) --> 1 3 6 10 15
    # accumulate([1,2,3,4,5], initial=100) --> 100 101 103 106 110 115
    # accumulate([1,2,3,4,5], operator.mul) --> 1 2 6 24 120
    it = iter(iterable)
    total = initial
    if initial is None:
        try:
            total = next(it)
        except StopIteration:
            return
    yield total
    for element in it:
        total = func(total, element)
        yield total

Аргумент func можно использовать по-разному. Он может быть установлен на min() для текущего минимума, max() для текущего максимума или operator.mul() для текущего умножения. Таблицы амортизации можно построить путём накопления процентов и применения платежей. Рекуррентные отношения первого порядка можно смоделировать, указав начальное значение в итерации и используя только накопленную сумму в аргументе func:

>>> data = [3, 4, 6, 2, 1, 9, 0, 7, 5, 8]
>>> list(accumulate(data, operator.mul))     # выполнение произведения
[3, 12, 72, 144, 144, 1296, 0, 0, 0, 0]
>>> list(accumulate(data, max))              # выполнение максимума
[3, 4, 6, 6, 6, 9, 9, 9, 9, 9]

# Амортизизация кредита под 5% в размере 1000 с 4 ежегодными платежами по 90
>>> cashflows = [1000, -90, -90, -90, -90]
>>> list(accumulate(cashflows, lambda bal, pmt: bal*1.05 + pmt))
[1000, 960.0, 918.0, 873.9000000000001, 827.5950000000001]

# Хаотическое рекуррентное соотношение https://en.wikipedia.org/wiki/Logistic_map
>>> logistic_map = lambda x, _:  r * x * (1 - x)
>>> r = 3.8
>>> x0 = 0.4
>>> inputs = repeat(x0, 36)     # используется только начальное значение
>>> [format(x, '.2f') for x in accumulate(inputs, logistic_map)]
['0.40', '0.91', '0.30', '0.81', '0.60', '0.92', '0.29', '0.79', '0.63',
 '0.88', '0.39', '0.90', '0.33', '0.84', '0.52', '0.95', '0.18', '0.57',
 '0.93', '0.25', '0.71', '0.79', '0.63', '0.88', '0.39', '0.91', '0.32',
 '0.83', '0.54', '0.95', '0.20', '0.60', '0.91', '0.30', '0.80', '0.60']

См. functools.reduce() для аналогичной функции, которая возвращает только окончательное накопленное значение.

Добавлено в версии 3.2.

Изменено в версии 3.3: Добавлен необязательный параметр func.

Изменено в версии 3.8: Добавлен необязательный параметр initial.

itertools.chain(*iterables)

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

def chain(*iterables):
    # chain('ABC', 'DEF') --> A B C D E F
    for it in iterables:
        for element in it:
            yield element
classmethod chain.from_iterable(iterable)

Альтернативный конструктор для chain(). Получает связанные входные данные из одного итерируемого аргумента, который вычисляется лениво. Примерно эквивалентно

def from_iterable(iterables):
    # chain.from_iterable(['ABC', 'DEF']) --> A B C D E F
    for it in iterables:
        for element in it:
            yield element
itertools.combinations(iterable, r)

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

Кортежи комбинаций выдаются в лексикографическом порядке в соответствии с порядком ввода iterable. Таким образом, если ввод iterable отсортирован, кортежи комбинаций будут создаваться в отсортированном порядке.

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

Примерно эквивалентно

def combinations(iterable, r):
    # combinations('ABCD', 2) --> AB AC AD BC BD CD
    # combinations(range(4), 3) --> 012 013 023 123
    pool = tuple(iterable)
    n = len(pool)
    if r > n:
        return
    indices = list(range(r))
    yield tuple(pool[i] for i in indices)
    while True:
        for i in reversed(range(r)):
            if indices[i] != i + n - r:
                break
        else:
            return
        indices[i] += 1
        for j in range(i+1, r):
            indices[j] = indices[j-1] + 1
        yield tuple(pool[i] for i in indices)

Код для combinations() также может быть выражен как подпоследовательность permutations() после фильтрации записей, в которых элементы не отсортированы (в соответствии с их положением во входном пуле):

def combinations(iterable, r):
    pool = tuple(iterable)
    n = len(pool)
    for indices in permutations(range(n), r):
        if sorted(indices) == list(indices):
            yield tuple(pool[i] for i in indices)

Количество возвращенных элементов равно n! / r! / (n-r)!, если 0 <= r <= n, или ноль, если r > n.

itertools.combinations_with_replacement(iterable, r)

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

Кортежи комбинаций выдаются в лексикографическом порядке в соответствии с порядком iterable. Таким образом, если ввод iterable отсортирован, кортежи комбинаций будут создаваться в отсортированном порядке.

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

Примерно эквивалентно

def combinations_with_replacement(iterable, r):
    # combinations_with_replacement('ABC', 2) --> AA AB AC BB BC CC
    pool = tuple(iterable)
    n = len(pool)
    if not n and r:
        return
    indices = [0] * r
    yield tuple(pool[i] for i in indices)
    while True:
        for i in reversed(range(r)):
            if indices[i] != n - 1:
                break
        else:
            return
        indices[i:] = [indices[i] + 1] * (r - i)
        yield tuple(pool[i] for i in indices)

Код для combinations_with_replacement() также может быть выражен как подпоследовательность product() после фильтрации записей, в которых элементы не отсортированы (в соответствии с их положением во входном пуле):

def combinations_with_replacement(iterable, r):
    pool = tuple(iterable)
    n = len(pool)
    for indices in product(range(n), repeat=r):
        if sorted(indices) == list(indices):
            yield tuple(pool[i] for i in indices)

Количество возвращаемых элементов равно (n+r-1)! / r! / (n-1)!, когда n > 0.

Добавлено в версии 3.1.

itertools.compress(data, selectors)

Создаёт итератор, фильтрующий элементы из data, возвращая только те, у которых есть соответствующий элемент в selectors, который вычисляется как True. Останавливается, когда итерации data или selectors исчерпаны. Примерно эквивалентно

def compress(data, selectors):
    # compress('ABCDEF', [1,0,1,0,1,1]) --> A C E F
    return (d for d, s in zip(data, selectors) if s)

Добавлено в версии 3.1.

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

Создаёт итератор, возвращающий равномерно распределенные значения, начиная с номера start. Часто используется в качестве аргумента для map() для создания последовательных точек данных. Также используется с zip() для добавления порядковых номеров. Примерно эквивалентно

def count(start=0, step=1):
    # count(10) --> 10 11 12 13 14 ...
    # count(2.5, 0.5) -> 2.5 3.0 3.5 ...
    n = start
    while True:
        yield n
        n += step

При подсчете чисел с плавающей запятой иногда можно добиться большей точности, заменив мультипликативный код, например: (start + step * i for i in count()).

Изменено в версии 3.1: Добавлен аргумент step и разрешены нецелочисленные аргументы.

itertools.cycle(iterable)

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

def cycle(iterable):
    # cycle('ABCD') --> A B C D A B C D A B C D ...
    saved = []
    for element in iterable:
        yield element
        saved.append(element)
    while saved:
        for element in saved:
              yield element

Обратите внимание, что для этого члена набора инструментов может потребоваться значительная вспомогательная память (в зависимости от длины итерируемого объекта).

itertools.dropwhile(predicate, iterable)

Создаёт итератор, удаляющий элементы из итерируемого, пока предикат истинен; впоследствии возвращает каждый элемент. Обратите внимание, что итератор не вызывает любые до тех пор, пока предикат не станет ложным, поэтому его запуск может занять длительное время. Примерно эквивалентно

def dropwhile(predicate, iterable):
    # dropwhile(lambda x: x<5, [1,4,6,4,1]) --> 6 4 1
    iterable = iter(iterable)
    for x in iterable:
        if not predicate(x):
            yield x
            break
    for x in iterable:
        yield x
itertools.filterfalse(predicate, iterable)

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

def filterfalse(predicate, iterable):
    # filterfalse(lambda x: x%2, range(10)) --> 0 2 4 6 8
    if predicate is None:
        predicate = bool
    for x in iterable:
        if not predicate(x):
            yield x
itertools.groupby(iterable, key=None)

Создаёт итератор, возвращающий последовательные ключи и группы из iterable. key — это функция, вычисляющая значение ключа для каждого элемента. Если не указано или равно None, key по умолчанию использует функцию идентификации и возвращает элемент без изменений. Как правило, итерируемый объект уже должен быть отсортирован по одной и той же ключевой функции.

Работа groupby() аналогична фильтру uniq в Unix. Он создаёт разрыв или новую группу каждый раз, когда значение ключевой функции изменяется (именно поэтому обычно необходимо отсортировать данные, используя одну и ту же ключевую функцию). Это поведение отличается от SQL GROUP BY, который объединяет общие элементы независимо от порядка их ввода.

Возвращаемая группа сама по себе является итератором, который разделяет базовый итерируемый объект с groupby(). Поскольку источник является общим, при расширении объекта groupby() предыдущая группа больше не отображается. Поэтому, если данные данные понадобятся позже, их следует сохранить в виде списка:

groups = []
uniquekeys = []
data = sorted(data, key=keyfunc)
for k, g in groupby(data, keyfunc):
    groups.append(list(g))      # Сохранить итератор группы в виде списка
    uniquekeys.append(k)

groupby() примерно эквивалентен:

class groupby:
    # [k for k, g in groupby('AAAABBBCCDAABBB')] --> A B C D A B
    # [list(g) for k, g in groupby('AAAABBBCCD')] --> AAAA BBB CC D
    def __init__(self, iterable, key=None):
        if key is None:
            key = lambda x: x
        self.keyfunc = key
        self.it = iter(iterable)
        self.tgtkey = self.currkey = self.currvalue = object()
    def __iter__(self):
        return self
    def __next__(self):
        self.id = object()
        while self.currkey == self.tgtkey:
            self.currvalue = next(self.it)    # Выход StopIteration
            self.currkey = self.keyfunc(self.currvalue)
        self.tgtkey = self.currkey
        return (self.currkey, self._grouper(self.tgtkey, self.id))
    def _grouper(self, tgtkey, id):
        while self.id is id and self.currkey == tgtkey:
            yield self.currvalue
            try:
                self.currvalue = next(self.it)
            except StopIteration:
                return
            self.currkey = self.keyfunc(self.currvalue)
itertools.islice(iterable, stop)
itertools.islice(iterable, start, stop[, step])

Создаёт итератор, возвращающий выбранные элементы из итерируемого объекта. Если start не равен нулю, то элементы из итерации пропускаются до тех пор, пока не будет достигнуто начало. После этого элементы возвращаются последовательно, если только step не установлен выше единицы, что приводит к пропуску элементов. Если stop равен None, то итерация продолжается до тех пор, пока итератор не будет исчерпан, если вообще будет исчерпан; в противном случае он останавливается в указанной позиции. В отличие от обычного разделения, islice() не поддерживает отрицательные значения для start, stop или step. Может использоваться для извлечения связанных полей из данных, внутренняя структура которых была сглажена (например, в многострочном отчете поле имени может отображаться в каждой третьей строке). Примерно эквивалентно

def islice(iterable, *args):
    # islice('ABCDEFG', 2) --> A B
    # islice('ABCDEFG', 2, 4) --> C D
    # islice('ABCDEFG', 2, None) --> C D E F G
    # islice('ABCDEFG', 0, None, 2) --> A C E G
    s = slice(*args)
    start, stop, step = s.start or 0, s.stop or sys.maxsize, s.step or 1
    it = iter(range(start, stop, step))
    try:
        nexti = next(it)
    except StopIteration:
        # Использовать *iterable* до позиции *start*.
        for i, element in zip(range(start), iterable):
            pass
        return
    try:
        for i, element in enumerate(iterable):
            if i == nexti:
                yield element
                nexti = next(it)
    except StopIteration:
        # Использовать до *stop*.
        for i, element in zip(range(i + 1, stop), iterable):
            pass

Если start равен None, то итерация начинается с нуля. Если step равен None, то шаг по умолчанию равен единице.

itertools.permutations(iterable, r=None)

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

Если r не указан или равен None, то r по умолчанию соответствует длине iterable, и генерируются все возможные полноразмерные перестановки.

Кортежи перестановок выдаются в лексикографическом порядке в соответствии с порядком ввода iterable. Таким образом, если ввод iterable отсортирован, кортежи комбинаций будут создаваться в отсортированном порядке.

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

Примерно эквивалентно

def permutations(iterable, r=None):
    # permutations('ABCD', 2) --> AB AC AD BA BC BD CA CB CD DA DB DC
    # permutations(range(3)) --> 012 021 102 120 201 210
    pool = tuple(iterable)
    n = len(pool)
    r = n if r is None else r
    if r > n:
        return
    indices = list(range(n))
    cycles = list(range(n, n-r, -1))
    yield tuple(pool[i] for i in indices[:r])
    while n:
        for i in reversed(range(r)):
            cycles[i] -= 1
            if cycles[i] == 0:
                indices[i:] = indices[i+1:] + indices[i:i+1]
                cycles[i] = n - i
            else:
                j = cycles[i]
                indices[i], indices[-j] = indices[-j], indices[i]
                yield tuple(pool[i] for i in indices[:r])
                break
        else:
            return

Код для permutations() также может быть выражен как подпоследовательность product(), отфильтрованная для исключения записей с повторяющимися элементами (находящимися в одном и том же месте во входном пуле):

def permutations(iterable, r=None):
    pool = tuple(iterable)
    n = len(pool)
    r = n if r is None else r
    for indices in product(range(n), repeat=r):
        if len(set(indices)) == r:
            yield tuple(pool[i] for i in indices)

Количество возвращенных элементов равно n! / (n-r)!, если 0 <= r <= n, или ноль, если r > n.

itertools.product(*iterables, repeat=1)

Декартово произведение входных итераций.

Примерно эквивалентно вложенным циклам for в выражении генератора. Например, product(A, B) возвращает то же самое, что и ((x,y) for x in A for y in B).

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

Чтобы вычислить произведение итерируемого объекта на самого себя, указать количество повторений с необязательным ключевым аргументом repeat. Например, product(A, repeat=4) означает то же, что и product(A, A, A, A).

Данная функция примерно эквивалентна следующему коду, за исключением того, что фактическая реализация не создаёт в памяти промежуточные результаты:

def product(*args, repeat=1):
    # product('ABCD', 'xy') --> Ax Ay Bx By Cx Cy Dx Dy
    # product(range(2), repeat=3) --> 000 001 010 011 100 101 110 111
    pools = [tuple(pool) for pool in args] * repeat
    result = [[]]
    for pool in pools:
        result = [x+[y] for x in result for y in pool]
    for prod in result:
        yield tuple(prod)
itertools.repeat(object[, times])

Создаёт итератор, снова и снова возвращающий object. Работает бесконечно, если не указан аргумент times. Используется в качестве аргумента map() для инвариантных параметров вызываемой функции. Также используется с zip() для создания неизменной части записи кортежа.

Примерно эквивалентно

def repeat(object, times=None):
    # repeat(10, 3) --> 10 10 10
    if times is None:
        while True:
            yield object
    else:
        for i in range(times):
            yield object

Обычно repeat используется для передачи потока постоянных значений в map или zip:

>>> list(map(pow, range(10), repeat(2)))
[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
itertools.starmap(function, iterable)

Создаёт итератор, вычисляющий функцию, используя полученные аргументы из итерируемого объекта. Используется вместо map(), когда параметры аргументов уже сгруппированы в кортежи из одного итерируемого объекта (данные предварительно заархивированы). Разница между map() и starmap() аналогична различию между function(a,b) и function(*c). Примерно эквивалентно

def starmap(function, iterable):
    # starmap(pow, [(2,5), (3,2), (10,3)]) --> 32 9 1000
    for args in iterable:
        yield function(*args)
itertools.takewhile(predicate, iterable)

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

def takewhile(predicate, iterable):
    # takewhile(lambda x: x<5, [1,4,6,4,1]) --> 1 4
    for x in iterable:
        if predicate(x):
            yield x
        else:
            break
itertools.tee(iterable, n=2)

Возвращает n независимых итераторов из одного итерируемого объекта.

Следующий код Python помогает объяснить, что делает tee (хотя фактическая реализация более сложна и использует только одну базовую очередь FIFO).

Примерно эквивалентно

def tee(iterable, n=2):
    it = iter(iterable)
    deques = [collections.deque() for i in range(n)]
    def gen(mydeque):
        while True:
            if not mydeque:             # когда локальная очередь пуста
                try:
                    newval = next(it)   # получить новое значение и
                except StopIteration:
                    return
                for d in deques:        # загружает его во все очереди
                    d.append(newval)
            yield mydeque.popleft()
    return tuple(gen(d) for d in deques)

После разделения tee() исходный iterable больше нигде не должен использоваться; в противном случае iterable может быть продвинут без уведомления объектов-троек.

Итераторы tee не являются потокобезопасными. RuntimeError может возникнуть при одновременном использовании итераторов, возвращаемых одним и тем же вызовом tee(), даже если исходный iterable является потокобезопасным.

Этому itertool может потребоваться значительное вспомогательное хранилище (в зависимости от того, сколько временных данных необходимо хранить). В общем, если один итератор использует большую часть или все данные до запуска другого итератора, быстрее использовать list() вместо tee().

itertools.zip_longest(*iterables, fillvalue=None)

Создаёт итератор, который агрегирует элементы из каждого итерируемого объекта. Если итерации разной длины, отсутствующие значения заполняются fillvalue. Итерация продолжается до тех пор, пока самая длинная итерация не будет исчерпана. Примерно эквивалентно

def zip_longest(*args, fillvalue=None):
    # zip_longest('ABCD', 'xy', fillvalue='-') --> Ax By C- D-
    iterators = [iter(it) for it in args]
    num_active = len(iterators)
    if not num_active:
        return
    while True:
        values = []
        for i, it in enumerate(iterators):
            try:
                value = next(it)
            except StopIteration:
                num_active -= 1
                if not num_active:
                    return
                iterators[i] = repeat(fillvalue)
                value = fillvalue
            values.append(value)
        yield tuple(values)

Если одна из итераций потенциально бесконечна, то функция zip_longest() должна быть обернута чем-то, что ограничивает количество вызовов (например, islice() или takewhile()). Если не указано, fillvalue по умолчанию имеет значение None.

Рецепты Itertools

В этом разделе показаны рецепты создания расширенного набора инструментов с использованием существующих инструментов itertools в качестве строительных блоков.

Практически все данные и многие другие рецепты можно установить из проекта more-itertools, найденного в пакетном индексе Python:

pip install more-itertools

Расширенные инструменты обеспечивают такую же высокую производительность, как и базовый множество инструментов. Превосходная производительность памяти поддерживается за счет обработки элементов по одному, а не одновременного помещения всей итерации в память. Объём кода остаётся небольшим благодаря объединению инструментов в функциональном стиле, что помогает исключить временные переменные. Высокая скорость сохраняется за счет предпочтения «векторизованных» строительных блоков, а не использования циклов for и генераторов, вызывающие накладные расходы интерпретатора.

def take(n, iterable):
    "Возвращает первые n элементов итерируемого в виде списка"
    return list(islice(iterable, n))

def prepend(value, iterator):
    "Добавляет одно значение перед итератором"
    # prepend(1, [2, 3, 4]) -> 1 2 3 4
    return chain([value], iterator)

def tabulate(function, start=0):
    "Возвращает function(0), function(1), ..."
    return map(function, count(start))

def tail(n, iterable):
    "Возвращает итератор для последних n элементов"
    # tail(3, 'ABCDEFG') --> E F G
    return iter(collections.deque(iterable, maxlen=n))

def consume(iterator, n=None):
    "Продвигает итератор на n шагов вперед. Если n - None, потреблять полностью."
    # Использовать функции, которые используют итераторы на скорости C.
    if n is None:
        # передать весь итератор в deque нулевой длины
        collections.deque(iterator, maxlen=0)
    else:
        # перейти к пустому срезу, начиная с позиции n
        next(islice(iterator, n, n), None)

def nth(iterable, n, default=None):
    "Возвращает n-й элемент или значение по умолчанию"
    return next(islice(iterable, n, None), default)

def all_equal(iterable):
    "Возвращает True, если все элементы равны друг другу"
    g = groupby(iterable)
    return next(g, True) and not next(g, False)

def quantify(iterable, pred=bool):
    "Посчитать, сколько раз предикат истенен"
    return sum(map(pred, iterable))

def padnone(iterable):
    """Возвращает элементы последовательности, а затем возвращает None бесконечно.

    Полезно для эмуляции поведения встроенной функции map().
    """
    return chain(iterable, repeat(None))

def ncycles(iterable, n):
    "Возвращает элементы последовательности n раз"
    return chain.from_iterable(repeat(tuple(iterable), n))

def dotproduct(vec1, vec2):
    return sum(map(operator.mul, vec1, vec2))

def flatten(list_of_lists):
    "Сгладить один уровень вложенности"
    return chain.from_iterable(list_of_lists)

def repeatfunc(func, times=None, *args):
    """Повторяет вызовы func с указанными аргументами.

    Пример:  repeatfunc(random.random)
    """
    if times is None:
        return starmap(func, repeat(args))
    return starmap(func, repeat(args, times))

def pairwise(iterable):
    "s -> (s0,s1), (s1,s2), (s2, s3), ..."
    a, b = tee(iterable)
    next(b, None)
    return zip(a, b)

def grouper(iterable, n, fillvalue=None):
    "Собирает данные в блоки или блоки фиксированной длины"
    # grouper('ABCDEFG', 3, 'x') --> ABC DEF Gxx"
    args = [iter(iterable)] * n
    return zip_longest(*args, fillvalue=fillvalue)

def roundrobin(*iterables):
    "roundrobin('ABC', 'D', 'EF') --> A D E B F C"
    # Рецепт создан George Sakkis
    num_active = len(iterables)
    nexts = cycle(iter(it).__next__ for it in iterables)
    while num_active:
        try:
            for next in nexts:
                yield next()
        except StopIteration:
            # Удаляет итератор, который мы только что исчерпали из цикла.
            num_active -= 1
            nexts = cycle(islice(nexts, num_active))

def partition(pred, iterable):
    'Использование предиката для разделения записей на ложные и истинные записи'
    # partition(is_odd, range(10)) --> 0 2 4 6 8   and  1 3 5 7 9
    t1, t2 = tee(iterable)
    return filterfalse(pred, t1), filter(pred, t2)

def powerset(iterable):
    "powerset([1,2,3]) --> () (1,) (2,) (3,) (1,2) (1,3) (2,3) (1,2,3)"
    s = list(iterable)
    return chain.from_iterable(combinations(s, r) for r in range(len(s)+1))

def unique_everseen(iterable, key=None):
    "Список уникальных элементов, сохраняющих порядок. Запоминает все элементы, которые когда-либо видел."
    # unique_everseen('AAAABBBCCDAABBB') --> A B C D
    # unique_everseen('ABBCcAD', str.lower) --> A B C D
    seen = set()
    seen_add = seen.add
    if key is None:
        for element in filterfalse(seen.__contains__, iterable):
            seen_add(element)
            yield element
    else:
        for element in iterable:
            k = key(element)
            if k not in seen:
                seen_add(k)
                yield element

def unique_justseen(iterable, key=None):
    "Список уникальных элементов, сохраняющих порядок. Запоминает только тот элемент, который только что видел."
    # unique_justseen('AAAABBBCCDAABBB') --> A B C D A B
    # unique_justseen('ABBCcAD', str.lower) --> A B C A D
    return map(next, map(operator.itemgetter(1), groupby(iterable, key)))

def iter_except(func, exception, first=None):
    """Повторно вызывает функцию, пока не возникнет исключение.

    Преобразует интерфейс вызова до исключения в интерфейсе итератора. Как
    builtins.iter(func, sentinel), но использует исключение вместо часового для
    завершения цикла.

    Примеры:
        iter_except(functools.partial(heappop, h), IndexError)   # итератор очереди приоритетов
        iter_except(d.popitem, KeyError)                         # неблокирующий итератор dict
        iter_except(d.popleft, IndexError)                       # неблокирующий итератор deque
        iter_except(q.get_nowait, Queue.Empty)                   # зациклить на производителе Queue
        iter_except(s.pop, KeyError)                             # неблокирующий итератор множества

    """
    try:
        if first is not None:
            yield first()            # Для API баз данных, нуждающихся в начальном приведении к db.first()
        while True:
            yield func()
    except exception:
        pass

def first_true(iterable, default=False, pred=None):
    """Возвращает первое истинное значение в iterable.

    Если истинное значение не найдено, возвращает *default*

    Если *pred* не является None, возвращает первый элемент, для которого
    значение pred(item) истинно.

    """
    # first_true([a,b,c], x) --> a or b or c or x
    # first_true([a,b], x, f) --> a if f(a) else b if f(b) else x
    return next(filter(pred, iterable), default)

def random_product(*args, repeat=1):
    "Случайный выбор из itertools.product(*args, **kwds)"
    pools = [tuple(pool) for pool in args] * repeat
    return tuple(random.choice(pool) for pool in pools)

def random_permutation(iterable, r=None):
    "Случайный выбор из itertools.permutations(iterable, r)"
    pool = tuple(iterable)
    r = len(pool) if r is None else r
    return tuple(random.sample(pool, r))

def random_combination(iterable, r):
    "Случайный выбор из itertools.combinations(iterable, r)"
    pool = tuple(iterable)
    n = len(pool)
    indices = sorted(random.sample(range(n), r))
    return tuple(pool[i] for i in indices)

def random_combination_with_replacement(iterable, r):
    "Случайный выбор из itertools.combinations_with_replacement(iterable, r)"
    pool = tuple(iterable)
    n = len(pool)
    indices = sorted(random.randrange(n) for i in range(r))
    return tuple(pool[i] for i in indices)

def nth_combination(iterable, r, index):
    'Эквивалентно list(combinations(iterable, r))[index]'
    pool = tuple(iterable)
    n = len(pool)
    if r < 0 or r > n:
        raise ValueError
    c = 1
    k = min(r, n-r)
    for i in range(1, k+1):
        c = c * (n - k + i) // i
    if index < 0:
        index += c
    if index < 0 or index >= c:
        raise IndexError
    result = []
    while r:
        c, n, r = c*r//n, n-1, r-1
        while index >= c:
            index -= c
            c, n = c*(n-r)//n, n-1
        result.append(pool[-1-n])
    return tuple(result)