Python — база, ООП, веб, DevOps

Актуальная стабильная — Python 3.13 (вышла в 2024). Минимум для нового кода — 3.11 (значительный прирост скорости + улучшенные ошибки). Всё что 3.10 и старше — legacy. Python 2 мёртв с 2020 — не трогай, если только не поддерживаешь очень старый код.

# Через Homebrew
brew install python@3.13
python3 --version           # Python 3.13.x

# Или через pyenv — если нужно держать несколько версий
brew install pyenv
pyenv install 3.13.1
pyenv install 3.11.9
pyenv global 3.13.1         # default для системы
pyenv local 3.11.9          # для конкретного проекта (создаст .python-version)

# Ubuntu 24.04 — уже есть Python 3.12 из коробки
python3 --version

# Если нужна другая версия — PPA от deadsnakes
sudo add-apt-repository ppa:deadsnakes/ppa -y
sudo apt update
sudo apt install python3.13 python3.13-venv python3.13-dev -y

pip — Python-аналог composer в PHP или npm в JS. Ставит библиотеки из PyPI (Python Package Index).

# Установить пакет
pip install requests

# Конкретная версия
pip install django==5.0.1

# Список установленных
pip list

# Заморозить зависимости → requirements.txt
pip freeze > requirements.txt

# Восстановить из requirements.txt
pip install -r requirements.txt

# Обновить сам pip
python -m pip install --upgrade pip

uv — новый (2024) менеджер от Astral (авторы ruff). Написан на Rust, в 10-100 раз быстрее pip. Заменяет pip + venv + pip-tools одной утилитой. Стандарт де-факто в новых проектах.

# Установка
curl -LsSf https://astral.sh/uv/install.sh | sh

# Создать проект
uv init my-app && cd my-app

# Добавить зависимость (сам создаст venv, обновит pyproject.toml)
uv add fastapi uvicorn

# Запустить
uv run python main.py
uv run uvicorn main:app --reload

В Python отступы — часть синтаксиса. Блок кода определяется одинаковым уровнем отступа. Классические { } отсутствуют. Стандарт: 4 пробела (не таб, никогда не смешивай).

# Python
if user.age >= 18:
    print("adult")
    send_email(user)
else:
    print("minor")

# Аналог в PHP
# if ($user->age >= 18) {
#     echo "adult";
#     send_email($user);
# } else {
#     echo "minor";
# }

# Просто присваиваем — тип выводится автоматически
name = "Alice"       # str
age = 30              # int
salary = 1500.50      # float
is_admin = True       # bool (с большой буквы!)
tags = ["php", "python"]      # list
user = {"name": "Alice", "age": 30}   # dict

# Constants — просто UPPER_CASE конвенция, языком не защищено
MAX_RETRIES = 3

# Type hints (опционально, для читаемости и mypy)
name: str = "Alice"
age: int = 30

Ключевые отличия от PHP:

• Нет $ перед именем — просто name, не $name.
• True/False/None — с большой буквы. В PHP было true/false/null.
• Нет объявления типа обязательно — можно опционально через : (type hints).
• Констант в языке нет — только конвенция UPPER_CASE. Реальную неизменяемость даёт только Final[int] из typing (проверяется mypy, но не runtime).

print("Hello")                          # Hello
print("Hello", name)                    # Hello Alice (через пробел)
print("a", "b", "c", sep="-")          # a-b-c
print("no newline", end="")          # без переноса строки
print(f"Name: {name}, age: {age}")      # f-string — интерполяция

Один вызов input() читает ровно одну строку — до перевода строки — и возвращает её всегда как str, даже если там одни цифры. Поэтому для чисел результат сразу оборачивают в int(). Если на вход подано несколько строк, вызовы разбирают их по очереди: первый — первую, второй — вторую.

# на вход подано:
# 3
# 6200
# 2150

count  = int(input())   # 3
price1 = int(input())   # 6200
price2 = int(input())   # 2150

print(count, price1, price2)   # 3 6200 2150

В интерактивном запуске программа на каждом input() останавливается и ждёт ввода с клавиатуры. Когда ввод подаётся из файла или через конвейер, ожидания нет — строки просто разбираются подряд. Для кода разницы никакой: читается следующая непрочитанная строка.

# 1. количество задано первой строкой, дальше по числу в строке
n = int(input())
prices = [int(input()) for _ in range(n)]
print(sum(prices))

# 2. несколько чисел в одной строке через пробел: "6200 2150 11800"
a, b, c = map(int, input().split())
prices = list(map(int, input().split()))   # когда их неизвестно сколько

# 3. весь ввод разом, без оглядки на то, как он разбит на строки
import sys
nums = list(map(int, sys.stdin.read().split()))

# Однострочный (как // в PHP)

"""
Многострочный (docstring).
Стандарт для документации функций и классов.
"""

def divide(a, b):
    """Делит a на b. Бросает ZeroDivisionError если b == 0."""
    return a / b

Тройные кавычки — не «многострочный комментарий» (такого понятия нет), а обычная строка, которую можно не присваивать. Стандартное использование — как первая строка функции/класса — docstring. IDE и help(func) его показывают.

В Python «пустое» = False:

if not users:                # True если users — пустой list, dict, str, 0, None, False
    print("nothing to do")

# Явно проверить на None (правильный питонический способ)
if user is not None:
    ...

# hello.py
def main():
    name = input("Твоё имя: ")
    print(f"Привет, {name}!")

if __name__ == "__main__":
    main()

$ python hello.py
Твоё имя: Санжар
Привет, Санжар!

Конструкция if __name__ == "__main__": — питонический шаблон. Она выполняется, только когда файл запущен напрямую как скрипт, но не при import. Подробнее — в секции Модули + импорты.

users = ["alice", "bob", "charlie"]

# Доступ по индексу
users[0]                          # "alice"
users[-1]                         # "charlie" (с конца)

# Slicing — срезы
users[1:3]                        # ["bob", "charlie"]
users[:2]                         # ["alice", "bob"]
users[::2]                        # каждый второй → ["alice", "charlie"]
users[::-1]                       # reverse

# Модификация
users.append("dave")              # в конец
users.insert(0, "zoe")           # в начало
users.remove("bob")              # удалить по значению
del users[0]                     # удалить по индексу
users.pop()                        # удалить и вернуть последний

# Проверка
"alice" in users                 # True
len(users)                       # 3

# Сортировка
users.sort()                       # in-place, вернёт None
sorted(users)                    # возвращает НОВЫЙ отсортированный, не меняет
sorted(users, reverse=True)

coords = (55.75, 37.61)
x, y = coords                     # unpacking — очень частый паттерн

# Неизменяемый:
coords[0] = 99                    # TypeError

# Функции часто возвращают tuple — сразу распаковываем:
name, age = get_user()

# Именованные — namedtuple (легковесная замена классу)
from collections import namedtuple
Point = namedtuple("Point", ["x", "y"])
p = Point(1, 2)
print(p.x, p.y)                   # 1 2

Зачем tuple, если есть list: tuple немного быстрее, может быть ключом словаря (list — нельзя), и семантически говорит «эти данные вместе, порядок фиксирован» (координаты, RGB-цвет, дата разбитая на y/m/d).

user = {
    "name": "Alice",
    "age": 30,
    "roles": ["admin", "editor"],
}

# Доступ
user["name"]                      # "Alice"
user["phone"]                     # KeyError!
user.get("phone")                # None — безопасно
user.get("phone", "unknown")     # дефолт если нет

# Модификация
user["email"] = "a@b.c"          # добавили
del user["age"]                 # удалили

# Обход
for key in user:                  # обход ключей
    print(key, user[key])
for key, value in user.items():  # pythonic — пара сразу
    print(key, value)
for value in user.values():
    print(value)

# Слияние — Python 3.9+
merged = defaults | overrides     # справа побеждает

# Проверка ключа
"name" in user                  # True — работает по ключам

tags = {"php", "python", "js", "php"}
print(tags)                       # {"php", "python", "js"} — дубликат ушёл

# Операции над множествами (математические!)
a = {1, 2, 3}
b = {2, 3, 4}
a | b                             # объединение → {1, 2, 3, 4}
a & b                             # пересечение → {2, 3}
a - b                             # разность → {1}
a ^ b                             # симметрическая разность → {1, 4}

# Убрать дубликаты из списка
unique_users = list(set(users))

Immutable-объекты нельзя менять «на месте» — методы возвращают новую копию. У str: s.upper() вернёт новую строку, оригинал не тронется. Это как в PHP: str — value type.

def add_item(item, items=[]):    # ← []  создаётся ОДИН раз при определении функции!
    items.append(item)
    return items

add_item("a")   # ["a"]
add_item("b")   # ["a", "b"] !!! копится между вызовами

a = "hello"              # двойные
b = 'hello'              # одинарные — эквивалентны
c = """multi
line string"""          # тройные — многострочная
d = r"C:\path\file"     # raw — не экранирует \n \t \
e = b"bytes"             # bytes (не str)
f = f"Hi {name}"         # f-string — интерполяция

name = "Alice"
age = 30
price = 1234.5678

f"Hi, {name}!"                       # "Hi, Alice!"
f"{name} is {age} years old"          # подстановка нескольких
f"{name.upper()}"                    # выражения — не только имена
f"total: {a + b}"                    # арифметика внутри

# Форматирование
f"{price:.2f}"                       # "1234.57" — округление до 2
f"{price:,.2f}"                      # "1,234.57" — с разделителем
f"{price:10.2f}"                     # "   1234.57" — ширина 10, padding
f"{price:>10}"                       # выравнивание вправо
f"{price:<10}"                       # влево
f"{price:^10}"                       # по центру
f"{age:03d}"                         # "030" — паддинг нулями
f"{price:.0%}"                       # проценты
f"{now:%Y-%m-%d %H:%M}"              # дата (datetime)

# Debug (Python 3.8+) — печатает имя + значение
f"{name=}"                            # "name='Alice'"
f"{price=:.2f}"                      # "price=1234.57"

# repr vs str внутри f-string
f"{name!r}"                          # "'Alice'" — через repr()
f"{name!s}"                          # "Alice"

Способов встретится четыре, и выглядят они взаимозаменяемыми. На деле первые три дают строку, а четвёртый строку не создаёт вовсе.

text = 'привет'

# 1. f-строка — основной способ
print(f"Он зашёл в чат и написал: {text}!")
# Он зашёл в чат и написал: привет!

# 2. метод .format()
print("Скажи мне {} ещё раз.".format(text))
# Скажи мне привет ещё раз.

# 3. сложение через +
print("Она ответила: " + text)
# Она ответила: привет

# 4. перечисление через запятую в print()
print("Новое сообщение:", text, "всем")
# Новое сообщение: привет всем

Все методы возвращают НОВУЮ строку — str immutable. s.upper() не меняет s, а возвращает новую.

s = "hello world"

s[0]                    # "h"
s[-1]                   # "d"
s[0:5]                  # "hello"
s[:5]                   # "hello" — с начала
s[6:]                   # "world" — до конца
s[::-1]                 # "dlrow olleh" — reverse
s[::2]                  # "hlowrd" — каждый второй
len(s)                 # 11

import re

# Основные функции
re.search(pattern, string)     # найти первое → Match | None
re.match(pattern, string)      # только с НАЧАЛА строки
re.fullmatch(pattern, string)  # вся строка целиком
re.findall(pattern, string)    # все совпадения → list
re.finditer(pattern, string)   # все → iterator Match'ей (для больших текстов)
re.sub(pattern, repl, string)  # замена
re.split(pattern, string)     # split по regex

# Пример: проверить email
if re.fullmatch(r"[\w.+-]+@[\w-]+\.[\w.-]+", email):
    print("looks like email")

# Захват групп
m = re.search(r"(\d+)-(\d+)", "order 42-100")
if m:
    print(m.group(0))         # "42-100" — вся сматченная строка
    print(m.group(1))         # "42"
    print(m.group(2))         # "100"
    print(m.groups())         # ("42", "100")

# Именованные группы
m = re.search(r"(?P<year>\d{4})-(?P<month>\d{2})", "2026-09")
m.group("year")              # "2026"

# Компиляция для повторного использования (быстрее)
EMAIL_RE = re.compile(r"[\w.+-]+@[\w-]+\.[\w.-]+")
EMAIL_RE.fullmatch(email)

В Python 3 str — это Unicode (последовательность code point'ов). bytes — сырые байты. Между ними — явная конвертация через кодировку.

s = "Привет"                    # str (unicode)
b = s.encode("utf-8")             # bytes: b'\xd0\x9f\xd1\x80\xd0\xb8...'
s2 = b.decode("utf-8")            # обратно в str

# Файлы
with open("file.txt", encoding="utf-8") as f:  # явно всегда utf-8
    text = f.read()

# Бинарные — bytes
with open("image.png", "rb") as f:
    data = f.read()             # bytes

if age >= 18:
    status = "adult"
elif age >= 13:
    status = "teen"
else:
    status = "child"

# Тернарник: value_if_true if condition else value_if_false
status = "adult" if age >= 18 else "minor"

# Не путать с C-style — синтаксис Python другой:
# status = age >= 18 ? "adult" : "minor"   — SyntaxError

# Chained comparisons — красивая питоническая фича
if 18 <= age < 65:                # эквивалент age >= 18 and age < 65
    ...

# Walrus operator := (Python 3.8+) — присвоить внутри выражения
if (n := len(items)) > 10:
    print(f"too many: {n}")

# for — обход iterable (list/tuple/dict/str/set/generator)
for user in users:
    print(user)

# range(start, stop, step)
for i in range(10):           # 0..9
    ...
for i in range(1, 11):        # 1..10
    ...
for i in range(0, 100, 10):    # 0, 10, 20, ..., 90
    ...

# while — пока условие true
while queue:
    task = queue.pop()
    process(task)

# break / continue — как везде
for item in items:
    if item.is_bad:
        continue
    if item.is_stop:
        break
    process(item)

# enumerate — индекс + значение
for i, user in enumerate(users):
    print(f"{i}: {user}")

for i, user in enumerate(users, start=1):    # с 1
    ...

# zip — параллельный обход двух iterables
names = ["Alice", "Bob"]
ages  = [30, 25]
for name, age in zip(names, ages):
    print(name, age)

# dict — .items(), .keys(), .values()
for key, value in user.items():
    ...

# reversed — обход в обратном порядке
for item in reversed(items):
    ...

# sorted — обход отсортированного
for user in sorted(users, key=lambda u: u.age):
    ...

# else срабатывает если цикл завершился БЕЗ break
for item in items:
    if item.is_target:
        print("found!")
        break
else:
    print("not found")   # сработает только если target не встретился

Кто это придумал — вопрос философский. Практика — заменяют flag-переменной для читаемости.

Мощная замена switch — не просто сравнение по значению, а деструктуризация:

# Простой — как switch
match status:
    case "active":
        handle_active()
    case "paused" | "stopped":      # несколько значений
        handle_off()
    case _:                          # default
        handle_unknown()

# Деструктуризация — вот где magic
match event:
    case {"type": "order.created", "data": {"id": order_id}}:
        process_order(order_id)
    case {"type": "payment.received", "data": {"amount": amount, "currency": cur}}:
        record_payment(amount, cur)
    case {"type": "error", "message": msg}:
        logger.error(msg)

# Классы + деструктуризация
match shape:
    case Circle(radius=r):
        return 3.14 * r ** 2
    case Rectangle(width=w, height=h):
        return w * h

# Guard — доп условие
match point:
    case (x, y) if x == y:
        print("on diagonal")

def greet(name):
    """Docstring — первая строка, доступна через help(greet)."""
    return f"Hello, {name}!"

greet("Alice")              # "Hello, Alice!"

# С type hints (рекомендуется в новом коде)
def greet(name: str) -> str:
    return f"Hello, {name}!"

# Без явного return — функция вернёт None
def log_it(msg):
    print(msg)         # возвращает None автоматически

def create_user(name, age, role="user", active=True):
    return {"name": name, "age": age, "role": role, "active": active}

# Позиционные — по порядку
create_user("Alice", 30)

# Keyword — по имени, порядок не важен
create_user(age=30, name="Alice", role="admin")

# Смешанно — сначала позиционные, потом keyword
create_user("Alice", 30, role="admin")

# Keyword-only — принудительно через *
def create_order(items, *, currency="USD", express=False):
    ...
create_order([...], currency="EUR")   #
create_order([...], "EUR")             # TypeError

# Positional-only — до /
def divmod_(a, b, /):     # a и b нельзя передать как keyword
    return a // b, a % b

Сторона 1: в def — собирают

# *args — собрать все позиционные в кортеж
def sum_all(*args):
    return sum(args)

sum_all(1, 2, 3, 4)
# sum_all(1, 2, 3, 4)
#         └──┬───────┘
#       *args собирает всё это
#            ↓
#        args = (1, 2, 3, 4)   ← кортеж

# **kwargs — собрать все именованные в словарь
def make_dict(**kwargs):
    return kwargs

make_dict(name="Alice", age=30)
# kwargs = {"name": "Alice", "age": 30}   ← словарь

# Комбинация — обычная / позиционные / именованные
def log(level, *messages, **extras):
    print(level, messages, extras)

log("INFO", "user", "created", user_id=42, ip="1.1.1.1")
#     ↓         └────┬─────┘   └──────┬───────────┘
#   level      *messages           **extras
#              ("user","created")  {"user_id":42,"ip":"1.1.1.1"}

Сторона 2: при вызове — раскрывают (обратная операция)

# * при вызове — раскрыть список в позиционные
def add(a, b, c):
    return a + b + c

nums = [1, 2, 3]
add(nums)                # TypeError — передался ОДИН список
add(*nums)               # = add(1, 2, 3) → 6

# ** при вызове — раскрыть словарь в именованные
def create_user(name, age): ...

kwargs = {"name": "Alice", "age": 30}
create_user(**kwargs)     # = create_user(name="Alice", age=30)

Одна таблица — обе стороны:

Мнемоника: в def — «звёздочка собирает» (много в одно). При вызове — «звёздочка раскрывает» (одно в много). Это обратные операции одного механизма.

def f(*args, **kwargs):
    print("args   =", args, type(args).__name__)
    print("kwargs =", kwargs, type(kwargs).__name__)

f(1, 2, x=10, y=20)
# args   = (1, 2) tuple                     ← позиционные → КОРТЕЖ
# kwargs = {'x': 10, 'y': 20} dict          ← именованные → СЛОВАРЬ

# Раскрыть их и передать в другую функцию
def g(a, b, x, y): return a + b + x + y

args = [1, 2]
kwargs = {"x": 10, "y": 20}
g(*args, **kwargs)                        # = g(1, 2, x=10, y=20) → 33

Три аргумента через запятую — print напечатает их через пробел:

1. "args =" — обычная строка-подпись
2. args — переменная (кортеж, собранный *args)
3. type(args).__name__ — цепочка:
   • type(args) → <class 'tuple'> (объект-класс)
   • .__name__ → 'tuple' (имя класса как строка, без обёртки <class ...>)

Итого — «напечатай подпись, значение и красивое имя типа». Часто используется в отладке.

type(42).__name__       # 'int'
type("hi").__name__     # 'str'
type([1, 2]).__name__   # 'list'
type({"a": 1}).__name__ # 'dict'
type(None).__name__     # 'NoneType'
type(True).__name__     # 'bool'

В f-string короче и читаемее:

print(f"args = {args} ({type(args).__name__})")
# args = (1, 2) (tuple)

Декоратор не знает, какие аргументы принимает оборачиваемая функция. Ловит «всё» через *args, **kwargs и прокидывает дальше:

def logged(func):
    def wrapper(*args, **kwargs):     # СОБИРАЕТ что угодно
        print("вызов:", func.__name__)
        return func(*args, **kwargs)     # РАСКРЫВАЕТ и передаёт
    return wrapper

@logged
def add(a, b): return a + b

add(1, 2)
# вызов: add
# 3

d = {"a": 1, "b": 2}
f(*d)      # = f("a", "b") — раскрылись ключи, не значения!
f(**d)     # = f(a=1, b=2) — вот так правильно

def add(item, items=[]):    # [] создаётся ОДИН раз при определении!
    items.append(item)
    return items

add("a")     # ["a"]
add("b")     # ["a", "b"] — не пустой!

# Правильно:
def add(item, items=None):
    if items is None:
        items = []
    items.append(item)
    return items

def divmod_(a, b):
    return a // b, a % b       # на самом деле — tuple (a//b, a%b)

quotient, remainder = divmod_(10, 3)   # unpacking

# Часто возвращают dict / dataclass для читаемости
def get_user_stats(user_id):
    return {"orders": 42, "total": 1500.0, "last_order_at": ...}

Однострочные функции без имени. Полезны для sorted, map, filter. Не для сложной логики — там обычная def.

# Сортировка по полю
users = [{"name": "Bob", "age": 25}, {"name": "Alice", "age": 30}]
sorted(users, key=lambda u: u["age"])

# Максимум по критерию
max(users, key=lambda u: u["age"])

# Фильтр
list(filter(lambda u: u["age"] >= 18, users))
# Питоничнее — comprehension:
[u for u in users if u["age"] >= 18]

Внутренняя функция запоминает переменные внешней. Классический паттерн — фабрика функций:

def make_multiplier(factor):
    def multiply(x):
        return x * factor       # factor — из внешней области
    return multiply

double = make_multiplier(2)
triple = make_multiplier(3)
double(5)                        # 10
triple(5)                        # 15

# Изменение внешней переменной — через nonlocal
def counter():
    count = 0
    def inc():
        nonlocal count       # без этого count = local, будет UnboundLocalError
        count += 1
        return count
    return inc

next_id = counter()
next_id(), next_id(), next_id()   # 1, 2, 3

funcs = [lambda: i for i in range(3)]
[f() for f in funcs]           # [2, 2, 2] — не [0, 1, 2]!
# Все lambda ссылаются на ОДНУ и ту же i, к моменту вызова = 2

# Фикс через default:
funcs = [lambda i=i: i for i in range(3)]
[f() for f in funcs]           # [0, 1, 2]

# [expression for item in iterable if condition]

# Простое преобразование
squared = [x ** 2 for x in range(10)]
# [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]

# С фильтром
positives = [x for x in nums if x > 0]

# Оба сразу
even_squares = [x ** 2 for x in range(20) if x % 2 == 0]

# Извлечение из объектов
emails = [user.email for user in users if user.is_active]

# if/else в expression — тернарник (тогда if НЕ фильтр, а часть выражения)
labels = ["adult" if u.age >= 18 else "minor" for u in users]

# {key_expr: value_expr for item in iterable if condition}

# Из пары списков
names = ["Alice", "Bob", "Charlie"]
ages  = [30, 25, 35]
user_ages = {n: a for n, a in zip(names, ages)}
# {"Alice": 30, "Bob": 25, "Charlie": 35}

# Инверсия dict
inverted = {v: k for k, v in d.items()}

# Трансформация значений
upper_d = {k: v.upper() for k, v in d.items()}

# Индекс по id
users_by_id = {u.id: u for u in users}

# С фильтром
active = {k: v for k, v in d.items() if v.is_active}

unique_tags = {tag for post in posts for tag in post.tags}

# Уникальные домены email-ов
domains = {email.split("@")[1] for email in emails}

Просто скобки (...) вместо [...] — но получается генератор, а не список. Не занимает память под все элементы сразу, вычисляет по одному.

# List — сразу все 10^9 чисел в памяти. Убьёт RAM.
sum([x ** 2 for x in range(10 ** 9)])

# Generator — по одному, память O(1)
sum(x ** 2 for x in range(10 ** 9))

# При передаче в функцию скобки comprehension'а можно опустить
any(u.is_admin for u in users)
max(o.total for o in orders)

Универсальная формула перевода:

# Comprehension
[expr for A in X for B in Y if cond]

# Эквивалент через обычный код
result = []
for A in X:              # ← первый for (внешний)
    for B in Y:          # ← второй for (внутренний)
        if cond:
            result.append(expr)

matrix = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]
flat = [x for row in matrix for x in row]
# [1, 2, 3, 4, 5, 6, 7, 8, 9]

# Разворот в обычный цикл:
flat = []
for row in matrix:        # row = [1,2,3], потом [4,5,6], потом [7,8,9]
    for x in row:         # x = 1, 2, 3   потом 4, 5, 6   потом 7, 8, 9
        flat.append(x)

«Прочитай вслух» — [x for row in matrix for x in row] → «возьми x — для каждой row в matrix — для каждого x в row». Порядок for = порядок вложенности.

unique_tags = {tag for post in posts for tag in post.tags}

# Развёрнуто:
unique_tags = set()
for post in posts:            # каждый пост
    for tag in post.tags:     # каждый его тег
        unique_tags.add(tag)   # set сам убирает дубли

Второй for использует post, объявленный в первом → порядок нельзя менять. post.tags — коллекция внутри объекта.

domains = {email.split("@")[1] for email in emails}

# Развёрнуто:
domains = set()
for email in emails:
    domains.add(email.split("@")[1])

Один for — потому что вход плоский (список строк). В прошлых примерах был двумерный (список списков / список объектов с вложенными коллекциями) — оттуда два for.

pairs = [(a, b) for a in range(3) for b in range(3) if a != b]

# Развёрнуто:
pairs = []
for a in range(3):        # a = 0, 1, 2
    for b in range(3):    # b = 0, 1, 2 (для КАЖДОГО a)
        if a != b:
            pairs.append((a, b))

# Результат:
# a=0: (0,1) (0,2)
# a=1: (1,0) (1,2)
# a=2: (2,0) (2,1)
# → 6 пар

Разница с уплощением:

1. Найди первый for — это внешний цикл.
2. Найди второй for — внутренний (вложен в первый).
3. Всё, что стоит в начале (до первого for) — что собираем.
4. if в конце — фильтр (можно несколько).
5. if после for применяется к последнему циклу.

[ ВЫРАЖЕНИЕ for A in X for B in Y if УСЛОВИЕ ]
#     ↑         ↑          ↑          ↑
#  собираем  внешний   внутренний  фильтр

[x for row in matrix for x in row]     #
[x for x in row for row in matrix]     # NameError: row не объявлен

[x if x > 0 else 0 for x in nums]     # ← тернарник (преобразование каждого)
[x for x in nums if x > 0]            # ← фильтр (отбор)

# Все слова из списка предложений (плоский)
[word for sentence in text for word in sentence.split()]

# Все числа из вложенного списка
[n for group in groups for n in group]

# Все теги из постов (уникальные)
{tag for post in posts for tag in post.tags}

# Все комбинации цвет × размер
[(c, s) for c in colors for s in sizes]

# Пары без повторов (i < j)
[(a, b) for a in range(5) for b in range(5) if a < b]

# Все ключи из списка словарей
[k for d in dicts for k in d.keys()]

# Транспонировать матрицу
[[row[i] for row in matrix] for i in range(len(matrix[0]))]

Самый частый паттерн в реальном коде — обработка данных из БД, API-ответов, JSON. Держи как справочник:

users = [{"name": "Bob", "age": 25}, {"name": "Alice", "age": 30}]

# ─── Сортировка по полю ──────────────────────────────────────
sorted(users, key=lambda u: u["age"])
sorted(users, key=lambda u: u["age"], reverse=True)

# По нескольким полям (сначала age, потом name)
sorted(users, key=lambda u: (u["age"], u["name"]))

# Через itemgetter — быстрее lambda
from operator import itemgetter
sorted(users, key=itemgetter("age"))

# ─── Максимум / минимум ──────────────────────────────────────
max(users, key=lambda u: u["age"])          # {"name": "Alice", "age": 30}
min(users, key=lambda u: u["age"])

# ─── Фильтр (питонично) ──────────────────────────────────────
[u for u in users if u["age"] >= 18]

# ─── Извлечь одно поле (аналог array_column PHP) ─────────────
[u["name"] for u in users]              # ["Bob", "Alice"]

# ─── Сумма / среднее по полю ─────────────────────────────────
sum(u["age"] for u in users)               # 55
sum(u["age"] for u in users) / len(users)   # 27.5

# ─── Логика по коллекции ─────────────────────────────────────
any(u["age"] > 28 for u in users)           # True — есть хоть один
all(u["age"] >= 18 for u in users)          # True — все

# ─── Найти первого по условию (безопасно) ────────────────────
next((u for u in users if u["name"] == "Bob"), None)
# default None — если не нашли (иначе StopIteration)

# ─── Индекс по ключу (dict из списка) ────────────────────────
users_by_name = {u["name"]: u for u in users}
users_by_name["Alice"]                          # O(1) доступ

# ─── Группировка по полю ─────────────────────────────────────
from collections import defaultdict
by_age = defaultdict(list)
for u in users:
    by_age[u["age"]].append(u["name"])
# {25: ["Bob"], 30: ["Alice"]}

# itertools.groupby — работает ТОЛЬКО с отсортированными по ключу
from itertools import groupby
sorted_users = sorted(users, key=itemgetter("age"))
for age, group in groupby(sorted_users, key=itemgetter("age")):
    print(age, list(group))

# ─── Добавить / изменить поле у каждого ──────────────────────
for u in users:
    u["is_adult"] = u["age"] >= 18          # мутация in-place

# Или через comprehension — новый список из новых dict'ов
enriched = [{**u, "is_adult": u["age"] >= 18} for u in users]

# ─── Удалить дубликаты по полю (сохранить первое) ────────────
seen = set()
unique = []
for u in users:
    if u["name"] not in seen:
        seen.add(u["name"])
        unique.append(u)

# ─── Разбить на два по условию (partition) ───────────────────
adults = [u for u in users if u["age"] >= 18]
minors = [u for u in users if u["age"] < 18]

# ─── Топ-N по полю ───────────────────────────────────────────
import heapq
top_3 = heapq.nlargest(3, users, key=itemgetter("age"))
bottom_3 = heapq.nsmallest(3, users, key=itemgetter("age"))
# быстрее sorted(...)[:3] для больших списков

# ─── Есть ли dict с таким полем ──────────────────────────────
"Bob" in {u["name"] for u in users}       # True

# ─── Слить два списка dict'ов по ключу ───────────────────────
orders = [{"user": "Bob", "total": 100}, {"user": "Alice", "total": 200}]
merged = [{**u, **next((o for o in orders if o["user"] == u["name"]), {})}
          for u in users]
# Для больших данных — переходи на pandas.merge

Python предоставляет ~70 функций без импорта — они всегда доступны из любого модуля. Живут в модуле builtins, автоматически загружаемом. Полный список: dir(__builtins__) (там ~150 имён, включая исключения типа ValueError).

Реальный use-case:

# Все users имеют email?
if all(u.email for u in users):
    send_bulk(users)

# Есть хоть один админ?
if any(u.is_admin for u in users):
    ...

# Ленивое короткое замыкание — как в SQL EXISTS
# При первом True в any / False в all — обход прекращается

Используются редко — в основном для отладки и метапрограммирования (декораторы, ORM, тестовые фреймворки).

eval("2 + 3")              # 5 — выполнить ВЫРАЖЕНИЕ, вернуть значение
eval("len('hi')")          # 2

exec("x = 5\nprint(x)")     # выполнить ИНСТРУКЦИИ, вернуть None

Безопасные альтернативы:

• Парсинг чисел из строки → int(s) / float(s), а не eval(s)
• Парсинг литералов (числа, строки, списки, dict) → ast.literal_eval(s) — только литералы, никаких вызовов функций
• Парсинг математических выражений → библиотека sympy или свой AST-парсер
• Динамическое выполнение кода из БД → крайне пересматривай архитектуру, обычно есть безопасное решение

class User:
    # Class-атрибут — общий для всех экземпляров
    role = "guest"

    # Конструктор — __init__
    def __init__(self, name: str, age: int):
        self.name = name           # instance-атрибуты
        self.age = age

    # Обычный метод — первый аргумент всегда self
    def greet(self) -> str:
        return f"Hi, I'm {self.name}"

user = User("Alice", 30)
user.greet()                    # "Hi, I'm Alice"
user.name                       # "Alice"
user.role                       # "guest" (из class-атрибута)

class Admin(User):                    # extends User
    role = "admin"                       # переопределили class-атрибут

    def __init__(self, name, age, permissions):
        super().__init__(name, age)      # вызов конструктора родителя
        self.permissions = permissions

    def greet(self) -> str:
        base = super().greet()             # вызов метода родителя
        return f"{base} (admin)"

admin = Admin("Bob", 40, ["read", "write"])
admin.greet()                       # "Hi, I'm Bob (admin)"
isinstance(admin, User)            # True — Admin наследник User

Множественное наследование возможно (в отличие от PHP). Порядок разрешения — MRO (Method Resolution Order) по алгоритму C3:

class A: def hi(self): print("A")
class B(A): def hi(self): print("B")
class C(A): def hi(self): print("C")
class D(B, C): pass

D().hi()               # "B" — MRO: D → B → C → A → object
D.__mro__              # покажет полный порядок

class Circle:
    def __init__(self, radius):
        self._radius = radius

    @property
    def radius(self) -> float:
        return self._radius

    @radius.setter
    def radius(self, value):
        if value < 0:
            raise ValueError("radius must be positive")
        self._radius = value

    @property
    def area(self) -> float:            # вычисляемое поле
        return 3.14159 * self._radius ** 2

c = Circle(5)
c.radius                        # 5 (вызовет getter, но выглядит как атрибут)
c.radius = 10                   # вызовет setter
c.radius = -1                   # ValueError
c.area                          # 314.159 — без скобок!

Питоническое решение: начинай с обычного публичного атрибута; когда потребуется валидация/вычисление — превращай в @property, интерфейс наружу не меняется.

class User:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    @classmethod
    def from_dict(cls, data: dict) -> "User":
        # cls = сам класс. Работает и в наследниках.
        return cls(data["name"], data["age"])

    @staticmethod
    def is_valid_email(email: str) -> bool:
        # Ни self, ни cls — обычная функция в namespace класса
        return "@" in email

user = User.from_dict({"name": "Alice", "age": 30})
User.is_valid_email("a@b.c")   # True

Различие: @classmethod получает класс — используется для альтернативных конструкторов (from_dict, from_json). @staticmethod — просто функция, помещённая в namespace класса для семантики.

Специальные методы с двойным подчёркиванием — «крючки» в поведение языка. Питон вызывает их сам при определённых операциях.

class Money:
    def __init__(self, amount, currency):
        self.amount = amount
        self.currency = currency

    def __repr__(self) -> str:
        return f"Money({self.amount}, {self.currency!r})"

    def __str__(self) -> str:
        return f"{self.amount} {self.currency}"

    def __eq__(self, other) -> bool:
        return self.amount == other.amount and self.currency == other.currency

    def __hash__(self) -> int:
        return hash((self.amount, self.currency))

    def __add__(self, other):
        if self.currency != other.currency:
            raise ValueError("cannot add different currencies")
        return Money(self.amount + other.amount, self.currency)

Money(100, "USD") + Money(50, "USD")   # Money(150, 'USD')

В Python есть два вида dunder-имён (double underscore, «двойное подчёркивание с двух сторон»). Их часто путают:

Не методы, а готовая информация об объекте. Читаешь без скобок.

Особый случай — __name__ у разных объектов:

Отсюда идиома:

# mymodule.py
def main(): ...

if __name__ == "__main__":
    main()      # сработает только при `python mymodule.py`
                    # НЕ при `import mymodule`

Ты определяешь в своём классе, Python сам вызывает когда пользователь делает обычную вещь. В этом и есть «магия».

1. Жизненный цикл

2. Строковое представление

3. Сравнение

Хочешь все 6 операторов сравнения сразу — @functools.total_ordering сгенерирует их из __eq__ + __lt__.

4. Арифметика

5. Контейнеры (list/dict-подобное поведение)

6. Context managers (with)

7. Другие важные хуки

class Basket:
    def __init__(self, items=None):        # создание
        self._items = items or []

    def __repr__(self):                    # debug
        return f"Basket({self._items!r})"

    def __str__(self):                     # print
        return f"Корзина: {len(self._items)} товаров"

    def __len__(self):                     # len()
        return len(self._items)

    def __getitem__(self, i):                # basket[i]
        return self._items[i]

    def __contains__(self, item):            # item in basket
        return item in self._items

    def __iter__(self):                    # for x in basket
        return iter(self._items)

    def __bool__(self):                    # if basket:
        return len(self._items) > 0

    def __add__(self, other):                # basket1 + basket2
        return Basket(self._items + other._items)

    def __eq__(self, other):                 # basket1 == basket2
        return self._items == other._items

# Использование — Python сам дёргает нужные хуки
b = Basket(["хлеб", "молоко"])
print(b)                # __str__      → "Корзина: 2 товаров"
len(b)                  # __len__      → 2
b[0]                    # __getitem__  → "хлеб"
"молоко" in b            # __contains__ → True
bool(b)                 # __bool__     → True
for item in b:            # __iter__
    print(item)

# Что даёт Python сам как атрибуты — без определения:
b.__class__.__name__     # 'Basket'
b.__dict__               # {'_items': ['хлеб', 'молоко']}

x = "hello"

callable(x.__str__)         # True — метод, можно вызвать
callable(x.__class__)       # True — класс сам callable (создаёт объект)
callable(x.__doc__)         # False — атрибут (строка)

# Ещё способ — type
type(x.__str__)             # <class 'method-wrapper'>
type(x.__doc__)             # <class 'str'>

from dataclasses import dataclass, field

@dataclass
class User:
    name: str
    age: int
    role: str = "user"
    tags: list[str] = field(default_factory=list)   # для mutable default

user = User("Alice", 30)
print(user)                    # User(name='Alice', age=30, role='user', tags=[])
user == User("Alice", 30)      # True — __eq__ автоматом

# Опции:
@dataclass(frozen=True)          # иммутабельный
@dataclass(slots=True)           # меньше памяти, быстрее (3.10+)
@dataclass(kw_only=True)         # только keyword-arguments

Автоматически генерирует __init__, __repr__, __eq__. Аналог PHP readonly class или Java records. Используй по умолчанию для всех классов-DTO. Для валидации данных из внешнего мира (API/форм) — Pydantic.

Любой .py-файл — модуль. Импорт делает его переменные/функции/классы доступными в другом файле.

# math_utils.py
PI = 3.14159
def area(radius): return PI * radius ** 2

# app.py
import math_utils                      # модуль целиком
math_utils.area(5)
math_utils.PI

from math_utils import area, PI       # только нужное
area(5)

from math_utils import area as circle_area   # переименовать
circle_area(5)

from math_utils import *                    # анти-паттерн, засоряет namespace

myapp/
├── __init__.py            # делает директорию пакетом
├── main.py
├── users/
│   ├── __init__.py
│   ├── models.py          # class User
│   └── service.py         # def register(...)
└── orders/
    ├── __init__.py
    └── models.py

# В main.py — абсолютные импорты (рекомендуется)
from myapp.users.models import User
from myapp.users.service import register

# Внутри users/service.py — относительные (только между модулями пакета)
from .models import User         # тот же пакет
from ..orders.models import Order  # родительский пакет

__init__.py может быть пустым (просто маркер пакета) или содержать re-exports:

# myapp/users/__init__.py
from .models import User
from .service import register

# Теперь можно короче:
from myapp.users import User, register

Каждый модуль имеет специальную переменную __name__:

• Если файл запущен напрямую (python app.py) → __name__ == "__main__"
• Если файл импортирован (import app) → __name__ == "app"

# cli.py
def main():
    print("Running CLI")

if __name__ == "__main__":
    main()      # сработает только при `python cli.py`,
                    # не при `import cli`

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

Проект A требует Django 4.2, проект B — Django 5.1. Оба ставить глобально нельзя. Virtual environment — изолированная копия интерпретатора со своим site-packages/. Аналог vendor/ в PHP, но на уровне интерпретатора.

# Создать окружение в текущей директории
python -m venv .venv

# Активировать
source .venv/bin/activate         # macOS/Linux
.venv\Scripts\activate            # Windows PowerShell

# Теперь python/pip = из .venv/
which python                     # /path/to/project/.venv/bin/python
pip install fastapi uvicorn sqlalchemy

# Заморозить
pip freeze > requirements.txt

# Восстановить в новом окружении
pip install -r requirements.txt

# Деактивировать
deactivate

Добавь .venv/ в .gitignore — окружение локально, восстанавливается из requirements.txt. По той же логике, что vendor/ в PHP.

uv (Astral, 2024) — Rust-based замена pip + venv + pip-tools. В 10-100 раз быстрее. Управляет всем через pyproject.toml + uv.lock — воспроизводимые сборки как composer.lock.

# Установка (один раз)
curl -LsSf https://astral.sh/uv/install.sh | sh

# Создать проект
uv init my-api && cd my-api

# Установить конкретную версию Python (если её нет — скачает)
uv python install 3.13

# Добавить зависимости — сам создаст .venv, обновит pyproject.toml + uv.lock
uv add fastapi uvicorn sqlalchemy
uv add --dev pytest ruff mypy

# Запустить — не нужно `source .venv/bin/activate`
uv run python app.py
uv run uvicorn main:app --reload

# Установить из lock-файла (для CI/деплоя)
uv sync                           # reproducible install

Poetry (2018) — до uv был стандартом. Тот же принцип (pyproject.toml + lock), но написан на Python и в 100 раз медленнее.

poetry init
poetry add fastapi
poetry install
poetry run pytest

Для нового проекта в 2026 — uv. Poetry — только если проект уже на нём.

# pyproject.toml — как composer.json в PHP
[project]
name = "my-api"
version = "0.1.0"
requires-python = ">=3.11"
dependencies = [
    "fastapi>=0.110",
    "sqlalchemy>=2.0",
    "asyncpg",
]

[project.optional-dependencies]
dev = ["pytest", "ruff", "mypy"]

[tool.ruff]
line-length = 100
target-version = "py313"

[tool.mypy]
strict = true

try:
    data = json.loads(payload)
    result = data["user"]["id"]
except json.JSONDecodeError as e:
    logger.error(f"Invalid JSON: {e}")
    result = None
except KeyError as e:
    logger.warning(f"Missing key: {e}")
    result = None
except Exception:
    logger.exception("Unexpected")   # exception() = error() + traceback
    raise                              # перебросить дальше
else:
    # выполнится только если НЕ было исключения в try
    logger.info(f"Got user_id={result}")
finally:
    # выполнится ВСЕГДА — успех, исключение или return/break
    connection.close()

Не ловить BaseException напрямую — там KeyboardInterrupt (Ctrl+C) и SystemExit. Пользователь не сможет прервать программу.

def divide(a, b):
    if b == 0:
        raise ValueError("cannot divide by zero")
    return a / b

# Перебросить с сохранением контекста
try:
    do_something()
except Exception as e:
    raise RuntimeError("failed") from e
    # traceback покажет ОБА — оригинал не потерян

# Голый raise — только внутри except, перебрасывает текущее
try:
    ...
except Exception:
    log("got exception")
    raise

class OrderError(Exception):
    """Base для всех доменных ошибок заказов."""

class OrderNotFound(OrderError):
    pass

class InsufficientStock(OrderError):
    def __init__(self, sku, requested, available):
        super().__init__(f"SKU {sku}: need {requested}, have {available}")
        self.sku = sku
        self.requested = requested
        self.available = available

# Ловим одним except по базовому классу
try:
    place_order(...)
except OrderError as e:
    logger.error(f"Order failed: {e}")

Свой класс — когда обработчик выше по стеку должен различать типы ошибок. Внутри одного модуля обычные ValueError/RuntimeError сойдут.

Гарантированное освобождение ресурсов даже при исключении. Аналог try/finally, только короче:

# Без with — легко забыть закрыть
f = open("data.txt")
data = f.read()
f.close()                          # не выполнится если read() кинет

# С with — close автоматически
with open("data.txt") as f:
    data = f.read()

# Несколько ресурсов сразу
with open("in.txt") as src, open("out.txt", "w") as dst:
    dst.write(src.read())

Свой context manager — через декоратор @contextmanager:

from contextlib import contextmanager

@contextmanager
def db_transaction(conn):
    conn.begin()
    try:
        yield conn
        conn.commit()
    except:
        conn.rollback()
        raise

with db_transaction(conn) as tx:
    tx.execute(...)

Два подхода к «а вдруг что-то пойдёт не так»:

if "key" in d:
    v = d["key"]

try:
    v = d["key"]
except KeyError:
    v = None

Питоничнее — EAFP, но не догматично. d.get("key") ещё короче. Правило: EAFP когда «в обычном случае получится, ошибка — редкая»; LBYL когда «проверка дешёвая, ошибка ожидаема».

# Всегда через with — гарантированное закрытие
with open("data.txt", encoding="utf-8") as f:
    content = f.read()

# Режимы
open(path, "r")                # чтение (default) — если файла нет, FileNotFoundError
open(path, "w")                # запись — создаст / ПЕРЕЗАПИШЕТ
open(path, "a")                # append — создаст / допишет в конец
open(path, "x")                # exclusive create — упадёт если файл есть
open(path, "r+")               # чтение + запись
open(path, "rb")               # binary read (для картинок, PDF)
open(path, "wb")               # binary write

# Три способа чтения
with open("log.txt") as f:
    all_at_once = f.read()          # одна строка
    # или
    lines = f.readlines()           # список строк (все в память)
    # или (лучший для больших файлов) — построчно
    for line in f:
        process(line.rstrip())        # O(1) память

# Запись
with open("out.txt", "w", encoding="utf-8") as f:
    f.write("one line\n")
    f.writelines(["a\n", "b\n"])   # не добавит \n сам!

Забудь про os.path.join, os.path.exists, os.listdir. pathlib (Python 3.4+) — ООП-обёртка, чище и переносимо.

from pathlib import Path

p = Path("/var/log/app.log")
p = Path("data") / "users.json"       # склейка через /
p = Path.home() / ".config" / "app"     # $HOME/.config/app

# Свойства
p.name                          # "app.log"
p.stem                          # "app" (без расширения)
p.suffix                        # ".log"
p.parent                        # Path("/var/log")
p.parts                         # ("/", "var", "log", "app.log")
p.absolute()                    # абсолютный путь

# Проверки
p.exists()
p.is_file()
p.is_dir()

# Операции
p.mkdir(parents=True, exist_ok=True)     # создать директорию (рекурсивно, no-op если есть)
p.unlink(missing_ok=True)                # удалить файл
p.rename(Path("new_name.log"))
p.rmdir()                                # удалить пустую директорию

# Обход директории
for item in Path(".").iterdir():           # прямые потомки
    print(item)

for py in Path("src").rglob("*.py"):       // рекурсивно по glob
    print(py)

# Чтение / запись — методы прямо на Path
text = Path("config.txt").read_text(encoding="utf-8")
Path("out.txt").write_text("hello", encoding="utf-8")
data = Path("image.png").read_bytes()

import json

# Из строки → Python-объект
data = json.loads('{"name": "Alice", "age": 30}')
# data = {"name": "Alice", "age": 30}

# Python-объект → строку
s = json.dumps(data)
s = json.dumps(data, indent=2, ensure_ascii=False)
# ensure_ascii=False — не эскейпить кириллицу в \uXXXX

# Из / в файл — load/dump без "s"
with open("data.json", encoding="utf-8") as f:
    data = json.load(f)

with open("out.json", "w", encoding="utf-8") as f:
    json.dump(data, f, indent=2, ensure_ascii=False)

# Соответствия типов
# JSON     → Python
# object   → dict
# array    → list
# string   → str
# number   → int / float
# true     → True
# null     → None

# Ошибки
try:
    data = json.loads(payload)
except json.JSONDecodeError as e:
    logger.error(f"bad JSON: {e}")

import csv

# Чтение — обычные списки-строки
with open("users.csv", encoding="utf-8") as f:
    reader = csv.reader(f)
    header = next(reader)          # первая строка — обычно шапка
    for row in reader:
        print(row)              # ['Alice', '30', 'a@b.c']

# Чтение как dict — DictReader (питоничнее)
with open("users.csv", encoding="utf-8") as f:
    for row in csv.DictReader(f):
        print(row["name"], row["email"])

# Запись
with open("out.csv", "w", encoding="utf-8", newline="") as f:
    # newline="" — обязательно, иначе на Windows \r\r\n
    writer = csv.DictWriter(f, fieldnames=["name", "age"])
    writer.writeheader()
    writer.writerow({"name": "Alice", "age": 30})
    writer.writerows([{"name": "Bob", "age": 25}])

# Кастомный разделитель — TSV, semicolon
reader = csv.reader(f, delimiter=";")

Декоратор — функция, принимающая другую функцию и возвращающая новую (обычно с дополнительным поведением до/после вызова). Синтаксис @decorator — просто сахар над func = decorator(func).

# Простой декоратор — измеряет время выполнения
import time
from functools import wraps

def timed(func):
    @wraps(func)                     # сохраняет __name__/__doc__ оригинала
    def wrapper(*args, **kwargs):
        start = time.perf_counter()
        result = func(*args, **kwargs)
        elapsed = time.perf_counter() - start
        print(f"{func.__name__} took {elapsed:.3f}s")
        return result
    return wrapper

@timed
def slow_calc(n):
    time.sleep(1)
    return n * 2

slow_calc(5)
# slow_calc took 1.001s
# 10

Эквивалент без синтаксиса @:

def slow_calc(n): ...
slow_calc = timed(slow_calc)   # ровно то же самое

# Retry с настраиваемым числом попыток
def retry(times=3, delay=1.0):
    def decorator(func):
        @wraps(func)
        def wrapper(*args, **kwargs):
            last_error = None
            for attempt in range(times):
                try:
                    return func(*args, **kwargs)
                except Exception as e:
                    last_error = e
                    time.sleep(delay)
            raise last_error
        return wrapper
    return decorator

@retry(times=5, delay=0.5)
def fetch_url(url):
    return requests.get(url)

Три уровня функций: retry(times=3) возвращает decorator, тот принимает func, а wrapper уже делает работу. Синтаксический сахар разворачивается в fetch_url = retry(times=5, delay=0.5)(fetch_url).

from functools import cache

@cache
def fib(n):
    if n < 2: return n
    return fib(n-1) + fib(n-2)

fib(100)     # мгновенно — благодаря кешу

# Flask
@app.route("/users/<int:id>")
def get_user(id): ...

# FastAPI
@app.get("/users/{id}")
def get_user(id: int): ...

# pytest — параметризация тестов
@pytest.mark.parametrize("a, expected", [(1, 2), (2, 4)])
def test_double(a, expected):
    assert double(a) == expected

# Django — авторизация
@login_required
def profile(request): ...

# Переменные
name: str = "Alice"
age: int = 30
is_active: bool = True
tags: list[str] = ["php", "python"]
user: dict[str, int] = {"age": 30}

# Функции
def greet(name: str, times: int = 1) -> str:
    return (f"Hi {name}! ") * times

# Возврат None (void в других языках)
def log_it(msg: str) -> None:
    print(msg)

# Классы
class User:
    name: str
    age: int

    def __init__(self, name: str, age: int) -> None:
        self.name = name
        self.age = age

# X | None — может быть X или None (Python 3.10+)
def find_user(id: int) -> User | None:
    ...

# Legacy до 3.10 (ещё встречается)
from typing import Optional
def find_user(id: int) -> Optional[User]:
    ...

# Union — X или Y или Z
def parse(value: str | int | float) -> float:
    ...

# Коллекции с несколькими типами внутри
users: list[User | Admin] = [...]

В новом коде — только list/dict/|. Импорты из typing для этих типов больше не нужны.

from typing import Any, Callable, Literal, Final, TypedDict, Protocol

# Any — «выключить» type-check (использовать в крайних случаях)
def parse_json(s: str) -> Any:
    return json.loads(s)

# Callable — функция как аргумент
def apply(func: Callable[[int, int], int], a: int, b: int) -> int:
    return func(a, b)

# Literal — конкретные значения
def set_status(status: Literal["active", "paused", "stopped"]) -> None:
    ...
set_status("active")     #
set_status("deleted")    # mypy error

# Final — константа, mypy запретит перезаписать
MAX_RETRIES: Final[int] = 3

# TypedDict — структура словаря
class UserDict(TypedDict):
    name: str
    age: int
    email: str | None

def save_user(u: UserDict) -> None: ...

# Protocol — duck typing со статической проверкой
class HasName(Protocol):
    name: str

def greet(obj: HasName) -> str:
    return f"Hi {obj.name}"
# Работает с любым классом у которого есть поле name — независимо от наследования

# Установка
uv add --dev mypy

# Запуск
mypy app.py
mypy src/

# Конфиг — pyproject.toml
[tool.mypy]
python_version = "3.13"
strict = true                    # все проверки на максимум
warn_unused_ignores = true
disallow_untyped_defs = true

# Игнорировать одну строку
result = something_weird()  # type: ignore[assignment]

# Игнорировать модуль без типов
[[tool.mypy.overrides]]
module = "legacy_lib.*"
ignore_missing_imports = true

HTTP-запрос к БД, вызов внешнего API, чтение файла — во всех случаях процесс ждёт I/O. Синхронный код в этот момент блокирует поток. Async позволяет одному потоку обслуживать сотни одновременных операций I/O — пока один запрос ждёт БД, поток обрабатывает другие.

Когда нужен async:

• HTTP API с тысячами RPS (FastAPI async — стандарт)
• WebSocket-серверы, real-time
• Web-scrapers — тысячи параллельных запросов
• Микросервисы с множеством внешних вызовов

Когда НЕ нужен: CPU-heavy вычисления (тут async не помогает — нужен multiprocessing), простые CRUD с 5 RPS, скрипты. Не тащить async туда, где он не нужен — иначе получишь сложный код без выигрыша.

import asyncio

# async def создаёт корутину, не исполняет функцию сразу
async def fetch_user(id: int) -> dict:
    await asyncio.sleep(1)          # эмуляция I/O
    return {"id": id, "name": "Alice"}

# Обычный вызов вернёт корутину, не результат:
fetch_user(1)         # <coroutine object fetch_user at 0x...>

# Правильный запуск — только через event loop:
result = asyncio.run(fetch_user(1))

# await — только внутри async def
async def main():
    user = await fetch_user(1)      # дождались, получили dict
    print(user)

asyncio.run(main())

async def fetch_user(id):
    await asyncio.sleep(1)
    return {"id": id}

# Последовательно — 3 секунды
async def bad():
    a = await fetch_user(1)
    b = await fetch_user(2)
    c = await fetch_user(3)

# Параллельно — 1 секунда
async def good():
    a, b, c = await asyncio.gather(
        fetch_user(1),
        fetch_user(2),
        fetch_user(3),
    )

# Обработка ошибок в gather
results = await asyncio.gather(*tasks, return_exceptions=True)
# исключения будут В списке, не бросят весь gather

# Timeout — Python 3.11+
async def get_with_timeout():
    async with asyncio.timeout(5.0):
        return await slow_operation()

# Legacy до 3.11 — wait_for
result = await asyncio.wait_for(slow_operation(), timeout=5.0)

# Создать задачу в фоне — не блокировать текущую функцию
task = asyncio.create_task(background_job())
print("main continues...")
await task                       # дождаться когда потребуется
task.cancel()                    # можно отменить

# HTTP через httpx (async-first, поддерживает и sync)
import httpx

async def fetch_all(urls):
    async with httpx.AsyncClient() as client:
        tasks = [client.get(url) for url in urls]
        responses = await asyncio.gather(*tasks)
        return [r.json() for r in responses]

# БД через asyncpg (PostgreSQL)
import asyncpg

async def get_users():
    conn = await asyncpg.connect("postgresql://...")
    rows = await conn.fetch("SELECT id, name FROM users")
    await conn.close()
    return rows

# SQLAlchemy 2.0 async
from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession

engine = create_async_engine("postgresql+asyncpg://...")
async with AsyncSession(engine) as session:
    result = await session.execute(select(User))
    users = result.scalars().all()

Iterable — объект, у которого есть __iter__(). Возвращает iterator. Iterator — объект с __next__(), возвращает следующий элемент, кидает StopIteration когда всё кончилось. for x in obj: — сахар над этим протоколом.

# Внутри for крутится примерно вот это:
it = iter(users)          # получить iterator из iterable
while True:
    try:
        user = next(it)     # next() зовёт __next__()
    except StopIteration:
        break
    process(user)

# Свой iterator — редко, обычно используем генератор (см. ниже)
class Counter:
    def __init__(self, limit): self.n, self.limit = 0, limit
    def __iter__(self): return self
    def __next__(self):
        if self.n >= self.limit: raise StopIteration
        self.n += 1
        return self.n

for i in Counter(3): print(i)     # 1, 2, 3

Функция с yield — генератор. При вызове не выполняется сразу, возвращает generator-объект. Каждый next() исполняет до следующего yield, потом заморозит состояние.

def count_up_to(limit):
    n = 1
    while n <= limit:
        yield n
        n += 1

gen = count_up_to(3)   # НИЧЕГО не выполнилось; gen — генератор-объект
next(gen)               # 1
next(gen)               # 2
next(gen)               # 3
next(gen)               # StopIteration

# Обычно через for
for n in count_up_to(10):
    print(n)

# Или превратить в list (загрузит всё в память)
list(count_up_to(100))

Главный use-case: обработка больших потоков данных без загрузки всего в память.

# Загрузим весь 10GB лог в память — OOM
def read_all(path):
    with open(path) as f:
        return f.readlines()      # list всех строк

# Читаем по строке, память O(1)
def read_lazy(path):
    with open(path) as f:
        for line in f:
            yield line.rstrip()

# Пайплайн — можно накладывать фильтры/преобразования лениво
def errors_only(lines):
    for line in lines:
        if "ERROR" in line:
            yield line

def parse_json(lines):
    for line in lines:
        yield json.loads(line)

# Читаем 10GB, фильтруем, парсим — всё лениво, память O(1)
for event in parse_json(errors_only(read_lazy("app.log"))):
    save_to_db(event)

def flatten(matrix):
    for row in matrix:
        yield from row              # yield каждого элемента row

# Эквивалент:
# for row in matrix:
#     for x in row:
#         yield x

list(flatten([[1, 2], [3, 4]]))   # [1, 2, 3, 4]

from itertools import chain, islice, batched

# Соединить несколько источников
for item in chain(users_db, users_api, users_cache):
    ...

# Взять первые 100 из бесконечного generator
for line in islice(read_lazy("huge.log"), 100):
    ...

# Батчи по 100 — для bulk-INSERT в БД
for chunk in batched(records, 100):
    User.bulk_create(chunk)

Django (с 2005) — full-stack framework: ORM, миграции, admin-панель, auth, templates, sessions, forms, i18n. По философии — batteries included: почти всё что нужно для сайта, уже внутри.

На чём построены: Instagram, Pinterest, Disqus, Bitbucket, Mozilla, Washington Post. К 2026 — по-прежнему стандарт для «сайта с админкой», но для чистых API проиграл FastAPI.

uv add django
uv run django-admin startproject myapp .
uv run python manage.py startapp users
uv run python manage.py migrate
uv run python manage.py runserver
# http://localhost:8000

Структура:

myapp/
├── manage.py                # CLI как artisan
├── myapp/
│   ├── settings.py          # конфиг всего
│   ├── urls.py              # роуты
│   ├── wsgi.py / asgi.py    # entry points для сервера
├── users/                   # app
│   ├── models.py            # модели БД
│   ├── views.py             # контроллеры
│   ├── urls.py
│   ├── admin.py             # регистрация в admin-панели
│   ├── migrations/
│   └── templates/

Django-версия MVC. «View» здесь — не то же, что вью в Laravel: это контроллер. «Template» — HTML-шаблон (Blade-аналог).

# users/models.py
from django.db import models

class User(models.Model):
    name = models.CharField(max_length=100)
    email = models.EmailField(unique=True)
    created_at = models.DateTimeField(auto_now_add=True)

    def __str__(self):
        return self.name

# users/views.py
from django.shortcuts import render, get_object_or_404
from .models import User

def user_list(request):
    users = User.objects.all()
    return render(request, "users/list.html", {"users": users})

def user_detail(request, pk):
    user = get_object_or_404(User, pk=pk)
    return render(request, "users/detail.html", {"user": user})

# users/urls.py
from django.urls import path
from . import views

urlpatterns = [
    path("", views.user_list, name="user_list"),
    path("<int:pk>/", views.user_detail, name="user_detail"),
]

Template (аналог Blade):

<!-- users/templates/users/list.html -->
{% extends "base.html" %}

{% block content %}
<ul>
    {% for user in users %}
        <li><a href="{% url 'user_detail' user.pk %}">{{ user.name }}</a></li>
    {% empty %}
        <li>Пользователей нет</li>
    {% endfor %}
</ul>
{% endblock %}

# CRUD
u = User.objects.create(name="Alice", email="a@b.c")
User.objects.get(pk=1)                             # найти один или DoesNotExist
User.objects.filter(name__startswith="A")             # QuerySet
User.objects.exclude(is_active=False)
User.objects.filter(age__gte=18, name__icontains="ali")

# Обновление
u.name = "Bob"
u.save()

# Bulk update
User.objects.filter(is_active=False).update(archived=True)

# Удаление
u.delete()

# Связи (аналог relations в Eloquent)
class Post(models.Model):
    author = models.ForeignKey(User, on_delete=models.CASCADE, related_name="posts")
    title = models.CharField(max_length=200)

# Обход:
user.posts.all()                    # все посты юзера
post.author.name                    # автор поста

# Оптимизация N+1
User.objects.prefetch_related("posts")          # посты одним запросом
Post.objects.select_related("author")             # join с author

# Агрегация
from django.db.models import Count, Sum, Avg
User.objects.annotate(posts_count=Count("posts"))
User.objects.aggregate(total_age=Sum("age"))

# Сгенерировать по изменениям в models.py
python manage.py makemigrations
# Migrations for 'users':
#   users/migrations/0002_user_phone.py

# Применить
python manage.py migrate

# Откатить
python manage.py migrate users 0001

# SQL который выполнится
python manage.py sqlmigrate users 0002

В отличие от Laravel — ORM автогенерит миграции сам. Меняешь models.py, запускаешь makemigrations — Django поймёт диф и напишет миграцию.

# users/admin.py
from django.contrib import admin
from .models import User

@admin.register(User)
class UserAdmin(admin.ModelAdmin):
    list_display = ["name", "email", "created_at"]
    list_filter = ["is_active"]
    search_fields = ["name", "email"]
    ordering = ["-created_at"]

Одна регистрация — и в /admin/ получаешь готовую CRUD-панель с фильтрами, поиском, пермишенами. Это причина почему Django до сих пор берут для внутренних систем и админок.

Для API поверх Django ставят DRF — отдельный пакет:

uv add djangorestframework

# users/serializers.py — аналог Pydantic-моделей
from rest_framework import serializers
from .models import User

class UserSerializer(serializers.ModelSerializer):
    class Meta:
        model = User
        fields = ["id", "name", "email", "created_at"]

# users/views.py
from rest_framework import viewsets
from .models import User
from .serializers import UserSerializer

class UserViewSet(viewsets.ModelViewSet):
    queryset = User.objects.all()
    serializer_class = UserSerializer
# Всё — 5 CRUD endpoints готовы (GET list, POST create, GET/PUT/DELETE detail)

FastAPI — современный async-first веб-фреймворк на type hints (Python 3.7+, актив с 2018, к 2026 — #1 выбор для нового Python-API). Основан на Starlette (ASGI) + Pydantic (валидация). Даёт из коробки: async endpoints, автоматическая валидация вход/выхода по type hints, автогенерация OpenAPI и Swagger UI, DI через Depends().

uv init my-api && cd my-api
uv add fastapi uvicorn[standard]

# main.py
from fastapi import FastAPI

app = FastAPI()

@app.get("/")
async def root():
    return {"status": "ok"}

@app.get("/users/{user_id}")
async def get_user(user_id: int):
    return {"id": user_id}

uv run uvicorn main:app --reload
# http://localhost:8000
# http://localhost:8000/docs — Swagger UI автоматом
# http://localhost:8000/redoc — ReDoc

from pydantic import BaseModel, Field, EmailStr

class CreateUserRequest(BaseModel):
    name: str = Field(min_length=2, max_length=50)
    email: EmailStr
    age: int = Field(ge=18, le=120)
    role: Literal["user", "admin"] = "user"

class UserResponse(BaseModel):
    id: int
    name: str
    email: str

@app.post("/users", response_model=UserResponse, status_code=201)
async def create_user(payload: CreateUserRequest) -> UserResponse:
    # payload — уже провалидирован, все типы правильные
    user = await user_service.create(payload)
    return user      # автоматом сериализуется по UserResponse (hide-hostile поля)

Что делает Pydantic:

• Приходит {"age": "30"} (string) → сконвертит в int автоматически
• Приходит {"age": "abc"} → 422 с "value is not a valid integer"
• Приходит {"email": "not-email"} → 422 с "value is not a valid email"
• Приходит лишние поля — игнорируются (или бросается ошибка если model_config = {"extra": "forbid"})
• response_model обрезает вывод — password не утечёт даже если в объекте есть

Laravel-аналог: Pydantic-модель ≈ FormRequest (валидация) + Eloquent (типы) + JsonResource (сериализация) в одном классе.

from fastapi import Query, Path

@app.get("/users/{user_id}/orders")
async def list_orders(
    user_id: int = Path(gt=0),                # из URL
    limit: int = Query(10, ge=1, le=100),      # ?limit=10
    status: str | None = None,                # ?status=paid (опц.)
    tag: list[str] = Query(default_factory=list),  # ?tag=a&tag=b
):
    ...

@app.post("/orders")
async def create_order(payload: OrderRequest):     # Pydantic — из body
    ...

Правило: FastAPI сам различает по типу. Path-параметр {user_id} в URL — берёт оттуда. Простые типы (int, str, bool) — из query. Pydantic-модель — из body JSON.

from fastapi import Depends, HTTPException, status

# Общий provider — сессия БД
async def get_db() -> AsyncSession:
    async with AsyncSession(engine) as session:
        yield session

# Auth-проверка
async def current_user(
    token: str = Depends(oauth2_scheme),
    db: AsyncSession = Depends(get_db),
) -> User:
    user = await verify_jwt(token, db)
    if not user:
        raise HTTPException(status.HTTP_401_UNAUTHORIZED)
    return user

# Использование — DI по типу параметра
@app.get("/me")
async def read_me(user: User = Depends(current_user)) -> User:
    return user

# Depends можно повесить на роут — auth ко всем эндпоинтам роутера
router = APIRouter(dependencies=[Depends(current_user)])

Как это работает: FastAPI смотрит на аннотации параметров и рекурсивно резолвит зависимости. get_db возвращает через yield → это context manager, сессия закроется после ответа. Кешируется в рамках запроса (одна БД-сессия на весь request).

myapi/
├── pyproject.toml
├── uv.lock
├── .env                       # DATABASE_URL, SECRET_KEY, ...
├── main.py                    # FastAPI() + include_router
├── src/
│   ├── config.py              # pydantic-settings — типизированный env
│   ├── database.py            # engine, get_db()
│   ├── auth/
│   │   ├── router.py          # /login, /register
│   │   ├── schemas.py         # Pydantic-модели входа/выхода
│   │   ├── service.py         # бизнес-логика
│   │   ├── models.py          # SQLAlchemy-модели
│   │   └── deps.py            # current_user, etc
│   ├── users/
│   │   └── ...
│   └── orders/
│       └── ...
└── tests/
    └── ...

# main.py
from fastapi import FastAPI
from src.auth.router import router as auth_router
from src.users.router import router as users_router

app = FastAPI(title="My API", version="1.0")
app.include_router(auth_router, prefix="/auth", tags=["auth"])
app.include_router(users_router, prefix="/users", tags=["users"])

from fastapi import HTTPException

@app.get("/users/{id}")
async def get_user(id: int):
    user = await find(id)
    if not user:
        raise HTTPException(status_code=404, detail="User not found")
    return user

# Глобальный обработчик кастомного исключения
from fastapi.responses import JSONResponse

@app.exception_handler(OrderError)
async def order_error_handler(request, exc: OrderError):
    return JSONResponse(
        status_code=400,
        content={"error": str(exc), "type": exc.__class__.__name__},
    )

Flask (с 2010) — микрофреймворк: даёт роутинг + шаблоны + request/response. Всё остальное (ORM, форма, auth) — плагины по выбору. Долгое время был «PHP для Python» — быстро написать что-то маленькое.

К 2026: уступает FastAPI. Для нового кода выбирают FastAPI (async + type hints + автодоки). Flask остался в: legacy-системах, обучении (простой для входа), небольших скриптах-веб-инструментах.

uv add flask

# app.py
from flask import Flask, request, jsonify

app = Flask(__name__)

@app.route("/")
def home():
    return "Hello!"

@app.route("/users/<int:user_id>", methods=["GET"])
def get_user(user_id):
    return jsonify({"id": user_id, "name": "Alice"})

@app.route("/users", methods=["POST"])
def create_user():
    data = request.get_json()          # ручной парсинг
    if not data or "name" not in data:
        return jsonify({"error": "name required"}), 400
    return jsonify({"created": data}), 201

if __name__ == "__main__":
    app.run(debug=True)

python app.py
# http://localhost:5000

Обрати внимание — валидация вручную (сравни с Pydantic в FastAPI, где просто аннотация типа). Это основной минус.

В сумме получается тот же Django, только собираешь его сам из кубиков.

• Мини-скрипт с 3-5 endpoint'ами (webhook receiver, health-check server)
• Проект на legacy Python 2 / 3.6 (FastAPI требует 3.7+)
• Обучение — синтаксис проще чем у FastAPI, меньше «магии»
• Работаешь в существующем Flask-проекте

Для нового REST-API в 2026 — берут FastAPI, не Flask. Скорость разработки выше за счёт Pydantic и автодоки.

Крупные компании часто смешивают:

• Django — «основной сайт» с админкой + бизнес-логика
• FastAPI — новые публичные API-эндпоинты, микросервисы, ML-inference
• Общая база данных через одну ORM (обычно SQLAlchemy)

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

Для нового backend-проекта на FastAPI — стандарт SQLAlchemy 2.0 async. Для Django-проекта — Django ORM (входит).

psycopg (v3, 2021) — актуальный драйвер PostgreSQL. Старая версия psycopg2 — legacy, но ещё популярна. Аналог PDO — прямой доступ к SQL.

uv add "psycopg[binary]"

import psycopg

with psycopg.connect("postgresql://user:pass@localhost/mydb") as conn:
    with conn.cursor() as cur:
        # SELECT с параметрами (защита от SQL-injection)
        cur.execute("SELECT id, name FROM users WHERE age > %s", (18,))
        rows = cur.fetchall()          # list of tuples
        for id, name in rows:
            print(id, name)

        # INSERT + RETURNING
        cur.execute(
            "INSERT INTO users (name, email) VALUES (%s, %s) RETURNING id",
            ("Alice", "a@b.c"),
        )
        new_id = cur.fetchone()[0]

    conn.commit()

# Row factory — получить dict вместо tuple
from psycopg.rows import dict_row
with psycopg.connect(DSN, row_factory=dict_row) as conn:
    with conn.cursor() as cur:
        cur.execute("SELECT id, name FROM users")
        for row in cur:
            print(row["name"])

SQLAlchemy — de-facto ORM в Python-экосистеме (кроме Django-проектов). Версия 2.0 (2023) кардинально переработана: новый API, полноценный async, отличные type hints.

uv add "sqlalchemy[asyncio]" "asyncpg"

# models.py — декларация моделей
from sqlalchemy.orm import DeclarativeBase, Mapped, mapped_column
from sqlalchemy import String, ForeignKey
from datetime import datetime

class Base(DeclarativeBase): pass

class User(Base):
    __tablename__ = "users"

    id: Mapped[int] = mapped_column(primary_key=True)
    name: Mapped[str] = mapped_column(String(100))
    email: Mapped[str] = mapped_column(String(200), unique=True)
    created_at: Mapped[datetime] = mapped_column(default=datetime.utcnow)

# database.py — async engine + session
from sqlalchemy.ext.asyncio import create_async_engine, AsyncSession, async_sessionmaker

engine = create_async_engine("postgresql+asyncpg://user:pass@localhost/mydb")
AsyncSessionLocal = async_sessionmaker(engine, expire_on_commit=False)

async def get_db():                     # для FastAPI Depends()
    async with AsyncSessionLocal() as session:
        yield session

# Использование в FastAPI
from sqlalchemy import select, insert, update, delete

@app.get("/users/{id}")
async def get_user(id: int, db: AsyncSession = Depends(get_db)):
    # SELECT one
    user = await db.get(User, id)
    if not user:
        raise HTTPException(404)
    return user

@app.get("/users")
async def list_users(db: AsyncSession = Depends(get_db)):
    # SELECT many
    stmt = select(User).where(User.name.ilike("a%")).limit(100)
    result = await db.execute(stmt)
    return result.scalars().all()

@app.post("/users")
async def create_user(payload: CreateUserRequest, db: AsyncSession = Depends(get_db)):
    user = User(name=payload.name, email=payload.email)
    db.add(user)
    await db.commit()
    await db.refresh(user)                # подтянуть id, created_at
    return user

# Связь один-ко-многим
class Post(Base):
    __tablename__ = "posts"
    id: Mapped[int] = mapped_column(primary_key=True)
    author_id: Mapped[int] = mapped_column(ForeignKey("users.id"))
    title: Mapped[str]
    author: Mapped["User"] = relationship(back_populates="posts")

class User(Base):
    ...
    posts: Mapped[list["Post"]] = relationship(back_populates="author")

# Оптимизация — selectinload = prefetch, joinedload = JOIN
from sqlalchemy.orm import selectinload

stmt = select(User).options(selectinload(User.posts))
# Один запрос за юзерами + один за всеми постами (через IN)

# Без — N+1: SELECT users, потом на каждого — SELECT posts

Стандарт для миграций SQLAlchemy. Работает как artisan migrate в Laravel — генерация SQL по diff моделей.

uv add alembic

alembic init migrations              # создать конфиг

# Настроить alembic/env.py — указать target_metadata = Base.metadata

# Автогенерация по diff моделей
alembic revision --autogenerate -m "add users table"

# Применить все миграции
alembic upgrade head

# Откатить одну
alembic downgrade -1

# Показать текущую версию
alembic current

# История
alembic history

Для нового кода — httpx. requests — для legacy или совсем маленьких скриптов.

uv add httpx

import httpx

# GET
r = httpx.get("https://api.example.com/users/1")
r.status_code                       # 200
r.text                              # raw body как строка
r.json()                            # JSON → dict
r.headers["content-type"]

# Query params
r = httpx.get("https://api.ex.com/search", params={"q": "python", "limit": 10})
# автосклейка → ?q=python&limit=10

# POST JSON
r = httpx.post("https://api.ex.com/users", json={"name": "Alice"})
# Content-Type: application/json автоматически

# POST form-data
r = httpx.post(url, data={"name": "Alice"})
# Content-Type: application/x-www-form-urlencoded

# POST file (multipart)
with open("img.png", "rb") as f:
    r = httpx.post(url, files={"image": f})

# Headers
r = httpx.get(url, headers={"Authorization": f"Bearer {token}"})

# Timeout
r = httpx.get(url, timeout=10.0)     # обязательно ставить!

# Обработка ошибок HTTP-статусов
r.raise_for_status()                # бросит HTTPStatusError если 4xx/5xx

Прямой вызов httpx.get() — каждый раз новое TCP-соединение. Для 10+ запросов к одному хосту используй Client:

# Sync client
with httpx.Client(
    base_url="https://api.example.com",
    headers={"Authorization": f"Bearer {token}"},
    timeout=10.0,
) as client:
    r1 = client.get("/users/1")
    r2 = client.get("/users/2")
    r3 = client.post("/users", json={...})
# Соединение переиспользуется, ~10× быстрее

import asyncio, httpx

async def fetch_all(urls):
    async with httpx.AsyncClient(timeout=10.0) as client:
        tasks = [client.get(u) for u in urls]
        responses = await asyncio.gather(*tasks)
        return [r.json() for r in responses]

data = asyncio.run(fetch_all(["url1", "url2", "url3"]))
# Три запроса параллельно

В httpx/requests нет retry из коробки. Стандарт — библиотека tenacity:

uv add tenacity

from tenacity import retry, stop_after_attempt, wait_exponential

@retry(
    stop=stop_after_attempt(3),
    wait=wait_exponential(multiplier=1, min=2, max=10),
)
def fetch(url):
    r = httpx.get(url, timeout=5.0)
    r.raise_for_status()
    return r.json()

uv add --dev respx pytest

import respx, httpx, pytest

@respx.mock
def test_fetch_user():
    route = respx.get("https://api.ex.com/users/1").mock(
        return_value=httpx.Response(200, json={"id": 1, "name": "Alice"})
    )
    result = fetch_user(1)
    assert result["name"] == "Alice"
    assert route.called

NumPy — библиотека для работы с многомерными массивами (ndarray) и векторизованных вычислений. На нём построены Pandas, scikit-learn, PyTorch, TensorFlow, SciPy. Для ML — обязательный фундамент.

uv add numpy

import numpy as np      # общепринятый alias, всегда np

# Из Python-списка
a = np.array([1, 2, 3, 4])                # 1D — вектор
b = np.array([[1, 2, 3], [4, 5, 6]])     # 2D — матрица
c = np.array([[[1], [2]], [[3], [4]]]) # 3D — тензор

# Из «шаблонов»
np.zeros((3, 4))                       # матрица 3×4 из нулей
np.ones((2, 3))                        # из единиц
np.full((2, 2), 7)                     # заполнить константой
np.eye(3)                              # единичная 3×3
np.arange(0, 10, 2)                    # [0, 2, 4, 6, 8] — как range
np.linspace(0, 1, 11)                  # 11 точек от 0 до 1

# Случайные
np.random.rand(3, 4)                    # uniform [0, 1)
np.random.randn(3, 4)                   # normal (0, 1)
np.random.randint(0, 10, size=(2, 3))    # целые

# Свойства
a.shape                             # (4,) — размеры
b.shape                             # (2, 3)
a.ndim                              # 1 — размерность
b.ndim                              # 2
a.dtype                             # int64 — тип элементов
a.size                              # 4 — общее число элементов

a = np.array([1, 2, 3, 4])

# Арифметика — поэлементно, БЕЗ циклов
a * 2              # [2, 4, 6, 8]
a + 10             # [11, 12, 13, 14]
a ** 2             # [1, 4, 9, 16]
a > 2              # [False, False, True, True]  — булева маска

# Между массивами — тоже поэлементно
b = np.array([10, 20, 30, 40])
a + b               # [11, 22, 33, 44]
a * b               # [10, 40, 90, 160]  — НЕ матричное умножение
a @ b               # 300 — скалярное произведение (dot product)

# Универсальные функции (ufuncs) — векторизованные
np.sqrt(a)          # [1., 1.41, 1.73, 2.]
np.exp(a)           # e^x
np.log(a)           # ln
np.sin(a)
np.abs(a)

NumPy автоматически «растягивает» меньший массив, если операция это допускает. Одно из самых мощных свойств.

a = np.array([[1, 2, 3],       # shape (2, 3)
              [4, 5, 6]])
row = np.array([10, 20, 30])       # shape (3,)

a + row
# [[11, 22, 33],
#  [14, 25, 36]]
# row «растянут» на 2 строки, потом поэлементно

# Классический use-case: нормализация features
# X shape (n_samples, n_features), mean shape (n_features,)
X_normalized = (X - X.mean(axis=0)) / X.std(axis=0)