ЗАМЕР

bench/calls/practice.py

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

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

/ru/python/runtime/function-call

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

Записи прогонов — в `runs/`. У `shapes.py` и `cells.py` записи на трёх версиях:
там разбирается байт-код и объекты, то есть свойства кода, а их между версиями
сравнивать можно. У `cost.py` запись одна: время между версиями не сравнивается
вовсе (корневой `bench/README.md`).

## Что замер делает с тремя ходовыми утверждениями

Все три числа — из одного прогона 3.13.7, из `runs/cost.txt`.

| утверждение | что вышло |
| --- | --- |
| «вызов метода дороже вызова функции» | `o.m()` 17,74 нс против `f0()` 15,35 нс — ×1,16, то есть разницы практически нет |
| «связать метод заранее дешевле» | `bound()` 18,34 нс против `o.m()` 17,74 нс — дешевле не стало; что дороже, не установлено, см. ниже |
| «`staticmethod` быстрее: у него нет `self`» | `C.s()` 27,88 нс против `o.m()` 17,74 нс — ×1,57 в другую сторону, но сравнение поставлено небрежно, см. ниже |

## Чего не проверяет `cost.py` и что доделывает `forms.py`

**Сравнение `o.m()` с `C.s()` меняет сразу две вещи** — вид метода и то, через
что его читают. `forms.py`, блок 1, разводит обе оси в одном прогоне: при чтении
через экземпляр `o.s()` стоит ×1,54 от `o.m()`, а способ чтения при том же виде
метода добавляет ×1,07. Вывод не перевернулся, но теперь он опирается на
сравнение, в котором меняется одна вещь.

**Разница `bound()` и `o.m()` — три процента**, и без разброса она ничего не
значит. `forms.py`, блок 2, печатает лучший и худший раунд каждой формы: разрыв
1,28 нс при разбросе до 2,24 нс у самого `o.m()`. То есть «заранее связанный
медленнее» не установлено; установлено, что не быстрее.

**Кратности звёздочек сняты на пустой функции.** `forms.py`, блок 3, повторяет
те же формы на функции с телом из пятидесяти витков арифметики: вместо ×5,17
выходит ×1,06. Переносится не коэффициент, а то, какая форма передачи дороже
остальных.

Числа `forms.py` и `cost.py` между собой не сравниваются: это разные прогоны.
Сравнивать внутри одного прогона — единственный способ что-то утверждать о
времени, и именно поэтому разброс печатается там же, где разрыв.

Первые два объясняются байт-кодом, и `shapes.py` его печатает: на пути
`o.m(t)` стоит пара `LOAD_ATTR_METHOD_WITH_VALUES` + `CALL_PY_EXACT_ARGS`, и
объект связанного метода не создаётся вовсе. На пути `bound(t)` он уже создан
и лежит в переменной, и вызывается через него — `CALL_BOUND_METHOD_EXACT_ARGS`.
То есть «сэкономить на создании объекта» нечего: на быстром пути его и не
создают.

Что объект действительно создаётся, когда его просят, проверяется отдельно и
без всякого байт-кода:

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

Замеры: вызов функции — сколько стоит, из чего состоит и где живут ячейки

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

скрипт	что показывает
`cost.py`	время: пятнадцать форм вызова в наносекундах, три ходовых утверждения о цене вызова и то, что с ними делает замер; звёздочки на передаче; цена чтения имени за вычетом вызова
`shapes.py`	байт-код: какую специализацию интерпретатор выбрал после прогрева, чем `o.m` отличается от `o.m()`, и есть ли у выбранных опкодов имя в `dis.opmap`
`cells.py`	объекты: ячейка как наблюдаемая величина, общая ячейка у двух функций, одна ячейка на весь цикл, `MAKE_CELL`/`STORE_DEREF`/`COPY_FREE_VARS`/`LOAD_DEREF`
`forms.py`	то, что `cost.py` оставляет непроверенным: матрица «вид метода × способ чтения», разброс по раундам как мера значимости разницы, звёздочки на непустой функции

Запуск:

python3.13 bench/calls/cost.py
for v in 3.12 3.13 3.14; do echo "== $v"; python$v bench/calls/shapes.py; done
for v in 3.12 3.13 3.14; do echo "== $v"; python$v bench/calls/cells.py; done

Записи прогонов — в runs/. У shapes.py и cells.py записи на трёх версиях: там разбирается байт-код и объекты, то есть свойства кода, а их между версиями сравнивать можно. У cost.py запись одна: время между версиями не сравнивается вовсе (корневой bench/README.md).

Что замер делает с тремя ходовыми утверждениями

Все три числа — из одного прогона 3.13.7, из runs/cost.txt.

утверждение	что вышло
«вызов метода дороже вызова функции»	`o.m()` 17,74 нс против `f0()` 15,35 нс — ×1,16, то есть разницы практически нет
«связать метод заранее дешевле»	`bound()` 18,34 нс против `o.m()` 17,74 нс — дешевле не стало; что дороже, не установлено, см. ниже
«`staticmethod` быстрее: у него нет `self`»	`C.s()` 27,88 нс против `o.m()` 17,74 нс — ×1,57 в другую сторону, но сравнение поставлено небрежно, см. ниже

Чего не проверяет `cost.py` и что доделывает `forms.py`

Сравнение o.m() с C.s() меняет сразу две вещи — вид метода и то, через что его читают. forms.py, блок 1, разводит обе оси в одном прогоне: при чтении через экземпляр o.s() стоит ×1,54 от o.m(), а способ чтения при том же виде метода добавляет ×1,07. Вывод не перевернулся, но теперь он опирается на сравнение, в котором меняется одна вещь.

Разница bound() и o.m() — три процента, и без разброса она ничего не значит. forms.py, блок 2, печатает лучший и худший раунд каждой формы: разрыв 1,28 нс при разбросе до 2,24 нс у самого o.m(). То есть «заранее связанный медленнее» не установлено; установлено, что не быстрее.

Кратности звёздочек сняты на пустой функции. forms.py, блок 3, повторяет те же формы на функции с телом из пятидесяти витков арифметики: вместо ×5,17 выходит ×1,06. Переносится не коэффициент, а то, какая форма передачи дороже остальных.

Числа forms.py и cost.py между собой не сравниваются: это разные прогоны. Сравнивать внутри одного прогона — единственный способ что-то утверждать о времени, и именно поэтому разброс печатается там же, где разрыв.

Первые два объясняются байт-кодом, и shapes.py его печатает: на пути o.m(t) стоит пара LOAD_ATTR_METHOD_WITH_VALUES + CALL_PY_EXACT_ARGS, и объект связанного метода не создаётся вовсе. На пути bound(t) он уже создан и лежит в переменной, и вызывается через него — CALL_BOUND_METHOD_EXACT_ARGS. То есть «сэкономить на создании объекта» нечего: на быстром пути его и не создают.

Что объект действительно создаётся, когда его просят, проверяется отдельно и без всякого байт-кода:

o.m is o.m    False
o.m == o.m    True

Про звёздочки

«Звёздочки дорогие» — из пяти форм дорога одна:

форма	к прямой передаче
`f3(*args)`	×1,16
`f3(**kwargs)`	×5,17
`fstar(1, 2, 3)` — приём в `*args`	×2,10
`fstar(a=1)` — приём в `**kwargs`	×2,29
`fstar(args, *one)`	×6,24

Дорога распаковка СЛОВАРЯ на передаче, и только она.

Чего этими замерами утверждать нельзя

Что какая-то версия быстрее другой. В runs/ лежит одна запись cost.py, и это сделано нарочно: второй файл с другой версией провоцировал бы сравнение, которое в проекте запрещено (корневой bench/README.md).

Что специализации — часть языка. Ни одного из имён CALL_PY_EXACT_ARGS, LOAD_ATTR_METHOD_WITH_VALUES, CALL_BOUND_METHOD_EXACT_ARGS, CALL_LEN нет в dis.opmap — блок 4 shapes.py проверяет это перечислением. Они видны только через dis.dis(..., adaptive=True), в Doc/library/dis.rst не описаны и меняются между выпусками: на 3.12.3 та же специализация len называется CALL_NO_KW_LEN, на 3.13.7 и 3.14.7 — CALL_LEN.

Скрипт

81 строк

"""Опора под задачи раздела «Практика» статьи про вызов функции.

ЗАЧЕМ ОТДЕЛЬНЫЙ СКРИПТ. Задача в статье спрашивает «что напечатает вот этот
код», и ответ на неё обязан быть выводом настоящей программы. Здесь лежит ровно
тот код, который видит читатель, и ровно тот вывод, из которого взяты варианты
ответа; `scripts/validate-practice.mjs` сверяет то и другое построчно.

ПОЧЕМУ КРАТНОСТЬ ПЕЧАТАЕТСЯ. Вторая задача просит оценить, во сколько раз
передача через `**kwargs` дороже позиционной. Деление на стороне редакции —
шаг, на котором вкрадывается ошибка, которую нечем поймать, поэтому кратность
печатает сам скрипт.

ЗАПУСК:

    python3.13 bench/calls/practice.py
"""

import platform
import sys
import timeit

ROUNDS = 7
REPEAT = 50
NUMBER = 20_000

SETUP = """
def f3(a, b, c): pass
args = (1, 2, 3)
kwargs = {"a": 1, "b": 2, "c": 3}
"""


def head(n: int, title: str) -> None:
    line = f"{n}. {title}"
    print(f"\n{line}\n{'-' * len(line)}")


def per_op(expr: str) -> float:
    stmt = "; ".join([expr] * REPEAT)
    sec = min(timeit.Timer(stmt, SETUP).repeat(ROUNDS, NUMBER)) / NUMBER
    return sec / REPEAT * 1e9


def main() -> None:
    print(f"Python {platform.python_version()}")
    print(f"Сборка: {sys.version.split('[')[-1].rstrip('] ')}")

    head(1, "ЗАДАЧА 1: ЧТО НАПЕЧАТАЕТ ЭТОТ КОД")

    def make():
        out = []
        for i in range(3):
            out.append(lambda: i)
        return out

    def make_bound():
        out = []
        for i in range(3):
            out.append(lambda i=i: i)
        return out

    class C:
        def m(self):
            return 1

    o = C()

    print([f() for f in make()])
    print([f() for f in make_bound()])
    print(o.m is o.m, o.m == o.m)

    head(2, "ЗАДАЧА 2: ВО СКОЛЬКО РАЗ f3(**kwargs) ДОРОЖЕ f3(1, 2, 3)")
    plain = per_op("f3(1, 2, 3)")
    starred = per_op("f3(**kwargs)")
    print(f"  f3(1, 2, 3)                  {plain:>8.2f} нс")
    print(f"  f3(**kwargs)                 {starred:>8.2f} нс")
    print(f"  кратность                    {starred / plain:.1f}")


main()