Глоссарий — Python для Data Engineer

# Демонстрация коллизий через подгонку capacity:
>>> hash("abc") % 8
3
>>> hash("xyz") % 8
3   # коллизия для capacity=8
# CPython probe sequence (5*i + 1 + perturb) — детерминированный обход слотов

Подробнее в уроках:

Dict: hash function, open addressing, perturbation probe

Хэш-функция

Hash function

Термин

Функция h: K → ℤ, отображающая ключи произвольного размера в целые числа фиксированного диапазона. Для словарей CPython используется реализация, основанная на SipHash (для str/bytes — рандомизированная при старте процесса, чтобы снизить риск hash-flood DoS). Хорошая хэш-функция распределяет ключи равномерно (uniform distribution), стремится минимизировать коллизии и вычисляется за O(|key|). Для пользовательских классов хэш переопределяется методом __hash__; объекты, равные по __eq__, обязаны иметь одинаковый хэш. См. CPython/Python/pyhash.c и dictobject.c.

Подробнее в уроках:

Dict: hash function, open addressing, perturbation probe

Big-O нотация

Big-O notation

Термин

Асимптотическая верхняя оценка скорости роста функции. f(n) = O(g(n)), если существуют константы c > 0 и n₀, такие что для всех n ≥ n₀ выполняется |f(n)| ≤ c·|g(n)|. Используется для классификации сложности алгоритмов независимо от константного фактора и младших членов. Ориентиры для Python: dict lookup amortized O(1), list.append amortized O(1), list.insert(0, x) — O(n), set membership — O(1), оператор `'x' in [...]` — O(n). Big-O описывает worst case (верхняя оценка); Big-Θ — точная оценка сверху и снизу одновременно; Big-Ω — нижняя оценка. Не путать с amortized big-O последовательности операций.

Подробнее в уроках:

Операторы и big-O / amortized analysis

Cache line (строка кэша)

Cache line

Термин

Минимальная единица передачи данных между основной памятью и L1/L2/L3 кэшами процессора — обычно 64 байта на x86_64 и aarch64. Когда CPU читает один байт, аппаратура загружает целиком всю cache line, в которой этот байт находится. Это объясняет, почему contiguous-memory структуры (list, tuple, NumPy ndarray) обеспечивают высокую пропускную способность при последовательном обходе: следующий элемент с большой вероятностью уже в той же cache line, что использует spatial locality. Linked list, напротив, требует random access к разным cache lines на каждом шаге, и каждый промах кэша стоит десятки-сотни циклов.

Подробнее в уроках:

Mutability vs immutability на уровне памяти и cache

Cache line CPython

CPython cache-line behavior

Термин

CPython объекты выровнены и аллоцированы так, чтобы next-element access попадал в ту же cache line (~64 байта на x86_64). PyListObject хранит указатели на PyObject в contiguous-памяти (`ob_item` — массив `PyObject **`), что обеспечивает spatial locality при последовательном обходе: 8 указателей умещаются в одну 64-байтовую cache line. Однако сами объекты-значения хранятся вразброс по heap (через указатель — indirection cost). Linked list, напротив, тратит cache miss на каждом шаге. Понимание cache line behavior — основа объяснения, почему `sum(lst)` быстрее `sum(linked_list)` на одинаковых N. Cross-link: M02 урок 06 (mutability + cache).

Пример:

# Contiguous list — cache-friendly
lst = [i for i in range(1_000_000)]
sum(lst)   # spatial locality: prefetch работает

# Linked-list (Python list of dicts) — random access pattern
# Каждый next pointer = potential cache miss

List/dict/set comprehension

Термин

Синтаксический сахар для построения list / dict / set из итерируемого источника одной строкой. Bytecode для `[x*2 for x in range(3)]` (Python 3.11+) использует `LIST_APPEND` opcode внутри отдельного frame — comprehension получает свой собственный scope (Python 3+) для переменной итерации, чтобы не загрязнять enclosing scope (см. PEP 3000). Сравнение с generator expression: `(x*2 for x in range(3))` использует `YIELD_VALUE` opcode и lazy iteration через PyGenObject — память O(1) vs O(n) для list comprehension. Dict / set comprehension — `{k: v for ...}` / `{x for ...}` — same machinery с `MAP_ADD` / `SET_ADD` opcodes.

Пример:

# List comprehension — eager, материализует весь список
>>> [x*2 for x in range(3)]
[0, 2, 4]
# Generator expression — lazy, O(1) память
>>> sum(x*2 for x in range(1_000_000))
# Dict / set comprehension
>>> {k: k*k for k in range(3)}
{0: 0, 1: 1, 2: 4}

Подробнее в уроках:

List/dict/set comprehensions, generator expressions

Context manager protocol

Термин

Протокол из двух dunder-методов __enter__ и __exit__, формализованный PEP 343 (Python 2.5, 2005). `with cm as v: body` — синтаксический сахар, эквивалентный: `_cm = cm; v = _cm.__enter__(); try: body(v); finally: _cm.__exit__(exc_type, exc_val, exc_tb)`. __enter__ — setup phase: возвращает значение для `as v`-binding (часто self для class-based pattern). __exit__ — teardown phase: tri-arg signature обязателен — exc_type (класс exception или None при normal exit), exc_val (instance exception или None), exc_tb (traceback object для traceback.format_tb). На normal exit все три = (None, None, None); на exception path — actual values из sys.exc_info(). Resource cleanup invariant: __exit__ ГАРАНТИРОВАННО вызывается на любом exit path (normal или exception) — это и есть main value `with`. Pitfall 3 — __exit__ returning truthy (True) подавляет exception (силлогизм PEP 343 — для conditional suppress); это anti-pattern для general usage (silent exception suppression — debugging impossible). Default __exit__ возвращает None → exception пробрасывается; conditional suppress: return exc_type is KeyError. Idiomatic suppress — contextlib.suppress(SpecificException) — targeted, self-documenting. Multi-context (PEP 617, Python 3.10+): `with a as x, b as y:` — синтаксический сахар для nested with, cleanup в LIFO order (b.__exit__ до a.__exit__). Bytecode lowering Python 3.12+: try/finally + with компилируются через ExceptionTable (отдельная structure на code object'е, описывающая (start, end, target, depth, lasti) tuples), а не через SETUP_FINALLY/END_FINALLY opcodes — zero-cost exceptions на normal path (empirically verified Python 3.12.7 через dis.dis). Forward-link Phase 67 pytest fixtures: yield-style fixtures используют context-manager protocol. Cite: PEP 343 (peps.python.org/pep-0343), PEP 617 (peps.python.org/pep-0617), datamodel.html#context-managers, Python 3.11 changelog ExceptionTable.

Подробнее в уроках:

with-statement: __enter__ и __exit__

Descriptor protocol

Термин

Соглашение Python data model: объект называется дескриптором, если у него определён хотя бы один из методов `__get__(self, obj, owner=None)`, `__set__(self, obj, value)`, `__delete__(self, obj)`. Дополнительный `__set_name__(self, owner, name)` (PEP 487, Python 3.6+) — вызывается ОДИН раз при создании класса (через type_new_impl в Objects/typeobject.c функция type_new_set_names) — сообщает дескриптору имя, под которым он живёт в class. Два типа: data descriptor (имеет __set__ или __delete__) — пример @property; non-data descriptor (только __get__) — пример @classmethod, @staticmethod, обычные functions (методы). Lookup precedence в _PyObject_GenericGetAttrWithDict (Objects/object.c): **data descriptor (class) > instance __dict__ > non-data descriptor (class)**. Это enforcement на уровне CPython — НЕ просто 'контракт на бумаге'. Use cases: typed attributes (Pydantic, attrs), runtime validation (Django ORM fields), lazy properties, computed attributes. См. docs.python.org/3/howto/descriptor.html (Raymond Hettinger); Objects/typeobject.c type_getattro_impl; Objects/descrobject.c.

Подробнее в уроках:

Дескрипторы: что под `@property`, classmethod, staticmethod

F-string (PEP 498)

f-string (formatted string literal)

Термин

Formatted string literal, введён PEP 498 (Python 3.6+). Префикс `f` или `F` перед строковым литералом превращает его в выражение: `{expr}` подставляет результат `expr` (с опциональным format spec через `:`). Реализация на уровне bytecode: компилятор генерирует `FORMAT_VALUE` + `BUILD_STRING` opcodes, минуя runtime parsing — быстрее чем `str.format()` (~2x) и `%-formatting`. Python 3.8+ — debug-вариант `f"{x=}"` печатает имя выражения + значение (`x=42`). Python 3.12+ — PEP 701 снимает ограничения на вложенные кавычки и многострочные выражения внутри `{}`. Cross-link: M01 урок 04 (PEP 393 — Latin-1/UCS-2/UCS-4 storage для строкового результата).

Пример:

>>> name = "Лев"; n = 42
>>> f"Привет, {name}! count={n:03d}"
'Привет, Лев! count=042'
>>> f"{n=}"           # Python 3.8+ debug
'n=42'

Подробнее в уроках:

str и PEP 393: flexible string representation

Generator expression

Generator expression (gen-expr)

Термин

Синтаксис `(expr for x in iter if cond)` (круглые скобки, не square / curly) — создаёт generator object: ленивый итератор, производящий элементы по требованию (по одному за `next()`). Ключевое отличие от list comprehension: O(1) память (≈120 байт PyGenObject) vs O(N) для list-comp (8MB для N=10⁶). Compiles в специальную generator function: PyGenObject содержит ссылку на frame, который suspended/resumed при каждом next(). Single-pass: после exhaustion (StopIteration) повторно итерировать нельзя — нужно создать новый. Идеально для агрегатных операций (sum/max/min/any/all) — потребитель читает по одному, никогда не materialize всё. Используется как input в map/filter chains, передача в функции, ожидающие iterable. См. Objects/genobject.c, PEP 289 (Generator Expressions, Python 2.4). Переходный мост к Phase 66 M05 (iterator/generator protocol).

Подробнее в уроках:

List/dict/set comprehensions, generator expressions

TypedDict

Термин

Класс из typing модуля (`typing.TypedDict`) для типизации **dict-as-record** pattern. Введён PEP 589 (Python 3.8, 2018), расширен PEP 655 (Python 3.11, 2022) с Required/NotRequired per-key optionality control. Use case: typed контракт для JSON API responses, configs, message envelopes — pattern dict с известными ключами и типами значений. Example: `class User(TypedDict): id: int; name: str; email: str` + `alice: User = {'id': 1, 'name': 'alice', 'email': '[email protected]'}`. Critical observation: **runtime — обычный dict** (`type(alice) == dict`, `isinstance(alice, dict) == True`); никакого custom класса; никакого runtime overhead. TypedDict — **только** static type-checker механизм (mypy / pyright проверяют ключи и типы values статически). Совместим с json.loads (returns dict, type-cast'ится в TypedDict без runtime validation — production combine с Pydantic / marshmallow для validation). PEP 655 расширение — Required[X] / NotRequired[X] для per-key optionality control: до 3.11 был binary `total=True` (все required) или `total=False` (все optional); per-key позволяет mixed. Example: `class APIResponse(TypedDict): status: int; data: Required[dict]; error: NotRequired[str]; cached: NotRequired[bool]` — status и data обязательны, error и cached optional. Combinable с total=False. Это решает реальную проблему API typing — большинство responses имеют mixed required/optional fields. Альтернативные подходы: @dataclass (M04 урок 05) — full Python class с runtime support, но overhead instance creation; namedtuple — immutable but no per-field optionality; Pydantic BaseModel — runtime-validated. TypedDict — middle ground: typed для dev experience, dict для performance. Cross-link M02 урок 03 (PyDictObject — hash table internals). Cite: PEP 589 (peps.python.org/pep-0589), PEP 655 (peps.python.org/pep-0655), Lib/typing.py TypedDict + Required + NotRequired classes.

Подробнее в уроках:

Protocol и TypedDict — structural subtyping и typed dict-as-record

Walrus operator (PEP 572)

Assignment expression (walrus operator)

Термин

Оператор присваивания-выражение `:=`, введён PEP 572 (Python 3.8+). Выполняет присваивание и одновременно возвращает значение — позволяет записать результат вычисления внутри условия / comprehension без отдельной строки. Использование: уменьшает дублирование вычислений (`while (chunk := f.read(8192)):`), упрощает чтение `if (m := pattern.match(line)) is not None:`. Ограничения: нельзя использовать на верхнем уровне выражения присваивания (`x := 5` синтаксическая ошибка — нужна обёртка `(x := 5)`); внутри comprehension scope — захватывает переменную в внешний scope (PEP 572 §«Scope of the target»).

Пример:

# Без walrus — двойной вызов
data = process()
if data:
    handle(data)

# С walrus — одна строка, одно вычисление
if (data := process()):
    handle(data)

# Comprehension использование (PEP 572 §scope)
result = [y for x in items if (y := transform(x)) is not None]

Подробнее в уроках:

Control flow, range и cache line behavior

yield from

`yield from` (PEP 380)

Pitfall: дефолтное значение параметра функции evaluated **один раз** at function-definition time и хранится в `func.__defaults__` tuple. Если default — mutable (list, dict, set), все вызовы без явного аргумента получают **один и тот же** объект, накапливая мутации. Пример: `def f(x, lst=[]): lst.append(x); return lst` — после `f(1); f(2)` второй вызов вернёт `[1, 2]`, не `[2]`. Корень: PyFunctionObject хранит default-tuple в func_defaults (Objects/funcobject.c), evaluated при executing `def`-statement. Каноничное решение — sentinel pattern: `def f(x, lst=None): if lst is None: lst = []; ...` — сравнение с `is None` вместо `== None` (identity check, None — singleton). Альтернативный sentinel: `_MISSING = object()` для случаев, где None — валидное значение. См. PEP 8, Python documentation 'Default argument values' note.

Подробнее в уроках:

Функции: positional, keyword, default — и mutable default trap

Protocol (structural subtyping)

Protocol — structural subtyping

Термин

Класс из typing модуля (`typing.Protocol`) реализующий **structural subtyping** — typed duck-typing. Введён PEP 544 (Python 3.8, 2018). Объект совместим с Protocol классом если у него есть **нужные методы / атрибуты** — никакого inheritance не требуется. Example: `class Drawable(Protocol): def draw(self) -> str: ...` — любой класс с методом `draw() -> str` (Circle, Square, etc.) structurally compatible, mypy approve'ит passing в `def render(item: Drawable)`. Это **fundamental** отличие от ABC (abstract base class — nominal subtyping, M04 урок 04 cross-link): ABC требует explicit `class Foo(MyABC):` + реализации abstractmethod (verified runtime — `Foo()` raises TypeError если abstract method missing); Protocol — duck-typing с типами (verified static, mypy structural compat check). Use cases: framework принимает arbitrary objects от users без forced inheritance. Pitfall 15 — `isinstance(obj, MyProtocol)` raises TypeError по default; добавить `@runtime_checkable` декоратор для opt-in. После opt-in — runtime check проверяет ТОЛЬКО method existence (не signature accuracy), не для data attributes (Python ≤ 3.12). Performance cost: runtime-checkable Protocol slower nominal isinstance (итерация по required attrs). 90% production-кода — Protocol достаточно (не forced inheritance). Standard library примеры: `collections.abc.*` — гибрид (formal ABCs but with structural-like behavior через `__subclasshook__`); `typing.Iterable`, `typing.Sized`, `typing.Container` — predefined Protocols. Cross-link M04 урок 04: descriptors / @property nominal hierarchy через ABC; M07 урок 03 fills structural side. Cite: PEP 544 (peps.python.org/pep-0544), Lib/typing.py Protocol class.

Подробнее в уроках:

Protocol и TypedDict — structural subtyping и typed dict-as-record

pytest fixture

Термин

Decorator-based dependency injection mechanism в pytest для setup/teardown shared test environment'а. Function декорированная `@pytest.fixture` регистрируется как fixture; pytest **автоматически** инжектит fixture в test function, если test function запрашивает её через parameter name. Это inverse of `unittest.setUp/tearDown` — declarative dependency injection вместо overriding methods. **Two styles:** (1) **Return-style** — `@pytest.fixture def alice(): return User('alice')` — простой setup без teardown. (2) **Yield-style** — `@pytest.fixture def db(): conn = open(); try: yield conn; finally: conn.close()` — setup + teardown через yield boundary. **Climax cross-link M06 урок 05:** yield-style fixtures используют **тот же** pattern, что `@contextlib.contextmanager` — pytest's `_pytest/fixtures.py:resolve_fixture_function` reuses `_GeneratorContextManager`-like handler. yield служит boundary между `__enter__` (setup) и `__exit__` (teardown в try/finally). Synthesis chain: closure (M03 урок 04) + generator (M05 урок 02) + context-manager protocol (M06 урок 04) → @contextmanager (M06 урок 05) → @pytest.fixture(yield-style) (M08 урок 02). **Scope hierarchy** (Pitfall 16): `function` (default — N invocations) / `class` (per Test* class) / `module` (per *.py file) / `package` (per Python package) / `session` (one per pytest invocation). Broader scope — cheaper, but shared mutable state risk. Match scope с test independence. **Fixture dependencies:** fixtures sами могут request other fixtures как parameters; pytest resolves graph automatically. Rule: **fixture scope ≥ scope of fixtures it requests** (else `ScopeMismatch`). **Auto-discovery via conftest.py:** fixtures defined в `tests/conftest.py` propagate recursively во все test files под directory — no explicit import needed. Cross-link `context-manager-protocol` (M06 урок 04). Cite: pytest 8 docs — fixtures (docs.pytest.org), [_pytest/fixtures.py](https://github.com/pytest-dev/pytest/blob/main/src/_pytest/fixtures.py), [Lib/contextlib.py](https://github.com/python/cpython/blob/3.13/Lib/contextlib.py).

Подробнее в уроках:

Fixtures и scope hierarchy — climax cross-link M06 урок 05

Подробнее в уроках:

Logging fundamentals: Logger / Handler / Formatter / Filter

Bytecode opcode

Bytecode opcode (CPython)

Термин

Python bytecode — sequence of (opcode, argument) pairs executed by CPython interpreter loop (`Python/ceval.c`). Каждый opcode — single-byte instruction, argument — usually small int (index в local variable table, constant table, or jump offset). Stdlib `dis` модуль предоставляет introspection: `dis.dis(code_obj)` (prints to stdout — quick CLI), `dis.get_instructions(code)` (iterator of `Instruction` namedtuples — programmatic analysis, used in Pattern 4 `py-m12-04-code-1`), `dis.Bytecode(code).info()` (mid-level — programmatic + pretty print). **Common opcodes** (Python 3.11+): `RESUME` (function entry / generator resume marker — 3.11+ added); `LOAD_FAST n` (load local variable by slot n); `LOAD_CONST k` (load constant from `co_consts[k]` — literals); `LOAD_GLOBAL` (load global / builtin — `print`, module-level vars); `STORE_FAST n` (store top-of-stack to local slot n); `BINARY_OP op` (3.11+ unified arithmetic/comparison — was `BINARY_ADD`/`BINARY_SUBTRACT`/etc separately); `CALL n` (3.11+ unified function call с n args); `RETURN_VALUE` (pop top-of-stack, return); `LIST_APPEND` (mutate intermediate list — emitted in list comprehensions); `YIELD_VALUE` (yield top-of-stack — emitted in generator expressions / `yield` statements); `GET_ITER` + `FOR_ITER` (iterator protocol — `for ... in ...:` loop). **Generator vs list comp distinction visible in bytecode:** `[x*2 for x in range(3)]` emits `LIST_APPEND` per iteration (memory O(n) — full list materialized); `(x*2 for x in range(3))` emits `YIELD_VALUE` (memory O(1) — lazy iteration via PyGenObject machinery, cross-link M05 урок 02). **PEP 659 — specialized adaptive interpreter** (Python 3.11+) — opcodes могут rewrite themselves в runtime для type-specific paths (`BINARY_OP` → `BINARY_OP_MULTIPLY_INT` после type-feedback). Это даёт ~10-30% speedup для tight loops, но имеет side effect для `dis` output: opcode names version-sensitive (Pitfall 40). **Решение для testCases:** `matchMode='contains'` — assert presence of generic opcode ('LIST_APPEND', 'YIELD_VALUE', 'BINARY_OP') — robust к version drift / specialization. **Constant folding caveat** (3.13+): literal-only expressions (`1+2`) folded compiler'ом в `RETURN_CONST 3` — НЕ emit BINARY_OP; testCases используют variable references. **Pragmatic NOT D-07** — observable through public dis API; не deep-diving в `PyCodeObject` struct (M02-M03 territory). Cross-course → Spark [02 catalyst-tungsten](/spark-internals/06-catalyst-tungsten/) — Catalyst optimizer + Tungsten code-generation produces JVM bytecode для optimized query plan; same idea (compile high-level expression → low-level instructions). Cite [docs.python.org/3/library/dis.html](https://docs.python.org/3/library/dis.html) + [PEP 659](https://peps.python.org/pep-0659/).

Подробнее в уроках:

dis — bytecode introspection + generators-vs-list-comp

dictConfig schema

dictConfig schema (PEP 391)

Термин

logging.config.dictConfig schema — Python dict matching PEP 391 (Dictionary-Based Configuration For Logging, 2009) versioning convention. Required key: `version: 1` (loader проверяет `if config.get("version") != 1: raise ValueError`; currently только value 1 supported, allows future schema evolution без breaking changes). Optional keys: `disable_existing_loggers` (default True — replace mode), `incremental` (partial update), `formatters` (dict of named formatter specs), `handlers` (dict of named handler specs — class string `"logging.handlers.RotatingFileHandler"` или factory `"()"` callable + kwargs), `loggers` (dict of logger configs — keys = dotted names, `""` empty-string key = root), `root` (alternative root config), `filters`. Special syntactic markers: `"class"` — fully-qualified class name imported by dictConfig; `"()"` — callable factory (alternative class); `"ext://sys.stderr"` — extension protocol resolved at config time; `"cfg://handlers.console"` — cross-reference внутри config. **Status:** modern replacement для legacy fileConfig (INI-based, Python 2.x carryover, kept для backward-compat only). dictConfig source-agnostic — dict from json.loads / yaml.safe_load (NOT stdlib) / tomllib.loads (Python 3.11+, M13 урок 01) / Python literal. **Pyodide constraint:** challenge `py-m11-03-code-1` parses JSON dictConfig schema (stdlib `json`); YAML — Run-on-Your-Machine only (`pyyaml` НЕ stdlib, micropip FORBIDDEN per Phase 69 Wave 0). Cite [docs.python.org/3/library/logging.config.html#dictionary-schema-details](https://docs.python.org/3/library/logging.config.html#dictionary-schema-details) + [PEP 391](https://peps.python.org/pep-0391/).

Подробнее в уроках:

logging.config.dictConfig + JSON config + RotatingFileHandler

LogRecord `extra` parameter

Термин

Параметр `extra` в `logger.info(msg, extra={...})` (Python stdlib `logging`). Словарь, ключи которого добавляются как атрибуты к создаваемому `LogRecord` объекту — доступны в format strings (`%(custom_field)s`) и в structured-logging обработчиках (JSON formatter сериализует все extra-ключи). Ограничение: ключи не должны конфликтовать с reserved attributes `LogRecord` (`message`, `levelname`, `pathname`, etc.) — конфликт вызывает `KeyError` в логировании. Production pattern: correlation IDs (request_id, trace_id), tenant_id, user_id передаются через extra → JSON output → ingested ELK / Loki.

Пример:

import logging
logger = logging.getLogger(__name__)
logger.info("user login", extra={"user_id": 42, "tenant": "acme"})
# JSON formatter (M11 урок 02) сериализует:
# {"msg": "user login", "user_id": 42, "tenant": "acme", ...}

Подробнее в уроках:

Structured logging: JSON output, extra={}, correlation IDs

psutil — process introspection

psutil.Process

Термин

Сторонняя cross-platform библиотека для system + process monitoring. `psutil.Process()` (current PID) или `psutil.Process(pid)` экспонирует CPU usage, memory (RSS / VMS / USS), open files, network connections, threads, child processes. `Process.memory_info().rss` — Resident Set Size в байтах (физическая память, занимаемая процессом — комплементарна к `tracemalloc` Python-heap трекингу). Production use: monitoring loop собирает RSS / CPU% и экспортирует в Prometheus (Counter / Gauge); alerts на memory leak (RSS monotonically растёт). Pyodide-limitation: НЕ работает в WASM (требует OS syscalls); пометка Run-on-Your-Machine. Cross-link: M12 урок 03 (tracemalloc Python-heap; psutil — process-level RSS).

Пример:

# Run on your machine — pip install psutil
import psutil, os
p = psutil.Process(os.getpid())
print(f"RSS: {p.memory_info().rss / 1024 / 1024:.1f} MB")
print(f"CPU%: {p.cpu_percent(interval=1.0):.1f}")

Подробнее в уроках:

tracemalloc — memory profiling + snapshots

RotatingFileHandler

logging.handlers.RotatingFileHandler

Термин

Handler из stdlib `logging.handlers`, ротирующий лог-файлы по размеру. Параметры: `maxBytes` (rollover порог в байтах) + `backupCount` (число backup файлов: `app.log.1`, `app.log.2`, ...). При достижении `maxBytes` текущий `app.log` переименовывается в `app.log.1`, старые файлы сдвигаются (старейший удаляется). Альтернатива — `TimedRotatingFileHandler` (rollover по времени: midnight / hourly / weekly). Production caveat: ротация выполняется в потоке логирования (sync I/O — может блокировать); для high-throughput сервисов используется `QueueHandler` + `QueueListener` чтобы вынести rollover в фоновый поток. Cross-link: M11 урок 03 (`dictConfig` пример с `RotatingFileHandler`).

Пример:

from logging.handlers import RotatingFileHandler
h = RotatingFileHandler("app.log", maxBytes=10_000_000, backupCount=5)
# 10 MB → rollover; хранит 5 предыдущих файлов
# Итого до 60 MB логов на диске

Подробнее в уроках:

logging.config.dictConfig + JSON config + RotatingFileHandler

Данные

Arrow IPC + C Data Interface

Apache Arrow IPC and C Data Interface

Термин

Apache Arrow — universal columnar in-memory format (since 2016). Состоит из (1) **memory layout spec** — fixed-width primitives contiguously, variable-length values + offsets buffer, separate null bitmap (cross-link M02 урок 01 PyListObject contiguous memory — extension cross-library); (2) **C Data Interface** — ABI-stable C struct (`ArrowSchema`, `ArrowArray`, `ArrowDeviceArray`) + reference counting — in-RAM handshake между libraries (pandas/Polars/DuckDB/Spark/DataFusion) без copy; (3) **IPC format** — bytes-on-wire equivalent для disk persistence или network transfer (Arrow Flight gRPC). PEP 749 standardises Python-level dunder methods (`__arrow_c_array__` / `__arrow_c_stream__` / `__arrow_c_schema__`) returning PyCapsule wrapping C Data Interface struct. **Production status (2026):** pandas 2.2+ producer; Polars 1.0+ producer + consumer; PyArrow 15+ full support; DuckDB 0.10+ Arrow-compatible result format. **Critical insight для DE:** zero-copy interop saves CPU + memory bandwidth для multi-library pipelines (pre-Arrow model — serialize/deserialize cycle per handoff = CPU + 2x memory). Cross-course: Storage Formats M07 (7 lessons Arrow deep dive — memory layout, type system, IPC format, Feather, Flight protocol, ecosystem); DataFusion M01 Arrow foundation (Rust FFI compatibility); Spark M11 Arrow Module + M06/03 Pandas UDFs. Cite [Apache Arrow Format spec](https://arrow.apache.org/docs/format/) + [PEP 749](https://peps.python.org/pep-0749/) + [PyArrow docs](https://arrow.apache.org/docs/python/).

Подробнее в уроках:

PyArrow — Arrow memory model, zero-copy, Table/RecordBatch

PyArrow zero-copy

PyArrow zero-copy interop

Термин

Передача Arrow-формат данных между Python библиотеками (pandas / Polars / DuckDB / PyArrow) без сериализации / десериализации. Реализация: C Data Interface (ABI-stable C struct `ArrowArray` + `ArrowSchema`) + PyCapsule wrapper (PEP 749, Python 3.12+). pandas 2.2+ → `df.__arrow_c_stream__()` возвращает Arrow stream; Polars 1.0+ принимает `__arrow_c_array__` как input. Преимущество vs CPython pickle / Apache Avro: ноль копий памяти buffer — receiver ссылается на тот же memory block через reference counting. Cross-course Storage Formats M07 разворачивает Arrow memory model + IPC format подробнее. Cross-link: M10 урок 03 (PyArrow concept).

Пример:

import pyarrow as pa, pandas as pd
ser = pd.Series([1, 2, 3])
arr = pa.array(ser)         # zero-copy: ser buffer reused
# Полное копирование произошло бы при .to_numpy().tolist()

Пример:

# pyproject.toml
[tool.mypy]
strict = true
python_version = "3.13"

# CLI
mypy --strict src/

Подробнее в уроках:

M07 summary + bridge к mypy — Run-on-Your-Machine

prometheus_client

prometheus_client (Python)

Термин

Официальная Python-библиотека для экспорта метрик в Prometheus формате. Четыре типа метрик: `Counter` (monotonic — request count, error count), `Gauge` (instantaneous — queue size, memory usage), `Histogram` (bucketed observations — latency), `Summary` (quantiles — p50/p95/p99). HTTP endpoint `/metrics` через `start_http_server(8000)` (built-in `http.server` — для production использовать ASGI-обёртку). Cross-course Spark M14 — Prometheus + Grafana monitoring stack для Spark cluster. Cross-link: M11 урок 04 (3 pillars observability — metrics pillar).

Пример:

from prometheus_client import Counter, start_http_server

requests = Counter("http_requests_total", "Total HTTP requests", ["method"])
start_http_server(8000)   # /metrics endpoint

requests.labels(method="GET").inc()

Подробнее в уроках:

Observability: 3 pillars (logs / metrics / traces)

pyproject.toml (PEP 621)

pyproject.toml — declarative project metadata (PEP 621)

Термин

pyproject.toml — declarative Python project metadata file standardized в PEP 621 (2020). Replaces legacy `setup.py` (executable, security risk install-time) + `setup.cfg` (declarative но setuptools-specific) — единственный manifest format для modern Python projects. **Two main tables:** (1) **`[build-system]`** (PEP 518, 2016) — `requires: list[str]` (build dependencies — installed в isolated venv frontend'ом) + `build-backend: str` (dotted path к backend module — hatchling.build / setuptools.build_meta / poetry.core.masonry.api / flit_core.buildapi / pdm.backend / maturin); (2) **`[project]`** (PEP 621) — unified metadata: `name` / `version` / `description` / `readme` / `requires-python` / `dependencies` / `optional-dependencies` / `dynamic` / `authors` / `maintainers` / `license` / `keywords` / `classifiers` / `urls` / `scripts` / `gui-scripts` / `entry-points`. **PEP 735** (2024) added **`[dependency-groups]`** — modern dev-deps grouping (replaces `[project.optional-dependencies]` для dev tools; не публикуется в wheel metadata; supports composition `include-group`; cross-tool support pip ≥24.1, uv, Poetry 2.0+). **Parsed via `tomllib`** (Python 3.11+ stdlib, PEP 680, **read-only** — для записи использовать third-party `tomli-w`; Pitfall 45). **Pitfall 44 — Poetry pre-2.0 `[tool.poetry]` proprietary table; Poetry 2.0+ supports `[project]` standard.** **Cross-link M07 урок 04** — pyproject.toml parsed via tomllib returns dict — accessed like dataclass field access. Cite [peps.python.org/pep-0517](https://peps.python.org/pep-0517/) + [pep-0518](https://peps.python.org/pep-0518/) + [pep-0621](https://peps.python.org/pep-0621/) + [pep-0680](https://peps.python.org/pep-0680/) + [pep-0735](https://peps.python.org/pep-0735/) + [packaging.python.org/en/latest/guides/writing-pyproject-toml/](https://packaging.python.org/en/latest/guides/writing-pyproject-toml/).

Подробнее в уроках:

pyproject.toml — PEP 517 / 518 / 621; build backends; tomllib

pytest fixture scope

Термин

Параметр `scope` в `@pytest.fixture(scope=...)` определяет lifecycle fixture'а: `function` (default; пересоздаётся для каждого test), `class` (один раз на test class), `module` (один раз на test файл), `package` (один раз на pytest package), `session` (один раз на pytest session — все tests). Fixture с большим scope живёт дольше — экономия на setup cost (DB connection, large file load). Trade-off: shared state между тестами риск flakiness — больший scope требует careful test isolation (no mutating shared fixture). Cross-link: M08 урок 02 (climax cross-link M06 урок 05 context manager protocol).

Пример:

import pytest

@pytest.fixture(scope="session")
def db_conn():
    conn = create_connection()
    yield conn
    conn.close()

@pytest.fixture(scope="function")
def temp_table(db_conn):
    # один conn на session, но fresh table per-test
    ...

Подробнее в уроках:

Fixtures и scope hierarchy — climax cross-link M06 урок 05

sdist vs wheel (PEP 427 / 517)

sdist vs wheel distribution formats

Термин

Two PyPI distribution formats. **sdist** (`.tar.gz`) — **source distribution**; archive исходников + pyproject.toml + README; install **fall back к manual build** (pip создаёт isolated venv, ставит `[build-system].requires`, вызывает `build_wheel(...)`); slower (compile time для C extensions); требует build toolchain (gcc, headers); larger archive. Filename convention `{pkg}-{version}.tar.gz`. **wheel** (`.whl`, [PEP 427](https://peps.python.org/pep-0427/), 2012) — **pre-built binary**; zip archive containing `{pkg}/` (directly copyable в site-packages) + `{pkg}-{version}.dist-info/` (METADATA + RECORD + WHEEL); install — pure copy без compile/subprocess; **на порядок быстрее** sdist install (особенно для C extensions); per-platform / per-Python-version artifacts. **Wheel filename anatomy:** `{pkg}-{version}-{python_tag}-{abi_tag}-{platform_tag}.whl` — example `pandas-2.1.4-cp312-cp312-manylinux_2_17_x86_64.whl`: `pandas` (name), `2.1.4` (version), `cp312` (Python tag — CPython 3.12), `cp312` (ABI tag — usually = Python tag для CPython; some C-extensions ABI-stable → `abi3`), `manylinux_2_17_x86_64` (platform tag — compatible glibc 2.17+). **Universal wheels** `pkg-1.0-py3-none-any.whl`: `py3` (any Python 3) + `none` (no specific ABI) + `any` (any platform). **manylinux ABI compatibility** ([PEP 600](https://peps.python.org/pep-0600/), 2020) — manylinux_2_17/2_28/2_34 баseline glibc versions; Alpine Linux uses musl libc → `musllinux_1_1_x86_64` tag (PEP 656, 2021). **Pitfall 48 — wheel filename mismatch** (cp310 wheel manually installed on Python 3.12 → ImportError shared object; modern pip handles automatically). **Recommend:** ship обе sdist + wheel(s); pure-Python — sdist + один universal wheel; C-extensions — sdist + per-platform wheels matrix через [cibuildwheel](https://cibuildwheel.pypa.io/). **Build via `python -m build`** (replaces legacy `python setup.py sdist bdist_wheel`); **upload via `twine upload dist/*`** к PyPI / TestPyPI. Cite [packaging.python.org/en/latest/specifications/binary-distribution-format/](https://packaging.python.org/en/latest/specifications/binary-distribution-format/) + [PEP 427](https://peps.python.org/pep-0427/) + [PEP 600](https://peps.python.org/pep-0600/).

Подробнее в уроках:

sdist vs wheel; manylinux ABI; python -m build; PyPI / TestPyPI

structlog

structlog (3rd-party)

Термин

Сторонняя библиотека structured logging, альтернатива stdlib `logging` + `python-json-logger`. Преимущества: declarative pipeline processors (`add_logger_name`, `add_log_level`, `TimeStamper`, `JSONRenderer`); thread-local + async-context bind (`structlog.contextvars.bind_contextvars(request_id=...)` — корелляция логов в async-handlers без передачи extra параметров); native ContextVar-aware propagation (Python 3.7+). Production-ready alternative для FastAPI / Starlette / async services; сохраняет совместимость с stdlib `logging` через `structlog.stdlib.LoggerFactory`. Cross-link: M11 урок 02 (Run-on-Your-Machine — pip install structlog).

Пример:

import structlog
log = structlog.get_logger()
log.info("user_login", user_id=42, tenant="acme")
# JSON output: {"event": "user_login", "user_id": 42, "tenant": "acme", ...}

Подробнее в уроках:

Structured logging: JSON output, extra={}, correlation IDs

tracemalloc snapshot

tracemalloc snapshot (PEP 454)

Термин

tracemalloc.take_snapshot() — capture current allocation state with traceback per allocation site (set by `tracemalloc.start(N)` где N — frames per traceback, default 1). Stdlib `tracemalloc` ([PEP 454](https://peps.python.org/pep-0454/), Python 3.4+) — memory profiling primitive — instruments allocator hook + records pointer + size + traceback для каждой allocation. **Snapshot API:** `snapshot.statistics(key_type)` — group by key (`'lineno'` — source line, `'filename'` — source file, `'traceback'` — full traceback) — returns `Statistic` objects sorted by total size. `snapshot.compare_to(other_snapshot, key_type='lineno')` — **diff** двух snapshots, returns `Statistic` objects с `size_diff` + `count_diff` + `traceback`. Это и есть **leak detection** workflow: (1) `tracemalloc.start(N)` (включить tracking — overhead per allocation: ~30% slowdown N=1, до 50%+ N=25); (2) `snap_baseline = tracemalloc.take_snapshot()`; (3) run suspicious workload (idempotent — должен НЕ накапливать state); (4) `snap_after = tracemalloc.take_snapshot()`; (5) `diff = snap_after.compare_to(snap_baseline, 'lineno')` — top growers per line; (6) `tracemalloc.stop()` — выключить tracking (Pitfall 39 — production process тормозит до restart если забыли stop). Production wraps в `try/finally` или DIY context-manager (cross-link M06 урок 04 protocol — `__enter__`/`__exit__` гарантирует cleanup даже при exception). **Comparison vs sys.getsizeof:** `sys.getsizeof(obj)` — per-object (single call, без traceback); `tracemalloc` — per-allocation site (granular, leak detection origin). **Comparison vs gc.get_objects():** `gc.get_objects()` — list of all currently-alive objects (type-based introspection — «сколько Foo instances right now?»); together they give full picture: «leak'ит **что** + **откуда**». **Pyodide constraint:** bounded examples OK (small dict/list snapshots — ~10ms overhead в browser); **production-scale snapshots** (1GB+ heap) — too slow для browser; T-69-23 disposition — accept; bounded examples только в lesson MDX prose, real production-scale → Run-on-Your-Machine. **Comparison vs memray:** `memray` (Bloomberg, 2022) — native C-level instrumentation, lower overhead, structured output (flame graphs HTML, allocator breakdown), **tracks C-extension allocations что tracemalloc НЕ делает** (only Python allocations). Production-scale memory analysis → memray; dev quick diagnostics → tracemalloc (stdlib, no-install). **Cross-course → Spark** [01/07 memory-management](/spark-internals/05-memory-storage-internals/01-memory-management/) — distributed equivalent: Spark UI Storage tab показывает RDD/DataFrame caching memory growth across stages — analogous к tracemalloc.compare_to. **Cross-course → DataFusion** [02/07 memory-management](/datafusion-course/02-architecture/07-memory-management/) — Rust's memory tracking primitives (MemoryConsumer trait, MemoryReservation) — explicit tracking analogous; Rust no-GC requires explicit reservation patterns. Cite [docs.python.org/3/library/tracemalloc.html](https://docs.python.org/3/library/tracemalloc.html) + [PEP 454](https://peps.python.org/pep-0454/).

Подробнее в уроках:

tracemalloc — memory profiling + snapshots

uv (Astral)

uv (Astral package manager)

Термин

Rust-based замена pip / pip-tools / virtualenv / pyenv от Astral Inc. (создатели Ruff). Установка пакетов в 10-100x быстрее pip за счёт parallel download + global cache + Rust-native dependency resolver (PubGrub algorithm). Совместим с PEP 517 / 518 / 621 (читает `pyproject.toml`); производит `uv.lock` файл (cross-platform reproducible builds; формат — human-readable TOML). Стабильный с октября 2024 (uv 0.4+); рекомендован Astral для новых проектов вместо rye / poetry / pdm. Cross-course Spark M14 — CI/CD pipeline pattern с lock-файлом.

Пример:

uv venv .venv
source .venv/bin/activate
uv pip install 'fastapi>=0.110'
uv lock                          # generate uv.lock
uv sync                          # reproduce env from uv.lock

Подробнее в уроках:

pip / uv / Poetry / rye (deprecated) — comparison + resolver