ЗАМЕР

bench/comprehensions/class_scope_walrus.py

Скрипт, которым получены числа в статье, и запись прогона. Файл читается на сборке из репозитория — это тот самый код, который запускали, а не его копия.

Цитируется в статье

/ru/interview/python/comprehensions

Как запустить

for v in 3.11 3.12 3.13 3.14; do python$v bench/comprehensions/scope.py; done

Запись прогона

Замеры для урока «Включения: где проходит граница»

Скрипт	Что показывает
`scope.py`	где именно проходит граница области видимости: переменная не течёт, первый итерируемый вычисляется снаружи, тело класса даёт `NameError` там, где функция не даёт
`walrus.py`	единственное, что ходит через границу наружу: `:=` связывает имя в объемлющей области (PEP 572), плюс два запрета и заявленный мотив
`silent.py`	две ошибки, которые не падают: подменённая константа в теле класса и утёкший морж
`cost.py`	включение против цикла против `map` — и что на самом деле решает
`bytecode.py`	что изменил PEP 709, чего не изменил, и почему «вынести метод в локальную» больше не помогает

for v in 3.11 3.12 3.13 3.14; do python$v bench/comprehensions/scope.py; done

Практика урока

practice.py — источник ответов двух практических задач урока, а runs/practice.txt — дословная запись его прогона. Ответ задачи не сочиняется: сборка сверяет заявленное с этой записью (scripts/validate-practice.mjs) и не проходит, если они разошлись.

Прогон снят 30.08.2026 на CPython 3.13.7 (Clang 20.1.4). Абсолютные числа — этой машины; переносится кратность, и задача «во сколько раз» стоит именно на ней.

Кратность устойчива только потому, что формы меряются ВПЕРЕМЕЖКУ: в каждом круге меряются все, минимум для каждой берётся по кругам. Пока замеры шли подряд, просадка машины в окне одной формы целиком доставалась ей, и отношение гуляло в полтора раза от запуска к запуску (измерено на декораторах: 5,9 / 7,1 / 7,5 / 9,2). После перехода на чередование расхождение между прогонами не выходит за несколько процентов. Перезаписывать запись прогона имеет смысл только вместе с проверкой задачи: если после перезапуска ответ изменился, менять нужно задачу, а не файл.

Главное, что здесь измерено

Граница проходит не по скобкам включения. Справочник: «aside from the iterable expression in the leftmost for clause, the comprehension is executed in a separate implicitly nested scope». Отсюда четыре строки подряд в одном теле класса, из которых работают первая и последняя:

[x for x in raw]                  -> [2, 3, 5]
[x * multiplier for x in raw]     -> NameError: name 'multiplier' is not defined
[x for x in raw if x > limit]     -> NameError: name 'limit' is not defined
[x + y for x in raw for y in raw] -> NameError: name 'raw' is not defined
обычный for/append по raw         -> [20, 30, 50]

Четвёртая строка — самая наглядная: raw в ней написано дважды, и первое вхождение видно, а второе нет.

Правило не менялось четыре версии подряд. PEP 709 (3.12) встроил включения в вызывающий код — MAKE_FUNCTION и вложенного объекта кода у них больше нет, — но область видимости осталась прежней. Проверено: на 3.11, 3.12, 3.13 и 3.14 scope.py печатает одни и те же три NameError.

Выбор «включение или цикл или map» почти ничего не стоит. На 3.13.7 разброс между тремя способами — 1,13 раза. Решает другое: убрать вызов кода на Python из тела даёт 1,7 раза, а заменить условие на Python вызовом filter(None, …) — ещё 1,8.

Приём «вынести метод в локальную» стоит дороже, чем не выносить. Около десяти процентов, устойчиво. Инструкций в теле цикла при этом поровну — девять и девять; разница в том, что out.append(...) компилируется в LOAD_ATTR с установленным младшим битом (форма, которая кладёт на стек метод и self сразу), а вызов через локальную переменную идёт обычным путём и подставляет self на каждом вызове.

Чего здесь нет и почему

Сравнения спискового включения с генераторным выражением. Оно разобрано в уроке «Итераторы и генераторы» — там же и про то, что PEP 709 генераторных выражений не касается. Повторять его здесь значило бы дать два разных набора чисел на один и тот же вопрос.

Времени для walrus.py и scope.py. Область видимости — вопрос семантики; наносекунды в этих разделах ничего бы не подкрепили.

Правило версий

Время между версиями не сравнивается. Числа 3.13.7 и 3.14.7 в cost.py приводятся рядом как два независимых результата; сравнивать можно только кратности внутри одного прогона. Наблюдения scope.py, walrus.py и bytecode.py от версии к версии сравнивать можно: там не время, а имена инструкций, наличие объектов кода и текст сообщений об ошибках.

Скрипт

79 строк

"""Три места, где `:=` внутри включения не компилируется.

ЗАЧЕМ ЭТОТ ФАЙЛ. Урок разбирал две ошибки времени компиляции: морж по итерируемому
и морж по цели цикла. Аудит указал на третью, из того же PEP 572 и особенно
уместную здесь: внутри тела КЛАССА присваивающее выражение в включении запрещено.
Урок одновременно подробно разбирает область видимости класса и говорит, что
«морж течёт наружу» — то есть ровно там, где читатель ждёт продолжения правила,
язык его обрывает.

ПОЧЕМУ ЧЕРЕЗ compile(), А НЕ ПРОСТО КОДОМ В ФАЙЛЕ. Это ошибки КОМПИЛЯЦИИ: файл
с таким текстом не запустился бы вовсе, и показать рядом три случая было бы
нечем. compile() позволяет спросить у самого интерпретатора, что он думает о
каждом фрагменте, и напечатать его ответ дословно.

ТЕКСТ СООБЩЕНИЯ ПЕЧАТАЕТСЯ, НО ОН НЕ КОНТРАКТ. Между версиями формулировки
меняются, и цитировать их в статье можно только с указанием версии. Контракт —
что фрагмент не компилируется и какого класса ошибка.

ЗАПУСК: python3.13 bench/comprehensions/class_scope_walrus.py
Вывод по версиям: runs/class_scope_walrus-3.11.txt и соседние.
"""

import sys

CASES: list[tuple[str, str]] = [
    (
        "морж по цели цикла",
        "[(i := i) for i in range(3)]",
    ),
    (
        # Тот же морж, но именем, которого цикл не связывает: запрет узкий — он
        # про ПЕРЕСВЯЗЫВАНИЕ переменной включения, а не про морж рядом с ней.
        # Первый черновик этого файла спутал одно с другим и получил
        # «компилируется» там, где ждал ошибку.
        "морж соседним именем",
        "[(k := i) for i in range(3)]",
    ),
    (
        "морж по итерируемому",
        "[x for x in (y := range(3))]",
    ),
    (
        "морж в теле класса",
        "class Example:\n    [(j := i) for i in range(5)]\n",
    ),
    (
        "тот же морж, но в теле функции",
        "def example():\n    [(j := i) for i in range(5)]\n    return j\n",
    ),
    (
        "тот же морж на уровне модуля",
        "[(j := i) for i in range(5)]\n",
    ),
]


def main() -> None:
    print(f"Python {sys.version.split()[0]} ({sys.implementation.name})")
    print()
    for title, source in CASES:
        try:
            compile(source, "<урок>", "exec")
        except SyntaxError as exc:
            print(f"{title}: {type(exc).__name__}")
            print(f"    {exc.msg}")
        else:
            print(f"{title}: компилируется")
    print()

    # Что морж в теле функции и на уровне модуля действительно СВЯЗЫВАЕТ имя
    # снаружи включения — то самое «течёт наружу», от которого класс отрезан.
    namespace: dict[str, object] = {}
    exec("[(j := i) for i in range(5)]\n", namespace)
    print("на уровне модуля после включения j =", namespace["j"])


if __name__ == "__main__":
    main()