"""Встроенные коллекции: что list, tuple, dict и set гарантируют и чего не гарантируют.

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

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

1. ДУБЛИ. Список хранит всё, множество — только разные элементы, у словаря
   ключи уникальны и при повторе побеждает последнее значение.

2. ХЕШИРУЕМОСТЬ. Ключом словаря и элементом множества может быть только
   хешируемый объект. Список — нет; кортеж — да, но только если хешируемо
   всё, что в нём лежит; frozenset — да. К ЗНАЧЕНИЯМ словаря требование не
   относится: {"items": []} работает — это показывает hashable.py.

3. ПОРЯДОК. Словарь хранит порядок вставки — это гарантия языка. Множество
   порядка не обещает: множество строк печатается в разном порядке при
   разных PYTHONHASHSEED. Скрипт запускает сам себя трижды с разными
   значениями переменной и сравнивает.

4. ПАМЯТЬ. Размер самого контейнера на 1000 целых — sys.getsizeof, без
   элементов: элементы общие и в счёт не идут.

5. ЧТО УМЕЕТ КАЖДЫЙ. Индекс, изменение на месте, ключ словаря — сводная
   проверка по четырём типам, которой и отвечают на «что когда брать».

6. ПАМЯТЬ И ВИД КЛЮЧЕЙ. dict на 1000 ключей-строк меньше, чем на 1000
   целых: в CPython записи словаря со строковыми ключами хранятся без поля
   под хеш. У множества размер от вида элементов не зависит.

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

if os.environ.get("ORDER_CHILD") == "1":
    print(list({"яблоко", "груша", "слива", "вишня", "дыня"}))
    sys.exit(0)

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


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


# ── 1 ─────────────────────────────────────────────────────────────────────
print("1) дубли")
data = [3, 1, 3, 2, 1]
print("   list(data)          ->", list(data))
print("   set(data)           ->", set(data))
print("   dict.fromkeys(data) ->", dict.fromkeys(data))
print("   {'a': 1, 'a': 2}    ->", {"a": 1, "a": 2})
print("   len(set(data)) == len(data) ->", len(set(data)) == len(data))
print()

# ── 2 ─────────────────────────────────────────────────────────────────────
print("2) хешируемость: что можно класть в set и в ключи dict")
print("   {[1, 2]}            ->", err(lambda: {[1, 2]}))
print("   {[1, 2]: 'x'}       ->", err(lambda: {[1, 2]: "x"}))
print("   {(1, 2)}            ->", err(lambda: {(1, 2)}))
print("   {(1, [2])}          ->", err(lambda: {(1, [2])}))
print("   {frozenset({1, 2})} ->", err(lambda: {frozenset({1, 2})}))
print("   {{1, 2}}            ->", err(lambda: {{1, 2}}))
print()

# ── 3 ─────────────────────────────────────────────────────────────────────
print("3) порядок")
d = {}
for key in ["дыня", "яблоко", "груша"]:
    d[key] = len(key)
print("   dict в порядке вставки:", list(d))
d.pop("яблоко")
d["яблоко"] = 6
print("   удалили и вставили снова — ключ в конце:", list(d))
print("   множество строк при разных PYTHONHASHSEED:")
orders = set()
for seed in ["1", "2", "3"]:
    env = dict(os.environ, ORDER_CHILD="1", PYTHONHASHSEED=seed)
    out = subprocess.run(
        [sys.executable, __file__], env=env, capture_output=True, text=True, check=True
    ).stdout.strip()
    orders.add(out)
    print(f"   PYTHONHASHSEED={seed}: {out}")
print("   разных порядков из трёх запусков:", len(orders))
print("   множество целых {5, 1, 3}:", {5, 1, 3}, "— порядок от хеша, а не от вставки")
print("   hash(1), hash(3), hash(5):", hash(1), hash(3), hash(5), "— хеш небольшого целого равен ему самому")
print("   множество целых {8, 1}:", {8, 1}, "— и не всегда по возрастанию")
print()

# ── 4 ─────────────────────────────────────────────────────────────────────
print("4) память: сам контейнер на 1000 целых, байт (sys.getsizeof)")
items = list(range(1000))
sizes = {
    "list": sys.getsizeof(list(items)),
    "tuple": sys.getsizeof(tuple(items)),
    "set": sys.getsizeof(set(items)),
    "dict": sys.getsizeof(dict.fromkeys(items)),
}
for name, size in sizes.items():
    print(f"   {name:<6}{size:>7}")
print(f"   set / list: {sizes['set'] / sizes['list']:.1f}")
print()

# ── 5 ─────────────────────────────────────────────────────────────────────
print("5) что умеет каждый")
samples = {"list": [1, 2], "tuple": (1, 2), "set": {1, 2}, "dict": {1: "a", 2: "b"}}


def can_index(x):
    try:
        x[0]
        return "да"
    except (TypeError, KeyError):
        return "нет"


def can_change(x):
    return "да" if hasattr(x, "append") or hasattr(x, "add") or hasattr(x, "__setitem__") else "нет"


def can_be_key(x):
    try:
        hash(x)
        return "да"
    except TypeError:
        return "нет"


print(f"   {'тип':<6}{'x[0]':>6}{'менять':>8}{'ключ':>6}")
for name, x in samples.items():
    idx = can_index(x) if name != "dict" else "по ключу"
    print(f"   {name:<6}{idx:>6}{can_change(x):>8}{can_be_key(x):>6}")
print()

# ── 6 ─────────────────────────────────────────────────────────────────────
# Добавлено 14.10.2026 по внешнему аудиту (PY-COL-02). Раздел 4 сравнивает
# контейнеры на целых. У словаря размер зависит и от вида ключей: записи
# словаря с ключами-строками (str) в CPython 3.11–3.14 хранятся без поля
# под хеш (Include/internal/pycore_dict.h: PyDictUnicodeEntry против
# PyDictKeyEntry), у множества запись одна и та же.
print("6) память и вид ключей: 1000 ключей, байт (sys.getsizeof)")
ints = list(range(1000))
strs = [str(i) for i in ints]
print(f"   dict, ключи int   {sys.getsizeof(dict.fromkeys(ints)):>7}")
print(f"   dict, ключи str   {sys.getsizeof(dict.fromkeys(strs)):>7}")
print(f"   set, int          {sys.getsizeof(set(ints)):>7}")
print(f"   set, str          {sys.getsizeof(set(strs)):>7}")