Справочник по Python

СПРАВОЧНИК

Назначение

Справочник-шпаргалка по Python — типы, синтаксис, стандартная библиотека, типовые паттерны. Не заменяет пошаговое обучение. Учебный курс: раздел.

Компактные таблицы в §1.5 частично восходят к шпаргалке OverAPI Python (MIT, исходники); здесь они переведены и приведены к CPython 3.12 (без устаревших конструкций Python 2).

Учебные статьи: Типы данных · Работа с типами · Даты и время · Магические методы.

Краткое пояснение

Основные свойства, особенности и детали языка.

Быстрый старт

python --version
python3 --version
python -c "print('ok')"
python -m venv .venv

Linux/macOS — source .venv/bin/activate

pip install -r requirements.txt python main.py

---

## Справочные таблицы

### Часть 1. Ядро языка Python

*Версия справочника соответствует CPython 3.12 (актуальная LTS-версия на 2025 год).*

---

#### 1.1 Встроенные типы  

Python определяет следующие встроенные типы. Все они реализованы на уровне интерпретатора и доступны без импорта.

---

##### `NoneType`  

Единственный экземпляр — `None`.  
- Атрибуты: отсутствуют  
- Методы: отсутствуют  
- Свойства:  
  - `__class__` — `<class 'NoneType'>`  
  - `__bool__()` возвращает `False`  
  - `__repr__()` возвращает `'None'`

---

##### `bool`  

Имеет два экземпляра: `True`, `False`. Наследует от `int`.  
- Атрибуты: отсутствуют  
- Методы: наследует все методы `int`, но не предоставляет новых  
- Свойства:  
  - `__class__` — `<class 'bool'>`  
  - `__new__(cls, x=False)` — создаёт `True`, если `x` истинно, иначе `False`  
  - `__abs__()`, `__add__()`, `__and__()`, `__eq__()`, `__float__()`, `__int__()`, `__invert__()`, `__or__()`, `__repr__()`, `__str__()` — определены явно  
  - Унарные и бинарные операции с `bool` возвращают `int`, если результат не может быть представлен как `bool` (например, `True + True` → `2`)

---

##### `int`  

Произвольной точности целое число.  
- Атрибуты:  
  - `real`, `imag`, `numerator`, `denominator` — свойства, возвращающие сам объект (для целых чисел)  
- Методы:  
  - `bit_length()` — количество бит, необходимых для представления абсолютного значения, без учёта знака  
  - `to_bytes(length, byteorder, *, signed=False)` — сериализация в `bytes`  
  - `from_bytes(bytes, byteorder, *, signed=False)` — конструктор класса из `bytes`  
  - `as_integer_ratio()` — возвращает кортеж `(self, 1)`  
  - `__ceil__()`, `__floor__()`, `__round__()`, `__trunc__()` — совместимость с `numbers.Integral`  
- Свойства:  
  - `__class__` — `<class 'int'>`  
  - `__new__(cls, x=0, base=10)` — поддерживает строку с указанием основания  
  - Допустимые основания: от 2 до 36 включительно  
  - Бинарные операции: `+ - * // % divmod &#42;&#42; &lt;&lt; &gt;&gt; & | ^`  
  - Бинарные операции с плавающей запятой возвращают `float`  
  - Операции сравнения: `< <= == != >= >`

---

##### `float`  

Число с плавающей запятой двойной точности (IEEE 754 binary64).  
- Атрибуты:  
  - `real`, `imag`, `is_integer()` — возвращает `True`, если значение целое  
- Методы:  
  - `as_integer_ratio()` — возвращает `(n, d)`, `n/d == self`, `d > 0`  
  - `hex()` — шестнадцатеричная строка вида `0x1.8p+1`  
  - `fromhex(s)` — конструктор из шестнадцатеричной строки  
- Свойства:  
  - `__class__` — `<class 'float'>`  
  - `__new__(cls, x=0.0)` — преобразует строки, целые, другие `float`  
  - Специальные значения — `inf`, `-inf`, `nan` (получаются через `float('inf')`, `float('nan')`)  
  - `nan == nan` возвращает `False`; `math.isnan()` используется для проверки  
  - Все операции с `nan` (кроме `!=`) возвращают `nan`  
  - Операции с `inf` — `inf + inf == inf`, `inf - inf == nan`, `inf / inf == nan`, `0 * inf == nan`

---

##### `complex`  

Комплексное число: `real + imag * 1j`  
- Атрибуты:  
  - `real`, `imag` — вещественная и мнимая части (`float`)  
- Методы:  
  - `conjugate()` — возвращает комплексно-сопряжённое  
  - `__abs__()` — модуль числа (`sqrt(real² + imag²)`)  
- Свойства:  
  - `__class__` — `<class 'complex'>`  
  - `__new__(cls, real=0.0, imag=0.0)` — принимает числа или строки вида `'3+4j'`  
  - Строковый литерал — `3+4j`, `1j`, `5.` (вещественное), но не `j`  
  - Нельзя сравнивать на `<`, `<=`, `>`, `>=`  
  - Поддерживает: `+ - * / // % &#42;&#42;`  
  - Целочисленное деление `//` и деление по модулю `%` не определены (выбрасывают `TypeError`)

---

##### `str`  

Неизменяемая последовательность Unicode-символов (UTF-8 внутри).  
- Атрибуты: отсутствуют (все методы — функции)  
- Методы (выборочно, наиболее употребительные; всего — 48):  
  - `capitalize()`  
  - `casefold()`  
  - `center(width[, fillchar])`  
  - `count(sub[, start[, end]])`  
  - `encode(encoding='utf-8', errors='strict')`  
  - `endswith(suffix[, start[, end]])`  
  - `expandtabs(tabsize=8)`  
  - `find(sub[, start[, end]])`  
  - `format(*args, &#42;&#42;kwargs)`  
  - `format_map(mapping)`  
  - `index(sub[, start[, end]])`  
  - `isalnum()`, `isalpha()`, `isascii()`, `isdecimal()`, `isdigit()`, `isidentifier()`, `islower()`, `isnumeric()`, `isprintable()`, `isspace()`, `istitle()`, `isupper()`  
  - `join(iterable)`  
  - `ljust(width[, fillchar])`  
  - `lower()`  
  - `lstrip([chars])`  
  - `maketrans(x[, y[, z]])` — статический метод, возвращает таблицу для `translate()`  
  - `partition(sep)`  
  - `removeprefix(prefix)`, `removesuffix(suffix)`  
  - `replace(old, new[, count])`  
  - `rfind(sub[, start[, end]])`  
  - `rindex(sub[, start[, end]])`  
  - `rjust(width[, fillchar])`  
  - `rpartition(sep)`  
  - `rsplit(sep=None, maxsplit=-1)`  
  - `rstrip([chars])`  
  - `split(sep=None, maxsplit=-1)`  
  - `splitlines([keepends])`  
  - `startswith(prefix[, start[, end]])`  
  - `strip([chars])`  
  - `swapcase()`  
  - `title()`  
  - `translate(table)`  
  - `upper()`  
  - `zfill(width)`  
- Свойства:  
  - `__class__` — `<class 'str'>`  
  - `__new__(cls, object='')` — преобразует объект в строку  
  - `__getitem__(key)` — возвращает `str` длины 1  
  - `__iter__()` — итератор по символам  
  - `__len__()` — длина в символах (не в байтах)  
  - `__contains__(sub)` — проверка подстроки  
  - `__add__`, `__mul__`, `__rmul__` — конкатенация и повторение  
  - `__mod__` — форматирование по `%`  
  - Литералы — `'`, `"`, `'''`, `"""`, `r''`, `f''`, `rf''`, `fr''`  
  - Escape-последовательности: `\n \r \t \\ \' \" \xhh \uhhhh \Uhhhhhhhh \N&#123;name&#125;`  
  - Строки — хэшируемы

---

##### `bytes`  

Неизменяемая последовательность байтов (целых от 0 до 255).  
- Атрибуты: отсутствуют  
- Методы (все аналогичны `str`, но для байтов):  
  - `capitalize()`, `center()`, `count()`, `decode(encoding='utf-8', errors='strict')`, `endswith()`, `expandtabs()`, `find()`, `hex()`, `index()`, `isalnum()`, `isalpha()`, `isascii()`, `isdigit()`, `islower()`, `isspace()`, `istitle()`, `isupper()`, `join()`, `ljust()`, `lower()`, `lstrip()`, `maketrans(from, to)` — статический, возвращает `bytes` таблицу  
  - `partition()`, `removeprefix()`, `removesuffix()`, `replace()`, `rfind()`, `rindex()`, `rjust()`, `rpartition()`, `rsplit()`, `rstrip()`, `split()`, `splitlines()`, `startswith()`, `strip()`, `swapcase()`, `title()`, `translate(table)`, `upper()`, `zfill()`  
  - `fromhex(s)` — статический метод  
- Свойства:  
  - `__class__` — `<class 'bytes'>`  
  - `__new__(cls, source=b'', encoding=None, errors='strict')` — принимает `int`, `str` (с `encoding`), `Iterable[int]`, `bytes-like`  
  - `__getitem__`, `__iter__`, `__len__`, `__contains__`, `__add__`, `__mul__`, `__rmul__` — как у `str`  
  - Литералы — `b''`, `br''`, `rb''`  
  - Escape-последовательности: только ASCII (`\n \r \t \\ \' \" \xhh`)  
  - Не поддерживает `format()`, `format_map()`  
  - Хэшируем

---

##### `bytearray`  

Изменяемая последовательность байтов.  
- Атрибуты: отсутствуют  
- Методы:  
  - Все методы `bytes`, плюс изменяющие:  
    - `append(x)`, `clear()`, `copy()`, `extend(iterable)`, `insert(i, x)`, `pop([i])`, `remove(value)`, `reverse()`  
    - `__setitem__`, `__delitem__`, `__iadd__`, `__imul__`  
- Свойства:  
  - `__class__` — `<class 'bytearray'>`  
  - `__new__(cls, source=b'', encoding=None, errors='strict')` — как `bytes`  
  - Не хэшируем

---

##### `memoryview`  

Представление буферного протокола без копирования.  
- Атрибуты:  
  - `format` — строка формата (например, `'B'`, `'d'`, `'3f'`)  
  - `itemsize` — размер одного элемента в байтах  
  - `ndim` — количество измерений  
  - `readonly` — `bool`  
  - `shape` — кортеж размеров, `None` для одномерных неизвестной длины  
  - `strides` — кортеж шагов, `None` при отсутствии  
  - `suboffsets` — кортеж смещений для вложенных структур  
  - `c_contiguous`, `f_contiguous`, `contiguous` — флаги расположения в памяти  
- Методы:  
  - `tobytes()`  
  - `tolist()`  
  - `toreadonly()`  
  - `cast(format[, shape])`  
  - `release()`  
- Свойства:  
  - `__class__` — `<class 'memoryview'>`  
  - `__new__(cls, obj)` — `obj` должен реализовывать буферный протокол  
  - `__getitem__`, `__setitem__` (если не `readonly`)  
  - `__len__`, `__eq__`, `__hash__` (хэш равен `None`, если не `readonly`)  
  - Поддерживает нарезку, возвращает `memoryview`

---

##### `list`  

Изменяемая упорядоченная последовательность произвольных объектов.  
- Атрибуты: отсутствуют  
- Методы:  
  - `append(x)`, `clear()`, `copy()`, `count(x)`, `extend(iterable)`, `index(x[, start[, end]])`, `insert(i, x)`, `pop([i])`, `remove(x)`, `reverse()`, `sort(*, key=None, reverse=False)`  
- Свойства:  
  - `__class__` — `<class 'list'>`  
  - `__new__(cls, iterable=())`  
  - `__getitem__`, `__setitem__`, `__delitem__`, `__len__`, `__iter__`, `__contains__`  
  - `__add__`, `__iadd__`, `__mul__`, `__imul__`, `__rmul__`  
  - Не хэшируем  
  - Реализует `collections.abc.MutableSequence`

---

##### `tuple`  

Неизменяемая упорядоченная последовательность произвольных объектов.  
- Атрибуты: отсутствуют  
- Методы:  
  - `count(x)`, `index(x[, start[, end]])`  
- Свойства:  
  - `__class__` — `<class 'tuple'>`  
  - `__new__(cls, iterable=())`  
  - `__getitem__`, `__len__`, `__iter__`, `__contains__`, `__add__`, `__mul__`, `__rmul__`  
  - Хэшируем (если все элементы хэшируемы)

---

##### `range`  

Неизменяемая арифметическая прогрессия целых чисел.  
- Атрибуты:  
  - `start`, `stop`, `step` — `int`  
- Методы:  
  - `count(value)`, `index(value)`  
- Свойства:  
  - `__class__` — `<class 'range'>`  
  - `__new__(cls, stop)` или `__new__(cls, start, stop[, step])`  
  - `__getitem__`, `__len__`, `__iter__`, `__contains__`, `__reversed__`  
  - Хэшируем  
  - Постоянный объём памяти (не хранит все элементы)  
  - Поддерживает срезы: `range(...)[::k]` → новый `range`

---

##### `dict`  

Изменяемое отображение "ключ → значение". Порядок вставки сохраняется (с Python 3.7 как гарантия).  
- Атрибуты: отсутствуют  
- Методы:  
  - `clear()`, `copy()`, `fromkeys(iterable[, value])` — статический  
  - `get(key[, default])`, `items()`, `keys()`, `pop(key[, default])`, `popitem()`, `setdefault(key[, default])`, `update([other])`, `values()`  
  - `__class_getitem__()` — поддержка `dict[str, int]` для аннотаций  
- Свойства:  
  - `__class__` — `<class 'dict'>`  
  - `__new__(cls, other=None, &#42;&#42;kwargs)` — принимает отображения, итераторы пар, ключевые аргументы  
  - `__getitem__`, `__setitem__`, `__delitem__`, `__len__`, `__iter__`, `__contains__`  
  - `__or__`, `__ror__`, `__ior__` (с Python 3.9) — объединение  
  - Не хэшируем  
  - Порог перестроения хэш-таблицы: ~2/3 заполнения  
  - Хэш-функция ключа: `hash(key)`, должен быть хэшируемым  
  - Операции `in`, `[]`, `get`, `setdefault` имеют амортизированную `O(1)` сложность

---

##### `set`  

Изменяемое неупорядоченное множество хэшируемых объектов без дубликатов.  
- Атрибуты: отсутствуют  
- Методы:  
  - `add(elem)`, `clear()`, `copy()`, `difference(*others)`, `difference_update(*others)`, `discard(elem)`, `intersection(*others)`, `intersection_update(*others)`, `isdisjoint(other)`, `issubset(other)`, `issuperset(other)`, `pop()`, `remove(elem)`, `symmetric_difference(other)`, `symmetric_difference_update(other)`, `union(*others)`, `update(*others)`  
- Свойства:  
  - `__class__` — `<class 'set'>`  
  - `__new__(cls, iterable=())`  
  - `__len__`, `__iter__`, `__contains__`, `__ior__`, `__iand__`, `__ixor__`, `__isub__`  
  - Не хэшируем  
  - Литералы — `{1, 2, 3}`, `{}` — **не** пустой `set`, а пустой `dict`; для `set()` требуется вызов конструктора  
  - Операции `in`, `add`, `discard`, `remove` — амортизированная `O(1)`

---

##### `frozenset`  

Неизменяемое множество.  
- Атрибуты: отсутствуют  
- Методы — все как у `set`, кроме изменяющих (`add`, `discard`, `pop`, и т.д.)  
- Свойства:  
  - `__class__` — `<class 'frozenset'>`  
  - `__new__(cls, iterable=())`  
  - `__len__`, `__iter__`, `__contains__`, `__or__`, `__and__`, `__xor__`, `__sub__`  
  - Хэшируем  
  - Литералов нет — только через конструктор

---

#### 1.2 Встроенные вызываемые объекты и служебные типы

##### `type`  

Метакласс по умолчанию.  
- Атрибуты:  
  - `__name__` — имя класса (`str`)  
  - `__qualname__` — квалифицированное имя (`str`)  
  - `__module__` — имя модуля, в котором определён класс  
  - `__bases__` — кортеж базовых классов  
  - `__mro__` — кортеж, порядок разрешения методов  
  - `__subclasses__()` — список прямых подклассов  
  - `__dict__` — `mappingproxy` с атрибутами класса  
  - `__annotations__` — словарь аннотаций типов полей класса (если есть)  
- Методы:  
  - `__call__()` — создаёт экземпляр класса (вызывает `__new__`, затем `__init__`)  
  - `__instancecheck__(instance)` — используется в `isinstance()`  
  - `__subclasscheck__(subclass)` — используется в `issubclass()`  
  - `mro()` — возвращает `__mro__`  
- Свойства:  
  - `__new__(cls, name, bases, dict, &#42;&#42;kwargs)` — конструктор класса  
  - Любой класс — экземпляр `type` или его подкласса  
  - Любой экземпляр класса — объект, чей `type(obj)` — класс  
  - Поддерживает наследование, множественное наследование, динамическое создание (`type('A', (), {})`)

---

##### `function`  

Объект, создаваемый при выполнении `def`.  
- Атрибуты:  
  - `__name__`, `__qualname__`, `__module__`, `__doc__`  
  - `__annotations__` — словарь аннотаций параметров и возвращаемого значения  
  - `__defaults__` — кортеж значений по умолчанию (позиционные, справа)  
  - `__kwdefaults__` — словарь значений по умолчанию для ключевых параметров  
  - `__code__` — объект `code`, байт-код функции  
  - `__globals__` — словарь глобальных переменных модуля  
  - `__closure__` — кортеж ячеек (`cell`), замыкание; `None`, если нет  
  - `__dict__` — пользовательский словарь (изменяемый, для метаданных)  
- Свойства:  
  - `__call__(*args, &#42;&#42;kwargs)` — вызов функции  
  - Поддерживает `pickle`, если не замыкает непикл-объекты  
  - Функции — хэшируемы

---

##### `builtin_function_or_method`  

Объекты, реализованные на уровне C (например, `len`, `print`, `int.bit_length`).  
- Атрибуты:  
  - `__name__`, `__doc__`, `__module__`  
  - `__self__` — для методов: экземпляр или класс, к которому привязан; у встроенных функций — `None`  
- Свойства:  
  - `__call__` — вызов реализован в C  
  - Не имеет `__code__`, `__defaults__`, `__closure__`, `__dict__`  
  - Хэшируем

---

##### `method`  

Метод экземпляра: вызов `obj.method` создаёт `method`, где `__func__` — функция из класса, `__self__` — `obj`.  
- Атрибуты:  
  - `__func__` — исходная функция (`function`)  
  - `__self__` — экземпляр  
  - `__doc__`, `__name__`, `__module__`, `__annotations__` — проксируются из `__func__`  
- Свойства:  
  - `__call__()` — вызывает `__func__(__self__, *args, &#42;&#42;kwargs)`  
  - Хэшируем, если `__self__` и `__func__` хэшируемы

---

##### `classmethod`  

Дескриптор, возвращающий `method`, где `__self__` — класс.  
- Атрибуты:  
  - `__func__` — функция, обёрнутая в `@classmethod`  
- Свойства:  
  - `__get__(instance, owner)` — возвращает `method(__func__, owner)`  
  - Вызываем напрямую: `cls.method()` → `__func__(cls, ...)`

---

##### `staticmethod`  

Дескриптор, возвращающий исходную функцию без привязки.  
- Атрибуты:  
  - `__func__` — функция  
- Свойства:  
  - `__get__(instance, owner)` — возвращает `__func__`  
  - Вызов: `cls.method()` или `obj.method()` → `__func__(...)`

---

##### `property`  

Дескриптор для управления доступом к атрибуту.  
- Атрибуты:  
  - `fget`, `fset`, `fdel`, `doc` — функции/строка  
- Методы:  
  - `getter(func)`, `setter(func)`, `deleter(func)` — возвращают новый `property`  
- Свойства:  
  - `__get__(obj, owner)` — вызывает `fget(obj)`  
  - `__set__(obj, value)` — вызывает `fset(obj, value)`  
  - `__delete__(obj)` — вызывает `fdel(obj)`  
  - Поддерживает декораторный синтаксис:  
```python
    @property
    def x(self): ...
    @x.setter
    def x(self, v): ...

`module`

Объект модуля (например, import math → math).

Атрибуты:
- __name__ — полное имя ('os.path', '__main__')
- __doc__ — строка документации модуля
- __package__ — имя пакета (или '' для верхнего уровня)
- __loader__, __spec__ — объекты загрузчика и спецификации
- __file__ — путь к .py (может отсутствовать)
- __cached__ — путь к .pyc
- __dict__ — словарь атрибутов модуля
Свойства:
- Все глобальные имена в модуле — атрибуты объекта module
- Поддерживает pickle (по имени)

`ellipsis`

Единственный экземпляр — ... (синтаксический литерал).

Атрибуты: отсутствуют
Использование:
- В типах: Tuple[int, ...]
- В срезах: a[...] для многомерных массивов (NumPy)
- Заглушка в заглушках (например, в abc.ABC)

`slice`

Объект среза ([start:stop:step]).

Атрибуты:
- start, stop, step — значения (None, если не указаны)
Методы:
- indices(length) — возвращает (start, stop, step), приведённые к length
Свойства:
- __new__(cls, stop) или __new__(cls, start, stop[, step])
- Хэшируем
- slice(None) эквивалентен [:]

`mappingproxy`

Только для чтения обёртка над dict (type.__dict__).

Атрибуты: отсутствуют
Методы:
- Все методы dict, кроме изменяющих (clear, update, __setitem__, и т.д.)
Свойства:
- __new__(cls, mapping)
- Динамически отражает изменения в оригинальном dict
- Хэшируем (только если оригинальный dict неизменяем, но в Python dict не хэшируем, поэтому mappingproxy не хэшируем)

`weakref.ref`

Слабая ссылка на объект.

Атрибуты: отсутствуют
Методы:
- __call__() — возвращает объект, если жив, иначе None
- __hash__() — хэш объекта, на который ссылается
Свойства:
- __new__(cls, obj[, callback])
- callback вызывается при сборке мусора объекта obj
- Не препятствует сборке мусора
- Нельзя создать для int, str, tuple, None, bool, type, function, если они не имеют __weakref__ в слотах

`weakref.proxy`

Прозрачная слабая ссылка (доступ как к оригиналу).

Атрибуты, методы: как у целевого объекта
Свойства:
- __new__(cls, obj[, callback])
- При обращении к атрибуту, если объект мёртв — ReferenceError
- Поддерживает арифметику, вызов, индексацию и т.д.

`generator`

Результат вызова функции с yield.

Атрибуты:
- __name__, __qualname__ — из функции
- gi_frame — объект frame (может быть None после завершения)
- gi_code — code функции
- gi_running — bool, выполняется ли сейчас
- gi_yieldfrom — None или подгенератор, если yield from
Методы:
- __next__() — продолжает выполнение до yield или StopIteration
- send(value) — передаёт значение в yield
- throw(type[, value[, traceback]]) — возбуждает исключение в генераторе
- close() — завершает генератор, вызывая GeneratorExit
Свойства:
- Реализует collections.abc.Iterator
- Не хэшируем
- После исчерпания — gi_frame = None, повторный __next__ → StopIteration

`coroutine`

Объект асинхронной функции (async def).

Атрибуты:
- __name__, __qualname__, __doc__
- cr_await — ожидаемый объект (None, если не в await)
- cr_frame, cr_code — текущий фрейм и код
- cr_running — bool
Методы:
- send(value)
- throw(type[, value[, traceback]])
- close()
Свойства:
- __await__() возвращает сам объект
- await coro → запускает выполнение до await или return
- После завершения — StopIteration (с value) или StopAsyncIteration; cr_frame = None

`async_generator`

Результат async def с yield.

Атрибуты:
- __name__, __qualname__
- ag_frame, ag_code, ag_running, ag_await
Методы:
- asend(value)
- athrow(type[, value[, traceback]])
- aclose()
- __aiter__() → сам объект
- __anext__() → awaitable, возвращает value или StopAsyncIteration
Свойства:
- Используется в async for
- Асинхронный аналог generator

`code`

Байт-код функции (доступен через func.__code__).

Атрибуты:
- co_argcount, co_posonlyargcount, co_kwonlyargcount
- co_nlocals, co_stacksize, co_flags
- co_code — bytes, байт-код
- co_consts — кортеж констант (None, int, str, code, ...)
- co_names — имена глобальных переменных
- co_varnames — имена локальных переменных
- co_filename, co_name, co_firstlineno
- co_lnotab — таблица сопоставления байт-код ↔ строки (устарела в 3.10+, заменена на co_lines())
- co_freevars, co_cellvars — имена замыканий
Методы:
- co_lines() — генератор (start, end, lineno) для отладки
- co_positions() — генератор (lineno, end_lineno, col_offset, end_col_offset)
Свойства:
- Хэшируем
- Конструируется через types.CodeType(...)

`frame`

Контекст выполнения (стек вызовов).

Атрибуты:
- f_back — предыдущий фрейм (None на вершине)
- f_code — code
- f_locals, f_globals, f_builtins — словари
- f_lasti — индекс текущей инструкции в co_code
- f_lineno — текущая строка
- f_trace — функция трассировки (sys.settrace)
- f_trace_lines, f_trace_opcodes — флаги трассировки
Свойства:
- Доступен через inspect.currentframe(), tb.tb_frame, gen.gi_frame
- Не рекомендуется к сохранению — содержит циклические ссылки
- f_locals может требовать f_locals.update() при изменении извне

`traceback`

Цепочка трассировок исключения.

Атрибуты:
- tb_next — следующий traceback (None, если конец)
- tb_frame — frame
- tb_lasti, tb_lineno — как в frame
Свойства:
- Хэшируем
- Сериализуется через traceback.print_tb(), traceback.format_tb()
- Используется в sys.exc_info()[2]

`getset_descriptor`

Дескриптор, вызываемый при доступе к атрибуту (__get__, __set__ реализованы в C).

Атрибуты:
- __name__, __doc__
Свойства:
- Используется в datetime.datetime.year, array.array.typecode и др.
- __get__(obj, type) → значение
- __set__(obj, value) → присваивание (если есть)
- __delete__ — опционален

`method_descriptor`, `wrapper_descriptor`

Объекты методов, реализованные в C (например, dict.get, list.append).

Атрибуты:
- __name__, __doc__, __qualname__, __objclass__
Свойства:
- При доступе через экземпляр → builtin_method_or_method_descriptor с __self__ = obj
- При доступе через класс → method_descriptor
- __get__(obj, type) возвращает привязанный метод
- Документация содержит сигнатуру в __text_signature__ (например, ($self, key, default=None, /))

1.3 Встроенные функции

(Выборочно — наиболее употребительные. Полный список: 70+)

`abs(x)`

Возвращает абсолютное значение:

int, float, complex → |x|
Объект с __abs__() → результат вызова
Сигнатура: abs(x: SupportsAbs[T]) -> T

`aiter(async_iterable)`

Возвращает асинхронный итератор через async_iterable.__aiter__()

`all(iterable)`

Возвращает True, если все элементы истинны или итерируемое пусто.

`any(iterable)`

Возвращает True, если хотя бы один элемент истинен.

`ascii(object)`

Возвращает repr(object), экранируя непечатаемые ASCII символы как \x, \u, \U.

`bin(x)`

Возвращает двоичную строку '0b...' для целого x.

`bool(x=False)`

Преобразует x в bool:

False — None, False, 0, 0.0, 0j, '', (), [], {}, set(), range(0)
True: всё остальное
Объект с __bool__() → результат вызова; иначе __len__() → len != 0

`breakpoint(*args, **kws)`

Вызывает sys.breakpointhook(*args, **kws) (по умолчанию — pdb.set_trace())

`bytearray(source=b'', encoding=None, errors='strict')`

Создаёт изменяемый байтовый массив.

source — int, str (с encoding), bytes, Iterable[int], buffer

`bytes(source=b'', encoding=None, errors='strict')`

Создаёт неизменяемый байтовый объект.

`callable(object)`

Возвращает True, если объект вызываем (__call__ существует и не None).

`chr(i)`

Возвращает строку длины 1 с Unicode-символом с кодом i (0 ≤ i ≤ 0x10FFFF)

`classmethod(func)`

Преобразует функцию в метод класса.

`compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)`

Компилирует source (строка/AST) в code.

mode — 'exec', 'eval', 'single'
optimize — -1 (текущий), 0, 1, 2

`complex(real=0, imag=0)`

Создаёт комплексное число.

real — int, float, complex, str (например, '3+4j')
imag: int, float

`delattr(object, name)`

Удаляет атрибут name из object (del object.name).

`dict(iterable=(), **kwargs)`

Создаёт словарь.

iterable: итератор пар (key, value)
**kwargs — именованные аргументы

`dir([object])`

Возвращает список имён в локальном пространстве имён (если object не указан) или атрибутов объекта.

Вызывает object.__dir__() при наличии
Иначе: sorted(object.__dict__.keys() + базовые атрибуты)

`divmod(a, b)`

Возвращает (a // b, a % b) для чисел; вызывает a.__divmod__(b).

`enumerate(iterable, start=0)`

Возвращает итератор кортежей (index, value).

`eval(expression, globals=None, locals=None)`

Выполняет строку как выражение.

globals, locals — словари; globals должен содержать __builtins__, если задан
Рекомендуется избегать при ненадёжном expression

`exec(object, globals=None, locals=None)`

Выполняет строку как оператор.

object — str, bytes, code
Возвращает None

`filter(function, iterable)`

Возвращает итератор, для которого function(item) истинно.

function = None → фильтрация на истинность

`float(x=0.0)`

Преобразует x в float.

x — int, float, str, bytes, объект с __float__()
float('inf'), float('-inf'), float('nan')

`format(value, format_spec='')`

Вызывает value.__format__(format_spec).

`frozenset(iterable=())`

Создаёт неизменяемое множество.

`getattr(object, name[, default])`

Возвращает object.name.

Если атрибут отсутствует и указан default — возвращает default
Иначе — AttributeError

`globals()`

Возвращает словарь глобальных переменных текущего модуля.

`hasattr(object, name)`

Возвращает True, если object имеет атрибут name.

`hash(object)`

Возвращает хэш объекта.

Объект должен быть хэшируем (__hash__ не None)
Хэш int равен значению (кроме -1, который отображается в -2)
Хэш str, bytes, tuple зависит от содержимого
Хэш None, True, False — фиксированные

`help([object])`

Запускает интерактивную справку.

help(str) → документация по str
Вызывает pydoc.help()

`hex(x)`

Возвращает шестнадцатеричную строку '0x...' для целого x.

`id(object)`

Возвращает уникальный идентификатор объекта (адрес в памяти в CPython).

`input([prompt])`

Читает строку из sys.stdin.

Выводит prompt, если задан
Возвращает str

`int(x=0, base=10)`

Преобразует x в целое.

x — int, float, str, bytes, Fraction, Decimal
base: 0 (авто) или 2–36
int('10', 2) == 2

`isinstance(object, classinfo)`

Проверяет, является ли object экземпляром classinfo.

classinfo — класс, кортеж классов, GenericAlias (например, list[int])
Учитывает наследование и __instancecheck__

`issubclass(class, classinfo)`

Проверяет, является ли class подклассом classinfo.

`iter(object[, sentinel])`

Возвращает итератор.

object с __iter__() → object.__iter__()
object с __getitem__() → итератор по индексам
sentinel: если задан — вызывает object() до возврата sentinel

`len(s)`

Возвращает длину: s.__len__()

`list(iterable=())`

Создаёт список.

`locals()`

Возвращает словарь локальных переменных текущего фрейма.

Изменения в словаре могут не влиять на фрейм (зависит от реализации)

`map(function, iterable, ...)`

Применяет function к элементам итерируемых.

Для нескольких итерируемых — function(item1, item2, ...)

`max(iterable, *[, key, default])`

Возвращает наибольший элемент.

key: функция для извлечения ключа сравнения
default: значение при пустом итерируемом

`min(...)`

Аналогично max, наименьший элемент.

`next(iterator[, default])`

Получает следующий элемент.

StopIteration, если итератор исчерпан и default не указан

`object()`

Создаёт базовый объект.

Единственный экземпляр без данных
Все объекты наследуют от object

`oct(x)`

Возвращает восьмеричную строку '0o...' для целого x.

`open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)`

Открывает файл.

mode — 'r', 'w', 'a', 'b', 't', '+'
buffering — -1 (по умолчанию), 0 (нет), 1 (строковый), >1 (размер)
encoding — 'utf-8', 'cp1251', и т.д.
errors — 'strict', 'ignore', 'replace', 'backslashreplace'
newline — управляет обработкой \n, \r\n, \r
Возвращает TextIOWrapper, BufferedWriter, FileIO в зависимости от режима

`ord(c)`

Возвращает код Unicode символа c (строка длины 1).

`pow(base, exp[, mod])`

Вычисляет base ** exp % mod, если mod задан, иначе base ** exp.

Поддерживает отрицательные степени при mod (только для целых, base и mod взаимно просты)

`print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)`

Выводит объекты.

sep — разделитель
end — завершающая строка
file — объект с write()
flush=True — сброс буфера немедленно

`property(fget=None, fset=None, fdel=None, doc=None)`

Создаёт дескриптор свойства.

`range(stop)`, `range(start, stop[, step])`

Создаёт арифметическую прогрессию.

Все параметры — целые
step != 0

`repr(object)`

Возвращает object.__repr__() — официальное строковое представление.

`reversed(seq)`

Возвращает итератор в обратном порядке.

seq должен иметь __reversed__() или поддерживать __len__ и __getitem__

`round(number[, ndigits])`

Округляет до ndigits знаков.

При .5 — к ближайшему чётному (round(2.5) == 2, round(3.5) == 4)
ndigits=None или не указан — округление до целого

`set(iterable=())`

Создаёт множество.

`setattr(object, name, value)`

Устанавливает object.name = value.

`slice(stop)`, `slice(start, stop[, step])`

Создаёт объект среза.

`sorted(iterable, *, key=None, reverse=False)`

Возвращает новый отсортированный список.

key: функция сортировки
reverse: порядок сортировки

`staticmethod(func)`

Преобразует функцию в статический метод.

`str(object='')`, `str(object=b'', encoding='utf-8', errors='strict')`

Создаёт строку.

Для bytes: декодирует через encoding

`sum(iterable, /, start=0)`

Суммирует элементы.

start — начальное значение
Не поддерживает строковые iterable (''.join вместо sum)

`super([type[, object-or-type]])`

Возвращает прокси для поиска атрибутов в базовых классах.

В методе: super() → super(текущий_класс, self)
Поддерживает MRO

`tuple(iterable=())`

Создаёт кортеж.

`type(object)`

Возвращает класс объекта.

`type(name, bases, dict, **kwargs)`

Создаёт новый класс.

`vars([object])`

Возвращает object.__dict__; без аргумента — locals().

`zip(*iterables, strict=False)`

Объединяет итерируемые поэлементно.

strict=False (по умолчанию): останавливается по короткому
strict=True: ValueError, если длины различаются

`import(name, globals=None, locals=None, fromlist=(), level=0)`

Низкоуровневый импорт модуля.

Используется в import ..., не рекомендуется напрямую
level: 0 (абсолютный), >0 (относительный)

1.4 Встроенные исключения

Иерархия (сокращённая, ключевые узлы):

BaseException
 ├── BaseExceptionGroup
 ├── GeneratorExit
 ├── KeyboardInterrupt
 ├── SystemExit
 └── Exception
      ├── ArithmeticError
      │    ├── FloatingPointError
      │    ├── OverflowError
      │    └── ZeroDivisionError
      ├── AssertionError
      ├── AttributeError
      ├── BufferError
      ├── EOFError
      ├── ImportError
      │    └── ModuleNotFoundError
      ├── LookupError
      │    ├── IndexError
      │    └── KeyError
      ├── MemoryError
      ├── NameError
      │    └── UnboundLocalError
      ├── OSError
      │    ├── BlockingIOError
      │    ├── ChildProcessError
      │    ├── ConnectionError
      │    │    ├── ...
      │    ├── FileExistsError
      │    ├── FileNotFoundError
      │    ├── InterruptedError
      │    ├── IsADirectoryError
      │    ├── NotADirectoryError
      │    ├── PermissionError
      │    ├── ProcessLookupError
      │    └── TimeoutError
      ├── ReferenceError
      ├── RuntimeError
      │    ├── NotImplementedError
      │    └── RecursionError
      ├── StopIteration
      ├── StopAsyncIteration
      ├── SyntaxError
      │    └── IndentationError
      │         └── TabError
      ├── SystemError
      ├── TypeError
      ├── ValueError
      │    └── UnicodeError
      │         ├── UnicodeDecodeError
      │         ├── UnicodeEncodeError
      │         └── UnicodeTranslateError
      └── Warning
           ├── ...

Каждый класс исключения имеет:

args — кортеж аргументов, переданных в конструктор
__cause__ — исключение, вызвавшее текущее (raise ... from ...)
__context__ — исключение, при обработке которого возникло текущее
__traceback__ — объект traceback
with_traceback(tb) — устанавливает __traceback__, возвращает исключение

1.5 Компактные шпаргалки

Таблицы для быстрого поиска по синтаксису. Подробнее о типах — в §1.1; о датах — в Даты и время; о дандер-методах — в Магические методы.

Индексы и срезы (`list`, `tuple`, `str`, `bytes`)

Для a = [0, 1, 2, 3, 4, 5]:

Выражение	Результат
`len(a)`	`6`
`a[0]`	`0`
`a[5]`	`5`
`a[-1]`	`5`
`a[-2]`	`4`
`a[1:]`	`[1, 2, 3, 4, 5]`
`a[:5]`	`[0, 1, 2, 3, 4]`
`a[:-2]`	`[0, 1, 2, 3]`
`a[1:3]`	`[1, 2]`
`a[1:-1]`	`[1, 2, 3, 4]`
`b = a[:]`	поверхностная копия списка

Отрицательный индекс считается с конца: -1 — последний элемент. Срез [start:stop:step] не включает stop.

Форматирование через `%` (устаревший стиль)

"значение: %s" % x или "%.2f" % (3.14159,). В новом коде предпочтительнее f-строки (f"{x}") и str.format().

Код	Назначение
`d`, `i`	целое со знаком (десятичное)
`o`	целое в восьмеричной системе
`x`, `X`	целое в шестнадцатеричной (`x` — нижний регистр)
`e`, `E`	экспоненциальная запись `float`
`f`, `F`	десятичная запись `float`
`g`, `G`	кратчайшая из `f` и `e`
`c`	один символ (целое или строка длины 1)
`r`	`repr()` объекта
`s`	`str()` объекта
`%`	литеральный символ `%`

Модификаторы: %(width)d, %(width).(prec)f, %-10s (выравнивание влево), %+d (знак у числа).

`strftime` — коды формата даты и времени

Работают в datetime.strftime(), date.strftime(), time.strftime() и time.strptime(). Локаль влияет на %a, %A, %b, %B, %c, %x, %X.

Код	Значение
`%a`	сокращённый день недели (`Sun`)
`%A`	полное название дня недели (`Sunday`)
`%b`	сокращённое название месяца (`Jan`)
`%B`	полное название месяца (`January`)
`%c`	дата и время в локали
`%d`	день месяца `01`–`31`
`%H`	час (24 ч) `00`–`23`
`%I`	час (12 ч) `01`–`12`
`%j`	день года `001`–`366`
`%m`	месяц `01`–`12`
`%M`	минуты `00`–`59`
`%p`	`AM` / `PM`
`%S`	секунды `00`–`59` (до `61` при високосной секунде)
`%U`	номер недели (воскресенье — первый день), `00`–`53`
`%w`	день недели `0` (вс) – `6` (сб)
`%W`	номер недели (понедельник — первый день), `00`–`53`
`%x`	дата в локали
`%X`	время в локали
`%y`	год без века `00`–`99`
`%Y`	год с веком (`2026`)
`%z`, `%Z`	смещение / имя часового пояса (если есть)
`%%`	литеральный `%`

Регистр важен: %m — месяц, %M — минуты; %d — день, %D — дата мм/дд/гг (расширение, не POSIX).

Часть 2. Стандартная библиотека Python

Версия: CPython 3.12. Покрытие — 130+ наиболее употребительных модулей.

2.1 `abc` — Abstract Base Classes

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

`ABC`

Базовый класс для абстрактных классов. Наследуется от metaclass=ABCMeta.

`ABCMeta`

Метакласс, проверяющий реализацию абстрактных методов при создании подкласса.

`abstractmethod(func)`

Декоратор: помечает метод как обязательный к переопределению.

Должен применяться до других декораторов (@property, @classmethod).
Если не переопределён — TypeError при создании экземпляра.

`abstractproperty`, `abstractclassmethod`, `abstractstaticmethod`

Устаревшие алиасы. Рекомендуется использовать комбинацию:

@property
@abstractmethod
def x(self): ...

`ABC.register(cls)`

Вручную регистрирует cls как виртуальный подкласс. Не проверяет реализацию.

`issubclass(cls, ABC)`, `isinstance(obj, ABC)`

Работают с виртуальными подклассами и проверяют реализацию интерфейса.

2.2 `argparse` — Парсинг аргументов командной строки

`ArgumentParser(prog=None, usage=None, description=None, epilog=None, parents=[], formatter_class=argparse.HelpFormatter, prefix_chars='-', fromfile_prefix_chars=None, argument_default=None, conflict_handler='error', add_help=True, allow_abbrev=True, exit_on_error=True)`

Основной класс.

parents — список других ArgumentParser, чьи аргументы наследуются
formatter_class — argparse.RawDescriptionHelpFormatter, argparse.ArgumentDefaultsHelpFormatter и др.
allow_abbrev — разрешить сокращённые имена (--ver → --verbose), по умолчанию True
exit_on_error — при ошибке вызывать sys.exit(), иначе — ArgumentError

`add_argument(name_or_flags..., action='store', nargs=None, const=None, default=None, type=None, choices=None, required=False, help=None, metavar=None, dest=None)`

Добавляет параметр.

action:
- 'store', 'store_const', 'store_true', 'store_false',
- 'append', 'append_const', 'count',
- 'help', 'version'
nargs — N, '?', '*', '+', argparse.REMAINDER
type — int, float, str, pathlib.Path, argparse.FileType('r'), пользовательские функции
choices: итерируемый, проверка in choices
default: значение по умолчанию (применяется, если аргумент не указан)
required: только для не-флагов (например, позиционных)
dest: имя атрибута в Namespace
metavar: имя в справке (--input FILE, а не --input INPUT)

`parse_args(args=None, namespace=None)`

Возвращает Namespace.

args=None → sys.argv[1:]
namespace=MyClass() → атрибуты присваиваются объекту

`parse_known_args(args=None, namespace=None)`

Возвращает (namespace, unknown_args) — для передачи неизвестных аргументов дальше.

`FileType(mode='r', bufsize=-1, encoding=None, errors=None)`

Тип для автоматического открытия файлов.

Используется как type=argparse.FileType('w')
Файлы закрываются при уничтожении Namespace

2.3 `asyncio` — Асинхронное программирование

Ядро асинхронного выполнения.

`run(coro, *, debug=None, loop_factory=None)`

Запускает корутину и возвращает результат.

Блокирует до завершения
Создаёт и закрывает EventLoop автоматически
loop_factory — вызываемый, возвращающий AbstractEventLoop

`create_task(coro, *, name=None, context=None)`

Создаёт Task в текущем цикле.

context — contextvars.Context, по умолчанию copy_context()

`gather(*aws, return_exceptions=False)`

Запускает awaitables параллельно.

Возвращает список результатов в порядке аргументов
return_exceptions=True → исключения возвращаются как значения
Отмена gather() отменяет все задачи

`wait(aws, *, timeout=None, return_when=ALL_COMPLETED)`

Ждёт завершения awaitables.

Возвращает (done: set, pending: set)
return_when — FIRST_COMPLETED, FIRST_EXCEPTION, ALL_COMPLETED

`as_completed(aws, *, timeout=None)`

Асинхронный итератор: итерирует по мере завершения.

`EventLoop`

Основной цикл событий.

run_until_complete(future)
run_forever(), stop()
call_soon(callback, *args, context=None)
call_later(delay, callback, *args, context=None)
call_at(when, callback, *args, context=None)
time() — монотонное время в секундах
create_future()
create_task(coro)
run_in_executor(executor, func, *args) — запускает в потоке/процессе
add_reader(fd, callback, *args) / remove_reader(fd)
add_writer(fd, callback, *args) / remove_writer(fd)

Потокобезопасные методы:

call_soon_threadsafe(callback, *args, context=None)
loop.call_soon_threadsafe(...) — единственный способ запланировать из другого потока

`Task(coro, *, loop=None, name=None, context=None)`

Обёртка над корутиной.

done(), cancelled(), result(), exception(), add_done_callback(fn), remove_done_callback(fn)
cancel() — запрашивает отмену; cancellation() не гарантирует немедленное завершение
get_name(), set_name(name)

`Future`

Низкоуровневый примитив.

set_result(value), set_exception(exc)
result(), exception() блокируют, если не готовы
Поддерживает await

`Lock`, `Event`, `Condition`, `Semaphore`, `Barrier`

Асинхронные аналоги threading.

Используют await acquire(), release()
Event.wait(), Event.set(), Event.clear()
Condition.wait(), Condition.notify(), Condition.notify_all()
Все примитивы привязаны к текущему циклу

`Stream`

open_connection(host, port, ...) → (reader: StreamReader, writer: StreamWriter)
start_server(client_connected_cb, host, port, ...)
StreamReader.read(n=-1), readline(), readuntil(), readexactly()
StreamWriter.write(Данные), drain(), close(), wait_closed()
drain() — await при буфере > 64 КБ (предотвращает OOM)

`subprocess`

create_subprocess_exec(*args, stdin=None, stdout=None, stderr=None, ...)
Возвращает Process с атрибутами stdin, stdout, stderr (StreamWriter/StreamReader)
wait(), communicate(), terminate(), kill()

`run_in_executor(executor, func, *args)`

Запускает func(*args) в concurrent.futures.Executor.

По умолчанию — ThreadPoolExecutor
Для CPU-bound — ProcessPoolExecutor

2.4 `collections` — Дополнительные типы данных

`namedtuple(typename, field_names, *, rename=False, defaults=None, module=None)`

Фабрика классов: неизменяемый кортеж с именованными полями.

rename=True — переименовывает некорректные имена (class, 1 → _1)
defaults — кортеж значений по умолчанию (справа)
Экземпляр имеет __slots__ = (), меньше памяти, чем dict
Поддерживает pickle, __eq__, __repr__, ._asdict(), ._replace(), ._fields, ._field_defaults

`deque(iterable=(), maxlen=None)`

Двусторонняя очередь.

append(x), appendleft(x), pop(), popleft() — O(1)
extend(iterable), extendleft(iterable)
rotate(n=1) — сдвиг на n (отрицательный — влево)
maxlen — автоматически popleft() при переполнении
copy(), __copy__(), __deepcopy__()
Потокобезопасен для операций с одной стороны (но не атомарен при maxlen)

`ChainMap(*maps)`

Цепочка словарей для поиска.

maps — список отображений ([first, second, ...])
new_child(m=None) → ChainMap(m, *maps)
parents → ChainMap(*maps[1:])
Изменения ведутся в первом словаре

`Counter(iterable_or_mapping=(), **kwds)`

Счётчик хэшируемых объектов.

инкремент

update(iterable_or_mapping)

subtract(iterable_or_mapping) — декремент
most_common(n=None) — сортировка по убыванию
elements() — итератор, повторяющий элементы по счётчику
+, -, &, | — арифметика (неотрицательные значения)

`OrderedDict()`

Устарел с Python 3.7 (обычный dict сохраняет порядок).

move_to_end(key, last=True)
popitem(last=True)

`defaultdict(default_factory=None)`

Словарь с автоматической инициализацией отсутствующих ключей.

default_factory — list, set, int, lambda: 0, и т.д.
__missing__(key) вызывает default_factory(), сохраняет и возвращает

`UserDict`, `UserList`, `UserString`

Обёртки для наследования с переопределением Данные.

UserDict → self.Данные: dict
UserList → self.Данные: list
UserString → self.Данные: str
Рекомендованы вместо прямого наследования от dict/list/str

2.5 `contextlib` — Управление контекстами

`contextmanager(func)`

Декоратор: превращает генератор в менеджер контекста.

@contextmanager
def ctx():
    setup()
    try:
        yield resource
    finally:
        cleanup()

`asynccontextmanager(func)`

Асинхронный аналог.

`ContextDecorator`

Базовый класс: позволяет использовать объект и как менеджер контекста, и как декоратор.

`nullcontext(enter_result=None)`

Пустой контекст: enter_result возвращается из __enter__().

`ExitStack()`

Динамическое управление несколькими контекстами.

enter_context(cm)
push(exit) — функция exit(exc_type, exc, tb)
callback(callback, *args, **kwds)
close() — вызывает все exit в обратном порядке
__enter__ возвращает self

`AsyncExitStack()`

Асинхронный аналог.

2.6 `dataclasses` — Классы данных

`@dataclass(*, init=True, repr=True, eq=True, order=False, unsafe_hash=False, frozen=False, match_args=True, kw_only=False, slots=False, weakref_slot=False)`

Декоратор для автоматической генерации методов.

init — генерирует __init__(self, a, b=...)
repr: __repr__() в виде ClassName(a=1, b=2)
eq: __eq__() по полям
order — генерирует __lt__, __le__, __gt__, __ge__
frozen=True: имитирует неизменяемость (__setattr__ → FrozenInstanceError)
kw_only=True: все поля — ключевые (начиная с Python 3.10)
slots=True: создаёт __slots__, снижает потребление памяти
weakref_slot=True: добавляет __weakref__ в __slots__

`field(*, default=MISSING, default_factory=MISSING, init=True, repr=True, hash=None, compare=True, metadata=None, kw_only=MISSING)`

Настройка отдельного поля.

default_factory=lambda: [] — для мутабельных значений
hash=False — исключить из __hash__()
compare=False — исключить из сравнения
metadata — произвольный Mapping (доступен через fields(cls)[i].metadata)

`asdict(obj, *, dict_factory=dict)`

Рекурсивно преобразует в dict.

dataclass → dict, tuple → list, set → list
Циклические ссылки → RecursionError

`astuple(obj, *, tuple_factory=tuple)`

Аналогично, в tuple.

`is_dataclass(obj)`

Проверяет, является ли obj классом или экземпляром dataclass.

`fields(cls)`

Возвращает кортеж Field объектов.

`replace(obj, **changes)`

Возвращает новый экземпляр с изменёнными полями (только для frozen=False или __post_init__ корректен).

2.7 `datetime` — Дата и время

`date(year, month, day)`

Атрибуты — year, month, day
Методы:
- today(), fromtimestamp(timestamp), fromordinal(ordinal)
- replace(year, month, day)
- timetuple() → time.struct_time
- toordinal()
- weekday() (0=понедельник), isoweekday() (1=понедельник)
- isocalendar() → (year, week, weekday)
- isoformat(), __str__() → YYYY-MM-DD
- ctime(), strftime(format)

`time(hour=0, minute=0, second=0, microsecond=0, tzinfo=None, fold=0)`

fold — для разрешения неоднозначности при переходе на зимнее время (0 или 1)
Методы — replace(), isoformat(), strftime(), utcoffset(), dst(), tzname()

`datetime(year, month, day, hour=0, minute=0, second=0, microsecond=0, tzinfo=None, *, fold=0)`

Наследует методы от date и time
now(tz=None), utcnow(), fromtimestamp(timestamp, tz=None), utcfromtimestamp(timestamp)
strptime(date_string, format)
combine(date, time, tzinfo=None)
timestamp() — возвращает POSIX timestamp (секунды с 1970-01-01 UTC)

`timedelta(days=0, seconds=0, microseconds=0, milliseconds=0, minutes=0, hours=0, weeks=0)`

Только days, seconds, microseconds хранятся; остальное конвертируется
Поддерживает +, -, * (int/float), /, //, %, divmod
total_seconds() — общее количество секунд (float)

`timezone(offset, name=None)`

offset: timedelta, -14:00 ≤ offset ≤ +14:00
utc = timezone.utc

`tzinfo`

Абстрактный базовый класс.

utcoffset(dt), dst(dt), tzname(dt)
fromutc(dt) — для обратного преобразования

`datetime.astimezone(tz=None)`

Преобразует в указанную зону.

tz=None → локальная зона (tzlocal())
Требует, чтобы исходный datetime был aware (либо tzinfo, либо вызван replace(tzinfo=...))

2.8 `functools` — Функциональные примитивы

`cache(user_function)`

Декоратор: кэширует вызовы (LRU без ограничения размера).

Аналог lru_cache(maxsize=None)
Потокобезопасен, использует dict

`lru_cache(maxsize=128, typed=False)`

Кэш с ограничением размера (Least Recently Used).

maxsize=None — без ограничения
typed=True — 3 и 3.0 кэшируются отдельно
Методы экземпляра: cache_info(), cache_clear()

`partial(func, /, *args, **keywords)`

Частичное применение.

partial(func, a, b=2)(c, d=3) → func(a, c, b=2, d=3)
Атрибуты — func, args, keywords

`partialmethod(func, /, *args, **keywords)`

Аналог partial, но для методов (работает в классе).

`singledispatch(func)`

Диспетчеризация по типу первого аргумента.

@func.register(cls) — регистрирует реализацию для cls
Поддерживает наследование
@func.register без аргумента — регистрация по аннотации func.__annotations__['obj']

`singledispatchmethod(func)`

Вариант для методов.

`wraps(wrapped, assigned=WRAPPER_ASSIGNMENTS, updated=WRAPPER_UPDATES)`

Декоратор — копирует метаданные (__name__, __doc__, __annotations__) из wrapped в обёртку.

`total_ordering(cls)`

Декоратор — добавляет недостающие методы сравнения, если реализованы __eq__ и один из __lt__, __le__, __gt__, __ge__.

`cmp_to_key(mycmp)`

Преобразует функцию сравнения mycmp(a, b) → -1/0/1 в ключ для sorted(), min(), max().

2.9 `itertools` — Итераторы для эффективных циклов

`count(start=0, step=1)`

Бесконечный счётчик. next() → start, start+step, ...

`cycle(iterable)`

Циклически повторяет iterable.

`repeat(object, times=None)`

Повторяет объект. times=None — бесконечно.

`chain(*iterables)`

Объединяет итерируемые в один поток.

`compress(Данные, selectors)`

Возвращает элементы Данные, где selectors истинны.

`dropwhile(predicate, iterable)`

Пропускает элементы, пока predicate истинен, затем возвращает остальное.

`takewhile(predicate, iterable)`

Возвращает элементы, пока predicate истинен.

`filterfalse(predicate, iterable)`

Обратное filter: возвращает, где predicate ложен.

`groupby(iterable, key=None)`

Группирует последовательные одинаковые элементы по key(item).

Требует предварительной сортировки, если нужна полная группировка

`islice(iterable, start, stop[, step])`

Срез итератора без полной материализации.

`starmap(function, iterable)`

function(*args) для каждого args в iterable.

`tee(iterable, n=2)`

Возвращает n независимых итераторов из одного.

Буферизация происходит по мере отставания итераторов
Не рекомендуется при большом разрыве

`zip_longest(*iterables, fillvalue=None)`

Как zip, но до самого длинного; недостающие — fillvalue.

`product(*iterables, repeat=1)`

Декартово произведение.

product('AB', 'xy') → ('A','x'), ('A','y'), ('B','x'), ('B','y')

`permutations(iterable, r=None)`

Все перестановки длины r (r=None → len(iterable)).

`combinations(iterable, r)`

Все сочетания без повторений.

`combinations_with_replacement(iterable, r)`

Сочетания с повторениями.

2.10 `json` — JSON-сериализация

`dumps(obj, *, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, cls=None, indent=None, separators=None, default=None, sort_keys=False, **kw)`

Сериализует в строку.

ensure_ascii=True — все не-ASCII экранируются (\uXXXX)
indent=2 или ' ' — красивый вывод
separators=(',', ':') — по умолчанию; (',', ': ') для читаемости
default — функция для несериализуемых объектов
sort_keys=True — для детерминированного вывода

`dump(obj, fp, ...)`

Записывает в файлоподобный объект fp.write().

`loads(s, *, cls=None, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, object_pairs_hook=None, **kw)`

Десериализует строку.

object_hook=dict → вызывается для каждого dict: object_hook(d)
object_pairs_hook — имеет приоритет; принимает список пар [('a',1), ...]
parse_float=float, parse_int=int, parse_constant для NaN, Infinity

`load(fp, ...)`

Читает из fp.read().

`JSONEncoder`, `JSONDecoder`

Базовые классы для кастомизации.

Переопределяется JSONEncoder.default(self, obj)
JSONDecoder.object_hook, JSONDecoder.parse_float, и т.д.

2.11 `logging` — Журналирование

`getLogger(name=None)`

Возвращает или создаёт логгер с именем name.

name=None или '' → корневой логгер (logging.root)
Иерархия через точки: getLogger('a.b') — дочерний для getLogger('a')
Наследует уровень и обработчики от родителя, если не переопределены

`Logger`

Основной класс.

Уровни (числовые значения):
- CRITICAL = 50
- ERROR = 40
- WARNING = 30
- INFO = 20
- DEBUG = 10
- NOTSET = 0
Методы записи:
- debug(msg, *args, **kwargs)
- info(...), warning(...), error(...), critical(...)
- log(level, msg, *args, **kwargs)
- exception(msg, *args, exc_info=True, **kwargs) — логирует текущее исключение
Дополнительно:
- setLevel(level)
- addHandler(hdlr), removeHandler(hdlr)
- isEnabledFor(level)
- findCaller(stack_info=False, stacklevel=1)
Поведение по умолчанию: корневой логгер имеет WARNING и StreamHandler(sys.stderr)

`Handler`

Базовый класс обработчиков.
Подклассы:

StreamHandler(stream=None) → sys.stderr по умолчанию
FileHandler(filename, mode='a', encoding=None, delay=False)
RotatingFileHandler(filename, mode='a', maxBytes=0, backupCount=0, encoding=None, delay=False)
- При maxBytes > 0 — переключает на filename.1, filename.2, ...
TimedRotatingFileHandler(filename, when='h', interval=1, backupCount=0, ...)
- when — 'S', 'M', 'H', 'D', 'W0'–'W6', 'midnight'
SocketHandler(host, port)
HTTPHandler(host, url, method='GET')
BufferingHandler(capacity) — буферизует до capacity записей
MemoryHandler(capacity, flushLevel=ERROR, target=None) — сбрасывает при flushLevel

`Formatter(fmt=None, datefmt=None, style='%', validate=True, *, defaults=None)`

Форматирует сообщения.

style='%': '%(levelname)s:%(name)s:%(message)s'
style='{': '{levelname}:{name}:{message}'
style='$': '$levelname:$name:$message'
Стандартные поля:
- name, levelno, levelname, pathname, filename, module, lineno, funcName,
- created (timestamp), asctime, msecs, relativeCreated,
- thread, threadName, process, processName,
- message
datefmt — как в time.strftime()
defaults — словарь дополнительных полей по умолчанию

`Filter`

Фильтрует записи.

filter(record) → 0 (отклонить) / 1 (пропустить)
name — допускает только логгеры, начинающиеся с name

`LogRecord`

Представляет одну запись.

Поля заполняются автоматически при вызове logger.info(...)
Доступны через record.levelname, record.message, и т.д.
getMessage() — возвращает msg % args

`basicConfig(**kwargs)`

Настройка корневого логгера один раз (игнорируется при повторном вызове, если уже настроен).
Параметры:

level
filename, filemode='a'
format, datefmt, style
handlers — список обработчиков (если задан, игнорирует filename, filemode, stream)
force=False — перенастроить, даже если уже настроен (Python ≥ 3.8)
encoding=None, errors=None

Потокобезопасность

Logger, Handler, Formatter — потокобезопасны
Используют внутренние блокировки (threading.RLock)
Не гарантируется порядок записей при высокой нагрузке

Стандартные обработчики для продвинутого использования

QueueHandler(queue) + QueueListener(handler, ...) — асинхронная запись
NullHandler() — заглушка для библиотек (не выводит, не создаёт предупреждения)

2.12 `multiprocessing` — Параллелизм на основе процессов

`Process(target=None, args=(), kwargs={}, *, name=None, daemon=None)`

Аналог threading.Thread, но запускает новый процесс.

, join([timeout]), is_alive(), terminate(), kill(), close()

start()

pid, exitcode, name, daemon
close() освобождает ресурсы (Python ≥ 3.7)

`Queue([maxsize])`

Межпроцессная очередь (на основе Pipe + фоновый поток).

put(obj[, block[, timeout]]), get([block[, timeout]])
qsize(), empty(), full() — ненадёжны в многопроцессной среде
Не поддерживает pickle-небезопасные объекты

`Pipe([duplex])`

Возвращает (conn1, conn2) — соединение "точка-точка".

duplex=True (по умолчанию) — двунаправленное
send(obj), recv()
poll([timeout]), close(), fileno()
Поддерживает передачу файловых дескрипторов (Unix)

`Manager()`

Создаёт прокси-объекты для совместного использования:

list(), dict(), Namespace(), Lock(), RLock(), Semaphore(), BoundedSemaphore(), Condition(), Event(), Barrier(), Queue(), Value(), Array()
Серверный процесс управляет состоянием
Медленнее, чем multiprocessing.Queue, но гибче

`Value(typecode_or_type, *args, lock=True)`

Разделяемая память для одного значения.

typecode_or_type — 'i', 'd', ctypes.c_int, и т.д.
lock=False — отключает синхронизацию (опасно)
Доступ через .value

`Array(typecode_or_type, size_or_initializer, *, lock=True)`

Разделяемый массив.

Доступ через arr[i], arr[:]
Поддерживает срезы и присваивание

`Pool([processes[, initializer[, initargs[, maxtasksperchild[, context]]]]])`

Пул рабочих процессов.

apply(func, args=..., kwds=...) — синхронно
apply_async(func, args=..., kwds=..., callback=None, error_callback=None)
map(func, iterable[, chunksize]), map_async(...)
starmap(func, iterable[, chunksize]), starmap_async(...)
imap(func, iterable[, chunksize]) → итератор (ленивый)
imap_unordered(...)
close(), terminate(), join()
maxtasksperchild — перезапуск процесса после N задач (предотвращает утечки)

`get_context(method=None)`

Возвращает контекст запуска:

'fork' (Unix, по умолчанию) — копирует процесс
'spawn' (Windows, также на Unix) — запускает новый интерпретатор
'forkserver' — отдельный сервер форкает процессы
Важно для совместимости с CUDA, GUI, и т.д.

`current_process()`

Возвращает объект текущего процесса (Process).

pid, name, authkey, exitcode, daemon

`set_start_method(method, force=False)`

Устанавливает метод запуска глобально. Вызывать до создания любых объектов.

2.13 `os` — Интерфейс к операционной системе

Пути и файлы

sep, altsep, pathsep, linesep, curdir, pardir, defpath, devnull — константы
name — 'posix', 'nt', 'java'
path — объект с методами:
- exists(path), isfile(path), isdir(path), islink(path)
- getsize(path), getmtime(path), getatime(path), getctime(path)
- join(a, *p), split(path), splitext(path), dirname(path), basename(path)
- normpath(path), abspath(path), realpath(path), relpath(path, start=curdir)
- expanduser(path), expandvars(path)
- commonprefix(list), commonpath(paths)

Рабочая директория

getcwd(), chdir(path), mkdir(path, mode=0o777), makedirs(name, mode=0o777, exist_ok=False)
rmdir(path), removedirs(name)
listdir(path='.'), walk(top, topdown=True, onerror=None, followlinks=False)

Процессы и окружение

getpid(), getppid(), getuid(), getgid(), geteuid(), getegid()
environ — мутабельный словарь переменных окружения
getenv(key, default=None), putenv(key, value), unsetenv(key)
System(command), popen(cmd, mode='r', buffering=-1) — устаревшее, использовать subprocess

Управление файлами

open(path, flags, mode=0o777, *, dir_fd=None) — низкоуровневое (os.O_RDONLY, os.O_WRONLY | os.O_CREAT, и т.д.)
close(fd), read(fd, n), write(fd, str), lseek(fd, pos, how)
fstat(fd), stat(path), lstat(path) → объект os.stat_result
chmod(path, mode), chown(path, uid, gid), utime(path, times=None, *, ns=None)
link(src, dst), symlink(src, dst), readlink(path), unlink(path), rename(src, dst), replace(src, dst)

Сигналы (Unix)

kill(pid, sig), getpgid(pid), setpgid(pid, pgid)
killpg(pgid, sig)

Прочее

urandom(n) — криптостойкий генератор (/dev/urandom или CryptGenRandom)
ctermid() — путь к управляющему терминалу
ttyname(fd) — имя терминала по дескриптору
getloadavg() — загрузка системы (Unix)

Потокобезопасность

Большинство вызовов — обёртки над системными вызовами, атомарны
environ — не потокобезопасен в CPython < 3.4; с 3.4+ — потокобезопасен

2.14 `pathlib` — Объектно-ориентированный интерфейс к путям

`PurePath(*pathsegments)`

Чисто вычислительный, без доступа к ФС.

PurePosixPath, PureWindowsPath — platform-specific
Операторы — / (конкатенация), // (аналогично /), in (проверка подпути)
Свойства:
- drive, root, anchor, parents, parent, name, stem, suffix, suffixes
Методы:
- as_posix(), as_uri(), is_absolute(), is_relative_to(other), joinpath(*other),
- match(pattern), relative_to(*other), with_name(name), with_stem(stem), with_suffix(suffix)

`Path(*pathsegments)`

Наследует от PurePath, добавляет ФС-операции.

cwd(), home() — классовые методы
ФС-методы:
- stat(), lstat(), owner(), group()
- chmod(mode), lchmod(mode), utime(times=None, ns=None)
- exists(), is_dir(), is_file(), is_symlink(), is_block_device(), is_char_device(), is_fifo(), is_socket()
- resolve(strict=False), absolute()
- glob(pattern), rglob(pattern)
- open(mode='r', buffering=-1, encoding=None, errors=None, newline=None)
- read_text(encoding=None, errors=None), write_text(Данные, encoding=None, errors=None)
- read_bytes(), write_bytes(Данные)
- mkdir(mode=0o777, parents=False, exist_ok=False)
- touch(mode=0o666, exist_ok=True)
- rename(target), replace(target), unlink(missing_ok=False)
- rmdir(), iterdir(), walk(top_down=True, on_error=None, follow_symlinks=False)

Совместимость

os.PathLike — протокол: __fspath__()
Все функции os, shutil, open принимают Path

2.15 `re` — Регулярные выражения

Общие параметры

Все функции принимают pattern (строка или скомпилированный Pattern)
Флаги (flags):
- re.IGNORECASE (re.I)
- re.MULTILINE (re.M)
- re.DOTALL (re.S)
- re.UNICODE (re.U, по умолчанию в Python 3)
- re.ASCII (re.A) — ограничивает \w, \d, \s ASCII
- re.VERBOSE (re.X) — игнорирует пробелы и комментарии в шаблоне

Компиляция

compile(pattern, flags=0) → re.Pattern
- Атрибуты: pattern, flags
- Методы — match(), fullmatch(), search(), findall(), finditer(), split(), sub(), subn()

Поиск и сопоставление

match(string, pos=0, endpos=sys.maxsize)
- Сопоставляет только с начала строки
- Возвращает Match или None
fullmatch(string, pos=0, endpos=sys.maxsize)
- Требует полного совпадения всей строки
search(string, pos=0, endpos=sys.maxsize)
- Ищет первое совпадение в любом месте
findall(string, pos=0, endpos=sys.maxsize)
- Возвращает список строк или кортежей (если групп > 1)
finditer(string, pos=0, endpos=sys.maxsize)
- Возвращает итератор Match

Замена и разбиение

sub(repl, string, count=0)
- repl: строка или вызываемый (lambda m: ...)
- \g<0>, \g<name>, \1, \g<1> — подстановка групп
subn(repl, string, count=0) → (new_string, n_subs)
split(string, maxsplit=0)
- Возвращает список фрагментов; совпадения не включаются
- Если группа в шаблоне — совпадения групп также включаются в результат

`Match` объект

group([group1, ...]) → строка или кортеж
groups(default=None) → кортеж всех групп
groupdict(default=None) → dict именованных групп
, end([group]), span([group])

start([group])

expand(template) — как sub(), но только для одного совпадения

Синтаксис шаблонов

. — любой символ (кроме \n, если не re.S)
^, $ — начало/конец строки (re.M → начало/конец строки в многострочном тексте)
\d, \D, \s, \S, \w, \W
[abc], [^abc], [a-z]
*, +, ?, {m,n}, {m,}, {,n}
(...), (?P<name>...), (?:...), (?=...), (?!...), (?<=...), (?<!...)
\A, \Z, \b, \B

Безопасность

Некоторые регулярные выражения вызывают катастрофический откат (catastrophic backtracking)
Используйте re.search() с ограничением по длине, либо сторонние движки (regex вместо re) при необходимости

2.16 `shutil` — Высокоуровневые операции с файлами

Копирование

copyfile(src, dst, *, follow_symlinks=True)
- Только содержимое, без метаданных
- dst — путь, не дескриптор
copymode(src, dst, *, follow_symlinks=True)
- Права доступа (chmod)
copystat(src, dst, *, follow_symlinks=True)
- Временные метки, права, ACL (если поддерживается)
copy(src, dst, *, follow_symlinks=True)
- copyfile() + copymode()
copy2(src, dst, *, follow_symlinks=True)
- copyfile() + copystat() — "полная" копия
copytree(src, dst, symlinks=False, ignore=None, copy_function=copy2, ignore_dangling_symlinks=False, dirs_exist_ok=False)
- Рекурсивно копирует дерево каталогов
- ignore — вызываемый: ignore(dir, names) → set(names_to_skip)
- dirs_exist_ok=True (Python ≥ 3.8) — разрешает существование dst

Перемещение и удаление

move(src, dst, copy_function=copy2)
- Атомарно при os.rename() (если на одной ФС), иначе копия + удаление
rmtree(path, ignore_errors=False, onerror=None)
- Рекурсивное удаление каталога
- onerror(function, path, exc_info) — для обработки ошибок
.rmtree.avoids_symlink_attacks — флаг (True на Unix с lstat)

Архивирование

make_archive(base_name, format, root_dir=None, base_dir=None, verbose=0, dry_run=0, owner=None, group=None, logger=None)
- format — 'zip', 'tar', 'gztar', 'bztar', 'xztar'
- Возвращает полный путь к архиву
get_archive_formats() → список поддерживаемых форматов
unpack_archive(filename, extract_dir=None, format=None)
- Автоопределение формата, если format=None

Прочее

which(cmd, mode=os.F_OK | os.X_OK, path=None)
- Ищет исполняемый файл в PATH, как which в оболочке
disk_usage(path) → namedtuple(total, used, free)
chown(path, user=None, group=None)
- Принимает имена или UID/GID
get_terminal_size(fallback=(80, 24)) → (columns, lines)
register_archive_format(name, function, ...)
register_unpack_format(name, extensions, function, ...)

2.17 `signal` — Обработка сигналов (Unix)

Константы сигналов

SIGINT, SIGTERM, SIGKILL, SIGSTOP, SIGHUP, SIGUSR1, SIGUSR2, SIGALRM, и др.
SIG_DFL, SIG_IGN, SIG_ERR

Управление

signal(signalnum, handler)
- handler: вызываемый (def handler(signum, frame): ...), SIG_DFL, SIG_IGN
- Возвращается предыдущий обработчик
getsignal(signalnum)
pause() — приостанавливает процесс до получения сигнала
alarm(seconds) → оставшееся время предыдущего таймера
setitimer(which, seconds, interval=0.0) — интервальные таймеры (ITIMER_REAL, ITIMER_VIRTUAL, ITIMER_PROF)
getitimer(which)
siginterrupt(signalnum, flag) — прерывать ли системные вызовы (EINTR)

Ограничения

Обработчики выполняются в основном потоке
Внутри обработчика допустимо только async-signal-safe API:
- signal(), write(), kill(), _exit(), getattr() на простых объектах
- Нельзя — print(), logging, sys.stdout.write() (если буферизован), threading, gc, sys.exit()
В Windows поддерживается только SIGINT, SIGBREAK, SIGABRT

2.18 `socket` — Сетевые сокеты

Константы

AF_INET, AF_INET6, AF_UNIX
SOCK_STREAM, SOCK_DGRAM, SOCK_RAW
SOL_SOCKET, IPPROTO_TCP, IPPROTO_UDP
SO_REUSEADDR, SO_REUSEPORT, SO_KEEPALIVE, TCP_NODELAY

Создание

socket(family=AF_INET, type=SOCK_STREAM, proto=0, fileno=None)
fromfd(fd, family, type, proto=0)
socketpair(family=AF_UNIX, type=SOCK_STREAM, proto=0)

Атрибуты

family, type, proto, fileno()

Основные методы

bind(address)
listen([backlog])
accept() → (conn, address)
connect(address)
connect_ex(address) → код ошибки (0 при успехе)
send(bytes[, flags]), sendall(bytes[, flags])
recv(bufsize[, flags]), recvfrom(bufsize[, flags])
sendto(bytes, address[, flags])
close(), detach()
shutdown(how) — SHUT_RD, SHUT_WR, SHUT_RDWR

Управление

setblocking(flag)
settimeout(value) — None (блокирующий), 0.0 (неблокирующий), >0 (таймаут)
gettimeout()
setsockopt(level, optname, value)
getsockopt(level, optname[, buflen])
getpeername(), getsockname()

Вспомогательные функции

gethostname()
gethostbyname(hostname)
getaddrinfo(host, port, family=0, type=0, proto=0, flags=0)
- Возвращает список (family, type, proto, canonname, sockaddr)
getnameinfo(sockaddr, flags)
inet_aton(ip_string), inet_ntoa(packed_ip)
inet_pton(address_family, ip_string), inet_ntop(address_family, packed_ip)

Исключения

error — базовый класс (OSError подкласс)
herror, gaierror, timeout

2.19 `subprocess` — Запуск дочерних процессов

`run(args, *, stdin=None, input=None, stdout=None, stderr=None, capture_output=False, timeout=None, check=False, encoding=None, errors=None, text=None, env=None, universal_newlines=None, **other_popen_kwargs)`

Рекомендуемый интерфейс
Возвращает CompletedProcess(args, returncode, stdout, stderr)
capture_output=True ⇔ stdout=PIPE, stderr=PIPE
text=True ⇔ encoding='utf-8' (или universal_newlines=True)
check=True → CalledProcessError, если returncode != 0
timeout → TimeoutExpired, если превышено

`Popen(args, bufsize=-1, executable=None, stdin=None, stdout=None, stderr=None, preexec_fn=None, close_fds=True, shell=False, cwd=None, env=None, universal_newlines=None, startupinfo=None, creationflags=0, restore_signals=True, start_new_session=False, pass_fds=(), *, encoding=None, errors=None, text=None)`

Низкоуровневый интерфейс
Методы:
- poll() → returncode или None
- wait(timeout=None)
- communicate(input=None, timeout=None) → (stdout, stderr)
- send_signal(signal), terminate(), kill()
- pid, returncode
shell=True — интерпретирует args как строку и запускает /bin/sh -c
preexec_fn — вызывается в дочернем процессе перед exec (только Unix)
pass_fds — передача дескрипторов (Unix)

Потокобезопасность и буферизация

stdout=PIPE не следует использовать при объёме > 64 КБ без communicate()
Для потоковой обработки — использовать asyncio.create_subprocess_* или threading + queue.Queue

2.20 `sys` — Системные параметры и функции

Атрибуты

argv — аргументы командной строки (argv[0] — имя скрипта или -c)
path — пути поиска модулей
modules — кэш загруженных модулей
builtin_module_names — кортеж встроенных модулей
platform — 'linux', 'win32', 'darwin'
version, version_info, hexversion
implementation — namedtuple(name, version, _multiarch)
byteorder — 'little', 'big'
maxsize — максимальный int для Py_ssize_t (≈ 2**63-1)
stdin, stdout, stderr — файлоподобные объекты
__stdin__, __stdout__, __stderr__ — оригиналы (до переназначения)
ps1, ps2 — приглашения интерпретатора (только в интерактивном режиме)
flags — namedtuple флагов (debug, inspect, optimize, dont_write_bytecode, no_user_site, …)
float_info, int_info, hash_info, thread_info

Пример sys.argv при запуске python foo.py bar -c qux --h:

Индекс	Значение
`sys.argv[0]`	`foo.py`
`sys.argv[1]`	`bar`
`sys.argv[2]`	`-c`
`sys.argv[3]`	`qux`
`sys.argv[4]`	`--h`

Для разбора флагов удобнее argparse, чем ручной обход argv.

Функции

exit([status]) — вызывает SystemExit
getsizeof(object[, default]) — размер в байтах (не рекурсивно)
getrefcount(object)
getfilesystemencoding(), getdefaultencoding()
getprofile(), setprofile(function)
gettrace(), settrace(function)
intern(string) — интернирование строк (экономия памяти для часто используемых строк)
setrecursionlimit(limit)
getrecursionlimit()
addaudithook(hook) — безопасный аудит событий (Python ≥ 3.8)
breakpointhook() — переопределяется через PYTHONBREAKPOINT

2.21 `threading` — Потоки

`Thread(group=None, target=None, name=None, args=(), kwargs={}, *, daemon=None)`

, join(timeout=None), is_alive()

start()

name, ident, daemon
run() — переопределяется в подклассах

Примитивы синхронизации

Lock — acquire(blocking=True, timeout=-1), release(), locked()
RLock: рекурсивная блокировка
Condition(lock=None):
- acquire(), release()
- wait(timeout=None), wait_for(predicate, timeout=None)
- notify(n=1), notify_all()
Semaphore(value=1), BoundedSemaphore(value=1)
Event — set(), clear(), is_set(), wait(timeout=None)
Barrier(parties, action=None, timeout=None)
- wait(timeout=None) — блокирует до parties вызовов

Вспомогательные

current_thread()
active_count(), enumerate()
main_thread()
get_ident()
local() — потоколокальные данные (x = local(); x.v = 1)

Ограничения

GIL не позволяет параллельное исполнение Python-кода в нескольких потоках
Блокировки атомарны благодаря GIL
Для CPU-bound задач — использовать multiprocessing

2.22 `time` — Время

Функции

time() → float, секунды с epoch (1970-01-01 UTC)
monotonic() → монотонное время (нельзя использовать для дат, только для замеров)
perf_counter() → высокоточное время (лучше monotonic() для профилирования)
process_time() → время CPU текущего процесса
sleep(secs)
strftime(format[, t]), strptime(string[, format])
gmtime([secs]), localtime([secs]) → struct_time
mktime(t) — обратное localtime()
clock_gettime(clk_id), clock_settime(clk_id, time) (Unix)
- CLOCK_REALTIME, CLOCK_MONOTONIC, CLOCK_PROCESS_CPUTIME_ID, и др.

`struct_time`

Атрибуты — tm_year, tm_mon, tm_mday, tm_hour, tm_min, tm_sec, tm_wday, tm_yday, tm_isdst
Доступ по индексу и имени

Константы

timezone — смещение локального часового пояса от UTC (секунды, запад — положительно)
altzone — аналогично, для летнего времени
daylight — 1, если летнее время используется
tzname — ('CST', 'CDT')

2.23 `types` — Встроенные типы и утилиты

Типы

MappingProxyType(mapping) — read-only dict-обёртка
SimpleNamespace(**kwargs) — object с __dict__, __repr__, __eq__
CellType — ячейка замыкания
CodeType, FrameType, TracebackType, GeneratorType, CoroutineType, AsyncGeneratorType
MethodType(func, obj) — привязанный метод
BuiltinMethodType, WrapperDescriptorType, MethodDescriptorType, GetSetDescriptorType

Интроспекция

new_class(name, bases=(), kwds=None, exec_body=None)
resolve_bases(bases) — для метаклассов
GenericAlias — для list[int], dict[str, int]
UnionType — для int | str (Python ≥ 3.10)

2.24 `typing` — Поддержка аннотаций типов

Базовые

Any, Never, NoReturn
None, Literal[...], LiteralString
Union[T1, T2], Optional[T] == Union[T, None], T | U (Python ≥ 3.10)
Tuple[T, ...], List[T], Dict[K, V], Set[T], FrozenSet[T] (устаревшие, предпочтительно list[T], dict[K, V])
Sequence[T], Iterable[T], Iterator[T], Container[T], Callable[[T], R], Protocol, TypeVar, Generic, TypeGuard, ParamSpec, Concatenate, TypeAlias, TypedDict, Final, ClassVar, Annotated, Required, NotRequired, Unpack, Type, Self, assert_type, reveal_type, cast, overload, final, runtime_checkable, dataclass_transform

Примеры

T = TypeVar('T')
P = ParamSpec('P')
class C(Generic[T]): ...
def f(x: int | None) -> str: ...
MyDict = dict[str, list[int]]
@overload def f(x: int) -> str: ...
@final class A: ...

Совместимость

Аннотации не влияют на выполнение (кроме cast, assert_type)
Проверяются статическими анализаторами (mypy, pyright)
from __future__ import annotations — откладывает вычисление аннотаций

2.25 `unittest` — Фреймворк тестирования

`TestCase`

Методы — setUp(), tearDown(), setUpClass(), tearDownClass()
Утверждения:
- assertEqual(a, b), assertNotEqual(a, b)
- assertTrue(x), assertFalse(x)
- assertIs(a, b), assertIsNot(a, b)
- assertIn(a, b), assertNotIn(a, b)
- assertIsInstance(a, b), assertNotIsInstance(a, b)
- assertRaises(exc, callable, *args, **kwds)
- assertWarns(warn, callable, *args, **kwds)
- assertLogs(logger=None, level=None)
- assertAlmostEqual(a, b, places=7), assertNotAlmostEqual(...)
- assertRegex(s, r), assertNotRegex(s, r)
- assertMultiLineEqual(a, b)
- assertCountEqual(a, b)

Тест-раннеры

TestRunner.run(test)
TextTestRunner(verbosity=1, stream=sys.stderr, ...)
unittest.main() — запуск из __main__

Прочее

TestSuite, TestLoader, skip, skipIf, skipUnless, expectedFailure
mock.patch, mock.Mock, mock.MagicMock — встроены с Python 3.3 (unittest.mock)

2.26 `warnings` — Предупреждения

Функции

warn(message, category=UserWarning, stacklevel=1, source=None)
warn_explicit(message, category, filename, lineno, module=None, registry=None, module_globals=None)
simplefilter(action, category=Warning, lineno=0, append=False)
filterwarnings(action, message='', category=Warning, module='', lineno=0, append=False)
resetwarnings()

Действия

'default' — печатать первое предупреждение в модуле
'error' → исключение
'ignore'
'always' — печатать всегда
'module' — первое в модуле
'once' — первое глобально

2.27 `math` — Математические функции

Модуль import math — функции с плавающей точкой (аргументы и результат обычно float). Для целых степеней и точной арифметики смотрите также встроенный pow() и модуль decimal.

Константы

Имя	Значение
`math.pi`	π ≈ 3.141592…
`math.e`	e ≈ 2.718281…
`math.tau`	2π
`math.inf`, `math.nan`	бесконечность и «не число»

Числовые и целочисленные

ceil(x), floor(x), trunc(x), fabs(x), copysign(x, y), fmod(x, y), factorial(n), fsum(iterable), gcd(a, b), isclose(a, b, *, rel_tol=1e-09, abs_tol=0.0), isfinite(x), isinf(x), isnan(x), ldexp(x, i), modf(x), frexp(x), remainder(x, y), prod(iterable) (≥ 3.8).

Степени и логарифмы

exp(x), expm1(x), log(x[, base]), log1p(x), log2(x), log10(x), pow(x, y), sqrt(x), hypot(x, y), dist(p, q) (≥ 3.8, евклидово расстояние).

Тригонометрия и гиперболика

sin, cos, tan, asin, acos, atan, atan2(y, x), sinh, cosh, tanh, asinh, acosh, atanh, degrees(x), radians(x).

Углы в радианах, если не указано иное.

2.28 `random` — Псевдослучайные числа

Модуль import random — детерминированный ГПСЧ (не криптостойкий). Для паролей и токенов — модуль secrets и os.urandom() (см. §2.13).

Базовые операции

seed(a=None, version=2), getstate(), setstate(state), getrandbits(k), randrange(stop) / randrange(start, stop[, step]), randint(a, b), choice(seq), choices(population, weights=None, *, cum_weights=None, k=1), shuffle(x), sample(population, k, *, counts=None).

Распределения `float`

random() → [0.0, 1.0), uniform(a, b), triangular(low, high, mode), betavariate(alpha, beta), expovariate(lambd), gammavariate(alpha, beta), gauss(mu, sigma), lognormvariate(mu, sigma), normalvariate(mu, sigma), vonmisesvariate(mu, kappa), paretovariate(alpha), weibullvariate(alpha, beta).

Отдельный генератор с собственным состоянием: rng = random.Random(); метод jumpahead удалён в Python 3 — для параллельных потоков используйте разные экземпляры Random с разными seed.

Часть 3. Экосистема Python

3.1 Веб-фреймворки

`Django` (синхронный full-stack)

Основные компоненты:
- django.core.management.execute_from_command_line() — точка входа CLI
- django.conf.settings — lazy-объект конфигурации
- django.urls.path(route, view, kwargs=None, name=None), re_path()
- django.http.HttpRequest, HttpResponse, JsonResponse
- django.views.generic.View, TemplateView, ListView, DetailView, CreateView, и др.
Модели:
- models.Model — поля (CharField, IntegerField, ForeignKey, ManyToManyField, JSONField, UUIDField, и т.д.)
- Мета-опции — db_table, ordering, indexes, constraints, verbose_name, unique_together
- QuerySet API — filter(), exclude(), annotate(), aggregate(), select_related(), prefetch_related(), only(), defer(), bulk_create(), update(), delete()
Админка:
- admin.ModelAdmin — list_display, list_filter, search_fields, inlines, readonly_fields, get_queryset()
Безопасность:
- django.middleware.csrf.CsrfViewMiddleware
- django.contrib.auth — пользователи, группы, права
- @login_required, @permission_required, user_passes_test()

`Flask` (микрофреймворк)

Flask(__name__, static_url_path, static_folder, template_folder, instance_relative_config=False)
Декораторы:
- @app.route(rule, methods=['GET'], endpoint=None)
- @app.before_request, @app.after_request, @app.teardown_request
- @app.errorhandler(code_or_exception)
Контексты:
- request, session, g, current_app
Расширения:
- Flask-SQLAlchemy: db = SQLAlchemy(app)
- Flask-Migrate: migrate = Migrate(app, db)
- Flask-Login — login_user(), current_user, @login_required
- Flask-CORS: CORS(app)
Конфигурация: app.config.from_object(), from_pyfile(), from_envvar()

`FastAPI` (асинхронный, на основе `Starlette` и `Pydantic`)

FastAPI(title, description, version, openapi_url, docs_url, redoc_url, ...)
Маршрутизация:
- @app.get("/items/{item_id}")
- Поддержка async def
Валидация и документация:
- Параметры: Path(...), Query(...), Header(...), Cookie(...), Body(...)
- Ответы — response_model, status_code, responses={404: {"model": Error}}
- Depends() — внедрение зависимостей:

    def get_db(): ...
    def read_items(db: Session = Depends(get_db)): ...

OpenAPI/Swagger — автоматическая генерация /docs, /redoc, /openapi.json
Поддержка WebSocket: @app.websocket("/ws")
Совместимость: WSGI (uvicorn.run(app, ...)), ASGI напрямую

`Starlette` (низкоуровневая основа FastAPI)

Request, Response, JSONResponse, PlainTextResponse, HTMLResponse, RedirectResponse, StreamingResponse, FileResponse
Роутинг — Router, Mount, Host, WebSocketRoute, Route
Middleware — Middleware, CORSMiddleware, SessionMiddleware, AuthenticationMiddleware
Тестирование: TestClient(app)

`ASGI-серверы`

uvicorn.run(app, host="127.0.0.1", port=8000, reload=False, workers=1, loop="auto", http="auto", ws="auto", lifespan="auto", interface="asgi3", debug=False, ...)
hypercorn.run(app, ...) — поддержка HTTP/2, graceful shutdown
daphne — для channels

3.2 ORM и работа с БД

`SQLAlchemy` (реляционные БД)

Режимы:
- Core — SQL Expression Language
- ORM — маппинг объектов
create_engine(url, echo=False, pool_size=5, max_overflow=10, ...)
Session = sessionmaker(bind=engine), session = Session()
ORM-модель:

  class User(Base):
      __tablename__ = 'users'
      id = Column(Integer, primary_key=True)
      name = Column(String(50), nullable=False)
      emails = relationship("Email", back_populates="user")

Запросы:
- session.query(User).filter(User.name == '...').first() (Legacy)
- (2.0-style)

select(User).where(User.name == '...')

session.execute(stmt).scalars().all()
Поддержка асинхронности — create_async_engine, AsyncSession, await session.execute(...)
Миграции — Alembic — alembic init, revision --autogenerate, upgrade head

`Pydantic` (валидация и сериализация)

BaseModel
Поля: Field(default=..., alias=..., ge=0, le=100, pattern=r'^\w+$')
Валидация:
- @validator('name', pre=True)
- @root_validator
- model_config = ConfigDict(extra='forbid', frozen=True, strict=True)
Сериализация:
- .model_dump(), .model_dump_json()
- .model_validate(obj), .model_validate_json(json_str)
Поддержка Generic, Union, Literal, Annotated, Field, computed_field
Интеграция — FastAPI, SQLModel, MongoEngine, Django Ninja

`SQLModel` (SQLAlchemy + Pydantic)

class Hero(SQLModel, table=True): id: int = Field(default=None, primary_key=True)
Единая модель для ORM и API
Поддержка select(), session.exec(select(...))
Совместим с FastAPI "из коробки"

`MongoEngine` (MongoDB, документная)

Document, EmbeddedDocument
Поля — StringField, IntField, ListField, ReferenceField, DateTimeField, ObjectIdField
Запросы: User.objects(name="...").first(), User.objects(age__gte=18)
Индексы: meta = {'indexes' — ['name', ('age', '-created')]}
Соединение — connect('db', host='localhost', port=27017)

`Tortoise ORM` (асинхронный ORM)

Определение:

  class User(Model):
      id = fields.IntField(pk=True)
      name = fields.CharField(max_length=50)

Инициализация: await Tortoise.init(db_url="sqlite://db.sqlite3", modules={"models": ["__main__"]})
Запросы: await User.filter(name="...").first(), await User.create(...), await user.save()
Миграции — aerich init, aerich migrate, aerich upgrade

3.3 Асинхронное программирование (помимо `asyncio`)

`httpx` (асинхронный HTTP-клиент)

AsyncClient(base_url=None, headers=None, timeout=5.0, ...)
Методы — get(), post(), put(), delete(), stream()
Поддержка:
- HTTP/2 (с httpx[http2])
- соединения: client = AsyncClient(); await client.get(...); await client.aclose()
- таймауты: timeout=httpx.Timeout(5.0, connect=2.0)
Синхронный интерфейс: httpx.Client()

`aiohttp`

aiohttp.ClientSession() — сессия
session.get(...), session.post(...)
aiohttp.web.Application() — сервер
WebSocket: ws = aiohttp.web.WebSocketResponse()

`trio`

async with trio.open_nursery() as nursery: nursery.start_soon(...)
Отмена

with trio.move_on_after(5): ...

Каналы: send_channel, receive_channel = trio.open_memory_channel(0)
trio.run(main) — точка входа

3.4 Обработка данных

`pandas`

DataFrame(data=None, index=None, columns=None, dtype=None, copy=False)
Конструкторы:
- pd.read_csv(), read_json(), read_sql(), read_excel(), read_parquet(), read_pickle()
- pd.DataFrame.from_dict(), .from_records()
Индексация:
- .loc[rows, cols], .iloc[pos], .at[label, col], .iat[pos, col]
Операции:
- groupby(), agg(), transform(), apply()
- , join(), concat()

merge()

pivot(), melt(), stack(), unstack()
Пропуски — isna(), dropna(), fillna(), interpolate()
Временные ряды — resample(), rolling(), shift(), diff()
Производительность — dtypes, categorical, query(), eval()

`NumPy`

array(object, dtype=None, copy=True, order='K', ...)
Типы — int32, int64, float32, float64, bool_, complex128, object_
Формы — shape, ndim, size, T, reshape(), ravel(), flatten()
Создание — zeros(), ones(), empty(), arange(), linspace(), logspace(), meshgrid()
Операции:
- Универсальные — +, -, *, /, **, sin, cos, exp, log, sqrt
- Свёртка — sum(), prod(), mean(), std(), var(), min(), max(), argmin(), argmax()
- По оси: axis=0 (столбцы), axis=1 (строки)
Линейная алгебра — @, dot(), matmul(), linalg.inv(), linalg.solve(), linalg.eig()

`polars` (альтернатива pandas, Rust-ядро)

pl.DataFrame(Данные), pl.from_pandas(df)
Lazy API: df.lazy().filter(...).group_by(...).agg(...).collect()
Оптимизации: pushdown predicate, column pruning
Поддержка — Arrow, Parquet, CSV, JSON, IPC

3.5 CLI и инструменты разработки

`click`

@click.group(), @click.command()
Параметры:
- @click.argument('name', type=str)
- @click.option('--count', '-c', default=1, type=int)
- @click.option('--verbose/--no-verbose', default=False)
- @click.option('--file', type=click.File('r'))
Подкоманды:

  @cli.command()
  def init(): ...

Контекст: @click.pass_context, ctx.obj

`typer` (на основе `click`, типизированный)

app = typer.Typer()
@app.command()
Аннотации:

  def main(name: str, count: int = 1, verbose: bool = False):

Поддержка Annotated, Union, Enum, Path, FileText
Автогенерация CLI из функций

`rich`

print() → rich.print()
console = Console(), console.print(...), console.log(...), console.rule()
Таблицы: Table(), table.add_column(), table.add_row()
Прогресс

with Progress() as progress: task = progress.add_task("...", total=100)

Панель, дерево, markdown, traceback — inspect(obj), Traceback(), Syntax(code, "python")

`loguru`

logger.add("file.log", rotation="500 MB", retention="10 days", compression="zip", level="INFO")
logger.info("msg {x}", x=1)
Поддержка — цвета, traceback, opt(exception=True), patch(lambda r: r["extra"].update(...))
Замена logging: logger.remove(); logger.add(sys.stderr)

3.6 Тестирование

`pytest`

Фикстуры: @pytest.fixture, autouse=True, scope="function"/"module"/"session"
Параметризация: @pytest.mark.parametrize("a,b", [(1,2), (3,4)])
Маркеры: @pytest.mark.skip, @pytest.mark.xfail, @pytest.mark.slow
Плагины:
- pytest-cov — покрытие
- pytest-asyncio — @pytest.mark.asyncio
- pytest-mock — mocker фикстура
Конфигурация: pytest.ini, pyproject.toml

`hypothesis`

@given(st.integers(), st.text())
Стратегии: st.lists(), st.dictionaries(), st.builds(MyClass), st.from_type(MyClass)
Настройка: settings(max_examples=100, deadline=1000)
Интеграция с pytest

3.7 Кэширование

`redis-py`

redis.Redis(host='localhost', port=6379, db=0, password=None, ...)
Операции:
- get(key), set(key, value, ex=60), mget(), mset()
- hgetall(key), hset(key, mapping={})
- lpush(), rpop(), blpop()
- sadd(), smembers(), zadd(), zrange()
Пайплайны:

  with r.pipeline() as pipe:
      pipe.set('a', 1)
      pipe.get('a')
      res = pipe.execute()

Асинхронный: redis.asyncio.Redis()

`cachetools` (in-memory)

LRUCache(maxsize, getsizeof=None)
TTLCache(maxsize, ttl, timer=time.monotonic)
cached(cache, key=lambda args, kwargs: hash(args))
cachedmethod(cache) — для методов

3.8 Сериализация

`orjson`

orjson.dumps(obj, option=orjson.OPT_INDENT_2 | orjson.OPT_SORT_KEYS)
Поддержка — datetime, uuid, dataclass, numpy, pandas (частично)
Опции — OPT_NAIVE_UTC, OPT_UTC_Z, OPT_OMIT_MICROSECONDS
loads() — быстрее json.loads

`msgpack`

msgpack.packb(obj, use_bin_type=True)
msgpack.unpackb(Данные, raw=False)
Бинарный, компактный, кросс-платформенный

3.9 Аутентификация и авторизация

`authlib`

Универсальный инструмент для OAuth, OpenID Connect, JWT, JWS, JWE.

OAuth2Client(client_id, client_secret, token_url, ...)
jwt.encode(header, payload, key, algorithm='HS256')
jwt.decode(token, key, algorithms=['HS256'], audience=None, issuer=None)
Поддержка client_credentials, authorization_code, implicit, password грантов
Интеграция — Flask, Django, Starlette, FastAPI через authlib.integrations

`pyjwt`

jwt.encode(payload, key, algorithm='HS256', headers=None)
jwt.decode(token, key, algorithms=['HS256'], options={'verify_signature': True, 'verify_exp': True})
Алгоритмы — HS256, RS256, ES256, PS256
Поддержка leeway для временных допусков
Безопасность: рекомендуется явно указывать algorithms, избегать verify=False

`django-allauth`

Поддержка — локальный логин + OAuth (Google, GitHub, Facebook, и др.)
URL-паттерны: path('accounts/', include('allauth.urls'))
Настройки:
- ACCOUNT_EMAIL_REQUIRED = True
- ACCOUNT_EMAIL_VERIFICATION = 'mandatory'
- SOCIALACCOUNT_PROVIDERS = { 'google': { 'SCOPE': ['profile', 'email'] } }
Signals — user_logged_in, user_signed_up, social_account_added

`oauthlib`

Низкоуровневая реализация OAuth1/OAuth2.

WebApplicationServer — для authorization_code
MobileApplicationServer — для implicit
LegacyApplicationServer — для password
TokenEndpoint, AuthorizationEndpoint — составные части
Не включает HTTP-транспорт — используется в связке с requests-oauthlib, authlib, Django OAuth Toolkit

3.10 Валидация данных

`pydantic` (уже частично описан, дополнения)

Модели:

  class User(BaseModel):
      id: int
      name: str = Field(min_length=1, max_length=100)
      email: EmailStr
      tags: list[str] = []
      created_at: datetime = Field(default_factory=datetime.utcnow)

Валидаторы:
- @field_validator('email', mode='before') — предварительно
- @model_validator(mode='after') — после инициализации
Конфигурация:

  model_config = ConfigDict(
      extra='forbid',
      frozen=True,
      strict=True,
      populate_by_name=True,
      alias_generator=to_camel,
      json_schema_extra={'Примеры': [...]}
  )

Сериализация:
- .model_dump(mode='json') — преобразует datetime, UUID, Decimal в JSON-совместимые
- .model_dump_json(indent=2, exclude_unset=True)
Производительность: pydantic-core (Rust-ядро) ускоряет валидацию в ~5–10×

`cerberus`

Схема как словарь:

  schema = {
      'name': {'type': 'string', 'required': True, 'minlength': 1},
      'age': {'type': 'integer', 'min': 0, 'max': 150},
      'tags': {'type': 'list', 'schema': {'type': 'string'}}
  }
  v = Validator(schema)
  v.validate({'name': 'Timur', 'age': 30})  # → True
  v.errors  # → {}

Поддержка — coerce, rename, default, allowed, regex, вложенные схемы
Не использует аннотации типов — полностью декларативен

`jsonschema`

Поддержка Draft 7, 2019-09, 2020-12
Валидация:

  from jsonschema import validate, Draft202012Validator
  schema = {"type": "object", "properties": {"name": {"type": "string"}}, "required": ["name"]}
  validate(instance={"name": "Timur"}, schema=schema)

Кастомизация:
- Draft202012Validator(schema).iter_errors(instance) — ленивая проверка
- FormatChecker — для email, date-time, uri, и др.
Интеграция: OpenAPI/Swagger, JSON Schema Store

3.11 Тестирование (дополнения)

`pytest` (расширенные фичи)

Фикстуры:
- scope='session' — одна на весь запуск
- autouse=True — автоматически включается
- yield — teardown:

    @pytest.fixture
    def db():
        db = connect()
        yield db
        db.close()

Параметризация по файлам/директориям:

  @pytest.mark.parametrize("case", load_test_cases("Кейсы/*.json"))
  def test_api(case):
      ...

Кастомные маркеры:

  # conftest.py
  def pytest_configure(config):
      config.addinivalue_line("markers", "slow: marks tests as slow")

Плагин pytest-asyncio:
- @pytest.mark.asyncio
- loop_scope='function' (новое в 0.23+) — позволяет разделять event loop между тестами

`hypothesis`

Стратегии:
- st.text(), st.integers(min_value=0), st.floats(allow_nan=False)
- st.lists(st.text(), min_size=1, unique=True)
- st.builds(MyModel, name=st.text(), age=st.integers(0, 120))
Настройка:

  @given(st.text())
  @settings(max_examples=1000, deadline=500)  # ms
  def test_upper_lower(text):
      assert text.upper().lower() == text.lower()

Интеграция — pytest, unittest, unittest.TestCase через @given как декоратор метода

`factory_boy`

Определение:

  class UserFactory(factory.Factory):
      class Meta:
          model = User
      name = factory.Faker('name')
      email = factory.LazyAttribute(lambda o: f'{o.name.lower()}@example.com')
      is_active = True

Использование:
- UserFactory() → один экземпляр
- UserFactory.create_batch(5)
- UserFactory.build() — без сохранения в БД
Поддержка — Django (DjangoModelFactory), SQLAlchemy (SQLAlchemyModelFactory), peewee, mongoengine

3.12 Задачи и фоновая обработка

`celery`

Брокеры — Redis, RabbitMQ, Amazon SQS
Конфигурация:

  app = Celery('proj', broker='redis://localhost', backend='redis://localhost')
  app.conf.update(
      task_serializer='json',
      accept_content=['json'],
      result_serializer='json',
      timezone='UTC',
      enable_utc=True,
  )

Задачи:

  @app.task(bind=True, max_retries=3)
  def send_email(self, to, subject):
      try:
          ...
      except Exception as exc:
          raise self.retry(exc=exc, countdown=60 * (2 ** self.request.retries))

Отслеживание:
- task.delay(...), task.apply_async(args=..., countdown=10), task.signature(...)
- AsyncResult(task_id).get(timeout=10)
Мониторинг — flower — веб-интерфейс с графиками, статистикой, управлением

`rq` (Redis Queue)

Простота:

  from rq import Queue
  from redis import Redis
  q = Queue(connection=Redis())
  job = q.enqueue(send_email, 'user@example.com', 'Hello')
  job.result  # после завершения

Воркеры: rq worker
Поддержка: @job('high'), job.timeout = 60, job.retries = 3
Плагины: rq-scheduler — отложенные задачи, django-rq — интеграция с Django

`dramatiq`

Акцент на надёжность:
- Автоматический повтор при падении процесса
- Акторы как задачи
Брокеры: Redis, RabbitMQ
Middleware — AgeLimit, Callbacks, CurrentMessage, Prometheus, Retries, TimeLimit
Пример:

  @dramatiq.actor(max_retries=3, time_limit=10000)
  def compute(Данные):
      return heavy_computation(Данные)
  compute.send(Данные)

3.13 Сериализация

`marshmallow`

Схемы:

  class UserSchema(Schema):
      name = fields.Str(required=True, validate=validate.Length(min=1))
      email = fields.Email()
      created_at = fields.DateTime(dump_only=True)
      
      @post_load
      def make_user(self, Данные, **kwargs):
          return User(**Данные)

Использование:
- schema.load(Данные) → объект (или ValidationError)
- schema.dump(obj) → dict
Поддержка: вложенные схемы (Nested), списки (List(Nested(...))), pre_load, post_dump, validates_schema
Интеграция — Flask, Django, SQLAlchemy через marshmallow-sqlalchemy

`orjson`

Высокая производительность:
- Сериализация в ~2–5× быстрее ujson, json
- Десериализация ~1.5–2× быстрее
Поддержка:
- datetime, date, time, UUID, dataclass, namedtuple, Enum, numpy (скаляры, ndarray с .tolist())
Опции:

  orjson.dumps(obj,
               option=orjson.OPT_NAIVE_UTC | orjson.OPT_UTC_Z | orjson.OPT_SERIALIZE_NUMPY)

Безопасность: не поддерживает произвольные __dict__ или __getattr__ — только явные типы

`msgpack`

Бинарный формат: компактнее JSON, быстрее парсится
Установка: pip install msgpack

pip install msgpack

Использование:

  packed = msgpack.packb({'a': 1, 'b': [1, 2, 3]}, use_bin_type=True)
  unpacked = msgpack.unpackb(packed, raw=False)

Поддержка: datetime через ext-типы (msgpack.ExtType), кастомные типы через default, ext_hook

3.14 CLI и интерактивные инструменты

`rich` (дополнения)

Таблицы:

  table = Table(title="Users")
  table.add_column("Name", style="cyan")
  table.add_column("Age", justify="right")
  table.add_row("Timur", "30")
  console.print(table)

Прогресс:

  with Progress() as progress:
      task = progress.add_task("[green]Processing...", total=100)
      for i in range(100):
          time.sleep(0.01)
          progress.update(task, advance=1)

Markdown, Syntax, Traceback:

  console.print(Markdown("# Hello"), Syntax("print('hi')", "python"), Traceback())

Журналирование — RichHandler(show_time=True, show_path=True, enable_link_path=True)

`click` и `typer`

Критерий	`click`	`typer`
Типизация	Необязательна	Обязательна (на основе аннотаций)
Вложенность команд	`@cli.group() → @group.command()`	`app = typer.Typer(); sub = typer.Typer(); app.add_typer(sub)`
Автодокументация	`--help` генерируется	То же + поддержка `Enum`, `Path`, `FileText`
Поддержка async	Через `asyncio.run()`	`@app.command()` + `async def` напрямую
Генерация shell-автодополнения	`eval "$(_CLI_COMPLETE=zsh_source cli)"`	`typer --install-completion`

3.15 DevOps и инфраструктура

`ansible`

Inventory: hosts.ini или hosts.yaml
Playbook:

Код ITЗагрузка примера кода…

Модули — copy, template, file, package, service, uri, shell, command
Динамические inventory — aws_ec2, azure_rm, gcp_compute

`supervisor`

Конфиг /etc/supervisor/conf.d/app.conf:

  [program:app]
  command=/venv/bin/gunicorn app:app -b 0.0.0.0:8000
  directory=/opt/app
  user=www-Data
  autostart=true
  autorestart=true
  redirect_stderr=true
  stdout_logfile=/var/log/app.log
  environment=PATH="/venv/bin"

Управление — supervisorctl reread, update, start app, status

`psutil`

Процессы:
- psutil.Process(pid).cpu_percent(interval=1), .memory_info(), .children(recursive=True)
Система:
- psutil.cpu_percent(percpu=True), .virtual_memory(), .disk_usage('/'), .net_io_counters()
Утилиты:
- psutil.sensors_temperatures(), .sensors_fans(), .sensors_battery()
Кроссплатформенность — Windows, Linux, macOS, FreeBSD

3.16 Наука и анализ

`scikit-learn`

Пайплайны:

  pipe = Pipeline([
      ('scaler', StandardScaler()),
      ('pca', PCA(n_components=10)),
      ('clf', LogisticRegression())
  ])
  pipe.fit(X_train, y_train)

Модели:
- LinearRegression, LogisticRegression, RandomForestClassifier, SVC, KMeans, DBSCAN
Валидация:
- cross_val_score(pipe, X, y, cv=5)
- GridSearchCV, RandomizedSearchCV
Метрики:
- accuracy_score, precision_recall_fscore_support, roc_auc_score, mean_squared_error

`PyTorch`

Тензоры:
- torch.tensor([1, 2, 3]), .cuda(), .to(device), .requires_grad_(True)
Модель:

  class Net(nn.Module):
      def __init__(self):
          super().__init__()
          self.fc = nn.Linear(10, 1)
      def forward(self, x):
          return self.fc(x)

Обучение:

  model.train()
  for batch in dataloader:
      optimizer.zero_grad()
      loss = criterion(model(batch.x), batch.y)
      loss.backward()
      optimizer.step()

DataLoader:
- DataLoader(dataset, batch_size=32, shuffle=True, num_workers=4, pin_memory=True)

`pandas` (дополнения)

Производительность:
- df.eval('a + b * c') — быстрее Python-цикла
- df.query('x > 0 and y < 10')
- pd.read_csv(..., dtype={'col': 'category'}, low_memory=False)
Пропуски:
- df.interpolate(method='linear'), .fillna(method='ffill')
- pd.isna(), pd.notna()
Группировка с кастомными функциями:

  df.groupby('category').agg(
      mean=('value', 'mean'),
      std=('value', 'std'),
      count=('value', 'size'),
      custom=('value', lambda x: x.quantile(0.95))
  )

3.17 GUI Разработка (расширенное покрытие)

`PyQt6` / `PySide6`

Создание приложения:

  app = QApplication(sys.argv)
  window = QMainWindow()
  window.setWindowTitle("Title")
  window.setGeometry(100, 100, 800, 600)

Виджеты:
- QLabel, QPushButton, QLineEdit, QTextEdit, QComboBox, QListWidget, QTableWidget, QTreeWidget
- QVBoxLayout, QHBoxLayout, QGridLayout, QFormLayout — компоновка
Сигналы и слоты:

  button.clicked.connect(on_click)
  line_edit.textChanged.connect(on_text_change)

Модальные окна:
- QDialog, QMessageBox.information(), .question(), .warning(), .critical()
Стилизация:
- widget.setStyleSheet("color: red; font-size: 14px;")
- Поддержка QSS (Qt Style Sheets), совместимого с CSS
Модели-представления:
- QStandardItemModel, QAbstractTableModel, QAbstractListModel
- QTableView, QListView, QTreeView
Асинхронность:
- QTimer.singleShot(0, callback) — возврат в event loop
- QThread + сигналы — без блокировки UI
- Интеграция с asyncio: qasync (сторонняя библиотека)

`Flet`

Архитектура — клиент-сервер (веб, нативный, мобильный)
Базовый шаблон:

  import flet as ft

  def main(page: ft.Page):
      page.title = "Flet app"
      page.add(ft.Text("Hello, world!"))

  ft.app(target=main)  # локально
  # ft.app(target=main, view=ft.WEB_BROWSER)  # браузер
  # ft.app(target=main, port=8000)  # веб-сервер

Компоненты — Text, TextField, ElevatedButton, Column, Row, Container, Image, AppBar, Banner
Состояние: обновление через page.update() или автоматически при изменении Control
Роутинг: page.route = "/home" + page.on_route_change
Деплой: flet build windows/mac/linux/web/android/ios, flet deploy

`DearPyGui`

GPU-ускоренный, императивный стиль:

  import dearpygui.dearpygui as dpg

  dpg.create_context()
  dpg.create_viewport(title='DearPyGui', width=600, height=400)
  dpg.setup_dearpygui()

  with dpg.window(label="Main"):
      dpg.add_text("Hello, world!")
      dpg.add_button(label="Click", callback=lambda: print("Clicked"))

  dpg.show_viewport()
  dpg.start_dearpygui()
  dpg.destroy_context()

Поддержка — графики (add_plot, add_line_series), таблицы, вкладки, drag-drop, темы
Низкоуровневый контроль — set_value, get_value, configure_item, bind_item_handler_registry

`Tkinter` (встроен)

Минимальный пример:

  import tkinter as tk
  root = tk.Tk()
  tk.Label(root, text="Hello").pack()
  tk.Button(root, text="Quit", command=root.quit).pack()
  root.mainloop()

Геометрия — pack(), grid(), place()
События: widget.bind("<Button-1>", handler)
Диалоги: tkinter.messagebox, tkinter.filedialog, tkinter.colorchooser
Преимущества — встроен, кроссплатформен, лёгкий старт
Недостатки: устаревший внешний вид, ограниченная функциональность — больше примеров: Tkinter и GUI, Lab — окна и виджеты

3.18 Web Crawling & Content Extraction

`Scrapy`

Проект: scrapy startproject myproject
Паук:

  class MySpider(scrapy.Spider):
      name = 'example'
      start_urls = ['https://example.com']

      def parse(self, response):
          for item in response.css('.item'):
              yield {
                  'title': item.css('h2::text').get(),
                  'url': item.css('a::attr(href)').get(),
              }
          next_page = response.css('a.next::attr(href)').get()
          if next_page:
              yield response.follow(next_page, self.parse)

Пайплайны:
- process_item(item, spider) — очистка, валидация, сохранение
Настройки (settings.py):
- ROBOTSTXT_OBEY = True
- CONCURRENT_REQUESTS = 16
- DOWNLOAD_DELAY = 1
- USER_AGENT = 'MyBot/1.0'
- FEEDS = {'items.json': {'format': 'json'}}
Middleware:
- UserAgentMiddleware, RetryMiddleware, HttpProxyMiddleware
Расширения:
- scrapy-splash — JavaScript-рендеринг
- scrapy-redis — распределённое выполнение

`Playwright`

Высокоуровневый, поддержка Chromium, Firefox, WebKit:

  from playwright.sync_api import sync_playwright

  with sync_playwright() as p:
      browser = p.chromium.launch(headless=False)
      page = browser.new_page()
      page.goto("https://example.com")
      page.wait_for_selector("h1")
      print(page.title())
      page.screenshot(path="screenshot.png")
      browser.close()

Асинхронный: await playwright.chromium.launch()
Возможности:
- Эмуляция устройства (page.emulate_media(media="screen"))
- Перехват запросов (page.route("**/*", handler))
- Аутентификация: context.add_cookies([...]), page.fill("input#login", ...), page.click("button#submit")
- Скачать файлы

with page.expect_download() as download_info: ...

`newspaper3k`

Извлечение статьи:

  from newspaper import Article
  article = Article('https://example.com/article')
  article.download()
  article.parse()
  article.nlp()  # keywords, summary
  print(article.title, article.text, article.keywords, article.summary)

Поддержка — мультиязычность, извлечение изображений, авторов, дат
Ограничения: не для динамических сайтов (SPA)

`requests-html`

Простая альтернатива:

  from requests_html import HTMLSession
  session = HTMLSession()
  r = session.get('https://example.com')
  r.html.render()  # запускает Chromium (требует установки)
  titles = r.html.find('h1', first=True).text

XPath, CSS-селекторы, JavaScript-рендеринг через pyppeteer

3.19 Static Site Generators

`MkDocs`

Конфиг mkdocs.yml:

  site_name: My Project
  theme: readthedocs
  nav:
    - Home: index.md
    - Guide: guide.md
  plugins:
    - search
    - markdownextradata

Команды:
- mkdocs build → site/
- mkdocs serve — локальный сервер с hot-reload
Темы — mkdocs-material, readthedocs, windmill
Расширения Markdown — admonitions, footnotes, tables, task lists

`Pelican`

Поддержка reStructuredText и Markdown
Генерация:

  pelican content -o output -s pelicanconf.py

Плагины — sitemap, neighbors, assets, minify
Темы — notmyidea, flex, alchemy

`Lektor`

CMS-подобный интерфейс
Админка: lektor server --admin → http://localhost:5000/admin
Модели данных: models/, шаблоны: templates/
Публикация: lektor deploy

3.20 Serialization (дополнения)

`ultrajson`

Высокая производительность:

  import ujson
  ujson.dumps(obj, ensure_ascii=False, escape_forward_slashes=False)
  ujson.loads(json_str, precise_float=False)

precise_float=False — использует float вместо Decimal, быстрее
Поддержка — None, bool, int, float, str, list, dict

`pysimdjson`

Обёртка над simdjson (C++): парсинг JSON в 4–10× быстрее json.loads
Использование:

  import pysimdjson
  parser = pysimdjson.Parser()
  obj = parser.parse(b'{"a": 1}')
  # или
  obj = pysimdjson.loads('{"a": 1}')

Безопасность — не поддерживает object_hook, parse_float, только строгий JSON

3.21 Hardware & Low-Level

`scapy`

Отправка пакетов:

  from scapy.all import *
  pkt = IP(dst="192.168.1.1")/ICMP()
  reply = sr1(pkt, timeout=2)
  if reply:
      reply.show()

Анализ:
- sniff(filter="tcp port 80", prn=lambda x: x.summary())
- wrpcap("capture.pcap", packets)
Поддержка — Ethernet, IP, TCP, UDP, ICMP, ARP, DNS, HTTP, TLS (частично)
Требует привилегий (sudo)

`pynput`

Клавиатура:

  from pynput import keyboard
  def on_press(key):
      print(f'{key} pressed')
  listener = keyboard.Listener(on_press=on_press)
  listener.start()

Мыши:

  from pynput.mouse import Controller
  mouse = Controller()
  mouse.position = (100, 200)
  mouse.click(Button.left, 1)

Кроссплатформенность — Windows, macOS, Linux (X11)

3.22 Shell & CLI Enhancements

`xonsh`

Python + Bash:

  #!/usr/bin/env xonsh
  for file in $(ls *.py):
      echo @(file.upper())

Переменные — $PATH, $HOME, $PWD — как в Python (os.environ)
Алиасы:
- aliases['ll'] = ['ls', '-lh']
- aliases['gitlog'] = lambda args: ![git --no-pager log @args]
Плагины: xontrib load prompt_ret_code autoxsh

`thefuck`

Использование: после ошибки — ввести fuck (или настроить ESC-ESC)
Пример:

  $ git brnch
  git: 'brnch' is not a git command...
  $ fuck  # → git branch

Правила — ~200 встроенных (cd_parent, git_add, man_no_space, yarn_alias)

3.23 Code Analysis & Refactoring

`ruff`

Замена flake8 + isort + pydocstyle + часть pylint
Конфиг .ruff.toml:

  select = ["E", "F", "I", "N", "UP"]
  ignore = ["E501"]
  line-length = 88
  isort.required-imports = ["from __future__ import annotations"]

Команды:
- ruff check .
- ruff format . — форматирование (альтернатива black)
- ruff check --fix . — автоматическое исправление
Производительность: ~10–100× быстрее flake8

`Bowler`

Безопасный рефакторинг на основе LibCST:

  from bowler import Query
  Query("src/").select_function("old_name").rename("new_name").execute()

Паттерны — select_method, select_class, filter, modify, insert_after
Поддержка: dry-run, интерактивный режим

3.24 RESTful API Frameworks (дополнения)

`FastAPI` (расширенные возможности)

Зависимости уровня приложения:

  def get_db():
      db = SessionLocal()
      try:
          yield db
      finally:
          db.close()

  app = FastAPI(dependencies=[Depends(get_db)])

Совместимость с OpenAPI:
- openapi_url="/openapi.json"
- docs_url="/docs" (Swagger UI), redoc_url="/redoc"
- openapi_tags=[{"name": "users", "description": "User management"}]
Метаданные моделей:

  class User(BaseModel):
      name: str = Field(..., min_length=1, max_length=50, json_schema_extra={"example": "Timur"})

Обработка ошибок:

  @app.exception_handler(ValidationError)
  async def validation_exception_handler(request, exc):
      return JSONResponse(status_code=422, content={"detail": exc.errors()})

Поддержка async и sync:
- def вызывается в ThreadPoolExecutor автоматически
- async def — напрямую в event loop
Интеграция с SQLModel, Pydantic, ORJSONResponse, Uvicorn

`Django REST Framework (DRF)`

Сериализаторы:

  class UserSerializer(serializers.ModelSerializer):
      class Meta:
          model = User
          fields = ['id', 'username', 'email']
      def validate_email(self, value):
          if 'spam' in value:
              raise serializers.ValidationError("Spam not allowed")
          return value

ViewSets:

  class UserViewSet(viewsets.ModelViewSet):
      queryset = User.objects.all()
      serializer_class = UserSerializer
      permission_classes = [IsAuthenticated]
      filter_backends = [DjangoFilterBackend, SearchFilter]
      filterset_fields = ['is_active']
      search_fields = ['username', 'email']

Аутентификация:
- TokenAuthentication, SessionAuthentication, JWTAuthentication (через djangorestframework-simplejwt)
Пагинация:
- PageNumberPagination, LimitOffsetPagination, CursorPagination
- Настройка: PAGE_SIZE = 20, MAX_PAGE_SIZE = 100

`Flask-RESTful`

Ресурсы:

  class UserResource(Resource):
      def get(self, user_id):
          return users.get(user_id), 200
      def post(self):
          args = parser.parse_args()
          user_id = users.create(args)
          return {'id': user_id}, 201
  api.add_resource(UserResource, '/users/<int:user_id>')

Парсер аргументов:

  parser = reqparse.RequestParser()
  parser.add_argument('name', type=str, required=True)
  parser.add_argument('age', type=int, default=18)

Расширения — flask-jwt-extended, flask-cors, flask-marshmallow

3.25 Серверлесс и облачные платформы

`Zappa`

Конфиг zappa_settings.json:

  {
    "production": {
      "app_function": "app.app",
      "aws_region": "us-east-1",
      "profile_name": "default",
      "project_name": "myapp",
      "runtime": "python3.12",
      "s3_bucket": "zappa-xxxx"
    }
  }

Команды:
- zappa deploy production
- zappa update production
- zappa tail production
Поддержка — WSGI, Django, Flask, Bottle
Лимиты — 15 минут выполнения, 250 МБ пакета (сжатый), 3 ГБ памяти

`AWS Lambda + Mangum`

Совместимость с ASGI:

  from mangum import Mangum
  from fastapi import FastAPI

  app = FastAPI()
  handler = Mangum(app)

Развёртывание через serverless, chalice, aws-cdk
Холодный старт → Provisioned Concurrency, SnapStart

3.26 Конфигурация приложений

`hydra`

Конфиг config.yaml:

  db:
    driver: postgresql
    host: localhost
    port: 5432

Декоратор:

  @hydra.main(version_base=None, config_path="conf", config_name="config")
  def main(cfg: DictConfig) -> None:
      print(cfg.db.host)

Композиция: defaults: [db: postgresql, model: resnet]
Переопределения в CLI: python app.py db.host=prod.example.com

`python-decouple`

.env:

  DEBUG=True
  DATABASE_URL=postgresql://user:pass@localhost/db

Использование:

  from decouple import config
  DEBUG = config('DEBUG', default=False, cast=bool)
  DATABASE_URL = config('DATABASE_URL')

Поддержка: .env, settings.ini, os.environ, Django settings.py

3.27 Текстовая обработка

`spacy`

Загрузка модели:

  import spacy
  nlp = spacy.load("en_core_web_sm")
  doc = nlp("Apple is looking at buying U.K. startup for — billion")

Извлечение:
- doc.ents → Apple (ORG), U.K. (GPE), $1 billion (MONEY)
- token.pos_, token.dep_, token.head
Пайплайн: nlp.pipe(texts, batch_size=1000, n_process=4)
Кастомные компоненты:

  @Language.component("custom_component")
  def custom_component(doc):
      ...
      return doc
  nlp.add_pipe("custom_component", last=True)

`nltk`

Скачивание данных: nltk.download('punkt'), 'stopwords', 'wordnet'
Токенизация: word_tokenize, sent_tokenize
Частеречная разметка: pos_tag(tokens)
Лемматизация: WordNetLemmatizer().lemmatize('went', 'v')
Стоп-слова: stopwords.words('english')

`textdistance`

Расстояния:

  import textdistance
  textdistance.levenshtein('test', 'text')  # 1
  textdistance.jaro_winkler('test', 'text')  # 0.916...
  textdistance.cosine('test', 'text')  # 0.5

Поддержка — hamming, damerau_levenshtein, jaccard, sorensen, overlap, sift4, и др.

3.28 Обработка видео

`moviepy`

Базовое редактирование:

  from moviepy.editor import *
  clip = VideoFileClip("input.mp4").subclip(10, 20)
  txt_clip = TextClip("Hello", fontsize=70, color='white').set_position('center').set_duration(10)
  final = CompositeVideoClip([clip, txt_clip])
  final.write_videofile("output.mp4", fps=24)

Аудио: clip.audio.write_audiofile("audio.wav")
Экспорт GIF: clip.write_gif("anim.gif", fps=5)
Поддержка — маски, переходы, эффекты (fx), наложение

`vidgear`

Высокопроизводительное захватывание:

  from vidgear.gears import CamGear
  stream = CamGear(source=0).start()
  while True:
      frame = stream.read()
      if frame is None:
          break
      cv2.imshow("Frame", frame)
  stream.stop()

Потоковая передача: WebGear, NetGear (ZeroMQ)
Экспорт — WriteGear → MP4, MKV, HLS, DASH

3.29 Тестирование (дополнения)

`pytest` + `Schemathesis`

Автоматическое тестирование OpenAPI:

  import schemathesis
  schema = schemathesis.from_uri("http://localhost/openapi.json")

  @schema.parametrize()
  def test_api(case):
      response = case.call()
      case.validate_response(response)

Параметры — endpoint="/users", method="POST", tags=["users"]
Фаззинг: hypothesis.settings(max_examples=100)

`locust`

Тест пользовательской нагрузки:

  from locust import HttpUser, task
  class WebsiteUser(HttpUser):
      @task
      def index(self):
          self.client.get("/")
      @task(3)
      def profile(self):
          self.client.get("/profile")

Запуск: locust -f load_test.py --host=http://localhost:8000
Веб-интерфейс: http://localhost:8089

3.30 Управление пакетами

`uv` (Rust-ускоритель)

Команды:
- uv venv — создаёт виртуальное окружение
- uv pip install requests — устанавливает быстрее pip
- uv pip compile requirements.in -o requirements.txt — генерация фиксированных зависимостей
- uv pip sync requirements.txt — синхронизация окружения
Производительность:
- Установка torch в ~2–5× быстрее pip
- Решение зависимостей в ~10–50× быстрее pip-tools

`poetry`

Управление проектом:
- poetry init → pyproject.toml
- poetry add requests
- poetry install --no-dev
- poetry build → dist/project-0.1.0-py3-none-any.whl
Виртуальные окружения: изолированные, управляемые автоматически
Поддержка: group.dev.dependencies, scripts, plugins

3.31 Генерация фейковых данных

`faker`

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

  from faker import Faker
  fake = Faker('ru_RU')
  fake.name()      # 'Иванов Иван Иванович'
  fake.email()     # 'ivanov@example.com'
  fake.phone_number()  # '+7 (912) 345-67-89'
  fake.date_of_birth(minimum_age=18, maximum_age=90)

Провайдеры — address, job, credit_card, company, ssn, isbn
Локализация — 70+ локалей (en_US, de_DE, ja_JP, zh_CN, ru_RU)

`mimesis`

Аналог faker, но:
- Чистый Python, без зависимостей
- Поддержка Schema:

    from mimesis.schema import Schema
    from mimesis.locales import Locale
    schema = Schema(schema=lambda: {
        'id': uuid(),
        'name': full_name(),
        'email': email(),
        'age': age(),
    }, iterations=10)
    schema.create()

Специализированные данные — Наука, Cryptographic, Разработка, Datetime

3.32 Профилирование и мониторинг

`py-spy`

Непрерывное профилирование:

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

Поддержка — native-раскадровки, --native, --gil
Без изменения кода — attach к запущенному процессу

`sentry-sdk`

Интеграция:

  import sentry_sdk
  sentry_sdk.init(
      dsn="https://...@sentry.io/12345",
      traces_sample_rate=1.0,
      profiles_sample_rate=1.0,
  )

Автоматический захват — исключений, логов (logging), celery, django, fastapi, sqlalchemy

Основа по протоколу

Базовый разбор HTTP и HTTPS находится в отдельной статье — HTTP как основа веб-интеграций.

В подборках

Статья входит в тематические подборки и блок "С чего начать?" на главной. Соседние шаги того же маршрута:

Справочники — Справочник по Flask, Справочник по конфигурациям в Java, Справочник по модулю Turtle, Справочник по Java, Справочник по Django, Документация и инструменты Java (Microsoft).

Назначение​

Краткое пояснение​

Быстрый старт​

Linux/macOS — source .venv/bin/activate

module​

ellipsis​

slice​

mappingproxy​

weakref.ref​

weakref.proxy​

generator​

coroutine​

async_generator​

code​

frame​

traceback​

getset_descriptor​

method_descriptor, wrapper_descriptor​

1.3 Встроенные функции​

abs(x)​

aiter(async_iterable)​

all(iterable)​

any(iterable)​

ascii(object)​

bin(x)​

bool(x=False)​

breakpoint(*args, &#42;&#42;kws)​

bytearray(source=b'', encoding=None, errors='strict')​

bytes(source=b'', encoding=None, errors='strict')​

callable(object)​

chr(i)​

classmethod(func)​

compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)​

complex(real=0, imag=0)​

delattr(object, name)​

dict(iterable=(), &#42;&#42;kwargs)​

dir([object])​

divmod(a, b)​

enumerate(iterable, start=0)​

eval(expression, globals=None, locals=None)​

exec(object, globals=None, locals=None)​

filter(function, iterable)​

float(x=0.0)​

format(value, format_spec='')​

frozenset(iterable=())​

getattr(object, name[, default])​

globals()​

hasattr(object, name)​

hash(object)​

help([object])​

hex(x)​

id(object)​

input([prompt])​

int(x=0, base=10)​

isinstance(object, classinfo)​

issubclass(class, classinfo)​

iter(object[, sentinel])​

len(s)​

list(iterable=())​

locals()​

map(function, iterable, ...)​

max(iterable, *[, key, default])​

min(...)​

next(iterator[, default])​

object()​

oct(x)​

open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)​

ord(c)​

pow(base, exp[, mod])​

print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)​

property(fget=None, fset=None, fdel=None, doc=None)​

range(stop), range(start, stop[, step])​

repr(object)​

reversed(seq)​

round(number[, ndigits])​

set(iterable=())​

setattr(object, name, value)​

slice(stop), slice(start, stop[, step])​

sorted(iterable, *, key=None, reverse=False)​

staticmethod(func)​

Назначение

Краткое пояснение

Быстрый старт

`module`

`ellipsis`

`slice`

`mappingproxy`

`weakref.ref`

`weakref.proxy`

`generator`

`coroutine`

`async_generator`

`code`

`frame`

`traceback`

`getset_descriptor`

`method_descriptor`, `wrapper_descriptor`

1.3 Встроенные функции

`abs(x)`

`aiter(async_iterable)`

`all(iterable)`

`any(iterable)`

`ascii(object)`

`bin(x)`

`bool(x=False)`

`breakpoint(*args, **kws)`

`bytearray(source=b'', encoding=None, errors='strict')`

`bytes(source=b'', encoding=None, errors='strict')`

`callable(object)`

`chr(i)`

`classmethod(func)`

`compile(source, filename, mode, flags=0, dont_inherit=False, optimize=-1)`

`complex(real=0, imag=0)`

`delattr(object, name)`

`dict(iterable=(), **kwargs)`

`dir([object])`

`divmod(a, b)`

`enumerate(iterable, start=0)`

`eval(expression, globals=None, locals=None)`

`exec(object, globals=None, locals=None)`

`filter(function, iterable)`

`float(x=0.0)`

`format(value, format_spec='')`

`frozenset(iterable=())`

`getattr(object, name[, default])`

`globals()`

`hasattr(object, name)`

`hash(object)`

`help([object])`

`hex(x)`

`id(object)`

`input([prompt])`

`int(x=0, base=10)`

`isinstance(object, classinfo)`

`issubclass(class, classinfo)`

`iter(object[, sentinel])`

`len(s)`

`list(iterable=())`

`locals()`

`map(function, iterable, ...)`

`max(iterable, *[, key, default])`

`min(...)`

`next(iterator[, default])`

`object()`

`oct(x)`

`open(file, mode='r', buffering=-1, encoding=None, errors=None, newline=None, closefd=True, opener=None)`

`ord(c)`

`pow(base, exp[, mod])`

`print(*objects, sep=' ', end='\n', file=sys.stdout, flush=False)`

`property(fget=None, fset=None, fdel=None, doc=None)`

`range(stop)`, `range(start, stop[, step])`

`repr(object)`

`reversed(seq)`

`round(number[, ndigits])`

`set(iterable=())`

`setattr(object, name, value)`

`slice(stop)`, `slice(start, stop[, step])`

`sorted(iterable, *, key=None, reverse=False)`

`staticmethod(func)`

`str(object='')`, `str(object=b'', encoding='utf-8', errors='strict')`