"""Включение против цикла и против map — и что на самом деле решает.

ЧТО ИЗМЕРЯЕТСЯ. Спор «включение или цикл или map» ведут так, будто выбор между
ними что-то стоит. Здесь он измерен — и оказывается, что разброс между всеми
тремя укладывается в четверть, а главный множитель лежит совсем в другом месте:
происходит ли на каждый элемент вызов кода на Python.

Поэтому строк здесь два набора:

  1. ТРИ СПОСОБА ОДНОГО И ТОГО ЖЕ, все с вызовом `f(x)` на элемент.
  2. ТЕ ЖЕ ОБЪЁМЫ БЕЗ ВЫЗОВА — выражение вместо функции и `filter(None, …)`
     вместо условия на Python.

Отдельная строка — приём «вынести метод в локальную переменную». Он остался в
советах с тех времён, когда поиск атрибута был дороже; измерение показывает
обратный знак, а дизассемблер объясняет почему (`bytecode.py`).

ВСЁ МЕРЯЕТСЯ ВНУТРИ ФУНКЦИЙ, а не на модульном уровне. Иначе `out` и `append`
оказались бы глобальными именами, и сравнение «в локальной или нет» потеряло бы
смысл ровно в том месте, ради которого делается.

ОБЩЕЕ ПРАВИЛО ЗАМЕРОВ: время между версиями не сравнивается вообще.
Сравнивается только измеренное внутри одного запуска одного интерпретатора —
все кратности ниже такие.
"""
import sys
import timeit

N = 2_000
REPEAT = 7
SIZE = 1_000

SETUP = f"""
src = list(range({SIZE}))

def f(x):
    return x + 1

def by_comprehension(src, f):
    return [f(x) for x in src]

def by_loop(src, f):
    out = []
    for x in src:
        out.append(f(x))
    return out

def by_loop_hoisted(src, f):
    out = []
    append = out.append
    for x in src:
        append(f(x))
    return out

def by_map(src, f):
    return list(map(f, src))

def by_expression(src):
    return [x + 1 for x in src]

def by_comprehension_filter(src):
    return [x for x in src if x]

def by_filter_none(src):
    return list(filter(None, src))
"""

WITH_CALL = [
    ("включение [f(x) for x in src]", "by_comprehension(src, f)"),
    ("цикл с out.append(...)", "by_loop(src, f)"),
    ("цикл, append в локальной", "by_loop_hoisted(src, f)"),
    ("list(map(f, src))", "by_map(src, f)"),
]
WITHOUT_CALL = [
    ("включение [x + 1 for x in src]", "by_expression(src)"),
    ("включение с условием if x", "by_comprehension_filter(src)"),
    ("list(filter(None, src))", "by_filter_none(src)"),
]


def best(stmt):
    return min(timeit.repeat(stmt, setup=SETUP, number=N, repeat=REPEAT)) / N


# ЗАЧЕМ ВЕСЬ ЗАМЕР ПОВТОРЯЕТСЯ ЦЕЛИКОМ.
#
# Несущее утверждение урока — не «включение быстрее цикла», а «разброс между
# тремя способами меньше, чем шатание самого прибора, поэтому выбирать надо по
# читаемости». Проверить это одиночным прогоном нельзя: он печатает три числа
# и молчит о том, повторимы ли они и в том ли порядке. Поэтому весь замер
# прогоняется OUTER раз, и внизу печатается, укладывается ли разброс между
# тремя способами в собственное шатание каждого из них.
OUTER = 5

print("PY", sys.version.split()[0], f"| лучшее из {REPEAT} прогонов, список из {SIZE}")

ALL_ROWS = WITH_CALL + WITHOUT_CALL
series = {label: [] for label, _ in ALL_ROWS}
for _ in range(OUTER):
    for label, stmt in ALL_ROWS:
        series[label].append(best(stmt))
results = {label: min(vals) for label, vals in series.items()}

print()
print("  С вызовом функции на каждый элемент:")
for label, _ in WITH_CALL:
    print(f"    {label:<32} {results[label] * 1e6:8.1f} мкс")

print()
print("  Без вызова кода на Python:")
for label, _ in WITHOUT_CALL:
    print(f"    {label:<32} {results[label] * 1e6:8.1f} мкс")

base = results["включение [f(x) for x in src]"]
print()
print("  Относительно включения с вызовом:")
for label in results:
    print(f"    {label:<32} x{results[label] / base:5.2f}")

# Три способа — включение, цикл и map. Строка «append в локальной» из этого
# счёта исключена намеренно: это не четвёртый способ написать то же самое, а
# приём оптимизации, и меряется он отдельно.
THREE = [
    "включение [f(x) for x in src]",
    "цикл с out.append(...)",
    "list(map(f, src))",
]
spread = max(results[k] for k in THREE) / min(results[k] for k in THREE)
hoist = results["цикл, append в локальной"] / results["цикл с out.append(...)"]
print()
print(f"  РАЗМАХ ПО {OUTER} ПОВТОРАМ ВСЕГО ЗАМЕРА, в кратностях к включению:")
ratios = {label: sorted(v / base for v in vals) for label, vals in series.items()}
for label in THREE:
    lo, hi = ratios[label][0], ratios[label][-1]
    print(f"    {label:<32} x{lo:.2f} .. x{hi:.2f}   размах {hi - lo:.2f}")
worst_spread = max(ratios[k][-1] - ratios[k][0] for k in THREE)
gap = max(ratios[k][0] for k in THREE) - min(ratios[k][0] for k in THREE)
print(f"    расстояние между крайними способами   {gap:.2f}")
print(f"    наибольший размах одного способа      {worst_spread:.2f}")
print(f"    различим ли выбор способа прибором    {'да' if gap > worst_spread else 'нет'}")

print()
print(f"  Разброс между тремя способами с вызовом: {spread:.2f} раза.")
print(f"  «append в локальной» против обычного цикла: x{hoist:.2f} — приём стоит дороже.")
print(f"  Убрать вызов: {base / results['включение [x + 1 for x in src]']:.2f} раза.")
print(f"  Убрать код на Python совсем: {results['включение с условием if x'] / results['list(filter(None, src))']:.2f} раза.")