20 Python-идиом для ЕГЭ по информатике — сэкономь время на экзамене

Короткий ответ

На ЕГЭ 2026 у тебя 235 минут на 27 заданий. Экономия 30 секунд на каждом — это лишние 15 минут на проверку. 20 идиом ниже — твой арсенал: каждая сокращает код в 2-3 раза и уменьшает шанс описаться.

Все примеры проверены на реальных задачах КЕГЭ и работают только со стандартной библиотекой Python. Если ты только выбираешь язык, сначала посмотри сравнение Python или C++ для ЕГЭ — там разобрано, почему именно Python.

1. Чтение файла в список целых

Половина задач ЕГЭ начинается с «дан файл с числами». Классический способ — 4 строки. Идиоматический — одна:

nums = [int(x) for x in open('17.txt')]

Работает, когда в файле по одному числу на строке. Для нескольких чисел в строке — аналогично:

nums = [int(x) for line in open('24.txt') for x in line.split()]

Применимо в заданиях 17, 22, 24, 26, 27.

2. sum с генератором и условием

Типовая задача: «сколько чисел делятся на 3». Лобовое решение — цикл с счётчиком. Идиома:

print(sum(1 for n in nums if n % 3 == 0))

Одна строка вместо четырёх. Аналогично считается сумма только «нужных» элементов:

print(sum(n for n in nums if n > 100))

Применимо в заданиях 17, 26 (подсчёт по условию), 22 (подсчёт процессов).

3. max/min с параметром key

Когда нужно найти не самое большое число, а элемент с самым большим полем — используй key:

data = [('Иванов', 67), ('Петров', 85), ('Сидоров', 72)]
best = max(data, key=lambda x: x[1])  # ('Петров', 85)

Для задания 22 (планирование процессов) — найти процесс с самым поздним временем завершения:

latest = max(processes, key=lambda p: p['end'])

Применимо в заданиях 3 (базы данных в виде списка кортежей), 22, 27.

4. sorted с кортежем-ключом

Сортировка по нескольким полям. Правило: первое поле — основное, следующие — тай-брейкеры. Если по убыванию — ставь минус:

students = sorted(data, key=lambda x: (-x[1], x[0]))

Сначала по второму полю убыванию, при равенстве — по первому полю по возрастанию (алфавит). Без minus — возрастание по обоим:

pairs = sorted(pairs, key=lambda p: (p[0], p[1]))

Применимо в заданиях 3, 9, 17.

5. enumerate — индекс и значение сразу

Когда нужна позиция элемента, не пиши for i in range(len(arr)):

for i, v in enumerate(arr):
    if v < 0:
        print(i, v)

С параметром start=1 нумерация идёт с единицы — удобно, если в условии строки нумеруются с 1:

for line_no, line in enumerate(open('27.txt'), start=1):
    ...

Применимо везде, где есть «номер элемента».

6. zip — параллельный обход двух списков

Задача: «даны два списка, найди количество позиций, где элементы совпадают»:

matches = sum(1 for a, b in zip(list1, list2) if a == b)

zip останавливается на более коротком — не нужно проверять длины вручную. Для трёх списков — zip(a, b, c).

Применимо в заданиях 2 (таблицы истинности), 3, 17.

7. List comprehension с условием

Фильтр и трансформация в одной строке. Вместо:

result = []
for x in nums:
    if x > 0:
        result.append(x * x)

Пишем:

result = [x * x for x in nums if x > 0]

Синтаксис «выражение — for — if» читается слева направо как обычное предложение. Применимо во всех файловых задачах.

8. Dict comprehension

Создать словарь по правилу. Часто нужно для задания 25 (факторизация):

freq = {x: nums.count(x) for x in set(nums)}

Или для задания 9 (таблица квадратов):

squares = {n: n*n for n in range(1, 11)}

Обратный словарь (поменять ключи и значения):

inverted = {v: k for k, v in d.items()}

9. set для уникальных

Самое короткое решение для «сколько различных чисел в файле»:

print(len(set(nums)))

Проверка на уникальность слов в строке:

words = line.split()
is_unique = len(set(words)) == len(words)

Пересечение двух множеств (общие элементы):

common = set(a) & set(b)

Применимо в заданиях 2, 9, 17.

10. collections.Counter

Когда нужны частоты и топ-N самых частых — Counter заменяет 10 строк:

from collections import Counter

freq = Counter(nums)
top3 = freq.most_common(3)  # [(val, count), (val, count), (val, count)]

Задача 24: «найти самый частый символ в файле»:

from collections import Counter
s = open('24.txt').read()
ch, cnt = Counter(s).most_common(1)[0]

Применимо в заданиях 24, 26, 27.

11. f-строки для форматирования

Забудь про % и .format(). f-строки — это и форматирование, и подстановка переменных в одной конструкции:

x = 3.14159
print(f"{x:.2f}")  # 3.14
print(f"{x:.4f}")  # 3.1416

Целые с заполнением нулями:

print(f"{5:03d}")  # 005

В двоичной системе с шириной 8:

print(f"{n:08b}")  # 00001010

Применимо в заданиях 5, 14 (системы счисления), 6.

12. Распаковка звёздочкой

«Первый элемент и всё остальное» — без срезов:

first, *rest = lst
*init, last = lst
a, b, *middle, c = lst

Полезно, когда файл устроен как «первая строка — заголовок, дальше данные»:

header, *rows = open('27.txt').read().splitlines()

13. itertools.combinations и permutations

Перебор сочетаний и перестановок без ручного написания рекурсии:

from itertools import combinations, permutations

# все пары из списка
for a, b in combinations(nums, 2):
    ...

# все перестановки букв слова
for p in permutations('АБВГ'):
    print(''.join(p))

Задача 9 (задачи на перебор) — 6 букв, сколько слов по условию:

from itertools import permutations
cnt = sum(1 for p in permutations('АЕИОУК') if p[0] != 'А')

Применимо в заданиях 9, 11, 20.

14. all и any

Проверка условия на всех элементах (all) или хотя бы на одном (any):

if all(x > 0 for x in nums):
    print("все положительные")

if any(x == target for x in nums):
    print("цель найдена")

Задача 2 (таблица истинности): «формула истинна во всех строках, где x1 = 1»:

ok = all(f(x) for x in table if x[0] == 1)

Применимо в заданиях 2, 8, 17.

15. Срезы [::-1], [1::2], [:-3]

Срезы — одна из самых мощных идиом Python. Три шаблона, которые закрывают 90% задач:

s[::-1]     # строка или список в обратном порядке
s[1::2]     # каждый второй, начиная с индекса 1
s[:-3]      # всё, кроме последних трёх
s[::2]      # каждый второй с начала

Задание 5 (проверка палиндрома):

is_palindrome = s == s[::-1]

Задание 12 (обработка строк с шагом):

after = s.replace("AB", "")[::-1]

16. math.isqrt и целочисленное деление

Для больших чисел никогда не пиши int(n**0.5) — будет ошибка округления:

from math import isqrt

n = 10**18 + 1
root = isqrt(n)   # точное целое

Целочисленное деление и остаток:

q, r = divmod(a, b)  # q = a // b, r = a % b

Задание 25 (поиск делителей):

from math import isqrt
divs = [i for i in range(1, isqrt(n) + 1) if n % i == 0]

17. Булевы как числа

В Python True == 1, False == 0, и это экономит строки:

positive = sum(n > 0 for n in arr)     # сколько положительных
evens = sum(n % 2 == 0 for n in arr)   # сколько чётных

Заменяет конструкцию:

cnt = 0
for n in arr:
    if n > 0:
        cnt += 1

Применимо в заданиях 17, 22, 26.

18. sys.setrecursionlimit и ускорение ввода

Глубокая рекурсия (задания 16, 22, 25) падает на стандартном лимите 1000:

import sys
sys.setrecursionlimit(10_000_000)

Медленный input на большом файле ускоряется через sys.stdin:

import sys
input = sys.stdin.readline

Или сразу всё разом:

import sys
data = sys.stdin.read().split()

Применимо в заданиях 16, 22, 24, 25.

19. Dict.get для подсчёта

Подсчёт без KeyError и без проверки if k in d:

d = {}
for k in keys:
    d[k] = d.get(k, 0) + 1

Альтернатива — defaultdict:

from collections import defaultdict
d = defaultdict(int)
for k in keys:
    d[k] += 1

Либо Counter, если нужны только частоты. Выбирай то, что помнишь под стрессом.

20. Мемоизация через functools.lru_cache

Ускорение рекурсии в десятки раз — одной строкой:

from functools import lru_cache

@lru_cache(maxsize=None)
def f(n):
    if n <= 1:
        return 1
    return f(n - 1) + f(n - 2)

Задание 16 (рекурсивные функции) без lru_cache падает по времени при n > 30. С lru_cache работает для n = 1000 за доли секунды. Главное — аргументы функции должны быть хешируемыми (числа, строки, кортежи — да; списки — нет).

Шпаргалка одной страницей

Идиома	Короткий синтаксис	Где применима
Чтение файла в список	[int(x) for x in open('f')]	17, 22, 24, 26, 27
Подсчёт по условию	sum(1 for x in a if cond)	17, 22, 26
Максимум по полю	max(a, key=lambda x: x[1])	3, 22, 27
Сортировка по полям	sorted(a, key=lambda x: (-x[1], x[0]))	3, 9, 17
Индекс и значение	for i, v in enumerate(a)	везде
Параллельный обход	for a, b in zip(x, y)	2, 3, 17
Фильтр и трансформация	[f(x) for x in a if cond]	везде
Словарь по правилу	{k: f(k) for k in keys}	9, 25
Уникальные	len(set(a))	2, 9, 17
Топ-N по частоте	Counter(a).most_common(N)	24, 26, 27
Форматирование	f"{x:.2f}", f"{n:08b}"	5, 6, 14
Распаковка	a, *rest = lst	27
Перестановки	itertools.permutations(a)	9, 11, 20
Все/хотя бы один	all(...), any(...)	2, 8, 17
Срезы	s[::-1], s[1::2], s[:-3]	5, 12
Целый корень	math.isqrt(n)	25
Булевы как счёт	sum(x > 0 for x in a)	17, 22, 26
Глубокая рекурсия	sys.setrecursionlimit(10**7)	16, 22, 25
Подсчёт в словаре	d[k] = d.get(k, 0) + 1	24, 26
Мемоизация	@lru_cache(maxsize=None)	16

Распечатай таблицу и держи под рукой первые две недели тренировок. Через месяц большая часть идиом уйдёт в моторную память — и ты перестанешь думать о синтаксисе, сосредоточишься на логике задачи.

Как тренироваться

1. Выбери одну идиому из списка.
2. Найди задачу, где она нужна (ссылки на разборы ниже).
3. Реши задачу «в лоб», а потом перепиши с идиомой.
4. Замерь разницу в количестве строк и времени решения.

За 20 дней так пройдёшь весь список и автоматизируешь приёмы. Это сэкономит на реальном ЕГЭ 15-20 минут — а на самом деле больше, потому что меньше кода — меньше багов, меньше перепроверок.

Если ты ещё только осваиваешь Python с нуля, сначала пройди пошаговый план подготовки — там есть минимальный набор синтаксиса на первые 2 недели. После него возвращайся к этой шпаргалке.

Типовые ошибки с идиомами

Идиомы экономят время, но создают новые способы ошибиться. Три самые частые:

1. Забыл about .read() против итерации по файлу. open('f') даёт итератор по строкам (с \n на конце), а open('f').read() — одну большую строку. Если путаешь — получаешь либо лишний \n, либо попытку итерироваться по символам.

2. lru_cache на функции со списком в аргументе. Падает с TypeError: unhashable type. Конвертируй список в кортеж перед вызовом.

3. max без key на смешанных типах. max([1, 'a']) в Python 3 падает. Явно указывай key или приводи к одному типу.

Подробнее — в статье про типичные ошибки на ЕГЭ по информатике.

Где применять на реальных заданиях

• Задание 1 (теория графов) — в расчётах таблица помогает, см. разбор задания 1.
• Задание 12 (обработка строк) — срезы и замены, см. разбор задания 12.
• Задание 27 (программирование) — почти все идиомы сразу, см. разбор задания 27.

Что дальше

1. Выучи идиомы 1-10 за первую неделю (они закрывают 70% задач).
2. Идиомы 11-20 — за вторую неделю, параллельно с тренировкой сложных задач.
3. Перед пробником распечатай шпаргалку и подержи на столе — с третьего пробника она перестанет быть нужна.
4. На самом ЕГЭ шпаргалка запрещена, но к тому моменту она тебе и не понадобится.

На экзамене сэкономленные 30 секунд на задачу превратятся в 15 запасных минут — а это ещё одно сложное задание, которое ты успеешь проверить. Работай на идиомы заранее, а не в ночь перед экзаменом.