🎯 Команда дня: вложенные функции в Python

Python позволяет определять функции *внутри* других. Зачем? Чтобы передавать поведение, создавать замыкания, делать partial-функции и, конечно, писать декораторы.

✅ Вложенные функции = функции внутри функций

def greet_me(name="друг"):
    def greet():
        print("Привет,", name)
    greet()

🚩 Внутренняя greet() знает о name, потому что захватила его из внешней функции. Это и есть замыкание — функция «помнит» переменные.

✅ Функция возвращает функцию

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

greet_ivan = greet_me("Иван")
greet_ivan()  # Привет, Иван

🚩 greet_ivan — это не результат, а сама функция! Причём она «помнит», что name = Иван. Удобно, если нужно повторно вызывать с теми же параметрами.

✅ Создаём функции с «настроенным поведением»

def make_adder(x):
    def add(y):
        return x + y
    return add

add5 = make_adder(5)
add5(10)  # ➡️ 15

🚩 Мы создали «фабрику» функций. add5 — это функция, которая всегда добавляет 5. Можно так же легко сделать add10, add100 и т.д.

✅ Своя версия partial-функции

def partial(func, *args, **kwargs):
    def new_func(*a, **kw):
        return func(*args, *a, **kwargs, **kw)
    return new_func

bin_to_int = partial(int, base=2)
bin_to_int("1101")  # ➡️ 13

🚩 Мы зафиксировали аргумент base=2 и получили удобную функцию bin_to_int(), которая всегда читает двоичное число. Быстро и понятно!

✅ Декораторы работают точно так же

def log(func):
    def wrapper(*args, **kwargs):
        print("Вызов", args, kwargs)
        result = func(*args, **kwargs)
        print("Результат", result)
        return result
    return wrapper

🚩 log — это функция, которая возвращает функцию-обёртку. Эта обёртка добавляет логирование вокруг вызова оригинальной функции. Никакой магии — только вложенные функции и замыкание.

Что нужно запомнить:
✔️ Вложенные функции — удобный способ передавать и «запоминать» контекст
✔️ Замыкание — функция несёт с собой значения переменных
✔️ partial и декораторы — мощные приёмы, основанные на этих идеях

Библиотека питониста #буст

✔️ Чек-лист: как отлаживать ошибки в Python

1️⃣ Чтение Traceback’ов (сообщений об ошибках)

*️⃣ Читайте каждую строку сообщения об ошибке внимательно.
*️⃣ Определите файл и строку, в которой возникла ошибка.
*️⃣Обратите внимание на тип ошибки (NameError, TypeError, SyntaxError и т. д.).
*️⃣ Ознакомьтесь с пояснением ошибки — оно поможет понять, что пошло не так.

2️⃣ Использование print() для отладки

*️⃣ Добавляйте print() до и после участков, вызывающих сомнения.
*️⃣ Используйте f-строки для наглядности: print(f"{переменная = }").
*️⃣ Следите за порядком выполнения кода и значениями переменных.
*️⃣ После устранения ошибки удаляйте print() или заменяйте на logging.

3️⃣ Использование breakpoints и отладчика

*️⃣ Устанавливайте точки останова в редакторе кода (например, VS Code, PyCharm).
*️⃣ Используйте встроенную функцию breakpoint() для остановки выполнения.
*️⃣ В режиме отладки применяйте команды:
n — выполнить следующую строку (next)
s — перейти внутрь функции (step)
c — продолжить выполнение (continue)
p переменная — вывести значение переменной

4️⃣ Отладка с помощью тестов

*️⃣ Пишите юнит-тесты для всех функций (с помощью unittest или pytest).
*️⃣ Тестируйте как корректные случаи, так и крайние (edge cases).
*️⃣ Используйте тесты для воспроизведения ошибок.
*️⃣ Запускайте тесты регулярно: python -m unittest или pytest.

5️⃣ Общий подход к отладке

*️⃣ Читайте полное сообщение об ошибке, а не только последнюю строку.
*️⃣ Изолируйте проблему — сократите код до минимального примера с ошибкой.
*️⃣ Проговаривайте код вслух или объясняйте его — это помогает найти ошибки.
*️⃣ Делайте частые коммиты, чтобы проще было вернуться к рабочей версии.

Библиотека питониста #буст

💬 Вопрос от подписчика: зачем вообще нужен uv

Один из наших подписчиков поделился мыслями после пары месяцев использования uv:

Вроде всё классно… но я всё ещё сомневался, зачем он мне лично.

В целом, инструмент делает именно то, что заявляет: ускоряет Python-проекты, улучшает стандартный tooling (установка пакетов, создание виртуалок и т.д.). Работает быстро и стабильно — не придраться.

Но! Как обычный пользователь Python-библиотек, он взаимодействует с uv всего 2–3 раза в месяц. Всё остальное время — старые добрые pip, venv и уже настроенные окружения.

И вот какие вопросы возникли:
🔘 Стоит ли удобство uv того, чтобы ставить ещё один инструмент?
🔘 Почему бы просто не остаться с pip и venv, пусть и чуть медленнее?
🔘 Может, я чего-то не понимаю?

А теперь к вам, сообщество:
Вы уже пробовали uv? Реально ли он экономит вам время? Или всё ещё кажется решением без боли, но и без особой необходимости?

Библиотека питониста #междусобойчик

👉 Мифы и сказки вокруг производительности Python

🔎 Миф 1: «Python не медленный» (а то мы не знали)

Многие считают, что Python достаточно быстр, ведь это язык-«клей», где для тяжёлых вычислений используют GPU или вызывают C/C++/Rust-библиотеки. Но на самом деле, для множества задач Python всё же медленен.

🔎 Миф 2: «Если медленно, перепиши горячие участки на C/C++/Rust»

Это действительно часто помогает — оптимизировать 20% кода, где происходит 80% работы (принцип Парето). Однако Amdahl's law говорит, что ускорение одной части программы в итоге упирается в остальной код. После ускорения «горячих» мест, всё остальное начинает доминировать по времени исполнения.

🔎 Миф 3: «Python медленный, потому что он интерпретируемый»

Интерпретация даёт некоторое замедление, но гораздо больше времени уходит на выполнение динамической семантики Python: поиск типов, вызовы методов вроде __getattribute__(), упаковку и распаковку значений, выделение памяти и т.д. Это не зависит от того, интерпретируется код или компилируется.

🔎 Статическая типизация и JIT — помогают, но не решают всё

Python набирает популярность с аннотациями типов, но статическая типизация не проверяется во время выполнения. Например:

def add(x: int, y: int) -> int:
    return x + y

print(add('hello ', 'world'))  # type: ignore

Здесь добавление строк работает, но не соответствует типам. Значит, оптимизации на основе типов невозможны в чистом Python.

JIT-компиляторы (например, в PyPy) действительно могут ускорить Python, но они усложняют предсказуемость производительности и требуют понимания, как именно JIT оптимизирует код. Иногда оптимизации «ломаются» при изменении программы, даже если код кажется простым.

🔎 Абстракции в Python — не бесплатны

Рассмотрим простой алгоритм:

def algo(points: list[tuple[float, float]]):
    res = 0
    for x, y in points:
        res += x**2 * y + 10
    return res

Если вынести вычисление в отдельную функцию:

def fn(x, y):
    return x**2 * y + 10

def algo(points: list[tuple[float, float]]):
    res = 0
    for x, y in points:
        res += fn(x, y)
    return res

То производительность падает из-за накладных расходов на вызовы функций. Если вместо кортежей использовать @dataclass:

from dataclasses import dataclass

@dataclass
class Point:
    x: float
    y: float

def fn(p: Point):
    return p.x**2 * p.y + 10

def algo(points: list[Point]):
    res = 0
    for p in points:
        res += fn(p)
    return res

Скорость падает ещё больше, потому что добавляется обращение к атрибутам объектов и накладные расходы, связанные с объектной моделью.

🔎 Кэш и память — главный узкий профиль

Основная проблема Python — не вычисления, а память. Современные процессоры быстро выполняют операции, но доступ к памяти (особенно к ОЗУ) намного медленнее.

Python-программы часто имеют плохую кэш-локалити из-за разброса объектов в памяти:

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

p = [Person('Alice', 16), Person('Bob', 21)]

В памяти объекты Person и их атрибуты могут быть разбросаны, что приводит к множеству переходов по указателям и к частым кеш-промахам.

Это проблема, которую невозможно решить только компиляцией или JIT, не изменяя семантику языка.

🔗 Если интересно, почему Python медленный, посмотрите подробный доклад: https://clc.to/YWmMIA

Библиотека питониста #буст