Pydantic V2: Забываем root_validator, используем model_validator правильно

Переход на Pydantic V2, это не только ускорение за счет ядра на Rust, но и переосмысление валидации. Самая частая боль при миграции, проверка зависимостей между несколькими полями.

В V1 мы использовали root_validator и работали со словарем values (прощай, автодополнение IDE). В V2 правильный путь - model_validator в режиме after.

В чем соль?
В режиме mode='after' валидация запускается после того, как поля были распаршены и приведены к типам. Вы работаете с экземпляром класса (self), а не с сырым словарем.

Пример (валидация периода дат):

from pydantic import BaseModel, model_validator
from datetime import datetime

class DateRange(BaseModel):
    start_dt: datetime
    end_dt: datetime

    @model_validator(mode='after')
    def check_dates_order(self):
        # Обращаемся через self — IDE видит поля и их типы!
        if self.end_dt <= self.start_dt:
            raise ValueError("Дата окончания должна быть позже начала")
        return self

# Тест
try:
    DateRange(
        start_dt="2024-01-01T12:00:00", 
        end_dt="2023-01-01T12:00:00"
    )
except ValueError as e:
    print(e)

Нюансы для профи:

1. mode='before': Используйте только если вам нужно модифицировать сырые входные данные (например, JSON) до того, как Pydantic начнет их парсить. Это аналог pre=True из V1.
2. Производительность: Валидаторы на Python, это узкое горлышко. Если у вас HighLoad, старайтесь выразить ограничения через Field (например, ge, le), так как они отрабатывают на Rust-уровне, что значительно быстрее вызова python-функции.

Используйте возможности типизации на 100%.

#pydantic #fastapi #bestpractices #python

📲 Мы в MAX

👉@BookPython

🐍 Как улучшить читаемость кода в Python?

Читаемый код - это не роскошь, а необходимость. Если ваш код трудно понять, даже если он работает, это плохой код. Сегодня разберем несколько простых, но мощных приемов, которые сделают ваш код более понятным.

1️⃣ Используйте говорящие имена переменных
Плохой пример:

a = 10
b = 20
c = a + b

Хороший пример:

price = 10
tax = 20
total_cost = price + tax

Теперь сразу понятно, что делает код!

2️⃣ Разбивайте код на функции
Вместо длинных кусков кода, используйте функции:

def calculate_total(price, tax):
    return price + tax

total_cost = calculate_total(10, 20)

Теперь код можно переиспользовать и проще тестировать.

3️⃣ Следуйте PEP 8
Форматирование кода влияет на его читаемость. Например, пробелы вокруг операторов делают код более понятным:

# Плохо
total=price+tax
# Хорошо
total = price + tax

Пользуйтесь black или flake8, чтобы следить за стилем.

4️⃣ Избегайте магических чисел
Если в коде встречаются непонятные числа, лучше заменить их на константы:

# Плохо
if age > 18:
    print("Взрослый")

# Хорошо
LEGAL_AGE = 18
if age > LEGAL_AGE:
    print("Взрослый")

5️⃣ Используйте list comprehensions
Вместо:

numbers = [1, 2, 3, 4, 5]
squared_numbers = []
for num in numbers:
    squared_numbers.append(num ** 2)

Лучше:

squared_numbers = [num ** 2 for num in numbers]

Чище и лаконичнее!

Читаемый код делает разработку приятнее, ускоряет исправление багов и упрощает поддержку. Напишите в комментариях, какие еще приемы вы используете для улучшения читаемости кода! 👇

📲 Мы в MAX

👉@BookPython

📌 Декораторы в Python: как они работают и зачем нужны?

Сегодня я покажу вам, как работают декораторы в Python и зачем они вообще нужны.

Декораторы позволяют изменять поведение функций без изменения их кода. Они широко применяются в логировании, кешировании, управлении доступом и многом другом.

Допустим, у нас есть функция, которая просто выводит «Hello, world!»:

def greet():
    print("Hello, world!")

Теперь мы хотим, чтобы перед выполнением этой функции выполнялся какой-то код, например, логирование. Вместо изменения greet(), мы создадим декоратор:

def log_decorator(func):
    def wrapper():
        print(f"Вызов функции {func.__name__}")
        return func()
    return wrapper

И теперь используем его:

@log_decorator
def greet():
    print("Hello, world!")

greet()

👉 Вывод:

Вызов функции greet
Hello, world!

Как это работает?
1. Декоратор принимает функцию (func) в качестве аргумента.
2. Внутри создаётся вложенная функция wrapper(), которая выполняет дополнительную логику перед вызовом func().
3. wrapper() возвращается вместо func, фактически подменяя её.

Можно даже передавать аргументы в декорируемую функцию:

def log_decorator(func):
    def wrapper(*args, **kwargs):
        print(f"Вызов {func.__name__} с аргументами: {args}, {kwargs}")
        return func(*args, **kwargs)
    return wrapper

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

print(add(3, 5))

👉 Вывод:

Вызов add с аргументами: (3, 5), {}
8

🔥 Декораторы это мощный инструмент, который делает код чище и удобнее. Если ещё не использовали их в проектах, самое время попробовать!

А какие декораторы вы используете в своих проектах? Делитесь в комментариях! ⬇️

📲 Мы в MAX

👉@BookPython

Локальное окружение для начинающего ML-инженера

ML начинается с окружения. Разберём настройку Python-окружения, виртуальных сред, Jupyter и VS Code, а также структуру ML-проекта и управление зависимостями.

📌22 января в 18:00 МСК Открытый урок курса «Machine Learning»

Зарегистрироваться: https://vk.cc/cTC0sV

Реклама. ООО «Отус онлайн-образование», ОГРН 1177746618576

Профилируем Python в продакшене: почему cProfile не подходит, и чем хорош py-spy

Когда на проде начинает течь память или скачет CPU, первая мысль, подключить профайлер. Стандартный cProfile, это детерминированный профайлер. Он хукает каждый вызов функции.

📉 Цена: Оверхед может замедлить приложение в 2-5 раз. На нагруженном проде это означает добить сервис окончательно.

Для Live-систем нужен Sampling Profiler (сэмплирующий профайлер). Золотой стандарт сейчас - py-spy.

Как это работает?
py-spy написан на Rust. Он работает как внешний процесс, который читает память вашего Python-процесса (через системные вызовы, аналогично gdb). Он делает «снимки» стека вызовов с высокой частотой (по дефолту 100 раз в секунду).

✅ Результат: Оверхед стремится к нулю. Код инструментализировать не нужно. Рестарт сервиса не нужен.

Два главных режима работы:

1. Live View (как htop, но для функций)
Посмотреть в реальном времени, в каких функциях процесс проводит больше всего времени.

# Нужно только знать PID процесса
py-spy top --pid 12345

Вы увидите список функций, отсортированный по OwnTime (время внутри функции) и TotalTime (время с учетом дочерних вызовов).

2. Flame Graph (Огненный граф)
Для глубокого анализа лучше записать работу сервиса за период и визуализировать стек.

py-spy record -o profile.noscript --pid 12345 --duration 60

Вы получите SVG-файл. Чем шире полоска, тем больше времени занимает функция. Вертикаль - это глубина стека. Сразу видно, кто «съел» процессорное время.

Нюансы для Middle+:

- GIL: py-spy умеет показывать, держит ли функция GIL. Добавьте флаг --gil.
- Docker/K8s: Так как py-spy использует системный вызов ptrace, контейнеру нужны привилегии. В Kubernetes часто нужно добавить securityContext: capabilities: add: ["SYS_PTRACE"] подам, чтобы иметь возможность профилировать их на лету.


#profiling #optimization #pyspy #debugging #python

📲 Мы в MAX

👉@BookPython

Ловушка замыканий: Почему ваши лямбды в цикле сломаны (Late Binding)

Вы пишете код, который генерирует список функций (например, колбэки для кнопок в UI или динамические фильтры). Кажется, что все логично, но на выходе получаете сюрприз.

Проблемный код:

# Хотим создать 3 функции, которые возвращают 0, 1 и 2 соответственно
funcs = []
for i in range(3):
    funcs.append(lambda: i)

# Проверяем
results = [f() for f in funcs]
print(results) 
# Ожидание: [0, 1, 2]
# Реальность: [2, 2, 2]

Почему так происходит?
Это называется Late Binding (позднее связывание).
В Python замыкания (closures) захватывают переменные по ссылке, а не по значению.
Когда вы объявляете lambda: i, Python не сохраняет текущее число 0, 1 или 2. Он сохраняет инструкцию: «когда меня вызовут, пойди в локальную область видимости, найди переменную с именем i и возьми ее значение».

К моменту, когда вы начинаете вызывать функции из списка results, цикл for уже завершился. Переменная i в этой области видимости навсегда осталась равной 2. Все три лямбды смотрят на одну и ту же переменную i.

Как лечить?

Есть два каноничных способа заставить Python запомнить значение «здесь и сейчас».

1. Аргумент по умолчанию (Hack way)
Значения аргументов по умолчанию вычисляются в момент определения функции.

funcs = []
for i in range(3):
    # i=i создает локальную переменную i внутри функции 
    # и присваивает ей текущее значение i из цикла
    funcs.append(lambda i=i: i) 

Это работает быстро, но выглядит немного грязно и может сбить с толку линтеры или коллег.

2. functools.partial (Enterprise way)
Более чистый и явный способ. partial создает новый callable-объект, «замораживая» переданные аргументы.

from functools import partial

funcs = []
for i in range(3):
    # Здесь значение i фиксируется жестко
    funcs.append(partial(lambda x: x, i))

Где это стреляет в реальной жизни?

- Генерация command для кнопок в Tkinter/PyQt.
- Динамическое создание task в asyncio циклах.
- Патчинг тестов в циклах.

Не дайте переменным пережить свое время.

#python #internals #functionalprogramming #gotchas

📲 Мы в MAX

👉@BookPython

⚡ Как ускорить код на Python? Используем map, filter, reduce ⚡

Привет, друзья! Сегодня расскажу о том, как можно ускорить выполнение кода, заменяя обычные циклы на встроенные функции map(), filter() и reduce(). Эти инструменты позволяют писать более компактный, читаемый и быстрый код.

✅ map()
Функция map() применяется к каждому элементу последовательности и возвращает новый итератор.

❌ Обычный способ:

numbers = [1, 2, 3, 4, 5]
squared = []
for num in numbers:
    squared.append(num ** 2)

✅ Быстрее с map():

numbers = [1, 2, 3, 4, 5]
squared = list(map(lambda x: x ** 2, numbers))

За счёт того, что map() использует C-оптимизированную логику, код выполняется быстрее.

✅ filter()
Фильтрует элементы последовательности по заданному условию.

❌ Медленный вариант:

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
evens = []
for num in numbers:
    if num % 2 == 0:
        evens.append(num)

✅ Быстрее с filter():

numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
evens = list(filter(lambda x: x % 2 == 0, numbers))

Такой код читается легче и работает быстрее.

✅ reduce()
Позволяет выполнять кумулятивные операции (например, суммирование, умножение).

❌ Классический способ:

numbers = [1, 2, 3, 4, 5]
product = 1
for num in numbers:
    product *= num

✅ Быстрее с reduce():

from functools import reduce

numbers = [1, 2, 3, 4, 5]
product = reduce(lambda x, y: x * y, numbers)

Этот метод полезен, если нужно свести список к одному значению.

💡 Важно: reduce() чаще заменяют sum() или math.prod(), но для сложных операций он остаётся полезным.


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

📲 Мы в MAX

👉@BookPython

Pytest Patterns: Элегантный Teardown через yield и оптимизация скоупов

Если вы все еще пишете def teardown_method(self): в классах тестов, вы не используете мощь Pytest на 100%.
Фикстуры (fixtures) - это не просто способ передать данные. Это полноценный механизм управления жизненным циклом зависимостей (DI).

1. yield вместо return: Встроенный Teardown
В Pytest фикстура может "замереть", отдать управление тесту, а потом продолжить выполнение. Это реализуется через генератор yield.

Код до yield - это setUp.
Код после yield - это tearDown.

Пример (временная база данных):

import pytest
from sqlalchemy import create_engine

@pytest.fixture
def db_engine():
    # Setup: Поднимаем соединение
    engine = create_engine("sqlite:///:memory:")
    
    # Передаем объект в тест
    yield engine
    
    # Teardown: Этот код выполнится ПОСЛЕ завершения теста
    # (даже если тест упал с ошибкой!)
    engine.dispose()

Это гарантирует, что ресурсы будут освобождены, и вам не нужны try/finally блоки внутри самих тестов.

2. Scopes: Не создавайте мир заново
По умолчанию фикстура имеет scope='function'. Она создается и умирает для каждого теста. Это безопасно, но медленно, если мы говорим о поднятии Docker-контейнера или коннекта к БД.

Используйте scope='session' для тяжелых ресурсов, которые можно переиспользовать.

Паттерн "Изоляция при общем ресурсе":
Частая задача Middle+: иметь одну БД на весь прогон тестов (быстро), но чистые таблицы для каждого теста (изолированно).

Решение: комбинируем скоупы.

# Живет весь прогон тестов (создается 1 раз)
@pytest.fixture(scope="session")
def db_engine():
    engine = create_engine(...)
    yield engine
    engine.dispose()

# Живет 1 тест (создается N раз)
@pytest.fixture(scope="function")
def db_session(db_engine):
    # Берем engine из сессионной фикстуры
    connection = db_engine.connect()
    transaction = connection.begin() # Начали транзакцию
    
    session = Session(bind=connection)
    yield session
    
    session.close()
    # ROLLBACK транзакции после теста вернет базу в исходное состояние!
    transaction.rollback() 
    connection.close()

Итог:

🟢Используйте yield для очистки ресурсов.
🟢Тяжелые объекты (Engine, Client, Container) - в scope='session'.
🟢Легкие объекты с состоянием (Session, User) - в scope='function', наследуясь от тяжелых.

#pytest #testing #qa #bestpractices #python

📲 Мы в MAX

👉@BookPython

🎥 Открытый урок «Подключение OpenAPI Swagger к Django-REST-Framework».

🗓 04 февраля в 20:00 МСК
🆓 Бесплатно. Урок в рамках старта курса «Django-разработчик».

Хорошее API — это не только код, но и понятная документация. Без неё REST-сервис быстро превращается в чёрный ящик для команды и клиентов.

Что будет на вебинаре:
✔️ Интеграция библиотеки drf-spectacular для генерации схемы OpenAPI 3.0.
✔️ Кастомизация документации: использование декоратора @extend_schema и типизации.
✔️ Подключение и настройка интерфейсов Swagger UI и Redoc.

В результате вебинара вы получите:
- Навык быстрой настройки автодокументации в существующих проектах.
- Умение описывать сложные параметры запросов и ответов.
- Готовый интерактивный интерфейс для тестирования API внутри браузера.

🔗 Ссылка на регистрацию: https://vk.cc/cTPi2Z

Реклама. ООО «Отус онлайн-образование», ОГРН 1177746618576