"""Быстрый путь `s += x` в CPython: когда он срабатывает и когда нет.

ЗАЧЕМ. cost.py показывает два случая: `s += x` в локальной переменной
линеен, а с одной лишней ссылкой на строку — квадратичен. Отсюда легко
вывести правило «условий два: локальная переменная и нет второй ссылки».
Внешний аудит урока (14.10.2026) указал, что этого мало: в исходнике
CPython проверяется больше. Здесь это проверено прогоном, а не чтением.

ЧТО МЕРЯЕТСЯ:

  1. склейка n кусков по десять символов, нс на кусок, n = 2 000 и 20 000,
     в трёх формах одного и того же цикла: `s += x` на своей строке;
     `s += x; k += 1` на одной строке; те же два оператора на двух строках.
     Если нс на кусок при ×10 кусков растёт примерно в десять раз —
     склейка квадратична.

  2. один шаг `s += x` на строке в миллион символов, мкс. Если шаг стоит
     доли микросекунды — строку дописали на месте; если сотни
     микросекунд — скопировали миллион символов. Случаи: ничего лишнего;
     вторая ссылка; перед шагом посчитан hash(s); строка прошла через
     sys.intern; строка — экземпляр подкласса str; ASCII-строка и кусок
     с не-ASCII символом; строка с 'é' и ASCII-кусок. Всё, что готовит
     случай, делается до замера, а замеряется только сам `s += x` — на
     своей строке.

  3. какой опкод выбрал интерпретатор для `+=` после прогрева и какая
     инструкция стоит за ним (dis с adaptive=True).

КАК. В разделе 1 формы меряются вперемежку, ROUNDS кругов; печатаются
медианы. В разделе 2 — медиана STEPS шагов после WARMUP прогревочных.

Запускать: python3.11 / 3.12 / 3.13 / 3.14. Числа — этой машины;
переносится картина «на месте / копия», а не микросекунды.
"""
import dis
import statistics
import sys
import time

print("PY", sys.version.split()[0])
print()

ROUNDS = 7
PIECE = "abcdefghij"
pc = time.perf_counter


# ── 1 ─────────────────────────────────────────────────────────────────────
def own_line(n):
    s = ""
    for _ in range(n):
        s += PIECE
    return len(s)


def one_line(n):
    s = ""
    k = 0
    for _ in range(n):
        s += PIECE; k += 1  # noqa: E702 — форма кода и есть предмет замера
    return len(s) + k


def two_lines(n):
    s = ""
    k = 0
    for _ in range(n):
        s += PIECE
        k += 1
    return len(s) + k


def timed(fn, n):
    t0 = pc()
    fn(n)
    return pc() - t0


print("1) склейка n кусков по десять символов, нс на кусок, медианы", ROUNDS, "кругов")
SIZES = (2_000, 20_000)
FORMS = [
    ("s += x", own_line),
    ("s += x; k += 1  (одна строка)", one_line),
    ("s += x и k += 1 (две строки)", two_lines),
]
samples = {(name, n): [] for name, _ in FORMS for n in SIZES}
for _ in range(ROUNDS):
    for n in SIZES:
        for name, fn in FORMS:
            samples[(name, n)].append(timed(fn, n) / n * 1e9)
print(f"   {'форма':<32}" + "".join(f"{n:>10}" for n in SIZES) + f"{'×10':>8}")
for name, _ in FORMS:
    med = [statistics.median(samples[(name, n)]) for n in SIZES]
    print(f"   {name:<32}" + "".join(f"{m:>10.1f}" for m in med) + f"{med[1] / med[0]:>8.1f}")
print()

# ── 2 ─────────────────────────────────────────────────────────────────────
N = 1_000_000
WARMUP, STEPS = 5, 25
LATIN = "abcdefghié"   # кусок с 'é' — символ вне ASCII


class Sub(str):
    pass


def step_plain():
    s = "a" * N
    out = []
    for _ in range(WARMUP + STEPS):
        t0 = pc()
        s += PIECE
        t1 = pc()
        out.append(t1 - t0)
    return out


def step_alias():
    s = "a" * N
    out = []
    for _ in range(WARMUP + STEPS):
        keep = s  # noqa: F841 — вторая ссылка на ту же строку
        t0 = pc()
        s += PIECE
        t1 = pc()
        out.append(t1 - t0)
    return out


def step_hashed():
    s = "a" * N
    out = []
    for _ in range(WARMUP + STEPS):
        hash(s)
        t0 = pc()
        s += PIECE
        t1 = pc()
        out.append(t1 - t0)
    return out


def step_interned():
    s = "a" * N
    out = []
    for _ in range(WARMUP + STEPS):
        s = sys.intern(s)
        t0 = pc()
        s += PIECE
        t1 = pc()
        out.append(t1 - t0)
    return out


def step_subclass():
    s = "a" * N
    out = []
    for _ in range(WARMUP + STEPS):
        s = Sub(s)
        t0 = pc()
        s += PIECE
        t1 = pc()
        out.append(t1 - t0)
    return out


def step_ascii_plus(piece):
    def run():
        s = "a" * N
        out = []
        for _ in range(WARMUP + STEPS):
            s = s[:N - 1] + "a"  # новая ASCII-строка, одна ссылка, хеша нет
            t0 = pc()
            s += piece
            t1 = pc()
            out.append(t1 - t0)
        return out
    return run


def step_latin_plus_ascii():
    s = "é" * N
    out = []
    for _ in range(WARMUP + STEPS):
        t0 = pc()
        s += PIECE
        t1 = pc()
        out.append(t1 - t0)
    return out


print(f"2) один шаг s += x на строке в {N:_} символов, мкс, медиана {STEPS} шагов".replace("_", " "))
CASES = [
    ("ничего лишнего", step_plain),
    ("есть вторая ссылка", step_alias),
    ("перед шагом посчитан hash(s)", step_hashed),
    ("s = sys.intern(s) перед шагом", step_interned),
    ("s — экземпляр подкласса str", step_subclass),
    ("ASCII-строка += ASCII-кусок", step_ascii_plus(PIECE)),
    ("ASCII-строка += кусок с 'é'", step_ascii_plus(LATIN)),
    ("строка из 'é' += ASCII-кусок", step_latin_plus_ascii),
]
for label, fn in CASES:
    med = statistics.median(fn()[WARMUP:]) * 1e6
    print(f"   {label:<32}{med:>10.1f}")
print()

# ── 3 ─────────────────────────────────────────────────────────────────────
print("3) опкод += после прогрева и следующая за ним инструкция")
for fn in (own_line, one_line, two_lines):
    ins = list(dis.get_instructions(fn, adaptive=True))
    at = next(k for k, i in enumerate(ins) if i.argrepr == "+=")  # первый += — это s += x
    print(f"   {fn.__name__:<10} {ins[at].opname:<32} -> {ins[at + 1].opname}")