{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Равенство: __eq__\n",
    "\n",
    "__eq__ задаёт, когда два объекта равны по смыслу. == против is, NotImplemented для чужого типа, __hash__ — и почему объект пропал из set.\n",
    "\n",
    "Курс ООП в Python · урок `oop-eq` · [урок на сайте](https://ds-edu-trainer.vercel.app/courses/oop/eq).\n",
    "\n",
    "Выполняйте ячейки по порядку (Shift+Enter), начиная с первой — она готовит урок. После каждого упражнения идёт\n",
    "ячейка проверки: она печатает ✓ / ✗ и итог."
   ],
   "id": "intro"
  },
  {
   "cell_type": "code",
   "metadata": {
    "cellView": "form",
    "jupyter": {
     "source_hidden": true
    }
   },
   "source": [
    "# @title Подготовка урока — выполните эту ячейку первой\n",
    "# Проверяет версии пакетов, записывает файлы данных в папку data/ и определяет _check — проверку упражнений.\n",
    "import base64, os, zlib\n",
    "\n",
    "import sys\n",
    "\n",
    "if sys.version_info < (3, 10):\n",
    "    print(f\"Урок написан для Python 3.10 и новее, у вас {sys.version.split()[0]} — часть кода может не работать\")\n",
    "\n",
    "# ─── Проверка упражнений: тот же раннер, что у задач на сайте ───\n",
    "# ─── Запуск тестов ───────────────────────────────────────────────────────────\n",
    "\n",
    "_TIMEOUT = 2.0  # секунд на тест; отдельный тест может задать свой: test_x.timeout = 10\n",
    "\n",
    "\n",
    "def _call_with_timeout(target, seconds: float) -> bool:\n",
    "    \"\"\"Запускает target() в отдельном потоке. Возвращает False, если за seconds он не завершился.\"\"\"\n",
    "    import sys\n",
    "    import threading\n",
    "\n",
    "    if sys.platform == \"emscripten\":  # Python в браузере: потоков нет, таймаут обеспечивает страница\n",
    "        target()\n",
    "        return True\n",
    "    # Большой стек нужен, чтобы глубокая рекурсия давала RecursionError, а не аварийное завершение Python.\n",
    "    for megabytes in (256, 64, 0):\n",
    "        try:\n",
    "            threading.stack_size(megabytes * 1024 * 1024)\n",
    "            worker = threading.Thread(target=target, daemon=True)\n",
    "            worker.start()\n",
    "        except (ValueError, RuntimeError, MemoryError):\n",
    "            continue\n",
    "        worker.join(seconds)\n",
    "        return not worker.is_alive()\n",
    "    target()  # потоки недоступны — запускаем без таймаута\n",
    "    return True\n",
    "\n",
    "\n",
    "def _test_info(fn) -> dict:\n",
    "    \"\"\"Описание теста, его лимит времени и сообщение на случай зависания.\"\"\"\n",
    "    limit = getattr(fn, \"timeout\", _TIMEOUT)\n",
    "    hint = getattr(fn, \"timeout_hint\", \"\")\n",
    "    message = (\n",
    "        f\"тест не завершился за {limit:g} с — возможно, бесконечный цикл или рекурсия: \"\n",
    "        \"проверьте, что границы/аргументы изменяются на каждом шаге\" + (f\". {hint}\" if hint else \"\")\n",
    "    )\n",
    "    return {\"title\": (fn.__doc__ or fn.__name__).strip(), \"timeout\": limit, \"timeout_message\": message}\n",
    "\n",
    "\n",
    "def _error_result(title: str, error: BaseException, user_file: str | None) -> dict:\n",
    "    \"\"\"Результат упавшего теста: статус, сообщение, тип исключения и строка в коде решения.\"\"\"\n",
    "    line = None\n",
    "    if user_file:  # самый глубокий кадр в коде решения; ошибка внутри самих тестов — без номера строки\n",
    "        tb = error.__traceback__\n",
    "        while tb is not None:\n",
    "            if tb.tb_frame.f_code.co_filename == user_file:\n",
    "                line = tb.tb_lineno\n",
    "            tb = tb.tb_next\n",
    "    status, message = \"error\", f\"{type(error).__name__}: {error}\"\n",
    "    if isinstance(error, NotImplementedError):\n",
    "        status, message, line = \"not_written\", \"функция ещё не написана\", None\n",
    "    elif isinstance(error, AssertionError):\n",
    "        status, message = \"failed\", str(error) or \"проверка не прошла\"\n",
    "    elif isinstance(error, RecursionError):\n",
    "        message = \"RecursionError: слишком глубокая рекурсия — проверьте базовый случай и то, что задача уменьшается\"\n",
    "    elif isinstance(error, MemoryError) or (isinstance(error, OverflowError) and \"index-sized\" in str(error)):\n",
    "        message = f\"{type(error).__name__}: не хватило памяти — возможно, создаётся слишком большая структура данных\"\n",
    "    return {\"title\": title, \"status\": status, \"message\": message, \"error_type\": type(error).__name__, \"line\": line}\n",
    "\n",
    "\n",
    "def _run_tests(verbose: bool = True, on_start=None, on_result=None, user_file: str | None = None) -> list[dict]:\n",
    "    \"\"\"Запускает тесты задачи (_TESTS — функции из tests.py) по порядку, каждый — с таймаутом.\n",
    "\n",
    "    Возвращает список результатов: {\"title\", \"status\", \"message\", \"error_type\", \"line\"}, где status —\n",
    "    passed · failed · error · not_written · timeout · not_run. Если тест завис, при verbose=True печатает\n",
    "    итог и завершает процесс: зависший поток остановить нельзя. on_start(i) и on_result(i, результат)\n",
    "    вызываются по мере выполнения; user_file — имя файла с кодом решения для номеров строк в ошибках.\n",
    "    \"\"\"\n",
    "    import os\n",
    "    import sys\n",
    "\n",
    "    if verbose:\n",
    "        try:  # ✓ и кириллица в консоли Windows со старой кодировкой\n",
    "            sys.stdout.reconfigure(encoding=\"utf-8\")\n",
    "        except Exception:  # noqa: BLE001 — reconfigure может не быть (перенаправленный вывод, браузер)\n",
    "            pass\n",
    "\n",
    "    tests = list(_TESTS)\n",
    "    results: list[dict] = []\n",
    "    not_written = hung = False\n",
    "    for index, fn in enumerate(tests):\n",
    "        info = _test_info(fn)\n",
    "        outcome: dict = {}\n",
    "\n",
    "        def target(fn=fn, outcome=outcome):\n",
    "            try:\n",
    "                fn()\n",
    "            except BaseException as e:\n",
    "                outcome[\"error\"] = e\n",
    "\n",
    "        if on_start:\n",
    "            on_start(index)\n",
    "        if not _call_with_timeout(target, info[\"timeout\"]):\n",
    "            results.append({\"title\": info[\"title\"], \"status\": \"timeout\", \"message\": info[\"timeout_message\"], \"error_type\": None, \"line\": None})\n",
    "            for other in tests[index + 1:]:\n",
    "                results.append({\"title\": _test_info(other)[\"title\"], \"status\": \"not_run\", \"message\": \"не запускался: предыдущий тест завис\", \"error_type\": None, \"line\": None})\n",
    "            hung = True\n",
    "            break\n",
    "        error = outcome.get(\"error\")\n",
    "        if error is None:\n",
    "            result = {\"title\": info[\"title\"], \"status\": \"passed\", \"message\": \"\", \"error_type\": None, \"line\": None}\n",
    "        else:\n",
    "            result = _error_result(info[\"title\"], error, user_file)\n",
    "            not_written = not_written or result[\"status\"] == \"not_written\"\n",
    "        results.append(result)\n",
    "        if on_result:\n",
    "            on_result(index, result)\n",
    "\n",
    "    if not_written:  # пока функция не написана, «даром» пройденные тесты не засчитываются\n",
    "        for r in results:\n",
    "            if r[\"status\"] == \"passed\":\n",
    "                r.update(status=\"not_written\", message=\"не засчитан, пока функция не написана\")\n",
    "    for r in results:\n",
    "        if len(r[\"message\"]) > 300:\n",
    "            r[\"message\"] = r[\"message\"][:300] + \"…\"\n",
    "\n",
    "    if verbose:\n",
    "        if not_written:\n",
    "            print(\"Функция ещё не написана — замените raise NotImplementedError своим кодом.\\n\")\n",
    "        for r in results:\n",
    "            mark = {\"passed\": \"✓\", \"not_run\": \"–\"}.get(r[\"status\"], \"✗\")\n",
    "            print(f\"{mark} {r['title']}\")\n",
    "            if r[\"message\"]:\n",
    "                print(f\"    {r['message']}\")\n",
    "        passed = sum(r[\"status\"] == \"passed\" for r in results)\n",
    "        print(\"─\" * 40)\n",
    "        print(f\"Прошло {passed} из {len(results)}\" + (\" — всё верно!\" if passed == len(results) else \"\"))\n",
    "        if hung:\n",
    "            print(\"Выполнение остановлено: один из тестов завис.\")\n",
    "            sys.stdout.flush()\n",
    "            os._exit(1)\n",
    "    return results\n",
    "\n",
    "\n",
    "def _check(*tests, names=()):\n",
    "    \"\"\"Запускает проверки упражнения и печатает ✓ / ✗ и итог — как на сайте.\"\"\"\n",
    "    for name in names:\n",
    "        if \".\" in name:  # «Класс.метод» из заготовки: класс должен быть объявлен\n",
    "            if not isinstance(globals().get(name.split(\".\")[0]), type):\n",
    "                print(f\"✗ класс {name.split('.')[0]} не объявлен — выполните ячейку упражнения\")\n",
    "                return\n",
    "            continue\n",
    "        if name not in globals():\n",
    "            print(f\"✗ переменная {name} не создана — выполните ячейку упражнения\")\n",
    "            return\n",
    "        if globals()[name] is Ellipsis:\n",
    "            print(f\"✗ {name} пока равна ... — замените многоточие своим кодом\")\n",
    "            return\n",
    "    globals()[\"_TESTS\"] = list(tests)\n",
    "    _run_tests()"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "setup"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В уроке о ссылках `==` у двух товаров с одинаковыми названием и ценой давал `False`: по умолчанию свой класс\n",
    "сравнивается по тождественности, как `is`. Но для кассы «латте за 220» и ещё один «латте за 220» — одно и то\n",
    "же. Научим объекты сравниваться по смыслу.\n",
    "\n",
    "## `__eq__`\n",
    "\n",
    "Оператор `a == b` вызывает метод `a.__eq__(b)`. Объявите его — и равенство будет означать то, что нужно\n",
    "вашему классу. `is` при этом не меняется: он по-прежнему отвечает, один ли это объект."
   ],
   "id": "text-9"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Товары равны по названию и цене\n",
    "class Product:\n",
    "    def __init__(self, name, price):\n",
    "        self.name = name\n",
    "        self.price = price\n",
    "\n",
    "    def __repr__(self):\n",
    "        return f\"Product({self.name!r}, {self.price})\"\n",
    "\n",
    "    def __eq__(self, other):\n",
    "        return self.name == other.name and self.price == other.price\n",
    "\n",
    "\n",
    "a = Product(\"Латте\", 220)\n",
    "b = Product(\"Латте\", 220)\n",
    "print(a == b, a is b)\n",
    "print(a != Product(\"Латте\", 250))"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "eq"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`!=` Python считает сам — как «не `==`», отдельный метод не нужен.\n",
    "\n",
    "## Чужой тип: NotImplemented\n",
    "\n",
    "Сравнивать можно с чем угодно: `latte == \"Латте\"`, `latte == 220`. Но у строки нет атрибутов `name` и\n",
    "`price`, и такой `__eq__` падает:"
   ],
   "id": "text-20"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Сравнение со строкой ломает __eq__\n",
    "# Эта ячейка показывает ошибку AttributeError: она перехвачена, чтобы «Выполнить всё» не останавливалось.\n",
    "try:\n",
    "    a == \"Латте\"\n",
    "except Exception as error:\n",
    "    print(f\"{type(error).__name__}: {error}\")"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "foreign"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Поэтому `__eq__` сначала проверяет тип другого объекта. Если тип чужой, метод возвращает специальное значение\n",
    "`NotImplemented` — «я не умею сравнивать с таким». Тогда Python спросит второй объект: `\"Латте\".__eq__(latte)`,\n",
    "и если и он не умеет — сравнит объекты по тождественности, как `is`: для двух разных объектов это `False`."
   ],
   "id": "text-29"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Сравнение с чужим типом\n",
    "class Product:\n",
    "    def __init__(self, name, price):\n",
    "        self.name = name\n",
    "        self.price = price\n",
    "\n",
    "    def __repr__(self):\n",
    "        return f\"Product({self.name!r}, {self.price})\"\n",
    "\n",
    "    def __eq__(self, other):\n",
    "        if not isinstance(other, Product):\n",
    "            return NotImplemented  # «не умею» — пусть ответит другой объект\n",
    "        return self.name == other.name and self.price == other.price\n",
    "\n",
    "\n",
    "latte = Product(\"Латте\", 220)\n",
    "print(latte == Product(\"Латте\", 220))\n",
    "print(latte == \"Латте\", latte == 220)"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "not-implemented"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Типичная ошибка: return False для чужого типа.**\n",
    ">\n",
    "> `return False` вместо `return NotImplemented` выглядит так же, пока сравнивают со строками и числами. Но\n",
    "> так класс отнимает слово у второго объекта: если другой класс умеет сравниваться с вашим, его `__eq__` уже не\n",
    "> вызовется. Демонстрация ниже — класс `Ticket` (код из кассы), который знает, какому товару он\n",
    "> соответствует."
   ],
   "id": "component-36"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# False не даёт ответить второму объекту\n",
    "class Ticket:\n",
    "    \"\"\"Строка кассового чека: знает, какому товару соответствует.\"\"\"\n",
    "\n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "\n",
    "    def __eq__(self, other):\n",
    "        if isinstance(other, (Product, StrictProduct)):\n",
    "            return self.name == other.name\n",
    "        return NotImplemented\n",
    "\n",
    "\n",
    "class StrictProduct:\n",
    "    def __init__(self, name, price):\n",
    "        self.name = name\n",
    "        self.price = price\n",
    "\n",
    "    def __eq__(self, other):\n",
    "        if not isinstance(other, StrictProduct):\n",
    "            return False  # ошибка: не даёт ответить Ticket\n",
    "        return self.name == other.name and self.price == other.price\n",
    "\n",
    "\n",
    "ticket = Ticket(\"Латте\")\n",
    "print(Product(\"Латте\", 220) == ticket)  # Python спросил Ticket — True\n",
    "print(StrictProduct(\"Латте\", 220) == ticket)  # ответ False, Ticket не спросили"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "false-vs-ni"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Не путайте `NotImplemented` (значение, которое возвращает магический метод) и `NotImplementedError`\n",
    "(исключение) — это разные вещи."
   ],
   "id": "text-44"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Упражнение 1. Равные напитки\n",
    "\n",
    "Допишите класс `Drink`: два напитка равны, если у них совпадают цена и название — **без учёта регистра**:\n",
    "кассиры пишут то «Латте», то «латте». Сравнение с объектом другого типа возвращает `NotImplemented`.\n",
    "\n",
    "<details><summary>Подсказка 1</summary>\n",
    "\n",
    "Сначала проверьте тип `other`, как в демонстрации; потом сравните цены и названия.\n",
    "\n",
    "</details>\n",
    "<details><summary>Подсказка 2</summary>\n",
    "\n",
    "Регистр убирает метод строки `lower()`: `self.name.lower() == other.name.lower()`.\n",
    "\n",
    "</details>"
   ],
   "id": "drink-eq-task"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "class Drink:\n",
    "    def __init__(self, name, price):\n",
    "        self.name = name\n",
    "        self.price = price\n",
    "\n",
    "    def __eq__(self, other):\n",
    "        ..."
   ],
   "execution_count": null,
   "outputs": [],
   "id": "drink-eq"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Проверка упражнения 1 — выполните после своего решения\n",
    "def test_equal():\n",
    "    \"напитки с одинаковыми названием и ценой равны\"\n",
    "    assert \"__eq__\" in Drink.__dict__, \"в классе нет __eq__ — объявите его\"\n",
    "    a, b = Drink(\"Латте\", 220), Drink(\"Латте\", 220)\n",
    "    assert (a == b) is True, \"Drink(\\\"Латте\\\", 220) == Drink(\\\"Латте\\\", 220) должно быть True\"\n",
    "    assert a is not b, \"проверка создаёт два разных объекта\"\n",
    "    assert Drink(\"латте\", 220) == Drink(\"Латте\", 220), \"«латте» и «Латте» по одной цене должны быть равны — сравнивайте названия без учёта регистра: lower()\"\n",
    "\n",
    "\n",
    "def test_different():\n",
    "    \"другая цена или название — не равны\"\n",
    "    assert \"__eq__\" in Drink.__dict__, \"сначала объявите __eq__\"\n",
    "    assert Drink(\"Латте\", 220) != Drink(\"Латте\", 250), \"у напитков разные цены, а они равны — сравнивайте и цену\"\n",
    "    assert Drink(\"Латте\", 220) != Drink(\"Раф\", 220), \"у напитков разные названия, а они равны — сравнивайте и название\"\n",
    "\n",
    "\n",
    "def test_foreign():\n",
    "    \"чужой тип — NotImplemented\"\n",
    "    assert \"__eq__\" in Drink.__dict__, \"сначала объявите __eq__\"\n",
    "    try:\n",
    "        got = Drink.__dict__[\"__eq__\"](Drink(\"Латте\", 220), \"Латте\")\n",
    "    except AttributeError:\n",
    "        assert False, \"сравнение со строкой падает с AttributeError — сначала проверьте тип: isinstance(other, Drink)\"\n",
    "    assert got is not False, \"для чужого типа __eq__ вернул False, а нужно return NotImplemented — пусть ответит второй объект\"\n",
    "    assert got is NotImplemented, f\"для чужого типа __eq__ вернул {got!r}, а нужно NotImplemented\"\n",
    "    assert (Drink(\"Латте\", 220) == \"Латте\") is False, \"сравнение со строкой должно давать False\"\n",
    "\n",
    "_check(test_equal, test_different, test_foreign, names=[\"Drink.__eq__\"])"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "drink-eq-check"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Решение</summary>\n",
    "\n",
    "```python\n",
    "class Drink:\n",
    "    def __init__(self, name, price):\n",
    "        self.name = name\n",
    "        self.price = price\n",
    "\n",
    "    def __eq__(self, other):\n",
    "        if not isinstance(other, Drink):\n",
    "            return NotImplemented\n",
    "        return self.name.lower() == other.name.lower() and self.price == other.price\n",
    "```\n",
    "\n",
    "</details>"
   ],
   "id": "drink-eq-solution"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## `__hash__`: объекты в set и ключи dict\n",
    "\n",
    "`set` и `dict` находят элементы не перебором, а по **хешу** (hash) — числу, которое вычисляет `hash(x)`. Правило:\n",
    "**равные объекты обязаны иметь равные хеши**, иначе `set` положит два «равных» товара в разные места.\n",
    "Поэтому, как только в классе появляется `__eq__`, Python отключает хеш по умолчанию — экземпляр перестаёт\n",
    "быть **хешируемым** (hashable):"
   ],
   "id": "text-55"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# unhashable type: 'Product'\n",
    "# Эта ячейка показывает ошибку TypeError: она перехвачена, чтобы «Выполнить всё» не останавливалось.\n",
    "try:\n",
    "    print(Product.__hash__)  # __eq__ есть — хеш отключён\n",
    "    {latte}\n",
    "except Exception as error:\n",
    "    print(f\"{type(error).__name__}: {error}\")"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "unhashable"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Чтобы вернуть хеш, объявляют `__hash__` и вычисляют его только из атрибутов, которые сравнивает `__eq__` — из\n",
    "всех или из части, — но не из других: иначе у равных объектов хеши разойдутся. Проще всего — хеш кортежа из\n",
    "всех сравниваемых атрибутов: `hash((self.name, self.price))`."
   ],
   "id": "text-64"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Product в set\n",
    "class Product:\n",
    "    def __init__(self, name, price):\n",
    "        self.name = name\n",
    "        self.price = price\n",
    "\n",
    "    def __repr__(self):\n",
    "        return f\"Product({self.name!r}, {self.price})\"\n",
    "\n",
    "    def __eq__(self, other):\n",
    "        if not isinstance(other, Product):\n",
    "            return NotImplemented\n",
    "        return self.name == other.name and self.price == other.price\n",
    "\n",
    "    def __hash__(self):\n",
    "        return hash((self.name, self.price))\n",
    "\n",
    "\n",
    "shelf = {Product(\"Латте\", 220), Product(\"Латте\", 220), Product(\"Чай\", 120)}\n",
    "print(len(shelf))\n",
    "print(Product(\"Латте\", 220) in shelf)\n",
    "stock = {Product(\"Чай\", 120): 30}\n",
    "print(stock[Product(\"Чай\", 120)])"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "hash"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Сами числа хешей не важны и меняются от запуска к запуску — важно только, что у равных объектов они равны."
   ],
   "id": "text-70"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Упражнение 2. Покупатель по телефону\n",
    "\n",
    "Допишите класс `Customer`: покупатели равны, если у них один и тот же телефон `phone` (имя может быть записано\n",
    "по-разному: «Анна» и «Аня»). Сравнение с другим типом — `NotImplemented`. Добавьте `__hash__`, чтобы\n",
    "покупателей можно было класть в `set` и делать ключами `dict`.\n",
    "\n",
    "<details><summary>Подсказка 1</summary>\n",
    "\n",
    "Равенство — только по телефону, а хеш можно считать лишь из того, что сравнивает `__eq__`.\n",
    "\n",
    "</details>\n",
    "<details><summary>Подсказка 2</summary>\n",
    "\n",
    "`__hash__` — `return hash(self.phone)`.\n",
    "\n",
    "</details>"
   ],
   "id": "customer-task"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "class Customer:\n",
    "    def __init__(self, name, phone):\n",
    "        self.name = name\n",
    "        self.phone = phone\n",
    "\n",
    "    def __eq__(self, other):\n",
    "        ...\n",
    "\n",
    "    def __hash__(self):\n",
    "        ..."
   ],
   "execution_count": null,
   "outputs": [],
   "id": "customer"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Проверка упражнения 2 — выполните после своего решения\n",
    "def test_eq():\n",
    "    \"равны по телефону, имя не важно\"\n",
    "    assert \"__eq__\" in Customer.__dict__, \"в классе нет __eq__\"\n",
    "    anna, anya = Customer(\"Анна\", \"+7 900 111-22-33\"), Customer(\"Аня\", \"+7 900 111-22-33\")\n",
    "    assert anna == anya, \"у Анны и Ани один телефон — это один покупатель, они должны быть равны\"\n",
    "    assert anna != Customer(\"Анна\", \"+7 900 999-88-77\"), \"у покупателей разные телефоны — они не равны, даже если имя одно\"\n",
    "\n",
    "\n",
    "def test_foreign():\n",
    "    \"чужой тип — NotImplemented\"\n",
    "    try:\n",
    "        got = Customer.__dict__[\"__eq__\"](Customer(\"Анна\", \"1\"), \"1\")\n",
    "    except AttributeError:\n",
    "        assert False, \"сравнение со строкой падает — сначала проверьте тип: isinstance(other, Customer)\"\n",
    "    assert got is NotImplemented, f\"для чужого типа __eq__ вернул {got!r}, а нужно NotImplemented\"\n",
    "\n",
    "\n",
    "def test_hash():\n",
    "    \"равные покупатели — один элемент set\"\n",
    "    try:\n",
    "        group = {Customer(\"Анна\", \"1\"), Customer(\"Аня\", \"1\"), Customer(\"Борис\", \"2\")}\n",
    "    except TypeError:\n",
    "        assert False, \"покупателя нельзя положить в set — объявите __hash__\"\n",
    "    assert len(group) == 2, f\"в set из Анны, Ани (тот же телефон) и Бориса {len(group)} элементов, а нужно 2 — хеш должен зависеть только от телефона\"\n",
    "    assert hash(Customer(\"Анна\", \"1\")) == hash(Customer(\"Аня\", \"1\")), \"у равных покупателей хеши разные — считайте хеш из телефона\"\n",
    "\n",
    "_check(test_eq, test_foreign, test_hash, names=[\"Customer.__eq__\",\"Customer.__hash__\"])"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "customer-check"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Решение</summary>\n",
    "\n",
    "```python\n",
    "class Customer:\n",
    "    def __init__(self, name, phone):\n",
    "        self.name = name\n",
    "        self.phone = phone\n",
    "\n",
    "    def __eq__(self, other):\n",
    "        if not isinstance(other, Customer):\n",
    "            return NotImplemented\n",
    "        return self.phone == other.phone\n",
    "\n",
    "    def __hash__(self):\n",
    "        return hash(self.phone)\n",
    "```\n",
    "\n",
    "</details>"
   ],
   "id": "customer-solution"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Почему объект пропал из set\n",
    "\n",
    "Хеш вычисляется в момент, когда объект кладут в `set`. Если потом изменить атрибут, от которого зависит хеш,\n",
    "объект окажется «не на своём месте» — `set` его больше не найдёт:"
   ],
   "id": "text-81"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Изменили цену — товар пропал\n",
    "latte = Product(\"Латте\", 220)\n",
    "basket = {latte}\n",
    "latte.price = 250  # хеш изменился, а в set объект лежит по старому\n",
    "print(latte in basket)\n",
    "print(len(basket), list(basket))"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "lost"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Типичная ошибка: изменяемый объект в set.**\n",
    ">\n",
    "> Объект, который лежит в `set` или служит ключом `dict`, нельзя менять в тех атрибутах, из которых считается\n",
    "> хеш. Надёжнее всего делать такие объекты **неизменяемыми** (immutable) — как это устроить, покажет урок\n",
    "> о настройках dataclass."
   ],
   "id": "component-89"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Упражнение 3. Визиты покупателей\n",
    "\n",
    "В `visits` — покупатели по порядку визитов за день; один и тот же человек мог представиться по-разному.\n",
    "Сохраните в `n_unique` число разных покупателей, а в `per_customer` — словарь «покупатель → сколько раз\n",
    "приходил». Используйте класс `Customer` из прошлого упражнения.\n",
    "\n",
    "<details><summary>Подсказка 1</summary>\n",
    "\n",
    "Разных покупателей столько, сколько элементов останется в `set` из визитов.\n",
    "\n",
    "</details>\n",
    "<details><summary>Подсказка 2</summary>\n",
    "\n",
    "Словарь-счётчик, как в первом уроке: `per_customer[c] = per_customer.get(c, 0) + 1`.\n",
    "\n",
    "</details>"
   ],
   "id": "visits-task"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "visits = [\n",
    "    Customer(\"Анна\", \"+7 900 111-22-33\"),\n",
    "    Customer(\"Борис\", \"+7 900 222-33-44\"),\n",
    "    Customer(\"Аня\", \"+7 900 111-22-33\"),\n",
    "    Customer(\"Вера\", \"+7 900 333-44-55\"),\n",
    "    Customer(\"Анна\", \"+7 900 111-22-33\"),\n",
    "]\n",
    "n_unique = ...\n",
    "per_customer = ..."
   ],
   "execution_count": null,
   "outputs": [],
   "id": "visits"
  },
  {
   "cell_type": "code",
   "metadata": {},
   "source": [
    "# Проверка упражнения 3 — выполните после своего решения\n",
    "def test_unique():\n",
    "    \"n_unique — разных покупателей\"\n",
    "    assert n_unique != 5, \"5 — это число визитов; Анна и Аня — один человек (телефон один): посчитайте len(set(visits))\"\n",
    "    assert n_unique != 4, \"4 — это число разных имён, а покупатель определяется телефоном\"\n",
    "    assert n_unique == 3, f\"n_unique = {n_unique!r}, а разных покупателей 3\"\n",
    "\n",
    "\n",
    "def test_counts():\n",
    "    \"per_customer — визиты каждого\"\n",
    "    assert isinstance(per_customer, dict), f\"per_customer — это {type(per_customer).__name__}, а нужен словарь\"\n",
    "    assert len(per_customer) == 3, f\"в per_customer {len(per_customer)} ключей, а разных покупателей 3 — ключи должны быть сами покупатели\"\n",
    "    got = per_customer.get(Customer(\"?\", \"+7 900 111-22-33\"))\n",
    "    assert got == 3, f\"у покупателя с телефоном +7 900 111-22-33 {got!r} визитов, а он приходил трижды\"\n",
    "\n",
    "_check(test_unique, test_counts, names=[\"n_unique\",\"per_customer\"])"
   ],
   "execution_count": null,
   "outputs": [],
   "id": "visits-check"
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<details><summary>Решение</summary>\n",
    "\n",
    "```python\n",
    "visits = [\n",
    "    Customer(\"Анна\", \"+7 900 111-22-33\"),\n",
    "    Customer(\"Борис\", \"+7 900 222-33-44\"),\n",
    "    Customer(\"Аня\", \"+7 900 111-22-33\"),\n",
    "    Customer(\"Вера\", \"+7 900 333-44-55\"),\n",
    "    Customer(\"Анна\", \"+7 900 111-22-33\"),\n",
    "]\n",
    "n_unique = len(set(visits))\n",
    "per_customer = {}\n",
    "for c in visits:\n",
    "    per_customer[c] = per_customer.get(c, 0) + 1\n",
    "```\n",
    "\n",
    "</details>"
   ],
   "id": "visits-solution"
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "name": "python"
  },
  "colab": {
   "provenance": []
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}