🐍 Python для ЕГЭ

print("Hello, world!")       # Вывод текста
print(10)                    # Вывод числа
print(x, y, z)               # Вывод нескольких значений через пробел

print("a", "b", "c", sep="-")   # Разделитель: a-b-c
print("Привет", end=" ")        # Не переносить строку, а поставить пробел
print("Мир")                    # Продолжится на той же строке: Привет Мир
print()                         # Пустая строка

name = input()                  # Ввод строки
age = int(input())              # Ввод целого числа
x = float(input())              # Ввод дробного числа
name = input("Введите имя: ")   # Ввод с подсказкой

# Ввод: 3 7
a, b = map(int, input().split())    # a=3, b=7

# Ввод: 1 2 3 4 5
nums = list(map(int, input().split()))  # [1, 2, 3, 4, 5]

# Выравнивание в f-строках:
for i in [1, 10, 100]:
    print(f"{i:>6}")       # выровнять вправо, ширина 6

# Нули в начале:
print(f"{7:03d}")          # 007

# Вывод в одну строку через цикл:
for i in range(1, 6):
    print(i, end=" ")      # 1 2 3 4 5

# Вывод элементов списка через запятую:
lst = [10, 20, 30]
print(*lst, sep=", ")      # 10, 20, 30

# Ввод N строк в список:
n = int(input())
lines = [input() for _ in range(n)]

# Ввод матрицы N×M:
n, m = map(int, input().split())
matrix = [list(map(int, input().split())) for _ in range(n)]

# Ввод до конца файла (в задачах с файлами):
import sys
data = sys.stdin.read().split()
numbers = list(map(int, data))

x = 10          # int   — целое число
y = 3.14        # float — дробное число
name = "Иван"   # str   — строка
flag = True     # bool  — логический тип (True / False)
nothing = None  # NoneType — отсутствие значения

int("123")       # Строку → целое число: 123
int(3.99)        # Дробное → целое (обрезает): 3
str(456)         # Число → строку: "456"
float("3.14")    # Строку → дробное: 3.14
float(5)         # Целое → дробное: 5.0
bool(0)          # 0 → False
bool(1)          # Любое ненулевое → True
list("abc")      # Строку → список: ['a', 'b', 'c']

x = 42
print(type(x))          # <class 'int'>
print(type(3.14))       # <class 'float'>
print(type("hello"))    # <class 'str'>
print(type(True))       # <class 'bool'>

a = b = c = 0          # все три переменные равны 0
x, y = 10, 20          # x=10, y=20
x, y = y, x            # обмен значений: x=20, y=10

# Большие числа: Python поддерживает целые числа любого размера
factorial_20 = 1
for i in range(1, 21):
    factorial_20 *= i
print(factorial_20)   # 2432902008176640000

# Проверка типа перед преобразованием:
s = "42"
if s.isdigit():
    n = int(s)

# Деление всегда возвращает float:
print(type(10 / 2))   # <class 'float'> — не int!
print(type(10 // 2))  # <class 'int'>

x = 42
isinstance(x, int)          # True — x является int?
isinstance(x, (int, float)) # True — x является int или float?

# Частый паттерн на ЕГЭ — проверить, число ли строка:
s = "123"
if s.isdigit():
    n = int(s)
    print("Число:", n)

# Python поддерживает числа любой длины:
big = 2 ** 1000       # Работает! Очень большое число
print(len(str(big)))  # 302 цифры

# Особенности float (важно знать для ЕГЭ!):
0.1 + 0.2             # 0.30000000000000004 (не 0.3!)
round(0.1 + 0.2, 1)   # 0.3 — правильное округление

# Целочисленное деление всегда int:
print(type(7 // 2))   # <class 'int'>
print(type(7 / 2))    # <class 'float'>

a + b      # Сложение:               5 + 3 = 8
a - b      # Вычитание:              5 - 3 = 2
a * b      # Умножение:              5 * 3 = 15
a / b      # Деление (float):        7 / 2 = 3.5
a // b     # Целочисленное деление:  7 // 2 = 3
a % b      # Остаток от деления:     7 % 2 = 1
a ** b     # Возведение в степень:   2 ** 10 = 1024

x += 5    # x = x + 5
x -= 3    # x = x - 3
x *= 2    # x = x * 2
x /= 4    # x = x / 4
x //= 3   # x = x // 3
x %= 7    # x = x % 7
x **= 2   # x = x ** 2

**          # Степень (наивысший)
*, /, //, % # Умножение, деление
+, -        # Сложение, вычитание

# Пример:
print(2 + 3 * 4)      # 14 (сначала 3*4=12, потом 2+12)
print((2 + 3) * 4)    # 20 (скобки меняют порядок)

abs(-7)         # Модуль числа: 7
round(3.7)      # Округление: 4
round(3.567, 2) # До 2 знаков: 3.57
pow(2, 8)       # Степень: 256 (= 2**8)
divmod(17, 5)   # (целая часть, остаток): (3, 2)
max(3, 7, 1)    # Максимум из чисел: 7
min(3, 7, 1)    # Минимум из чисел: 1

import math

math.sqrt(16)       # Квадратный корень: 4.0
math.floor(3.9)     # Округление вниз: 3
math.ceil(3.1)      # Округление вверх: 4
math.pi             # Число Пи: 3.14159...
math.factorial(5)   # Факториал: 120
math.log(100, 10)   # Логарифм: 2.0

# Цифры числа:
n = 347
units    = n % 10        # 7 — цифра единиц
tens     = n // 10 % 10  # 4 — цифра десятков
hundreds = n // 100      # 3 — цифра сотен

# Проверка делимости:
n = 120
print(n % 3 == 0)   # True — делится на 3
print(n % 7 == 0)   # False

# Количество цифр в числе:
n = 123456
count = len(str(n))  # 6

# Сумма цифр числа:
digit_sum = sum(int(d) for d in str(n))  # 21

# Количество цифр в числе:
n = 12345
count = len(str(n))        # 5 (через строку)
count2 = 0
tmp = n
while tmp > 0:
    count2 += 1
    tmp //= 10             # 5 (через цикл)

# Перевернуть цифры числа:
n = 1234
rev = int(str(n)[::-1])   # 4321

# Проверить, является ли число степенью двойки:
n = 16
is_power = n > 0 and (n & (n-1)) == 0  # True

# НОД (наибольший общий делитель):
import math
math.gcd(48, 36)   # 12

# НОК (наименьшее общее кратное):
a, b = 4, 6
lcm = a * b // math.gcd(a, b)  # 12

bin(10)         # '0b1010' — двоичное представление
oct(8)          # '0o10'  — восьмеричное
hex(255)        # '0xff'  — шестнадцатеричное

int('1010', 2)  # Из двоичной в десятичную: 10
int('ff', 16)   # Из шест-ной в десятичную: 255

# Побитовые операции (иногда встречаются на ЕГЭ):
5 & 3    # Побитовое И: 1
5 | 3    # Побитовое ИЛИ: 7
5 ^ 3    # Побитовое XOR: 6
~5       # Побитовое НЕ: -6
5 << 1   # Сдвиг влево (умножение на 2): 10
5 >> 1   # Сдвиг вправо (деление на 2): 2

a == b    # равно
a != b    # не равно
a > b     # больше
a < b     # меньше
a >= b    # больше или равно
a <= b    # меньше или равно

x > 0 and x < 10    # И: оба условия должны быть True
x < 0 or x > 100   # ИЛИ: хотя бы одно условие True
not x > 0           # НЕ: инверсия условия

# Сокращённая запись диапазона:
0 < x < 10          # то же что x > 0 and x < 10

"py" in "python"        # True — подстрока найдена
3 in [1, 2, 3, 4]      # True — элемент в списке
5 not in [1, 2, 3]     # True — элемент не в списке

# and (И) — истинно только если ОБА True:
True  and True   # True
True  and False  # False
False and True   # False
False and False  # False

# or (ИЛИ) — истинно если хотя бы ОДИН True:
True  or True    # True
True  or False   # True
False or True    # True
False or False   # False

# not (НЕ) — инверсия:
not True         # False
not False        # True
not 0            # True  (0 считается False)
not ""           # True  (пустая строка = False)

# Python останавливается при первом определённом результате:
# В and: если первое False — второе НЕ проверяется
# В or:  если первое True  — второе НЕ проверяется

lst = []
if lst and lst[0] > 0:     # Безопасно! lst пустой → False, lst[0] не выполняется
    print("Первый элемент положительный")

# Полезный трюк — значение по умолчанию:
name = input() or "Аноним"   # Если ввели пустую строку — будет "Аноним"

nums = [2, 4, 6, 8]
all(x % 2 == 0 for x in nums)   # True — все чётные
any(x > 7 for x in nums)        # True — хоть одно больше 7
all(x > 0 for x in nums)        # True — все положительные

words = ["яблоко", "абрикос", "арбуз"]
all(w.startswith("а") for w in words)  # False (яблоко не начинается с 'а')
any(len(w) > 6 for w in words)         # True (яблоко — 6, абрикос — 7)

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

x = int(input())
if x > 0:
    if x % 2 == 0:
        print("Положительное чётное")
    else:
        print("Положительное нечётное")
else:
    print("Не положительное")

result = "чётное" if x % 2 == 0 else "нечётное"
print(result)

# Ещё пример:
max_val = a if a > b else b   # максимум из двух чисел

grade = int(input())
if grade >= 90:
    print("Отлично")
elif grade >= 75:
    print("Хорошо")
elif grade >= 50:
    print("Удовлетворительно")
else:
    print("Неудовлетворительно")

# Проверка диапазона:
n = int(input())
if 10 <= n <= 99:
    print("Двузначное")

# Проверка знака:
if n > 0:
    sign = "положительное"
elif n < 0:
    sign = "отрицательное"
else:
    sign = "ноль"

# Максимум из трёх чисел без max():
a, b, c = 3, 7, 5
if a >= b and a >= c:
    m = a
elif b >= a and b >= c:
    m = b
else:
    m = c
print(m)  # 7

n = int(input())

# Определить знак и чётность одновременно:
if n > 0:
    print("Положительное", end=" ")
elif n < 0:
    print("Отрицательное", end=" ")
else:
    print("Ноль", end=" ")

if n % 2 == 0:
    print("чётное")
else:
    print("нечётное")

n = int(input())

# Принадлежность диапазону:
if 0 <= n <= 100:
    print("Оценка в допустимом диапазоне")

# Делимость на несколько чисел:
if n % 3 == 0 and n % 5 == 0:
    print("FizzBuzz")
elif n % 3 == 0:
    print("Fizz")
elif n % 5 == 0:
    print("Buzz")
else:
    print(n)

# Проверка двузначного числа:
if 10 <= abs(n) <= 99:
    print("Двузначное")

for i in range(5):          # i = 0, 1, 2, 3, 4
    print(i)

for i in range(1, 11):      # i = 1, 2, ..., 10
    print(i)

for i in range(10, 0, -1):  # обратный отсчёт: 10, 9, ..., 1
    print(i)

for i in range(0, 20, 3):   # с шагом 3: 0, 3, 6, 9, ...
    print(i)

fruits = ["яблоко", "груша", "банан"]
for fruit in fruits:
    print(fruit)

# Перебор строки по символам:
for ch in "Python":
    print(ch)

# Перебор с индексом:
for i, val in enumerate([10, 20, 30]):
    print(i, val)   # 0 10, 1 20, 2 30

i = 0
while i < 5:
    print(i)
    i += 1       # Не забудьте изменять переменную!

# Бесконечный цикл с выходом по break:
while True:
    n = int(input())
    if n == 0:
        break    # Выход из цикла
    print(n * 2)

# break — прерывает цикл полностью
for i in range(10):
    if i == 5:
        break        # остановится на 5
    print(i)         # выведет 0, 1, 2, 3, 4

# continue — пропускает текущую итерацию
for i in range(10):
    if i % 2 == 0:
        continue     # пропустить чётные
    print(i)         # выведет 1, 3, 5, 7, 9

# Таблица умножения 3x3
for i in range(1, 4):
    for j in range(1, 4):
        print(i * j, end="\t")
    print()     # перенос строки после каждой строки таблицы

# Накопление произведения:
product = 1
for i in range(1, 6):
    product *= i
print(product)   # 120 = 5!

# Поиск первого подходящего числа:
n = int(input())
found = -1
for i in range(2, n):
    if n % i == 0:
        found = i
        break
print(found)   # первый делитель, кроме 1 и самого числа

# Подсчёт количества по условию:
lst = [5, 12, 3, 18, 7, 24]
count = 0
for x in lst:
    if x > 10:
        count += 1
print(count)   # 3

# Найти первый элемент, удовлетворяющий условию:
lst = [3, 7, 2, 9, 4, 8]
result = -1
for x in lst:
    if x % 3 == 0:
        result = x
        break
print(result)   # 3

# Подсчёт элементов с условием:
count = sum(1 for x in lst if x > 5)   # 3

# Нахождение максимального элемента вручную (без max):
lst = [3, 7, 2, 9, 4]
cur_max = lst[0]
for x in lst[1:]:
    if x > cur_max:
        cur_max = x
print(cur_max)  # 9

# Флаг — булевая переменная-сигнал:
found = False
for x in [2, 4, 7, 8]:
    if x % 2 != 0:
        found = True
        break
print("Есть нечётный" if found else "Все чётные")

# else у for выполняется, если break не сработал:
for x in [2, 4, 6]:
    if x % 2 != 0:
        print("Нашли нечётный!")
        break
else:
    print("Нечётных нет")   # Выведет это

# Сумма чисел до первого отрицательного:
total = 0
while True:
    n = int(input())
    if n < 0:
        break
    total += n
print("Сумма:", total)

# Угадай число (классика):
secret = 42
while True:
    guess = int(input("Ваш вариант: "))
    if guess == secret:
        print("Угадали!")
        break
    elif guess < secret:
        print("Больше!")
    else:
        print("Меньше!")

s = "Hello, Python!"
len(s)          # Длина строки: 14
s[0]            # Первый символ: 'H'
s[-1]           # Последний символ: '!'
s[7:13]         # Срез: 'Python'
s[:5]           # С начала до 5: 'Hello'
s[7:]           # С 7 до конца: 'Python!'
s[::-1]         # Строка наоборот: '!nohtyP ,olleH'

s = "  Hello, World!  "
s.upper()           # Верхний регистр: 'HELLO, WORLD!'
s.lower()           # Нижний регистр: 'hello, world!'
s.strip()           # Убрать пробелы по краям: 'Hello, World!'
s.lstrip()          # Убрать слева
s.rstrip()          # Убрать справа
s.replace("l","L")  # Заменить все 'l' на 'L'
s.count("l")        # Количество вхождений: 3
s.find("World")     # Позиция первого вхождения: 9 (или -1)
s.startswith("H")   # Начинается с 'H'? True
s.endswith("!")     # Заканчивается на '!'? True

s = "яблоко груша банан"
words = s.split()       # Разбить по пробелам: ['яблоко', 'груша', 'банан']

s2 = "1,2,3,4,5"
parts = s2.split(",")   # Разбить по запятой: ['1','2','3','4','5']

lst = ["один", "два", "три"]
result = ", ".join(lst) # Собрать: 'один, два, три'

name = "Аня"
age = 16
# f-строка (самый современный способ):
print(f"Меня зовут {name}, мне {age} лет")

# Форматирование чисел:
pi = 3.14159
print(f"Пи ≈ {pi:.2f}")    # Пи ≈ 3.14
print(f"{100 * 7/8:.1f}%") # 87.5%

# Конкатенация (склеивание):
greeting = "Привет, " + name + "!"

s = "Python3"
s.isdigit()     # Все цифры? False
s.isalpha()     # Все буквы? False
s.isalnum()     # Буквы и цифры? True
s.isspace()     # Только пробелы? False
s.isupper()     # Все заглавные? False
s.islower()     # Все строчные? False

"123".isdigit() # True
"abc".isalpha() # True

# Подсчёт гласных:
s = input().lower()
vowels = "аеёиоуыъьэюя"
count = sum(1 for ch in s if ch in vowels)

# Переворот слов в предложении:
s = "Привет мир Python"
words = s.split()
words.reverse()
print(" ".join(words))   # Python мир Привет

# Удаление дубликатов символов (сохранить порядок):
s = "abracadabra"
seen = set()
result = ""
for ch in s:
    if ch not in seen:
        result += ch
        seen.add(ch)
print(result)   # abrcd

# Количество слов:
text = "раз два три четыре"
print(len(text.split()))   # 4

s = "python programming"
s.title()               # 'Python Programming' — с заглавных букв
s.capitalize()          # 'Python programming' — первую заглавной
s.center(30, "*")       # обрамление звёздочками по центру
s.ljust(20, "-")        # выравнивание влево с заполнением
s.rjust(20)             # выравнивание вправо пробелами
s.zfill(10)             # дополнение нулями слева: '00python'
s.rfind("o")            # последнее вхождение 'o': 13
"a,b,,c".split(",")     # ['a', 'b', '', 'c'] — пустые строки сохраняются
s.expandtabs(4)         # замена \t на пробелы

lst = [1, 2, 3, 4, 5]        # Создание списка
empty = []                   # Пустой список
mixed = [1, "два", 3.0]      # Разные типы
lst[0]                       # Первый элемент: 1
lst[-1]                      # Последний: 5
lst[1:4]                     # Срез: [2, 3, 4]
len(lst)                     # Длина: 5

lst = [3, 1, 4, 1, 5]
lst.append(9)       # Добавить в конец: [3,1,4,1,5,9]
lst.insert(2, 99)   # Вставить на позицию 2
lst.pop()           # Удалить последний (и вернуть его)
lst.pop(0)          # Удалить по индексу
lst.remove(1)       # Удалить первое вхождение значения
lst[0] = 100        # Изменить элемент
lst.clear()         # Очистить список

lst = [3, 1, 4, 1, 5, 9, 2, 6]
lst.sort()                  # Сортировка по возрастанию: [1,1,2,3,4,5,6,9]
lst.sort(reverse=True)      # По убыванию: [9,6,5,4,3,2,1,1]
sorted_lst = sorted(lst)    # Новый отсортированный список
lst.reverse()               # Перевернуть список
lst.count(1)                # Количество вхождений 1: 2
lst.index(4)                # Индекс первого вхождения 4: 2
sum(lst)                    # Сумма: 31
max(lst)                    # Максимум: 9
min(lst)                    # Минимум: 1

# Вместо:
squares = []
for i in range(1, 6):
    squares.append(i ** 2)

# Можно написать:
squares = [i ** 2 for i in range(1, 6)]   # [1, 4, 9, 16, 25]

# С условием:
evens = [i for i in range(20) if i % 2 == 0]  # [0,2,4,...,18]

# Из строки:
digits = [int(ch) for ch in "12345"]    # [1, 2, 3, 4, 5]

nums = [10, 20, 30, 40]

# Одновременный перебор двух списков через zip:
names = ["Аня", "Петя", "Вася"]
scores = [95, 80, 72]
for name, score in zip(names, scores):
    print(name, "→", score)

# Создание словаря из двух списков:
d = dict(zip(names, scores))   # {'Аня': 95, 'Петя': 80, 'Вася': 72}

# zip с тремя списками:
subjects = ["Математика", "Физика", "Python"]
for name, score, subj in zip(names, scores, subjects):
    print(f"{name} — {subj}: {score}")

# Создание матрицы 3x3:
matrix = [
    [1, 2, 3],
    [4, 5, 6],
    [7, 8, 9]
]

print(matrix[1][2])   # Строка 1, столбец 2: 6

# Перебор всей матрицы:
for row in matrix:
    for elem in row:
        print(elem, end=" ")
    print()

# Нулевая матрица N×M (ВАЖНО: не делать [[0]*m]*n !):
n, m = 3, 4
matrix = [[0] * m for _ in range(n)]

# Матрица из ввода:
n = int(input())
matrix = [list(map(int, input().split())) for _ in range(n)]

# Транспонирование матрицы:
transposed = [[matrix[i][j] for i in range(len(matrix))]
              for j in range(len(matrix[0]))]

# Сумма элементов матрицы:
total = sum(sum(row) for row in matrix)

# Максимум в каждой строке:
row_maxes = [max(row) for row in matrix]

# Подсчёт количества различных элементов:
lst = [1, 2, 2, 3, 3, 3]
unique_count = len(set(lst))    # 3

# Найти второй по величине элемент:
lst = [3, 1, 4, 1, 5, 9, 2, 6]
second = sorted(set(lst))[-2]   # 6

# Сдвиг списка циклически:
lst = [1, 2, 3, 4, 5]
k = 2
shifted = lst[k:] + lst[:k]    # [3, 4, 5, 1, 2]

# Удаление дубликатов с сохранением порядка:
seen = set()
unique = [x for x in lst if not (x in seen or seen.add(x))]

d = {"имя": "Иван", "возраст": 17, "класс": 11}
d["имя"]              # Значение по ключу: 'Иван'
d.get("город")        # Безопасный доступ: None (без ошибки)
d.get("город", "?")   # Со значением по умолчанию: '?'
len(d)                # Количество пар: 3

d["возраст"] = 18       # Изменить значение
d["город"] = "Москва"  # Добавить новую пару
del d["класс"]          # Удалить ключ
d.pop("класс")          # Удалить и вернуть значение

for key in d:                       # Перебор ключей
    print(key, d[key])

for key, val in d.items():          # Ключ и значение
    print(key, "→", val)

print(d.keys())     # Все ключи
print(d.values())   # Все значения

# Проверка наличия ключа:
if "имя" in d:
    print("Есть ключ 'имя'")

# Подсчёт частоты каждого символа в строке:
s = "abracadabra"
freq = {}
for ch in s:
    if ch in freq:
        freq[ch] += 1
    else:
        freq[ch] = 1
print(freq)   # {'a': 5, 'b': 2, 'r': 2, 'c': 1, 'd': 1}

# То же самое через .get():
freq = {}
for ch in s:
    freq[ch] = freq.get(ch, 0) + 1

# Найти наиболее частый символ:
most_common = max(freq, key=freq.get)
print(most_common, freq[most_common])   # a 5

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

# Инвертировать словарь (ключи ↔ значения):
d = {"a": 1, "b": 2, "c": 3}
inverted = {v: k for k, v in d.items()}
# {1:"a", 2:"b", 3:"c"}

# Фильтрация словаря:
scores = {"Аня": 95, "Петя": 60, "Вася": 80}
passed = {k: v for k, v in scores.items() if v >= 70}
# {'Аня': 95, 'Вася': 80}

# Сортировка по значению:
sorted_by_val = sorted(scores.items(), key=lambda x: x[1], reverse=True)
# [('Аня', 95), ('Вася', 80), ('Петя', 60)]

t = (1, 2, 3)           # Создание
t[0]                    # Доступ: 1
len(t)                  # Длина: 3
a, b, c = t             # Распаковка: a=1, b=2, c=3

# Используется когда данные менять нельзя:
point = (10, 20)        # Координаты (x, y)

s = {1, 2, 3, 3, 2, 1}   # Дубли убираются: {1, 2, 3}
s.add(4)                  # Добавить элемент
s.remove(2)               # Удалить элемент (ошибка если нет)
s.discard(99)             # Удалить если есть (без ошибки)
3 in s                    # Проверка принадлежности: True

# Операции с множествами:
a = {1, 2, 3, 4}
b = {3, 4, 5, 6}
a | b   # Объединение: {1,2,3,4,5,6}
a & b   # Пересечение: {3,4}
a - b   # Разность: {1,2}
a ^ b   # Симметрическая разность: {1,2,5,6}

# Удаление дублей из списка:
unique = list(set([1, 2, 2, 3, 3, 3]))

# Кортеж как ключ словаря (список нельзя!):
coords = {}
coords[(0, 0)] = "Начало"
coords[(1, 2)] = "Точка A"

# Именованные координаты через кортеж:
def distance(p1, p2):
    return ((p1[0]-p2[0])**2 + (p1[1]-p2[1])**2) ** 0.5

A = (0, 0)
B = (3, 4)
print(distance(A, B))   # 5.0

# Проверка пересечения двух списков через множества:
list1 = [1, 2, 3, 4, 5]
list2 = [3, 4, 5, 6, 7]
common = set(list1) & set(list2)    # {3, 4, 5}
only_in_1 = set(list1) - set(list2) # {1, 2}

# Проверка, все ли элементы уникальны:
lst = [1, 2, 3, 2]
all_unique = len(lst) == len(set(lst))  # False

def greet(name):
    print("Привет,", name)

greet("Аня")    # Вызов функции: Привет, Аня

# Функция с возвратом значения:
def square(x):
    return x * x

result = square(5)  # result = 25

def power(base, exp=2):     # exp=2 по умолчанию
    return base ** exp

print(power(3))     # 9  (3^2)
print(power(3, 3))  # 27 (3^3)

# Несколько возвращаемых значений:
def min_max(lst):
    return min(lst), max(lst)

lo, hi = min_max([3, 1, 7, 2])  # lo=1, hi=7

def factorial(n):
    if n == 0 or n == 1:
        return 1
    return n * factorial(n - 1)

print(factorial(5))   # 120

def fibonacci(n):
    if n <= 1:
        return n
    return fibonacci(n-1) + fibonacci(n-2)

print(fibonacci(10))  # 55

# lambda — короткая функция в одну строку:
square = lambda x: x ** 2
print(square(5))        # 25

add = lambda x, y: x + y
print(add(3, 4))        # 7

# Сортировка с ключом:
students = [("Аня", 95), ("Петя", 60), ("Вася", 80)]
students.sort(key=lambda s: s[1])           # по оценке
students.sort(key=lambda s: s[1], reverse=True) # по убыванию

words = ["banana", "apple", "cherry"]
words.sort(key=len)    # по длине слова: ['apple','banana','cherry']
words.sort(key=lambda w: w[-1])  # по последней букве

x = 10   # глобальная переменная

def foo():
    x = 20   # локальная переменная (другая!)
    print(x) # 20

foo()
print(x)     # 10 — глобальная не изменилась

# Изменение глобальной переменной — ключевое слово global:
counter = 0

def increment():
    global counter
    counter += 1

increment()
print(counter)  # 1

# Вариант 1 — построчно:
with open('file.txt', encoding='utf-8') as f:
    for line in f:
        print(line.strip())   # .strip() убирает \n

# Вариант 2 — всё сразу в список строк:
with open('file.txt', encoding='utf-8') as f:
    lines = f.readlines()

# Вариант 3 — числа из файла:
with open('file.txt') as f:
    numbers = [int(x) for x in f]

# Режим 'w' — перезапись файла:
with open('output.txt', 'w', encoding='utf-8') as f:
    f.write("Первая строка\n")
    f.write("Вторая строка\n")

# Режим 'a' — дописать в конец:
with open('output.txt', 'a') as f:
    f.write("Ещё строка\n")

# Вывод через print в файл:
with open('output.txt', 'w') as f:
    print("Привет!", file=f)

# Чтение чисел из файла и поиск максимума:
with open('numbers.txt') as f:
    nums = list(map(int, f.read().split()))
print(max(nums))

# Подсчёт строк, удовлетворяющих условию:
with open('data.txt', encoding='utf-8') as f:
    count = sum(1 for line in f if int(line.strip()) % 2 == 0)

# Чтение пар чисел (каждая строка — два числа):
pairs = []
with open('pairs.txt') as f:
    for line in f:
        a, b = map(int, line.split())
        pairs.append((a, b))

# Запись отфильтрованных данных:
with open('in.txt') as fin, open('out.txt', 'w') as fout:
    for line in fin:
        n = int(line.strip())
        if n > 0:
            fout.write(line)

try:
    x = int(input("Введите число: "))
    print(10 / x)
except ValueError:
    print("Ошибка: введено не число")
except ZeroDivisionError:
    print("Ошибка: деление на ноль")
except Exception as e:
    print("Неизвестная ошибка:", e)

try:
    f = open('data.txt')
    data = f.read()
except FileNotFoundError:
    print("Файл не найден")
finally:
    print("Программа завершена")

# NameError — переменная не определена:
print(x)          # NameError если x не объявлена

# IndexError — индекс вне диапазона:
lst = [1, 2, 3]
lst[5]            # IndexError

# KeyError — ключ не найден в словаре:
d = {"a": 1}
d["b"]            # KeyError — используйте d.get("b")

# TypeError — неверный тип данных:
"abc" + 5         # TypeError — нельзя сложить str и int

# Безопасный ввод числа:
while True:
    try:
        n = int(input("Введите целое число: "))
        break
    except ValueError:
        print("Попробуйте ещё раз!")

# map — применить функцию к каждому элементу:
nums = ["1", "2", "3", "4", "5"]
ints = list(map(int, nums))           # [1, 2, 3, 4, 5]
squares = list(map(lambda x: x**2, [1,2,3,4]))  # [1, 4, 9, 16]

# filter — оставить только элементы, удовлетворяющие условию:
nums = [-3, -1, 0, 2, 4, 7]
positives = list(filter(lambda x: x > 0, nums))  # [2, 4, 7]
evens = list(filter(lambda x: x % 2 == 0, nums)) # [0, 2, 4]

# zip — объединить несколько списков попарно:
names = ["Аня", "Петя", "Вася"]
marks = [5, 4, 3]
pairs = list(zip(names, marks))  # [('Аня',5),('Петя',4),('Вася',3)]
for name, mark in zip(names, marks):
    print(f"{name}: {mark}")

# all и any — проверка условий сразу на всём списке:
all(x > 0 for x in [1, 2, 3])      # True — все положительные?
any(x < 0 for x in [1, -1, 2])     # True — есть хоть один отрицательный?
all(x % 2 == 0 for x in [2, 4, 6]) # True — все чётные?

# Нескольких аргументов через map:
a = [1, 2, 3]
b = [10, 20, 30]
sums = list(map(lambda x, y: x + y, a, b))  # [11, 22, 33]

# То же самое через zip:
sums2 = [x + y for x, y in zip(a, b)]       # [11, 22, 33]

# Сортировка по нескольким ключам:
students = [("Аня", 10, 95), ("Петя", 11, 80), ("Вася", 10, 80)]
# Сначала по классу, потом по оценке убыв.:
students.sort(key=lambda s: (s[1], -s[2]))

# Разархивирование zip:
zipped = [(1, "a"), (2, "b"), (3, "c")]
nums, letters = zip(*zipped)
# nums=(1,2,3), letters=('a','b','c')

# Сумма цифр числа:
n = 12345
digit_sum = sum(int(d) for d in str(n))  # 15

# Количество чётных в списке:
lst = [1,2,3,4,5,6]
even_count = sum(1 for x in lst if x % 2 == 0)  # 3

# Максимальная сумма двух соседних элементов:
lst = [3, 7, 2, 9, 4]
max_pair = max(lst[i]+lst[i+1] for i in range(len(lst)-1))  # 11

# Проверка, что все элементы положительны:
all(x > 0 for x in [1, 2, 3])   # True
any(x < 0 for x in [1,-1, 2])   # True — хоть один отрицательный

# Развернуть число (цифры в обратном порядке):
n = 12345
rev = int(str(n)[::-1])   # 54321

# Список простых чисел до N (решето Эратосфена):
N = 50
sieve = [True] * (N+1)
sieve[0] = sieve[1] = False
for i in range(2, int(N**0.5)+1):
    if sieve[i]:
        for j in range(i*i, N+1, i):
            sieve[j] = False
primes = [i for i, v in enumerate(sieve) if v]