"""Во сколько обходится выбор между списком и кортежем — по операциям.

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

  1. СОЗДАНИЕ ИЗ ЛИТЕРАЛА. Здесь разница наибольшая, и она не про типы:
     константный кортеж во время исполнения не строится вовсе (`bytecode.py`).
  2. СОЗДАНИЕ ИЗ ПЕРЕМЕННЫХ. Как только внутри есть неконстантное выражение,
     оба собираются инструкцией — и разница схлопывается.
  3. ЧТЕНИЕ ПО ИНДЕКСУ. То, ради чего контейнер обычно и заводят.
  4. ОБХОД ЦЕЛИКОМ.

Плюс отдельная строка про распаковку — она в спорах не участвует, а в реальном
коде встречается чаще индексирования.

ПРАВИЛО (bench/README.md): время между версиями не сравнивается вообще.
Сравнивается только измеренное внутри одного запуска одного интерпретатора —
все кратности ниже такие. Числа 3.13.7 и 3.14.0rc2 приводятся рядом как два
независимых результата.
"""
import json
import subprocess
import sys
import timeit

N = 2_000_000
REPEAT = 7

SETUP = """
L = [1, 2, 3]
T = (1, 2, 3)
a = 1
BIG_L = list(range(1000))
BIG_T = tuple(range(1000))
"""

ROWS = [
    ("создать литерал: [1, 2, 3]", "[1, 2, 3]", N),
    ("создать литерал: (1, 2, 3)", "(1, 2, 3)", N),
    ("создать из переменной: [a, 2, 3]", "[a, 2, 3]", N),
    ("создать из переменной: (a, 2, 3)", "(a, 2, 3)", N),
    ("прочитать L[1]", "L[1]", N),
    ("прочитать T[1]", "T[1]", N),
    ("распаковать x, y, z = L", "x, y, z = L", N),
    ("распаковать x, y, z = T", "x, y, z = T", N),
    ("обойти список из 1000", "for _ in BIG_L: pass", N // 500),
    ("обойти кортеж из 1000", "for _ in BIG_T: pass", N // 500),
]


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


# ЗАЧЕМ ПОВТОРЫ РАЗНЕСЕНЫ ПО ОТДЕЛЬНЫМ ПРОЦЕССАМ.
#
# Урок держится не на наносекундах, а на кратностях, и про каждую обязан
# сказать, различима ли она прибором. Повторять замер внутри одного процесса
# для этого мало, и это здесь измерено: строка «создать из переменной» у
# одного процесса выходит 1.29, у другого — 1.79, и внутри каждого процесса
# все пять повторов держатся своего значения. То есть разброс живёт МЕЖДУ
# запусками, а не внутри них: он задаётся тем, в каком состоянии процесс
# стартовал (раскладка кучи, специализация, частота ядра). Замер, повторённый
# внутри процесса, этого не видит вовсе и печатает ложно узкий размах.
#
# Поэтому OUTER проходов запускаются отдельными процессами: родитель зовёт
# сам себя с --pass, ребёнок печатает одну строку JSON, родитель собирает.
OUTER = 5


def one_pass():
    return {label: best(stmt, number) for label, stmt, number in ROWS}


if "--pass" in sys.argv:
    print(json.dumps(one_pass()))
    raise SystemExit

series = {label: [] for label, _, _ in ROWS}
for _ in range(OUTER):
    out = subprocess.run(
        [sys.executable, __file__, "--pass"], capture_output=True, text=True, check=True
    ).stdout
    for label, sec in json.loads(out).items():
        series[label].append(sec)
results = {label: min(vals) for label, vals in series.items()}

print("PY", sys.version.split()[0], f"| лучшее из {REPEAT} прогонов в каждом из {OUTER} процессов")
for label, _, _ in ROWS:
    sec = results[label]
    unit, value = ("нс", sec * 1e9) if sec < 1e-6 else ("мкс", sec * 1e6)
    print(f"    {label:<36} {value:9.1f} {unit}")

print()
print("  Пары, ради которых всё это считается (кортеж против списка):")
PAIRS = [
    ("создать литерал", "создать литерал: [1, 2, 3]", "создать литерал: (1, 2, 3)"),
    ("создать из переменной", "создать из переменной: [a, 2, 3]", "создать из переменной: (a, 2, 3)"),
    ("прочитать по индексу", "прочитать L[1]", "прочитать T[1]"),
    ("распаковать", "распаковать x, y, z = L", "распаковать x, y, z = T"),
    ("обойти 1000 элементов", "обойти список из 1000", "обойти кортеж из 1000"),
]
for name, lst, tpl in PAIRS:
    ratio = results[lst] / results[tpl]
    print(f"    {name:<24} кортеж быстрее в {ratio:5.2f} раза")

print()
print(f"  Различима ли каждая кратность прибором (размах по {OUTER} процессам):")
for name, lst, tpl in PAIRS:
    rs = sorted(a / b for a, b in zip(series[lst], series[tpl]))
    lo, hi = rs[0], rs[-1]
    # Кратность «различима», если весь её размах лежит по одну сторону от
    # единицы: тогда знак разницы не меняется от повтора к повтору.
    verdict = "да " if lo > 1.0 or hi < 1.0 else "нет"
    print(f"    {name:<24} {lo:5.2f} .. {hi:5.2f}   размах {hi - lo:4.2f}   различима {verdict}")