Библиотека Python разработчика | Книги по питону

Стандартный модуль json имеет интерфейс командной строки, который может быть полезен для форматирования JSON исключительно средствами Python. Модуль называется json.tool и вызывается следующим образом:

$ echo '{"a": [], "b": "c"}' | python -m json.tool
{
    "a": [],
    "b": "c"
}

📲 Мы в MAX

👉@BookPython

default_factory в dataclass: мощнее, чем кажется

Многие используют dataclass как удобный способ задать структуру с полями. Но редко кто по-настоящему раскрывает силу default_factory. А зря — он спасает от багов и даёт гибкость.

Когда нужно задать значение по умолчанию для поля в dataclass, логично тянуться к default=. Но если это изменяемый тип (например, список или словарь) — вас поджидает ловушка.

from dataclasses import dataclass, field

@dataclass
class User:
    name: str
    tags: list[str] = []  # ⚠️ опасно!

Все экземпляры User будут делить один и тот же список. То есть:

a = User("Alice")
b = User("Bob")
a.tags.append("admin")

print(b.tags)  # ['admin'] 😱

Вместо этого используйте default_factory:

@dataclass
class User:
    name: str
    tags: list[str] = field(default_factory=list)

Теперь у каждого User будет свой список:

a = User("Alice")
b = User("Bob")
a.tags.append("admin")

print(b.tags)  # []

Но default_factory не только про списки. Это отличный способ задать любое значение "по умолчанию", включая кастомную логику:

import uuid

@dataclass
class Session:
    id: str = field(default_factory=lambda: str(uuid.uuid4()))

Или, например, значения из окружения:

import os

@dataclass
class Config:
    debug: bool = field(default_factory=lambda: os.getenv("DEBUG") == "1")

Кстати, это ещё и отличное место для внедрения DI:

@dataclass
class Service:
    client: "Client" = field(default_factory=create_default_client)

default_factory — это маленький хак, который позволяет сделать код чище и безопаснее, особенно когда работаешь с изменяемыми структурами или сложной инициализацией.

📲 Мы в MAX

👉@BookPython

yield from — элегантная передача управления

Если вы пишете генераторы, которые вызывают другие генераторы — забудьте про for x in sub(): yield x. Есть способ проще и мощнее.

Оператор yield from позволяет передавать элементы из подгенератора напрямую, без лишнего кода. Но фишка не только в лаконичности — он также автоматически пробрасывает исключения и возвращаемые значения из подгенератора.

Вот классика:

def gen():
    for x in range(3):
        yield x

def wrapper():
    for x in gen():
        yield x

Можно короче и лучше:

def wrapper():
    yield from gen()

Но главное — yield from пробрасывает return-значение из подгенератора (начиная с Python 3.3):

def sub():
    yield 1
    yield 2
    return 'done'

def main():
    result = yield from sub()
    print('Sub returned:', result)

for _ in main():
    pass
# Выведет: Sub returned: done

А ещё через yield from можно проксировать значения внутрь генератора — например, в сопрограммах:

def delegator():
    result = yield from coroutine()
    print('coroutine done:', result)

def coroutine():
    x = yield
    y = yield
    return x + y

g = delegator()
next(g)          # Старт
next(g)          # coroutine ждет x
g.send(10)       # x = 10
print(g.send(20))  # y = 20 → return 30
# Выведет: coroutine done: 30

Итог: если вы пишете генераторы — освоение yield from даст вам лаконичный синтаксис, проброс return-значений, исключений и взаимодействие на новом уровне.

📲 Мы в MAX

👉@BookPython

🚀 Подборка полезных IT каналов в Max


Системное администрирование, DevOps 📌

https://max.ru/i_odmin Все для системного администратора
https://max.ru/bash_srv Bash Советы
https://max.ru/sysadminof Книги для админов, полезные материалы
https://max.ru/i_odmin_book Библиотека Системного Администратора
https://max.ru/i_devops DevOps: Пишем о Docker, Kubernetes и др.

1C разработка 📌
https://max.ru/odin1c_rus Cтатьи, курсы, советы, шаблоны кода 1С

Программирование C++📌
https://max.ru/cpp_lib Библиотека C/C++ разработчика

Программирование Python 📌
https://max.ru/python_of Python академия.
https://max.ru/BookPython Библиотека Python разработчика

Java разработка 📌
https://max.ru/bookjava Библиотека Java разработчика

GitHub Сообщество 📌
https://max.ru/githublib Интересное из GitHub

Базы данных (Data Base) 📌
https://max.ru/database_info Все про базы данных

Фронтенд разработка 📌
https://max.ru/frontend_1 Подборки для frontend разработчиков

Библиотеки 📌
https://max.ru/programmist_of Книги по программированию
https://max.ru/proglb Библиотека программиста
https://max.ru/bfbook Книги для программистов

Программирование 📌
https://max.ru/bookflow Лекции, видеоуроки, доклады с IT конференций
https://max.ru/itmozg Программисты, дизайнеры, новости из мира IT
https://max.ru/php_lib Библиотека PHP программиста 👨🏼‍💻👩‍💻

Шутки программистов 📌
https://max.ru/itumor Шутки программистов

Защита, взлом, безопасность 📌
https://max.ru/thehaking Канал о кибербезопасности
https://max.ru/xakkep_1 Хакер Free

Книги, статьи для дизайнеров 📌
https://max.ru/odesigners Статьи, книги для дизайнеров

Математика 📌
https://max.ru/Pomatematike Канал по математике
https://max.ru/phismat_1 Обучающие видео, книги по Физике и Математике

Вакансии 📌
https://max.ru/progjob Вакансии в IT

Мир технологий 📌
https://max.ru/mir_teh Канал для любознательных


Бонус 📌
https://max.ru/piterspb_78 Свежие новости Санкт-Петербурга
https://max.ru/mockva_life Свежие новости Москвы

Python предоставляет мощную библиотеку для работы с датой и временем — datetime. Интересный момент: объекты datetime имеют специальный интерфейс для поддержки часовых поясов (атрибут tzinfo), однако сама библиотека `datetime реализует его лишь частично, оставляя остальную работу сторонним модулям.

Самым популярным модулем для этой задачи является pytz. Хитрость в том, что pytz не полностью соответствует интерфейсу tzinfo. В документации pytz прямо указано с самого начала: «Эта библиотека отличается от задокументированного API Python для реализаций tzinfo».

Вы не можете просто передать объект временной зоны pytz в атрибут tzinfo. Если попробуете, результат может быть абсолютно безумным:

In : paris = pytz.timezone('Europe/Paris')
In : str(datetime(2017, 1, 1, tzinfo=paris))
Out: '2017-01-01 00:00:00+00:09'

Посмотрите на этот смещение +00:09. Правильное использование pytz выглядит так:

In : str(paris.localize(datetime(2017, 1, 1)))
Out: '2017-01-01 00:00:00+01:00'

Кроме того, после любых операций с датой и временем, нужно нормализовать объект datetime, если есть вероятность смены смещения (например, на границе перехода на летнее время):

In : new_time = time + timedelta(days=2)
In : str(new_time)
Out: '2018-03-27 00:00:00+01:00'
In : str(paris.normalize(new_time))
Out: '2018-03-27 01:00:00+02:00'

Начиная с Python 3.6, рекомендуется использовать dateutil.tz вместо pytz. Он полностью совместим с tzinfo, может использоваться напрямую, не требует normalize, хотя и работает немного медленнее.

Если вам интересно, почему pytz не поддерживает API datetime, или вы хотите увидеть больше примеров, обязательно почитайте хорошую статью на эту тему.

📲 Мы в MAX

👉@BookPython

Когда вы используете модуль multiprocessing, и в одном из процессов происходит исключение, оно передаётся в основную программу с помощью механизма сериализации (pickling). Исключение сериализуется, передаётся в другой процесс и там десериализуется обратно.

Однако сериализация исключений может быть непростой задачей. Исключение создаётся с любым количеством аргументов, которые сохраняются в атрибуте args. Эти же аргументы используются при десериализации для воссоздания объекта исключения.

Но это может не сработать так, как вы ожидаете, особенно если используется наследование. Посмотрите на пример:

import pickle

class TooMuchWeightError(Exception):
    def __init__(self, weight):
        super().__init__()
        self._weight = weight

pickled = pickle.dumps(TooMuchWeightError(42))
pickle.loads(pickled)

Вызов TooMuchWeightError.__init__ приводит к вызову Exception.__init__, который устанавливает args как пустой кортеж. Этот пустой кортеж затем используется в качестве аргументов при десериализации, что, очевидно, приводит к ошибке:

TypeError: __init__() missing 1 required positional argument: 'weight'

Обходное решение — либо вообще не вызывать super().__init__() (что обычно считается плохой практикой при наследовании), либо передавать все аргументы явно в конструктор родительского класса:

class TooMuchWeightError(Exception):
    def __init__(self, weight):
        super().__init__(weight)
        self._weight = weight

📲 Мы в MAX

👉@BookPython

Функция map вызывает другую функцию для каждого элемента итерируемого объекта. Это значит, что функция должна принимать одно значение в качестве аргумента:

In : list(map(lambda x: x ** 2, [1, 2, 3]))
Out: [1, 4, 9]

Однако если каждый элемент итерируемого объекта — это кортеж, было бы удобно передавать каждый элемент кортежа как отдельный аргумент. В Python 2 это было возможно благодаря распаковке параметров кортежа (обратите внимание на скобки):

>>> map(lambda (a, b): a + b, [(1, 2), (3, 4)])
[3, 7]

В Python 3 эта возможность исчезла, но есть другое решение — itertools.starmap. Она распаковывает кортежи за вас, будто функция вызывается со звёздочкой: f(*arg) (отсюда и название функции):

from itertools import starmap

In [3]: list(starmap(lambda a, b: a + b, [(1, 2), (3, 4)]))
Out[3]: [3, 7]

📲 Мы в MAX

👉@BookPython

Функция super() позволяет обращаться к родительскому (базовому) классу. Это может быть очень полезно в случаях, когда производный класс хочет добавить что-то к реализации метода, а не полностью переопределять его:

class BaseTestCase(TestCase):
    def setUp(self):
        self._db = create_db()

class UserTestCase(BaseTestCase):
    def setUp(self):
        super().setUp()
        self._user = create_user()

Имя функции super не означает "отличный" или "очень хороший". В данном контексте слово super означает "выше" (как, например, в слове superintendent — заведующий). Несмотря на это, super() не всегда ссылается на базовый класс — он может вернуть и "соседний" класс. Более точным названием была бы, возможно, функция next(), так как возвращается следующий класс согласно цепочке разрешения методов (MRO — Method Resolution Order).

Пример:

class Top:
    def foo(self):
        return 'top'

class Left(Top):
    def foo(self):
        return super().foo()

class Right(Top):
    def foo(self):
        return 'right'

class Bottom(Left, Right):
    pass

# выводит 'right'
print(Bottom().foo())

Обрати внимание: результат работы super() может отличаться в зависимости от MRO вызвавшего объекта.

>>> Bottom().foo()
'right'
>>> Left().foo()
'top'

📲 Мы в MAX

👉@BookPython

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

$ echo /li*
/lib /lib64

Python поддерживает globbing с помощью модуля glob. Однако есть важное замечание: оболочка возвращает сам шаблон, если файлы не найдены, а Python — нет:

$ echo /zz**
/zz**
$ python -c 'from glob import glob; print(glob("/zz**"))'
[]

📲 Мы в MAX

👉@BookPython

Обычно вы взаимодействуете с генератором, запрашивая данные с помощью next(gen). В Python 3 вы также можете отправлять значения обратно в генератор с помощью g.send(x). Но существует техника, которой вы, вероятно, не пользуетесь каждый день, а возможно, и вовсе не знаете: выбрасывание исключений внутри генератора.

С помощью gen.throw(e) можно выбросить исключение в той точке, где генератор gen приостановлен — то есть на инструкции yield. Если генератор обрабатывает это исключение, gen.throw(e) возвращает следующее значение, полученное через yield (или выбрасывает StopIteration, если генератор завершён). Если генератор не перехватывает исключение, оно пробрасывается обратно к вызывающему коду.

def gen():
    try:
        yield 1
    except ValueError:
        yield 2

g = gen()

next(g)
# Out: 1

g.throw(ValueError)
# Out: 2

g.throw(RuntimeError('TEST'))
# RuntimeError: TEST

Эта техника позволяет более точно управлять поведением генератора — не только передавать данные внутрь, но и, например, сообщать о проблемах со значениями, полученными через yield. Однако такие случаи бывают редко, и встретить g.throw в дикой природе почти невозможно.

Тем не менее, декоратор @contextmanager из модуля contextlib использует именно такую технику, позволяя коду внутри контекста перехватывать исключения.

from contextlib import contextmanager

@contextmanager
def atomic():
    print('BEGIN')

    try:
        yield
    except Exception:
        print('ROLLBACK')
    else:
        print('COMMIT')

with atomic():
    print('ERROR')
    raise RuntimeError()

BEGIN  
ERROR  
ROLLBACK

📲 Мы в MAX

👉@BookPython

Одна и та же строка может быть представлена по-разному в Unicode, и стандарт это учитывает. Он определяет два типа эквивалентности: последовательности могут быть канонически эквивалентными или совместимыми.

Канонически эквивалентные последовательности выглядят одинаково, но содержат разные кодовые точки. Например, символ ö может быть представлен как LATIN SMALL LETTER O WITH DIAERESIS (U+00F6) или как комбинация из o и диакритического знака: LATIN SMALL LETTER O (U+006F) + COMBINING DIAERESIS (U+0308).

Совместимые последовательности выглядят по-разному, но могут трактоваться одинаково с точки зрения смысла, например, ff и ff.

Для каждого из этих типов эквивалентности можно нормализовать строку в Unicode, сжимая или расширяя последовательности. В Python для этого используется модуль unicodedata:

import unicodedata

modes = [
    # Сжать канонически эквивалентные
    'NFC',
    # Расширить канонически эквивалентные
    'NFD',
    # Сжать совместимые
    'NFKC',
    # Расширить совместимые
    'NFKD',
]

s = 'ff + ö'

for mode in modes:
    norm = unicodedata.normalize(mode, s)
    print('\t'.join([
        mode,
        norm,
        str(len(norm.encode('utf8'))),
    ]))

Результат:

NFC     ff + ö   8
NFD     ff + ö   9
NFKC    ff + ö  7
NFKD    ff + ö  8

📲 Мы в MAX

👉@BookPython

Сегодня я покажу вам простой, но очень полезный приём, который часто выручает при работе с Python-скриптами — автоматическое логирование вызовов функций с помощью декоратора.

Иногда, особенно в отладке, хочется видеть, какие функции вызываются, с какими аргументами и что они возвращают. Не писать же в каждую вручную print()? Вот тут и приходит на помощь наш герой — универсальный логгер-декоратор:

import functools

def log_calls(func):
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        print(f"[CALL] {func.__name__} args={args} kwargs={kwargs}")
        result = func(*args, **kwargs)
        print(f"[RETURN] {func.__name__} -> {result}")
        return result
    return wrapper

Пример использования:

@log_calls
def multiply(a, b):
    return a * b

multiply(3, 5)

📌 Вывод:

[CALL] multiply args=(3, 5) kwargs={}
[RETURN] multiply -> 15

Такой декоратор можно подключить временно на любую функцию — и сразу видеть, что происходит у вас в коде. Это особенно удобно при работе со сторонними библиотеками или когда вы разбираетесь в чужом проекте.

Кстати, с небольшими изменениями можно направить вывод не в print(), а в logging, или даже сохранять в файл — по вкусу.

Пользуетесь такими декораторами? Или у вас свой лайфхак?

📲 Мы в MAX

👉@BookPython

Если вы создаёте новые объекты внутри метода __init__, возможно, будет лучше передавать их как аргументы и использовать фабричный метод. Это позволяет разделить бизнес-логику и технические детали создания объектов.

В этом примере __init__ принимает host и port для создания подключения к базе данных:

class Query:
    def __init__(self, host, port):
        self._connection = Connection(host, port)

Возможный рефакторинг:

class Query:
    def __init__(self, connection):
        self._connection = connection
        
    @classmethod
    def create(cls, host, port):
        return cls(Connection(host, port))

Такой подход имеет как минимум следующие преимущества:

• Упрощает внедрение зависимостей. В тестах можно использовать Query(FakeConnection()).
• Класс может иметь столько фабричных методов, сколько нужно; подключение может создаваться не только по host и port, но и путём клонирования другого подключения, чтения конфигурационного файла или объекта, использования значения по умолчанию и т.д.
• Такие фабричные методы можно сделать асинхронными; это невозможно для __init__.

📲 Мы в MAX

👉@BookPython

Чтобы сохранить любую информацию в памяти или на устройстве хранения, её необходимо представить в виде байтов. Python, как правило, предоставляет уровень абстракции, при котором вы оперируете непосредственно данными, а не их байтовым представлением.

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

Существует сотни методов кодирования. Самый популярный — вероятно, Unicode, но он сам по себе не может преобразовывать данные в байты. В смысле байтового представления Unicode вообще не является кодировкой. Unicode определяет соответствие между символами и их числовыми кодами. Например, 🐍 имеет код 128013.

Но чтобы записать числа в файл, нужна настоящая кодировка. Unicode обычно используется вместе с utf-8, которая (в большинстве случаев) является стандартной в Python. При чтении из файла Python автоматически декодирует utf-8. Вы можете выбрать любую другую кодировку с помощью параметра encoding= функции open, либо читать «сырые» байты, добавив b к режиму открытия файла.

📲 Мы в MAX

👉@BookPython

В Python очень короткий список встроенных констант. Одна из них — Ellipsis, которую также можно записать как .... Эта константа не имеет особого значения для интерпретатора, но используется в местах, где такой синтаксис выглядит уместно.

Библиотека NumPy поддерживает Ellipsis в качестве аргумента __getitem__, например: x[...] возвращает все элементы массива x.

PEP 484 придаёт Ellipsis дополнительное значение: Callable[..., type] — это способ определить тип вызываемых объектов без указания типов аргументов.

Наконец, ... можно использовать, чтобы обозначить, что функция ещё не реализована. Это абсолютно валидный код на Python:

def x():
    ...

📲 Мы в MAX

👉@BookPython

Обработка исключений в асинхронных программах может быть непростой задачей.

В asyncio, если корутина выбрасывает исключение, оно передаётся в тот код, который ожидает соответствующий future. Если await вызывается в нескольких местах, то каждое из них получит это исключение (так как оно сохраняется внутри объекта исключения). Следующий код напечатает сообщение об ошибке пять раз:

import asyncio

async def error():
    await asyncio.sleep(1)
    raise ValueError()

async def waiter(task):
    try:
        await task
    except ValueError:
        print('error')
    else:
        print('OK')

async def main():
    task = asyncio.get_event_loop().create_task(error())

    for _ in range(5):
        asyncio.get_event_loop().create_task(waiter(task))

    await asyncio.sleep(2)

loop = asyncio.get_event_loop()
loop.run_until_complete(main())

Если исключение выброшено, но задача (task) ни разу не была ожидаема (awaited), исключение будет потеряно. В таком случае при уничтожении задачи вы получите предупреждение: “Task exception was never retrieved”.

Когда вы используете await asyncio.gather(tasks) и одна из задач выбрасывает исключение, оно передаётся наружу. Однако если несколько задач выбросят исключения, вы получите только первое, остальные будут проигнорированы:

import asyncio

async def error(i):
    await asyncio.sleep(1)
    raise ValueError(i)

async def main():
    try:
        await asyncio.gather(
            error(1),
            error(2),
            error(3),
        )
    except ValueError as e:
        print(e)

loop = asyncio.get_event_loop()
loop.run_until_complete(main())

Вы можете использовать gather с параметром return_exceptions=True, чтобы получать исключения как обычные значения. Следующий код напечатает: [42, ValueError(2,), ValueError(3,)]

import asyncio

async def error(i):
    await asyncio.sleep(1)
    if i > 1:
        raise ValueError(i)
    return 42

async def main():
    results = await asyncio.gather(
        error(1),
        error(2),
        error(3),
        return_exceptions=True,
    )

    print(results)

loop = asyncio.get_event_loop()
loop.run_until_complete(main())

📲 Мы в MAX

👉@BookPython

Сегодня покажу вам удобный способ следить за производительностью Python-кода прямо в терминале с помощью py-spy.

🔍 Что такое py-spy?

py-spy это sampling-профайлер для Python, который не требует модификации кода и может подключаться к уже работающим процессам. Он написан на Rust, работает очень быстро и почти не влияет на производительность.



🛠 Установка:

pip install py-spy

Или, если хочется поставить бинарник напрямую:

curl -sSL https://install.python-poetry.org | python3 -

🚀 Примеры использования:

1. Снять снимок с работающего процесса:

py-spy top --pid 12345

Альтернатива htop, но показывает, какие функции Python жрут CPU.

2. Записать flamegraph:

py-spy record -o profile.svg --pid 12345

Откроется красивая SVG-шечка, где видно, куда утекает время выполнения.

3. Запустить скрипт с профилированием:

py-spy top -- python my_script.py

🧠 Зачем это нужно?

- Падает производительность? Посмотри, какие функции грузят процессор.
- Программа зависла? Снимок покажет, где именно.
- Хотите оптимизировать горячие участки? Flamegraph быстро выведет подозреваемых.


🔥 Совет от меня: py-spy умеет работать с контейнерами и виртуальными окружениями, просто указывайте --pid правильного процесса. Идеален для DevOps'а и продакшн-серверов.

📲 Мы в MAX

👉@BookPython

Как отлаживать Python-код, не выходя из редактора - с помощью встроенного модуля pdb.

🔍 Быстрая отладка с pdb

Часто, когда код не работает как надо, мы начинаем закидывать print()-ами. Но это неудобно, медленно и мусорит код. Вместо этого вставь в нужное место строчку:

import pdb; pdb.set_trace()

Когда выполнение дойдет до этой строки, ты попадешь в интерактивную консоль отладчика прямо в терминале. Дальше можно:

- n (next) — перейти к следующей строке;
- s (step) — зайти внутрь функции;
- c (continue) — продолжить выполнение;
- l (list) — показать текущий контекст;
- p var — вывести значение переменной var.

💡 Пример

def calc(a, b):
    import pdb; pdb.set_trace()
    result = a + b
    return result

calc(2, 3)

На строке с pdb.set_trace() ты остановишься и сможешь изучить, что происходит внутри.

Зачем это нужно?

- Понять, почему что-то идет не так.
- Посмотреть, какие значения у переменных прямо в момент ошибки.
- Быстро отладить без запуска IDE - удобно в Docker, SSH или при работе с cron.

Попробуй - один раз освоишь, и уже не захочешь возвращаться к print().


📲 Мы в MAX

👉@BookPython

Python поддерживает цепочные присваивания со следующим синтаксисом:

a = b = c = 42

Выглядит как цепочка присваиваний в C, но работает совершенно иначе. В C результат одного присваивания используется в следующем:

a = (b = (c = 42))

В Python всё не так. Операция присваивания не возвращает результат — это оператор, а не выражение. Вместо этого происходит несколько присваиваний слева направо:

  2           0 LOAD_CONST       1 (42)
              2 DUP_TOP
              4 STORE_FAST       0 (a)
              6 DUP_TOP
              8 STORE_FAST       1 (b)
             10 STORE_FAST       2 (c)

📲 Мы в MAX

👉@BookPython

Чтобы объект можно было использовать в качестве ключа словаря, он должен быть хешируемым. Хешируемые объекты поддерживают метод __hash__, который возвращает целое число. Для получения хеша значения используется встроенная функция hash.

Встроенные типы, которые являются неизменяемыми, по умолчанию хешируемы. Все пользовательские объекты тоже хешируемы, но есть нюанс. Если вы определяете метод __eq__ для своего типа, то вы также должны определить __hash__ таким образом, чтобы hash(a) == hash(b) для всех a и b, которые считаются равными. Нарушение этого правила может привести к некорректной работе словаря:

class A:
    def __init__(self, x):
        self.x = x
        
    def __hash__(self):
        return random.randrange(10000)
    
    def __eq__(self, other):
        return self.x == other.x

d = {}
d[A(2)] = 2
d.get(A(2), 0)
# Вывод: 0

Обратите внимание: как только вы определяете __eq__ в классе, реализация __hash__ по умолчанию удаляется, так как она больше не подходит (по умолчанию все значения считаются неравными).

📲 Мы в MAX

👉@BookPython