✧ Перебираем и запоминаем: itertools и functools ✧

🚀 Запускаем

Из четырёх героев нужно собрать пары для испытания. Сколько их и какие? Писать вложенные циклы с проверкой «чтобы не повторялись» долго и легко ошибиться. Запусти:

from itertools import combinations

heroes = ["Эмбер", "Лиза", "Кли", "Барбара"]

for pair in combinations(heroes, 2):
    print(pair)

print(len(list(combinations(heroes, 2))))
('Эмбер', 'Лиза')
('Эмбер', 'Кли')
('Эмбер', 'Барбара')
('Лиза', 'Кли')
('Лиза', 'Барбара')
('Кли', 'Барбара')
6

Шесть пар, и ни одна не повторяется в обратном порядке: пара «Эмбер, Лиза» — то же самое, что «Лиза, Эмбер». Замени 2 на 3 и посмотри, сколько получится команд из трёх героев.

📜 Теория: готовые заготовки стандартной библиотеки

Комбинаторика: product, permutations, combinations

from itertools import product, permutations, combinations
import math

elements = ["Пиро", "Гидро"]
print(list(product(elements, repeat=2)))
# → [('Пиро', 'Пиро'), ('Пиро', 'Гидро'), ('Гидро', 'Пиро'), ('Гидро', 'Гидро')]

print(list(permutations("АБВ", 2)))
# → [('А', 'Б'), ('А', 'В'), ('Б', 'А'), ('Б', 'В'), ('В', 'А'), ('В', 'Б')]

print(len(list(combinations(range(8), 4))), math.comb(8, 4))     # → 70 70
  • product — все пары (тройки…) с повторами и учётом порядка;
  • permutations — порядок важен, повторов нет («кто за кем идёт»);
  • combinations — порядок не важен, повторов нет («кто в команде»).

Количество вариантов растёт быстро: четвёрок из 8 героев 70, а из 50 — уже около 230 тысяч. Если нужно только число, считай формулой: math.comb(n, k) и math.perm(n, k) дают ответ мгновенно, ничего не перебирая.

Склеивать, нарезать, накапливать

from itertools import chain, islice, accumulate, zip_longest

print(list(chain([1, 2], [3], [4, 5])))              # → [1, 2, 3, 4, 5]
print(list(islice(range(100), 3, 8)))                # → [3, 4, 5, 6, 7]
print(list(accumulate([40, 20, 40])))                # → [40, 60, 100]
print(list(zip_longest("АБВ", [1, 2], fillvalue=0))) # → [('А', 1), ('Б', 2), ('В', 0)]

chain склеивает несколько наборов в один без копирования. islice — срез для чего угодно, включая генераторы. accumulate считает накопленные суммы: сколько смолы потрачено после каждого шага. zip_longest работает как zip, но не обрывается на коротком наборе, а добирает значением по умолчанию.

Группировка: groupby и defaultdict

from itertools import groupby
from collections import defaultdict

team = [("Эмбер", "Пиро"), ("Лиза", "Электро"), ("Бэй Доу", "Электро"), ("Кли", "Пиро")]

team.sort(key=lambda hero: hero[1])               # без сортировки groupby ломается
for element, group in groupby(team, key=lambda hero: hero[1]):
    print(element, [name for name, _ in group])

by_element = defaultdict(list)
for name, element in team:
    by_element[element].append(name)
print(dict(by_element))
Пиро ['Эмбер', 'Кли']
Электро ['Лиза', 'Бэй Доу']
{'Пиро': ['Эмбер', 'Кли'], 'Электро': ['Лиза', 'Бэй Доу']}

groupby склеивает соседние элементы с одним ключом, поэтому данные надо предварительно отсортировать по этому же ключу; иначе одна группа распадётся на несколько. Чаще проще defaultdict(list) из collections: он сам создаёт пустой список при первом обращении к новому ключу, и сортировка не нужна.

Запоминать результаты: lru_cache

from functools import lru_cache
import time


@lru_cache(maxsize=None)
def ways(n):
    """Сколькими способами можно набрать n шагов по 1 или по 2."""
    if n <= 1:
        return 1
    return ways(n - 1) + ways(n - 2)


start = time.perf_counter()
print(ways(80))                                     # → 37889062373143906
print(time.perf_counter() - start < 0.1)            # → True
print(ways.cache_info())                            # → CacheInfo(hits=78, misses=81, maxsize=None, currsize=81)

Без кэша такая рекурсия вычисляла бы одни и те же значения миллионы раз и для 80 не закончила бы ни за час. @lru_cache запоминает результат каждого вызова: второй раз с теми же аргументами функция даже не запускается. Условие одно: аргументы должны быть неизменяемыми (числа, строки, кортежи), как ключи словаря, и функция должна всегда давать одинаковый результат на одинаковый вход. В Python 3.9+ есть и короткая запись @cache.

partial: заготовить функцию с частью аргументов

from functools import partial


def damage(attack, multiplier, crit=1.0):
    return int(attack * multiplier * crit)


skill = partial(damage, multiplier=2.5)
print(skill(100))                  # → 250
print(skill(100, crit=1.5))        # → 375

partial создаёт новую функцию с уже подставленными аргументами. Пригождается, когда куда-то надо передать функцию, а аргументов у неё больше, чем ждёт принимающая сторона (map, sorted(key=…)).

🧪 Попробуй сам

★★★

🎯 Задача: Команды без повторов стихий

10 очков

Для испытания нужно собрать команду из k героев так, чтобы стихии у всех были разные. Первая строка ввода — герои через пробел в формате Имя:Стихия, вторая — размер команды k.

Выведи все подходящие команды (имена через запятую и пробел, в том порядке, в каком герои стоят во вводе; сами команды идут в порядке, который выдаёт combinations), по одной на строку, а в конце — Всего: <сколько>.

Пример. Ввод:

Эмбер:Пиро Лиза:Электро Кли:Пиро Барбара:Гидро
2

Вывод:

Эмбер, Лиза
Эмбер, Барбара
Лиза, Кли
Лиза, Барбара
Кли, Барбара
Всего: 5

Заготовка (кнопка у блока отправит её в песочницу):

from itertools import combinations

# 1. Прочитай героев (имя и стихия) и размер команды

# 2. Переберём все команды нужного размера

# 3. Оставь только те, где стихии разные; выведи команды и «Всего: …»
★★★

🎯 Задача: Способы потратить смолу

25 очков

У тебя ровно n единиц смолы. Каждый заход стоит либо 20 (подземелье), либо 40 (босс). Сколькими способами можно потратить ровно n смолы? Порядок заходов важен: «подземелье, потом босс» и «босс, потом подземелье» — разные способы. Потратить 0 смолы можно одним способом (ничего не делать). Если потратить ровно n нельзя, ответ 0.

Введи n (от 0 до 2000), выведи количество способов одним числом. Числа получаются огромными, но Python их не боится.

Пример. Ввод 100, вывод 8. Ввод 40, вывод 2: два подземелья или один босс.

Простая рекурсия на больших n не уложится в время: она раз за разом считает одно и то же.

Заготовка (кнопка у блока отправит её в песочницу):

n = int(input())

# 1. Опиши ответ для n через ответы для меньших n (какой был последний заход?)

# 2. Сделай так, чтобы одно и то же значение не считалось дважды

# 3. Выведи число способов

✅ Что мы узнали

itertools даёт готовые перебиралки: product, permutations, combinations (а число вариантов считает math.comb), chain, islice, accumulate и groupby (только по отсортированным данным; чаще удобнее defaultdict). В functools лежат lru_cache, который запоминает результаты функции, и partial, который фиксирует часть аргументов.

Теперь самое полезное для хранения данных: настоящая база в одном файле.

⟵ Считаем даты и время Складываем данные в базу ⟶