{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Сортировка объектов\n", "\n", "__lt__ учит объекты сравниваться на «меньше» — и начинают работать sorted, min и max. @total_ordering дописывает остальные сравнения, а key= сортирует без магических методов.\n", "\n", "Курс ООП в Python · урок `oop-ordering` · [урок на сайте](https://ds-edu-trainer.vercel.app/courses/oop/ordering).\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": [ "Список чисел или строк сортируется сам: `sorted([3, 1, 2])`. А список товаров — нет: Python не знает, какой\n", "товар «меньше» другого." ], "id": "text-9" }, { "cell_type": "code", "metadata": {}, "source": [ "# Товары не сортируются\n", "# Эта ячейка показывает ошибку TypeError: она перехвачена, чтобы «Выполнить всё» не останавливалось.\n", "try:\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", "\n", " products = [Product(\"Раф\", 260), Product(\"Чай\", 120), Product(\"Латте\", 220)]\n", " sorted(products)\n", "except Exception as error:\n", " print(f\"{type(error).__name__}: {error}\")" ], "execution_count": null, "outputs": [], "id": "no-order" }, { "cell_type": "markdown", "metadata": {}, "source": [ "Есть два способа научить: объявить «естественный порядок» в самом классе или передать порядок в `sorted`\n", "снаружи — параметром `key`.\n", "\n", "## `__lt__`: «меньше»\n", "\n", "`a < b` вызывает `a.__lt__(b)` (lt — от less than). Этого одного метода достаточно для `sorted`, `min`, `max`\n", "и метода списка `sort`: `sorted`, `sort` и `min` сравнивают через `<`, а `max` — через `>`, который Python\n", "сводит к `<` второго объекта (подробнее — сразу под демонстрацией):" ], "id": "text-14" }, { "cell_type": "code", "metadata": {}, "source": [ "# Товары по цене\n", "class PricedProduct:\n", " def __init__(self, name, price):\n", " self.name = name\n", " self.price = price\n", "\n", " def __repr__(self):\n", " return f\"PricedProduct({self.name!r}, {self.price})\"\n", "\n", " def __lt__(self, other):\n", " if not isinstance(other, PricedProduct):\n", " return NotImplemented\n", " return self.price < other.price\n", "\n", "\n", "shelf = [PricedProduct(\"Раф\", 260), PricedProduct(\"Чай\", 120), PricedProduct(\"Латте\", 220)]\n", "print(sorted(shelf))\n", "print(min(shelf), max(shelf))\n", "print(shelf[0] > shelf[1]) # Python спросил shelf[1] < shelf[0]" ], "execution_count": null, "outputs": [], "id": "lt" }, { "cell_type": "markdown", "metadata": {}, "source": [ "Для чужого типа `__lt__`, как и `__eq__`, возвращает `NotImplemented`. А `a > b` Python сам превращает в\n", "`b < a`, если у `a` нет своего `__gt__`, — поэтому `>` тоже заработал." ], "id": "text-25" }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Упражнение 1. Напитки по объёму\n", "\n", "Допишите класс `Drink`: напиток «меньше» другого, если у него меньше объём `volume`; сравнение с чужим типом —\n", "`NotImplemented`. После этого сохраните в `ordered` список напитков из `menu`, отсортированный по объёму,\n", "а в `biggest` — самый большой напиток.\n", "\n", "
Подсказка 1\n", "\n", "`__lt__` устроен как `__eq__`: сначала тип `other`, потом сравнение нужного атрибута.\n", "\n", "
\n", "
Подсказка 2\n", "\n", "`ordered = sorted(menu)`, `biggest = max(menu)` — они сами вызовут `__lt__`.\n", "\n", "
" ], "id": "drink-lt-task" }, { "cell_type": "code", "metadata": {}, "source": [ "class Drink:\n", " def __init__(self, name, volume):\n", " self.name = name\n", " self.volume = volume\n", "\n", " def __repr__(self):\n", " return f\"Drink({self.name!r}, {self.volume})\"\n", "\n", " def __lt__(self, other):\n", " ...\n", "\n", "\n", "menu = [Drink(\"Латте\", 400), Drink(\"Эспрессо\", 60), Drink(\"Капучино\", 300)]\n", "ordered = ...\n", "biggest = ..." ], "execution_count": null, "outputs": [], "id": "drink-lt" }, { "cell_type": "code", "metadata": {}, "source": [ "# Проверка упражнения 1 — выполните после своего решения\n", "def test_lt():\n", " \"__lt__ сравнивает объём\"\n", " assert \"__lt__\" in Drink.__dict__, \"в классе нет __lt__ — объявите его\"\n", " small, big = Drink(\"Эспрессо\", 60), Drink(\"Латте\", 400)\n", " assert (small < big) is True, \"Drink(\\\"Эспрессо\\\", 60) < Drink(\\\"Латте\\\", 400) должно быть True\"\n", " assert (big < small) is False, \"Drink(\\\"Латте\\\", 400) < Drink(\\\"Эспрессо\\\", 60) должно быть False\"\n", " assert (Drink(\"А\", 300) < Drink(\"Б\", 300)) is False, \"при равных объёмах ни один напиток не меньше другого — сравнение строгое: <\"\n", "\n", "\n", "def test_foreign():\n", " \"чужой тип — NotImplemented\"\n", " assert \"__lt__\" in Drink.__dict__, \"сначала объявите __lt__\"\n", " try:\n", " got = Drink.__dict__[\"__lt__\"](Drink(\"Латте\", 400), 500)\n", " except AttributeError:\n", " assert False, \"сравнение с числом падает — сначала проверьте тип: isinstance(other, Drink)\"\n", " assert got is NotImplemented, f\"для чужого типа __lt__ вернул {got!r}, а нужно NotImplemented\"\n", "\n", "\n", "def test_sorted():\n", " \"ordered и biggest\"\n", " assert isinstance(ordered, list), f\"ordered — это {type(ordered).__name__}, а нужен список: sorted(menu)\"\n", " assert [d.name for d in ordered] == [\"Эспрессо\", \"Капучино\", \"Латте\"], f\"порядок в ordered: {[d.name for d in ordered]}\"\n", " assert isinstance(biggest, Drink), f\"biggest — это {type(biggest).__name__}, а нужен сам напиток: max(menu)\"\n", " assert biggest.name == \"Латте\", f\"biggest — {biggest.name}, а больше всех латте\"\n", "\n", "_check(test_lt, test_foreign, test_sorted, names=[\"Drink.__lt__\",\"ordered\",\"biggest\"])" ], "execution_count": null, "outputs": [], "id": "drink-lt-check" }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Решение\n", "\n", "```python\n", "class Drink:\n", " def __init__(self, name, volume):\n", " self.name = name\n", " self.volume = volume\n", "\n", " def __repr__(self):\n", " return f\"Drink({self.name!r}, {self.volume})\"\n", "\n", " def __lt__(self, other):\n", " if not isinstance(other, Drink):\n", " return NotImplemented\n", " return self.volume < other.volume\n", "\n", "\n", "menu = [Drink(\"Латте\", 400), Drink(\"Эспрессо\", 60), Drink(\"Капучино\", 300)]\n", "ordered = sorted(menu)\n", "biggest = max(menu)\n", "```\n", "\n", "
" ], "id": "drink-lt-solution" }, { "cell_type": "markdown", "metadata": {}, "source": [ "## `@total_ordering`: все шесть сравнений\n", "\n", "Сравнений шесть: `==`, `!=`, `<`, `>`, `<=`, `>=`. `!=` получается из `__eq__`, `>` — из `__lt__` второго\n", "объекта, а вот `<=` и `>=` сами не появятся:" ], "id": "text-37" }, { "cell_type": "code", "metadata": {}, "source": [ "# <= не работает\n", "# Эта ячейка показывает ошибку TypeError: она перехвачена, чтобы «Выполнить всё» не останавливалось.\n", "try:\n", " shelf[0] <= shelf[1]\n", "except Exception as error:\n", " print(f\"{type(error).__name__}: {error}\")" ], "execution_count": null, "outputs": [], "id": "no-le" }, { "cell_type": "markdown", "metadata": {}, "source": [ "Писать ещё два метода не нужно. Декоратор `total_ordering` из модуля `functools` стандартной библиотеки\n", "достраивает недостающие сравнения из `__eq__` и `__lt__`. Декоратор класса ставится над строкой `class`:" ], "id": "text-44" }, { "cell_type": "code", "metadata": {}, "source": [ "# Все сравнения из двух методов\n", "from functools import total_ordering\n", "\n", "\n", "@total_ordering\n", "class Version:\n", " def __init__(self, major, minor):\n", " self.major = major\n", " self.minor = minor\n", "\n", " def __repr__(self):\n", " return f\"Version({self.major}, {self.minor})\"\n", "\n", " def __eq__(self, other):\n", " if not isinstance(other, Version):\n", " return NotImplemented\n", " return (self.major, self.minor) == (other.major, other.minor)\n", "\n", " def __lt__(self, other):\n", " if not isinstance(other, Version):\n", " return NotImplemented\n", " return (self.major, self.minor) < (other.major, other.minor)\n", "\n", "\n", "old, new = Version(1, 9), Version(2, 0)\n", "print(old < new, old <= new, old >= new, old != new)" ], "execution_count": null, "outputs": [], "id": "total-ordering" }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Упражнение 2. Бронирование столиков\n", "\n", "Объявите класс `Booking` с декоратором `@total_ordering`: `Booking(\"Анна\", \"18:30\")` хранит имя гостя `name`\n", "и время `time` строкой «ЧЧ:ММ». Брони сравниваются по времени, а при одинаковом времени — по имени: объявите\n", "`__eq__` и `__lt__` (для чужого типа — `NotImplemented`), остальные сравнения достроит декоратор.\n", "\n", "
Подсказка 1\n", "\n", "Сравнивать удобно кортежи: `(self.time, self.name) < (other.time, other.name)` — кортежи сравниваются по первому элементу, при равенстве — по второму.\n", "\n", "
\n", "
Подсказка 2\n", "\n", "Строки «ЧЧ:ММ» с ведущим нулём («09:30») сравниваются как время: `\"09:30\" < \"18:00\"`.\n", "\n", "
" ], "id": "booking-task" }, { "cell_type": "code", "metadata": {}, "source": [ "from functools import total_ordering\n", "\n", "\n", "class Booking:\n", " def __init__(self, name, time):\n", " self.name = name\n", " self.time = time\n", "\n", " def __eq__(self, other):\n", " ...\n", "\n", " def __lt__(self, other):\n", " ..." ], "execution_count": null, "outputs": [], "id": "booking" }, { "cell_type": "code", "metadata": {}, "source": [ "# Проверка упражнения 2 — выполните после своего решения\n", "def test_methods():\n", " \"__eq__ и __lt__ объявлены\"\n", " for name in [\"__eq__\", \"__lt__\"]:\n", " assert name in Booking.__dict__, f\"в классе нет {name} — объявите его\"\n", "\n", "\n", "def test_order():\n", " \"по времени, при равном времени — по имени\"\n", " assert \"__lt__\" in Booking.__dict__, \"сначала объявите __lt__\"\n", " early, late = Booking(\"Борис\", \"09:30\"), Booking(\"Анна\", \"18:30\")\n", " assert early < late, \"бронь на 09:30 должна быть раньше брони на 18:30 — сравнивайте сначала время\"\n", " assert Booking(\"Анна\", \"18:30\") < Booking(\"Борис\", \"18:30\"), \"при одинаковом времени раньше та бронь, где имя по алфавиту раньше\"\n", " got = [b.name for b in sorted([Booking(\"Вера\", \"12:00\"), Booking(\"Борис\", \"09:30\"), Booking(\"Анна\", \"12:00\")])]\n", " assert got == [\"Борис\", \"Анна\", \"Вера\"], f\"после сортировки брони идут так: {got}\"\n", "\n", "\n", "def test_equal():\n", " \"равны — то же время и имя\"\n", " assert \"__eq__\" in Booking.__dict__, \"сначала объявите __eq__\"\n", " assert Booking(\"Анна\", \"18:30\") == Booking(\"Анна\", \"18:30\"), \"брони с одинаковыми именем и временем должны быть равны\"\n", " assert Booking(\"Анна\", \"18:30\") != Booking(\"Борис\", \"18:30\"), \"брони разных гостей на одно время не равны\"\n", " try:\n", " got = Booking.__dict__[\"__eq__\"](Booking(\"Анна\", \"18:30\"), \"18:30\")\n", " except AttributeError:\n", " assert False, \"сравнение со строкой падает — сначала проверьте тип: isinstance(other, Booking)\"\n", " assert got is NotImplemented, f\"для чужого типа __eq__ вернул {got!r}, а нужно NotImplemented\"\n", "\n", "\n", "def test_total_ordering():\n", " \"<= и >= работают\"\n", " a, b = Booking(\"Анна\", \"09:30\"), Booking(\"Борис\", \"18:30\")\n", " try:\n", " result = (a <= b, b >= a, a >= b)\n", " except TypeError:\n", " assert False, \"<= и >= не работают — поставьте над классом декоратор @total_ordering\"\n", " assert result == (True, True, False), f\"a <= b, b >= a, a >= b дали {result}\"\n", "\n", "_check(test_methods, test_order, test_equal, test_total_ordering, names=[\"Booking.__eq__\",\"Booking.__lt__\"])" ], "execution_count": null, "outputs": [], "id": "booking-check" }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Решение\n", "\n", "```python\n", "from functools import total_ordering\n", "\n", "\n", "@total_ordering\n", "class Booking:\n", " def __init__(self, name, time):\n", " self.name = name\n", " self.time = time\n", "\n", " def __eq__(self, other):\n", " if not isinstance(other, Booking):\n", " return NotImplemented\n", " return (self.time, self.name) == (other.time, other.name)\n", "\n", " def __lt__(self, other):\n", " if not isinstance(other, Booking):\n", " return NotImplemented\n", " return (self.time, self.name) < (other.time, other.name)\n", "```\n", "\n", "
" ], "id": "booking-solution" }, { "cell_type": "markdown", "metadata": {}, "source": [ "> **Типичная ошибка: время без ведущего нуля.**\n", ">\n", "> Строки сравниваются посимвольно: `\"9:30\" > \"18:00\"`, потому что символ `\"9\"` больше `\"1\"`. Если время хранится\n", "> строкой, оно должно быть в одном формате — «09:30». Надёжнее хранить числа или объекты времени (модуль\n", "> `datetime`), но это тема не этого курса." ], "id": "component-59" }, { "cell_type": "markdown", "metadata": {}, "source": [ "## `key=`: порядок снаружи\n", "\n", "Не у каждого класса есть один естественный порядок. Товары сортируют то по цене, то по названию, то по\n", "популярности — и ни один порядок не «главный». Тогда в классе ничего не объявляют, а передают `sorted`, `min`\n", "и `max` параметр `key` — функцию, которая для каждого элемента возвращает значение, по которому сравнивать:" ], "id": "text-64" }, { "cell_type": "code", "metadata": {}, "source": [ "# Сортировка с key\n", "def price_of(p):\n", " return p.price\n", "\n", "\n", "print(sorted(products, key=price_of))\n", "print(sorted(products, key=lambda p: p.price)) # то же самое\n", "print(max(products, key=lambda p: len(p.name)))" ], "execution_count": null, "outputs": [], "id": "key" }, { "cell_type": "markdown", "metadata": {}, "source": [ "`lambda p: p.price` — короткая безымянная функция (lambda): то же самое, что `def price_of(p): return p.price`,\n", "только в одну строку и прямо на месте аргумента." ], "id": "text-72" }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Упражнение 3. Прайс по-разному\n", "\n", "У класса `Product` из демонстрации нет сравнений. Для списка `products` сохраните в `by_name` названия товаров\n", "по алфавиту, в `by_price_desc` — названия от самого дорогого к самому дешёвому, а в `cheapest` — сам самый\n", "дешёвый товар.\n", "\n", "
Подсказка 1\n", "\n", "`sorted(products, key=lambda p: p.name)` даёт товары — названия соберите генератором списка.\n", "\n", "
\n", "
Подсказка 2\n", "\n", "От дорогого к дешёвому — `reverse=True`; самый дешёвый — `min(products, key=lambda p: p.price)`.\n", "\n", "
" ], "id": "key-sort-task" }, { "cell_type": "code", "metadata": {}, "source": [ "products = [Product(\"Раф\", 260), Product(\"Чай\", 120), Product(\"Латте\", 220), Product(\"Какао\", 190)]\n", "by_name = ...\n", "by_price_desc = ...\n", "cheapest = ..." ], "execution_count": null, "outputs": [], "id": "key-sort" }, { "cell_type": "code", "metadata": {}, "source": [ "# Проверка упражнения 3 — выполните после своего решения\n", "def test_by_name():\n", " \"by_name — названия по алфавиту\"\n", " assert isinstance(by_name, list), f\"by_name — это {type(by_name).__name__}, а нужен список названий\"\n", " assert all(isinstance(x, str) for x in by_name), \"в by_name должны быть названия-строки, а не товары: [p.name for p in …]\"\n", " assert by_name == [\"Какао\", \"Латте\", \"Раф\", \"Чай\"], f\"by_name = {by_name}\"\n", "\n", "\n", "def test_by_price():\n", " \"by_price_desc — от дорогого к дешёвому\"\n", " assert isinstance(by_price_desc, list) and all(isinstance(x, str) for x in by_price_desc), \"в by_price_desc нужен список названий\"\n", " assert by_price_desc != [\"Чай\", \"Какао\", \"Латте\", \"Раф\"], \"порядок от дешёвого к дорогому — нужен обратный: reverse=True\"\n", " assert by_price_desc == [\"Раф\", \"Латте\", \"Какао\", \"Чай\"], f\"by_price_desc = {by_price_desc}\"\n", "\n", "\n", "def test_cheapest():\n", " \"cheapest — сам самый дешёвый товар\"\n", " assert not isinstance(cheapest, (int, str)), f\"cheapest = {cheapest!r}, а нужен сам товар\"\n", " assert isinstance(cheapest, Product) and cheapest.name == \"Чай\", f\"cheapest = {cheapest!r}, а дешевле всех чай\"\n", "\n", "_check(test_by_name, test_by_price, test_cheapest, names=[\"by_name\",\"by_price_desc\",\"cheapest\"])" ], "execution_count": null, "outputs": [], "id": "key-sort-check" }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Решение\n", "\n", "```python\n", "products = [Product(\"Раф\", 260), Product(\"Чай\", 120), Product(\"Латте\", 220), Product(\"Какао\", 190)]\n", "by_name = [p.name for p in sorted(products, key=lambda p: p.name)]\n", "by_price_desc = [p.name for p in sorted(products, key=lambda p: p.price, reverse=True)]\n", "cheapest = min(products, key=lambda p: p.price)\n", "```\n", "\n", "
" ], "id": "key-sort-solution" }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Вопрос.** Кофейня печатает меню то по цене, то по калорийности, то по алфавиту. Как лучше сортировать напитки?\n", "\n", "- объявить `__lt__` по цене, а для остальных порядков — ещё классы\n", "- не объявлять `__lt__`, а передавать в `sorted` нужный `key=`\n", "- объявить три метода `__lt__` с разными условиями\n", "\n", "
Ответ\n", "\n", "не объявлять `__lt__`, а передавать в `sorted` нужный `key=`\n", "\n", "`__lt__` задаёт один естественный порядок — его стоит объявлять, когда он очевиден (время брони, номер версии). Когда порядков несколько и ни один не главный, честнее `key=`: порядок виден прямо в месте сортировки. Три метода `__lt__` в классе невозможны — останется последний.\n", "\n", "
" ], "id": "quiz-85" } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "name": "python" }, "colab": { "provenance": [] } }, "nbformat": 4, "nbformat_minor": 5 }