Основы Python для ЕГЭ по информатике

Ключевые тезисы

• Основные типы данных: числа (int, float), строки (str), списки (list), кортежи (tuple), множества (set), словари (dict).
• Ввод/вывод данных через input() и print().
• Работа с переменными и арифметические операции.
• Использование библиотек: math для математических функций, itertools для комбинаторики, functools для ускорения рекурсии.
• Условные операторы и циклы.
• Функции, лямбда-функции и рекурсия.
• Работа с файлами.
• Генераторы списков и словарей.
• Обработка исключений с помощью try-except.

Типы данных

Python имеет различные типы данных:

• Числовые: int (целые), float (вещественные).
• Строки (str) — последовательности символов.
• Списки (list) — упорядоченные изменяемые коллекции.
• Кортежи (tuple) — упорядоченные неизменяемые коллекции.
• Множества (set) — неупорядоченные коллекции уникальных элементов.
• Словари (dict) — коллекции пар "ключ-значение".

Ввод и вывод данных

Функция print()

Выводит данные в консоль:

print(120)  # Число
print("99 баллов")  # Строка
print([1, 2, 3])  # Список

Параметр sep — разделитель между выводимыми значениями:

print(x, y, z)  # По умолчанию: пробел
print(x, y, z, sep='')  # Без разделителя
print(x, y, z, sep='\n')  # Каждое значение с новой строки

Функция input()

Считывает данные с клавиатуры. Всегда возвращает строку:

value = input()  # Всегда str
number = int(input())  # Преобразование в число

Переменные и операции

Создание и изменение переменных

x = 10  # Создание переменной
x = 20  # Переопределение значения

Обмен значений без временной переменной:

x, y = y, x

Изменение типа данных

x = "99"
x = int(x)  # str → int (99)
x = float(x)  # int → float (99.0)
x = str(x)  # float → str ("99.0")

Арифметические операции

7 + 2  # Сложение (9)
7 - 2  # Вычитание (5)
7 * 2  # Умножение (14)
7 / 2  # Деление (3.5) - всегда float
7 // 2  # Целочисленное деление (3)
7 % 2  # Остаток от деления (1)
7 ** 2  # Возведение в степень (49)

Важно: операция возведения в степень выполняется справа налево:

2 ** 2 ** 3  # = 2 ** (2 ** 3) = 256, а не (2 ** 2) ** 3 = 64

Часто используемые функции и библиотеки

Встроенные функции

max(10, 20, 30)  # 30
min(10, 20, 30)  # 10
len([1, 2, 3, 4])  # 4 (количество элементов)
len("99 баллов")  # 9 (количество символов)
sum([1, 2, 3, 4, 5])  # 15

Функция map()

Применяет функцию ко всем элементам последовательности:

list(map(int, "123"))  # [1, 2, 3]
sum(map(int, "123"))  # 6 (сумма цифр строки)

Библиотека math

Содержит математические функции и константы:

import math
math.sqrt(4)  # Квадратный корень (2.0)
math.factorial(4)  # Факториал (24)
# Также: math.pi, math.e, логарифмы, тригонометрия и др.

Операции сравнения и логические операции

Сравнение

3 > 2  # True
1 == 2  # False
1 != 2  # True

Результат сравнения — булево значение (True/False).

Логические операции

not True  # False (инверсия)
True and False  # False (конъюнкция)
True or False  # True (дизъюнкция)

Для задач алгебры логики:

• Импликация: (x <= y) или (not x or y)
• Тождество: (x == y)
• Исключающее ИЛИ: (x != y)

Условные операторы

Базовый if-else

x = 10
if x > 0:
    print("Положительное")
else:
    print("Отрицательное")

Множественные условия (elif)

if x > 0:
    print("Положительное")
elif x == 0:
    print("Равно нулю")
else:
    print("Отрицательное")

Строки

Основные операции

s = "123"
s2 = "456"
s + s2  # Конкатенация: "123456"
s * 3  # Повторение: "123123123"

Сравнение строк

Сравниваются посимвольно согласно таблице ASCII:

1. Цифры (0-9)
2. Заглавные буквы (A-Z)
3. Строчные буквы (a-z)

"1" < "A"  # True (цифры раньше букв)
"A" < "a"  # True (заглавные раньше строчных)
"abc" < "abd"  # True (по алфавиту)

Методы строк

s = "1233434"
s.replace("3", "9")  # Замена всех "3" на "9": "1299494"
s.replace("34", "9", 1)  # Замена только первого вхождения

"a,b,c,d".split(",")  # Разделение по разделителю: ['a', 'b', 'c', 'd']
" ".join(["a", "b", "c"])  # Склеивание: "a b c"

s.strip()  # Удаление пробелов с обеих сторон
s.lower()  # Приведение к нижнему регистру
s.upper()  # Приведение к верхнему регистру

Срезы строк

s = "123456789"
s[1:5]  # С 1 по 5 индекс не включительно: "2345"
s[1:5:2]  # С шагом 2: "24"
s[5:1:-1]  # В обратном порядке: "6543"
s[:5]  # С начала до 5 индекса: "12345"
s[1:]  # С 1 индекса до конца: "23456789"
s[::-1]  # Реверс строки: "987654321"

Списки

Создание и основные операции

arr = [1, 2, 3]  # Создание
arr.append(4)  # Добавление в конец: [1, 2, 3, 4]
arr.insert(1, 1.5)  # Вставка на позицию 1: [1, 1.5, 2, 3, 4]
arr.pop(3)  # Удаление по индексу (возвращает удаленный элемент)
arr.remove(2)  # Удаление по значению (первое вхождение)

arr1 = [1, 2, 3]
arr2 = [4, 5, 6]
arr1 + arr2  # Конкатенация: [1, 2, 3, 4, 5, 6]

5 in arr  # Проверка наличия: True

Копирование списков

arr = [1, 2, 3]
arr_copy = arr  #  Не копия! Обе переменные ссылаются на один список
arr_true_copy = arr.copy()  #  Создается настоящая копия

Сортировка

arr = [3, 1, 4, 2, 5]
arr.sort()  # Изменяет исходный список: [1, 2, 3, 4, 5]
arr.sort(reverse=True)  # [5, 4, 3, 2, 1]
sorted_arr = sorted(arr)  # Возвращает новый список

Циклы

Цикл for

# По диапазону
for i in range(5):  # 0, 1, 2, 3, 4
    print(i)
# По элементам списка
for item in [1, 2, 3]:
    print(item)
# По символам строки
for char in "abc":
    print(char)

Функция range():

range(5)  # 0, 1, 2, 3, 4
range(2, 5)  # 2, 3, 4
range(1, 10, 2)  # 1, 3, 5, 7, 9 (с шагом 2)

Цикл while

x = 1
while x < 10:
    print(x)
    x += 1  # x = x + 1

Функции

Создание функций

def square(x):
    return x ** 2

def max_of_two(x, y):
    if x > y:
        return x
    else:
        return y

def factorial(n):
    result = 1
    for i in range(1, n + 1):
        result *= i
    return result

Область видимости переменных

x = 10  # Глобальная переменная
def func():
    global x  # Разрешение изменения глобальной переменной
    x = 20
    y = 30  # Локальная переменная (не видна вне функции)

Лямбда-функции

Короткие анонимные функции:

square = lambda x: x ** 2
add = lambda x, y: x + y
# Использование в сортировке
sorted(arr, key=lambda x: x[1])  # Сортировка по второму элементу

Рекурсия и её оптимизация

Рекурсивные функции могут работать медленно из-за повторных вычислений.

• Декоратор @lru_cache (из модуля functools) даёт рекурсии "память": функция запоминает результаты предыдущих вызовов.

  from functools import lru_cache
  @lru_cache(None)
  def fib(n):
      if n < 2: return n
      return fib(n-1) + fib(n-2)
  

• Увеличение глубины рекурсии:

  import sys
  sys.setrecursionlimit(5000)  # Устанавливает новый лимит
  

  Используйте, только если уверены, что рекурсия не уходит в бесконечность.

Обработка исключений: try-except

Конструкция позволяет обрабатывать ошибки, не прерывая выполнение программы.

• try: — блок с кодом, который может вызвать ошибку.
• except: — блок, который выполнится, если в try возникла ошибка.
• Применение в ЕГЭ (задача 16): В рекурсивных функциях try-except позволяет пропускать значения, которые уводят рекурсию в бесконечность или вызывают ошибки, и продолжать поиск.

Работа с файлами

Считывание из файла

# Открытие файла (по умолчанию режим чтения 'r')
with open('test.txt') as f:
    content = f.read()  # Чтение всего файла

# Построчное считывание
with open('test.txt') as f:
    for line in f:
        print(int(line.strip()))

# Чтение определенного количества строк
with open('test.txt') as f:
    line1 = f.readline()  # Первая строка
    line2 = f.readline()  # Вторая строка

# Считывание всех строк в список
with open('test.txt') as f:
    lines = f.readlines()  # Список строк (с символами \n)

Генераторы списков

Компактный способ создания списков:

# Обычный способ
squares = []
for i in range(10):
    squares.append(i ** 2)
# Через генератор
squares = [i ** 2 for i in range(10)]
# С условием
even_squares = [i ** 2 for i in range(10) if i % 2 == 0]
# По двум спискам
combined = [x + y for x in [1, 2, 3] for y in ['a', 'b', 'c']]
# Для считывания из файла
numbers = [int(line.strip()) for line in open('test.txt')]

Множества

Коллекции уникальных неупорядоченных элементов:

s = {1, 2, 3, 3, 4, 5}  # {1, 2, 3, 4, 5} (дубли удаляются)
s = set([1, 2, 3, 3, 4])  # Альтернативный способ создания
s.add(6)  # Добавление элемента
5 in s  # Проверка наличия
len(s)  # Количество элементов

Пустое множество создается только через set():

empty_set = set()  #  Пустое множество
empty_dict = {}  #  Пустой словарь, а не множество!

Словари

Коллекции пар "ключ-значение":

# Создание
d = {1: 'a', 2: 'b', 3: 'c'}
d = dict([(1, 'a'), (2, 'b'), (3, 'c')])

# Генератор словаря
squares = {x: x ** 2 for x in range(6)}  # {0:0, 1:1, 2:4, 3:9, 4:16, 5:25}

# Доступ и изменение
d[3]  # Получение значения по ключу: 'c'
d[3] = 'z'  # Изменение значения

# Полезные методы
d.keys()  # Все ключи (удобно для преобразования в список)
d.values()  # Все значения (удобно для операций: sum(d.values()))
d.items()  # Все пары ключ-значение

Практическое применение словарей

Словари идеально подходят для задач подсчёта частоты элементов (например, букв в строке):

1. Создать словарь, где ключи — элементы, а значения — счётчики.
2. Пройтись по данным и увеличивать соответствующий счётчик: dict[letter] += 1.
3. Для поиска элемента с максимальной частотой можно использовать max(dict.values()).

Библиотека itertools для комбинаторики

Основной инструмент для задач на перебор (например, задача №8). Импортируются: from itertools import ...

combinations(iterable, r)

Генерирует сочетания длины r. Порядок элементов в паре не важен (пары AB и BA считаются одинаковыми).

• combinations_with_replacement — позволяет использовать один элемент несколько раз в одной комбинации.

permutations(iterable, r)

Генерирует перестановки (размещения) длины r. Порядок элементов важен (AB и BA — разные комбинации).
Если в исходной строке есть повторяющиеся буквы, permutations будет создавать дубликаты слов. Чтобы получить только уникальные варианты, добавляйте результаты во множество (set).

product(iterable, repeat=n)

Генерирует декартово произведение, то есть все возможные комбинации длины n, где каждый элемент может повторяться неограниченное количество раз. Порядок важен. Используется, когда по условию задачи "каждую букву можно использовать любое количество раз".

Выводы

• Python предоставляет богатый набор типов данных и операций для решения задач ЕГЭ.
• Понимание основ синтаксиса, различий между изменяемыми и неизменяемыми типами, а также областей видимости необходимо для написания эффективного кода.
• Словари — мощный инструмент для задач на подсчёт и сопоставление.
• try-except, @lru_cache и управление глубиной рекурсии — ключевые приёмы для решения сложных рекурсивных задач (№16).
• Библиотека itertools предоставляет готовые и эффективные функции для решения практически любой комбинаторной задачи в ЕГЭ.