"""Строки: неизменяемость, срезы, методы, форматирование, str и bytes.

Времени здесь нет — только наблюдения. Цена склейки и форматирования — в
cost.py.

ШЕСТЬ СЮЖЕТОВ:

1. НЕИЗМЕНЯЕМОСТЬ. Символ строки не заменить; методы возвращают новую
   строку; `s += x` связывает s с новой строкой, а старая, на которую
   ссылается другое имя, не меняется.

2. СРЕЗЫ. Отрицательные индексы, шаг, разворот. Срез за пределами строки
   даёт пустую строку, а индекс за пределами — IndexError.

3. МЕТОДЫ, О КОТОРЫХ СПРАШИВАЮТ. split с разделителем и без, join, strip,
   find против index, replace со счётчиком.

4. ФОРМАТИРОВАНИЕ. Спецификации формата в f-строке, отладочное `=`,
   `!r`, str.format и %. И округление при `.0f` — к чётному.

5. STR И BYTES. Длина строки — в символах, длина байтов — в байтах.

6. ВЕРСИИ. Кавычки того же вида внутри f-строки (можно с 3.12) и t-строки
   (появились в 3.14) — проверяются компиляцией, чтобы скрипт работал на
   всех версиях.

Запускать: python3.11 / 3.12 / 3.13 / 3.14.
"""
import sys

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


def err(fn):
    try:
        return repr(fn())
    except Exception as e:  # noqa: BLE001 — нам нужен текст
        return f"{type(e).__name__}: {e}"


# ── 1 ─────────────────────────────────────────────────────────────────────
print("1) неизменяемость")
s = "привет"


def assign_char():
    s[0] = "П"


print("   s[0] = 'П'          ->", err(assign_char))
upper = s.upper()
print("   s.upper()           ->", repr(upper), "| s ->", repr(s))
t = s
s += "!"
print("   t = s; s += '!'     -> s =", repr(s), "| t =", repr(t), "| s is t:", s is t)
print()

# ── 2 ─────────────────────────────────────────────────────────────────────
print("2) срезы")
p = "Python"
for expr in ["p[0]", "p[-1]", "p[1:4]", "p[:2]", "p[-3:]", "p[::2]", "p[::-1]", "p[10:20]", "p[10]"]:
    print(f"   {expr:<10}->", err(lambda expr=expr: eval(expr)))
print()

# ── 3 ─────────────────────────────────────────────────────────────────────
print("3) методы")
cases = [
    ("'a,b,,c'.split(',')", lambda: "a,b,,c".split(",")),
    ("'  a  b '.split()", lambda: "  a  b ".split()),
    ("'-'.join(['a', 'b', 'c'])", lambda: "-".join(["a", "b", "c"])),
    ("'-'.join([1, 2])", lambda: "-".join([1, 2])),
    ("'  hi  '.strip()", lambda: "  hi  ".strip()),
    ("'abc'.find('z')", lambda: "abc".find("z")),
    ("'abc'.index('z')", lambda: "abc".index("z")),
    ("'hello'.replace('l', 'L', 1)", lambda: "hello".replace("l", "L", 1)),
    ("'hello world'.title()", lambda: "hello world".title()),
    ("'42'.isdigit(), '-42'.isdigit()", lambda: ("42".isdigit(), "-42".isdigit())),
]
for label, fn in cases:
    print(f"   {label:<34}->", err(fn))
print()

# ── 4 ─────────────────────────────────────────────────────────────────────
print("4) форматирование")
x = 3.14159
n = 1234567
name = "Аня"
print("   f'{x:.2f}'          ->", repr(f"{x:.2f}"))
print("   f'{n:,}'            ->", repr(f"{n:,}"))
print("   f'{n:_}'            ->", repr(f"{n:_}"))
print("   f'{name:>6}|'       ->", repr(f"{name:>6}|"))
print("   f'{name:*^9}'       ->", repr(f"{name:*^9}"))
print("   f'{name!r}'         ->", repr(f"{name!r}"))
print("   f'{x=}'             ->", repr(f"{x=}"))
print("   f'{x=:.2f}'         ->", repr(f"{x=:.2f}"))
print("   f'{0.25:.0%}'       ->", repr(f"{0.25:.0%}"))
print("   '{} и {}'.format(1, 2) ->", repr("{} и {}".format(1, 2)))
print("   '%s: %d' % ('n', 5) ->", repr("%s: %d" % ("n", 5)))
print("   f'{0.5:.0f} {1.5:.0f} {2.5:.0f}' ->", repr(f"{0.5:.0f} {1.5:.0f} {2.5:.0f}"))
print("   round(2.5), round(3.5) ->", round(2.5), round(3.5))
from decimal import ROUND_HALF_UP, Decimal  # noqa: E402

print("   Decimal('2.5').quantize(Decimal('1'), rounding=ROUND_HALF_UP) ->",
      Decimal("2.5").quantize(Decimal("1"), rounding=ROUND_HALF_UP))
print("   f'{2.675:.2f}', round(2.675, 2) ->", repr(f"{2.675:.2f}"), round(2.675, 2))
print("   Decimal(2.675) ->", Decimal(2.675))
print()

# ── 5 ─────────────────────────────────────────────────────────────────────
print("5) str и bytes")
for word in ["hello", "привет", "👍"]:
    b = word.encode("utf-8")
    print(f"   {word!r:<10} len = {len(word)}, в UTF-8 байт = {len(b)}")
b = "привет".encode()
print("   'привет'.encode()[0]  ->", b[0], "— байт, это int, а не символ")
print("   b.decode()            ->", repr(b.decode()))
print("   'привет'.encode('ascii') ->", err(lambda: "привет".encode("ascii")))
print("   'a' + b'b'            ->", err(lambda: "a" + b"b"))
print()

# ── 6 ─────────────────────────────────────────────────────────────────────
print("6) версии: что компилируется")
d = {"k": 1}


def compiles(src):
    try:
        code = compile(src, "<src>", "eval")
    except SyntaxError as e:
        return f"SyntaxError: {e.msg}"
    value = eval(code)
    if type(value).__name__ == "Template":
        return f"Template, значение выражения уже вычислено: {value.interpolations[0].value}"
    return repr(value)


print("   f\"{d[\"k\"]}\"   ->", compiles('f"{d["k"]}"'))
print("   f\"{d['k']}\"   ->", compiles("f\"{d['k']}\""))
print("   t\"x={1 + 1}\" ->", compiles('t"x={1 + 1}"'))
print()

# ── 7 ─────────────────────────────────────────────────────────────────────
# Добавлен по внешнему аудиту урока (14.10.2026). Разделы 1–6 выше не менялись.
#
# ТРИ УТОЧНЕНИЯ. Срез за границей не обязательно пуст: границы урезаются до
# длины строки. len считает кодовые точки Unicode, а не видимые символы:
# 'é', записанная буквой e и комбинирующим знаком U+0301, — две точки; и
# разворот [::-1] переставляет точки, отрывая знак от буквы. А «метод
# возвращает новую строку» — неточно: неизменяемость обещает только, что
# исходная не изменится; CPython может вернуть тот же объект, если результат
# с ним совпал. Входы с не-ASCII символами записаны escape-последовательностями
# и печатаются через ascii(), чтобы строка вывода читалась одинаково везде.
print("7) границы среза, кодовые точки, тот же объект")
import unicodedata  # noqa: E402

p = "Python"
for expr in ["p[:100]", "p[4:100]", "p[-100:2]"]:
    print(f"   {expr:<10}->", err(lambda expr=expr: eval(expr)))
FAMILY = "\U0001F468\u200d\U0001F469\u200d\U0001F467\u200d\U0001F466"
print("   FAMILY =", ascii(FAMILY))
uni = [
    ("len('\\u00e9')", lambda: len("\u00e9")),
    ("len('e\\u0301')", lambda: len("e\u0301")),
    ("len(unicodedata.normalize('NFC', 'e\\u0301'))", lambda: len(unicodedata.normalize("NFC", "e\u0301"))),
    ("len('\\U0001F44D\\U0001F3FD')", lambda: len("\U0001F44D\U0001F3FD")),
    ("len(FAMILY)", lambda: len(FAMILY)),
    ("ascii('cafe\\u0301'[::-1])", lambda: ascii("cafe\u0301"[::-1])),
]
for label, fn in uni:
    print(f"   {label:<46}->", fn())
same = [
    ("p.strip() is p", lambda: p.strip() is p),
    ("p.replace('z', 'y') is p", lambda: p.replace("z", "y") is p),
    ("p[:100] is p", lambda: p[:100] is p),
    ("p.upper() is p.upper()", lambda: p.upper() is p.upper()),
]
for label, fn in same:
    print(f"   {label:<46}->", fn())