Functools, Itertools, Collections и с чем это всё едят

Небольшое вступление

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

Хочу сказать, во-первых, это моя вторая статья на данной площадке, я ещё только начинаю писать и, так скажем, это всё пока что ещё проба пера. Во-вторых, я приветствую любое мнение окружающих, но ещё лучше, если это будет конструктивная критика по делу, а не просто так, и да, примеры мои сугубо учебные, придуманные на ровном месте, не обязательно из каких-то реальных проектов и задач, поэтому не стоит придерживаться к ним в комментариях. А теперь к сути дела.

Itertools – полезным итераторам нет конца

Как можно догадаться из названия, itertools – это кладезь полезных итераторов, которым можно найти огромное количество разных вариантов применений. Пройдёмся по всему порядку:

• itertools.count(start, step) — бесконечная арифметическая прогрессия На вход принимаем до двух аргументов: start и step. Start – начало прогрессии, step – шаг, с которым будет двигаться прогрессия. Вот пример с обращением к подобному итератора, простой и наглядный:

arithmetic_progression = count(2, 5) print(next(arithmetic_progression), end=" ") print(next(arithmetic_progression), end=" ") print(next(arithmetic_progression), end=" ")  # Вывод: 2 7 12 

• itertools.cycle(iterable) — возвращает по одному значению из последовательности, повторенной бесконечное количество раз, то есть зацикленной. На вход данная функция принимает любое итерируемое значение.

list_of_books_names = ["Война и мир", 'Отцы и дети', 'На дне'] infinity_iteration = cycle(list_of_books_names)  print(next(infinity_iteration)) print(next(infinity_iteration)) print(next(infinity_iteration)) print(next(infinity_iteration)) 

• itertools.repeat(element, n) — создает итератор, который многократно возвращает один и тот же объект. На вход принимает два значения: какой-нибудь элемент, а также сколько раз его надо повторить. По умолчанию значение n равно бесконечности.

result = list(repeat('Привет', 4))  print(result)  # Вывод: ['Привет', 'Привет', 'Привет', 'Привет'] 

• itertools.accumulate(iterable) — аккумулирует суммы, но если объяснять проще, то он берёт все итерируемые числа по порядку и складывает их с предыдущим числом, но уже из нового списка. Проще показать на примере:

original_list = [4, 1, 7, 3, 10] new_list = list(accumulate([4, 1, 7, 3, 10]))  print(new_list)  # Вывод: [4, 5, 12, 15, 25] 

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

• itertools.chain(iterable) — принимает на вход некоторое количество итерируемых объектов, последовательно берёт из каждого элемента по одному с самого начала и формирует новый итерируемый объект.

bin_number = list(chain([1, 0, 0, 1], [0, 1, 1, 1], [0, 1, 1, 0]))  print(bin_number)  # Вывод: [1, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0] 

• itertools.combinations(iterable, r) — возвращает все возможные комбинации нужной длины без повторяющихся элементов. На вход принимает итерируемый объект и длину комбинации.

list_of_combinations = list(combinations("ABCD", 2))  print(list_of_combinations)  # Вывод: [('A', 'B'), ('A', 'C'), ('A', 'D'), ('B', 'C'), ('B', 'D'), ('C', 'D')] 

• itertools.combinations_with_replacement(iterable, r) — возвращает все возможные комбинации нужной длины только уже с повторяющимися элементами.

list_of_combinations = list(combinations_with_replacement("ABCD", 2))  print(list_of_combinations)  # Вывод: [('A', 'A'), ('A', 'B'), ('A', 'C'), ('B', 'B'), ('B', 'C'), ('C', 'C')] 

• itertools.compress(iterable, mask) — этот метод позволяет фильтровать итерируемый объект по заданной маске. На вход принимаем сначала итерируемый объект, а потом маску состоящую из 0/1 или из логических значений (True/False).

a = compress("BBABCCA", [1,0,0,1,1,1,0]) print(list(a))   # Вывод: ['B', 'B', 'C', 'C'] 

• itertools.filterfalse(func, iterable) — возвращает итератор из значений, которые при постановке в функцию вернули значение False.

def is_perfect_power(n): """ Проверяет, является ли число степенью """     if n == 1: return True     if n <= 0: return False     max_exponent = math.floor(math.log2(n)) + 1     for m in range(2, max_exponent + 1):         k = round(n ** (1 / m))         if k ** m == n: return True     return False  no_power_of_nums = filterfalse(is_perfect_power, [1, 4, 9, 81, 16, 99, 100, 110, 101, 43, 25, 15])  # Вывод: [99, 110, 101, 43, 15] 

• itertools.dropwhile(func, iterable) — работает почти также, как и itertools.filterfalse, но с небольшим отличием. Оно заключается в том, что dropwhile вернёт ту часть итерируемого объекта, которая идёт после элемента, который выдал значения False при использовании в func. Возьму тот же пример:

def is_perfect_power(n): """ Проверяет, является ли число степенью """     if n == 1: return True     if n <= 0: return False     max_exponent = math.floor(math.log2(n)) + 1     for m in range(2, max_exponent + 1):         k = round(n ** (1 / m))         if k ** m == n: return True     return False  no_power_of_nums = dropwhile(is_perfect_power, [1, 4, 9, 81, 16, 99, 100, 110, 15])  # Вывод: [99, 100, 110, 15] 

• itertools.groupby(iterable, key=None) — эта функция создает итератор, который возвращает последовательность ключей и групп из итерируемой последовательности iterable. Под ключом(key) здесь подразумевается функция. Например:

# Создаём повторяющийся список x = list('AaBbCc' * 3)  # Промежуточный вывод: ['A', 'a', 'B', 'b', 'C', 'c', 'A', 'a', 'B', 'b', 'C', 'c', 'A', 'a', 'B', 'b', 'C', 'c']  x.sort() for key, elements in groupby(x):     print(key, list(elements))  # Итоговый вывод:  A ['A', 'A', 'A'] B ['B', 'B', 'B'] C ['C', 'C', 'C'] a ['a', 'a', 'a'] b ['b', 'b', 'b'] c ['c', 'c', 'c'] 

• itertools.islice(iterable, start, stop, step=1) — это итератор, состоящий из среза другого итерируемого объекта.

a = islice("Hello, world!", 7, 13) print(list(a))  # Вывод: ['w', 'o', 'r', 'l', 'd', '!'] 

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

a = islice("Hello, world!", 7) print(list(a))  # Вывод: ['H', 'e', 'l', 'l', 'o', ',', ' '] 

• itertools.permutations(iterable, R=None) — возвращает итератор, состоящий из перестановок размером с параметр R. Пример 1:

a = permutations("ABC") print(list(a))  # Вывод: [('A', 'B', 'C'), ('A', 'C', 'B'), ('B', 'A', 'C'), ('B', 'C', 'A'), ('C', 'A', 'B'), ('C', 'B', 'A')] 

Пример 2:

a = permutations("ABC", 2) print(list(a))  # Вывод: [('A', 'B'), ('A', 'C'), ('B', 'A'), ('B', 'C'), ('C', 'A'), ('C', 'B')] 

• itertools.product(*iterables, repeat=1) — возвращает итератор, состоящий из перестановок с длиной repeat, но в отличии от permutations здесь итерируемые объекты повторяются. Можно указать несколько итерируемый объектов. Пример 1:

a = product("AC", repeat=3) print(list(a))  # Вывод: [('A', 'A', 'A'), ('A', 'A', 'C'), ('A', 'C', 'A'), ('A', 'C', 'C'), ('C', 'A', 'A'), ('C', 'A', 'C'), ('C', 'C', 'A'), ('C', 'C', 'C')] 

Пример 2:

a = product("AB", "12", repeat=2) print(list(a))  # Вывод: [('A', '1', 'A', '1'), ('A', '1', 'A', '2'), ('A', '1', 'B', '1'), ('A', '1', 'B', '2'), ('A', '2', 'A', '1'), ('A', '2', 'A', '2'), ('A', '2', 'B', '1'), ('A', '2', 'B', '2'), ('B', '1', 'A', '1'), ('B', '1', 'A', '2'), ('B', '1', 'B', '1'), ('B', '1', 'B', '2'), ('B', '2', 'A', '1'), ('B', '2', 'A', '2'), ('B', '2', 'B', '1'), ('B', '2', 'B', '2')] 

• itertools.starmap(func, iterable) — применяет функцию к каждому элементу итерируемого объекта

data = [(2, 5), (3, 2), (10, 3)]  result = starmap(pow, data)  print(list(result))  # Вывод: [32, 9, 1000] 

• itertools.takewhile(func, iterable) — тоже самое, что и dropwhile, только наоборот. Возвращает итератор из бывшего итерируемого объекта, пока элементы возвращают True из функции. Пример всё тот же:

def is_perfect_power(n): """ Проверяет, является ли число степенью """     if n == 1: return True     if n <= 0: return False     max_exponent = math.floor(math.log2(n)) + 1     for m in range(2, max_exponent + 1):         k = round(n ** (1 / m))         if k ** m == n: return True     return False  power_of_nums = takewhile(is_perfect_power, [1, 4, 9, 81, 16, 99, 100, 110, 101, 43, 25, 15])  # Вывод: [1, 4, 9, 81, 16] 

• itertools.tee(iterable, n=2) — возвращает кортеж из n итераторов.

a = tee("AB", 3) print([list(x) for x in a])  # Вывод: [['A', 'B'], ['A', 'B'], ['A', 'B']] 

• itertools.zip_longest(*iterables, fillvalue=None) — работает примерно как встроенная функция zip, но берёт самый длинный итератор, объединяет с самым коротким попарно, а оставшиеся элементы без пары дополняет символом указанном в параметре fillvalue.

a = zip_longest('ABCDE', '01', fillvalue='*') print(list(a))  # Вывод: [('A', '0'), ('B', '1'), ('C', '*'), ('D', '*'), ('E', '*')] 

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

Collections — предоставляет новые типы данных на основе уже имеющихся

• collections.Counter — особый вид словаря, который может посчитать количество элементов в итерируемом объекте.

data = ["Aabb", "AAbb", "AaBB", "Aabb", "Aabb", "AAbb", "AaBb"]  result = Counter(data)  # Вывод: Counter({'Aabb': 3, 'AAbb': 2, 'AaBB': 1, 'AaBb': 1}) 

У Counter есть парочку своих особых методов:
1. elements() — возвращает все элементы в алфавитном порядке.
2. most_common(n) — возвращает n самых часто встречающихся элементов в словаре Counter, выводит всё в порядке убывания. Если n не указать, то вернёт все элементы.
3. subtract(iterable or mapping) — позволяет вычитать из Counter либо же словари такого же типа Counter, либо обычные словари.
Также словари типа Counter поддерживают обычное сложение, вычитание, объединение(&) и пересечение(|).

• collections.deque(iterable, maxlen) — создаёт очередь из итерируемого объекта, где максимальная длина задаётся переменной maxlen. Очереди похожи на списки, но элементы добавляются справкой стороны очереди, либо с левой, то же самое и с удалением элементов.
  Очереди поддерживают большинство методов списков, такие как: append, clear, count, pop, extend, remove, reverse. Также к обычным методам добавляются всё те же, только, которые производят действия с левой стороны очереди: appendleft, extendleft, popleft. Помимо этого есть ещё один новый метод – rotate(n). Данный метод переносит n элементов из начала очереди в конец. Если указать n отрицательным, то переносит наоборот из конца в начало.

• collections.defaultdict(type) — тип данных, почти ничем не отличающийся от обычного словаря (dict), за исключением того, что он не выдаёт ошибку типа KeyError, так как при попытке обратиться

defdict = defaultdict(list)  defdict[1].append("Ivan")  print(defdict)  # Вывод:  

• collections.OrderedDict — ещё одна разновидность словарь, которая в первую очередь отличается тем, что запоминает порядок ключей, записанных в этот словарь. Конечно, классический dict это тоже делает, но только начиная с версии Python 3.7, до этого вывод был не упорядоченным. Методы:

1. popitem(last=True) — Удаляет последний элемент словаря, но если указать аргумент last = False, то наоборот удалит первый элемент словаря

2. move_to_end(key, last=True) — перемещает существующий ключ в конец словаря, но если указать аргумент last = False, то в начало словаря.

• collections.namedtuple() — это своего рода класс, состоящий только из полей данных, без методов, и который ведёт себя как кортеж, то есть не изменяется.

Man = namedtuple('Ivan', ["Grade", "Surname"])  man1 = Man(5, "Pupkin") print(man1) print(man1.Grade)  # Вывод: Ivan(Grade=5, Surname='Pupkin') 5 

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

Начнём с моего любимого:

• @lru_cache(maxsize=128, typed=False) — это декоратор, который кэширует данные функции. Такое может пригодиться, чтобы сэкономить время при очень дорогих вычислениях, если вы вызываете функцию с одними и теми же аргументами. Параметр maxsize отвечает за максимальный размер кэша, если установить значение None, то кэш будет возрастать бесконечно. Параметр typed отвечает за кэширование аргументов функции в том случаи, если у них отличаются типы. Например, если у вас функция запускается с аргументом 3(int) и 3.0(float), то при значении аргумента typed=True, эти случаи будут кэшироваться отдельно, так как у них разные типы данных.

@lru_cache(maxsize=None) def fib(n):      if n < 2: return n      return fib(n-1) + fib(n-2)  print([fib(n) for n in range(10)]) 

Самый наглядный и распространённый пример это числа Фибоначчи. Если хотите убедиться, то попробуйте запустить этот же алгоритм, но без декоратора и с большими числами (100, 500, 1000…), увидите, что это будет слишком длительные вычисления.
Для этого декоратора также существуют две дополнительные функции:
1. cache_info() — возвращающая namedtuple, отображающий: попадания в кэш, промахи, максимальный размер и текущий размер кэша.
2. cache_clear() — очищает данные кэша.

• functools.cmp_to_key(func) — Используется с пользовательскими инструментами, которые в качестве ключа сортировки принимают подобные функции: sorted(), max, min, itertools.groupby(о которой как раз-таки говорили ранее), heapq.nlargest, heapq.nsmallest . Эта функция в основном используется в качестве инструмента перехода для программ, конвертируемых из Python 2. Сейчас местами это конечно не очень актуально, но как по мне знать такое полезно. Пояснение: В версии Python 2.4 или более ранних версиях, как таковой функции sorted() не было, а обычный list.sort() не принимал аргументов с ключевыми словами для сортировки. Вместо этого, все версии Pyton 2.X поддерживали параметр cmp для обработки пользовательских функций сравнения.

В Pyton 3.0 параметр cmp был удален для устранения конфликта между «богатыми сравнениями» и «магическим» методом __cmp__().

В Python 2 можно было писать:

numbers = [5, 2, 8, 1, 3] sorted_numbers = sorted(numbers, cmp=lambda a, b: b - a)  # Вывод: [8, 5, 3, 2, 1] 

В Python 3 подобное реализовывалось бы так:

def compare(a, b):     if a < b:         return 1     elif a == b:         return 0     else:         return -1  numbers = [5, 2, 8, 1, 3] sorted_numbers = sorted(numbers, key=cmp_to_key(compare))  # Вывод: [8, 5, 3, 2, 1] 

В целом данная функция нужна для сортировок со сложными условиями, например, если нужно сравнивать объекты по нескольким полям с разной логикой, а также данная функция необходима при портировании кода с Python 2 на Python 3.

• @functools.total_ordering — это декоратор, который помогает создавать объекты с «богатым сравнениям», то есть, если вы хотите создать класс, который можно будет сравнивать обычными знаками сравнения (<, >, =, <=, >=, !=), то вам пришлось бы вручную определить все шесть соответствующих «магических» методов: __lt__, __le__, __gt__, __ge__, __eq__, __ne__. Но этот декоратор делает это за вас. Основное правило для использования @total_ordering простое:

1. Примените декоратор @total_ordering к вашему классу.

2. Обязательно определите в классе метод __eq__(self, other) для проверки на равенство.

3. Определите хотя бы один из следующих методов:

   • __lt__(self, other) для операции «меньше» (<)

   • __le__(self, other) для операции «меньше или равно» (<=)

   • __gt__(self, other) для операции «больше» (>)

   • __ge__(self, other) для операции «больше или равно» (>=) Этого достаточно. Декоратор проанализирует существующие методы и доопределит все остальные, используя логические связи между ними. Например, если вы определили __eq__ и __lt__, то декоратор создаст __gt__, __le__ и __ge__ на их основе .

• functools.partial(func, *args, **kwargs) — это функция, которая позволяет создавать новые функции путем «замораживания» или фиксации некоторых аргументов существующей функции . Этот механизм называется частичным применением (partial application). Проще говоря, partial берет функцию и часть ее аргументов, а на выходе дает новую, более простую функцию, которая при вызове уже будет знать об этих «замороженных» аргументах. Например:

base_two = partial(int, base=2) # Функция конвертирует строку с записью двоичного кода в десятичное число типа int  print(basetwo('11001011'))  # Вывод: 203 

• functools.reduce(function, iterable) — эта функция которая работает по принципу сворачивания всего итерируемого объекта в одно значения. То есть, оно берёт первые два значения итерируемого объекта, применяет к ним функцию и получает новое одно значения, далее берёт третье значение из итерируемого объекта и к нему и ранее полученному значения применяет функцию и так далее, пока не получит одно единственное значение.

result = reduce(lambda a, b: a**2+b**2, [1,6, 8, 0, 2])  print(result)  # Вывод: 4216817073125 

• functools.update_wrapper(wrapper, wrapped, assigned=WRAPPER_ASSIGNMENTS, updated=WRAPPER_UPDATES) — используется для корректного копирования метаданных (например, имени, документации, аннотаций) из оригинальной функции в её обёртку (декоратор или другую функцию-заменитель). Когда вы создаёте декоратор или любую обёртку вокруг функции, Python по умолчанию теряет метаданные оригинальной функции (например, __name__, __doc__, __module__, __annotations__).

Функция обновляет у обёртки (wrapper) следующие атрибуты из исходной функции:

1. __module__

2. __name__

3. __qualname__ (в Python 3.3+)

4. __doc__

5. __annotations__ (в Python 3+)

6. __dict__ (дополнительные атрибуты)

Например:

def my_decorator(func):     def wrapper(*args, **kwargs):         result = func(*args, **kwargs)         return result     update_wrapper(wrapper, func)  # Копируем метаданные из func в wrapper     return wrapper  @my_decorator def greet(name):     print(f"Привет, {name}!")  print(greet.__name__)  # 'greet' (корректно!) print(greet.__doc__)   # 'Приветствует пользователя.' (корректно!) 

• @wraps(wrapped, assigned=WRAPPER_ASSIGNMENTS, updated=WRAPPER_UPDATES) — тоже самое, что и функция functools.update_wrapper, описанная выше. Это своего рода «синтаксически сахар» для упрощения жизни.

def my_decorator(func):     @wraps(func)  # Автоматически вызывает update_wrapper     def wrapper(*args, **kwargs):         result = func(*args, **kwargs)         return result     return wrapper 

На этом всё. Я постарался максимально подробно объяснить всё своими словами, используя документации этих библиотек. Хочется верить, что кому-то это было полезно, конечно же данная статья в первую очередь ориентирована больше на начинающих ребят-питонистов, ну, как минимум мне так кажется 🙂

Благодарю за прочтение!