{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Объекты в списках и ссылки\n", "\n", "Переменная не хранит объект, а ссылается на него. Две переменные — один объект, оператор is, изменение через ссылку, объекты в списках и изменяемое значение по умолчанию.\n", "\n", "Курс ООП в Python · урок `oop-references` · [урок на сайте](https://ds-edu-trainer.vercel.app/courses/oop/references).\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": [ "Экземпляр живёт отдельно от переменных. Переменная — это имя, которое **ссылается** на объект, и имён у\n", "одного объекта может быть несколько. Пока объекты не меняются, разницы не видно. Но экземпляры своих классов\n", "обычно меняются — и тут важно понимать, сколько объектов на самом деле.\n", "\n", "## Две переменные — один объект\n", "\n", "Присваивание `b = a` не копирует объект: оно даёт тому же объекту второе имя. Изменение через одно имя видно\n", "через другое:" ], "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", "\n", "latte = Product(\"Латте\", 220)\n", "same = latte # второе имя, не копия\n", "same.price = 250\n", "print(latte.price)" ], "execution_count": null, "outputs": [], "id": "alias" }, { "cell_type": "markdown", "metadata": {}, "source": [ "Проверить, один ли это объект, можно оператором `is`. Он отвечает на вопрос о **тождественности**\n", "(identity) — «тот же самый объект?», — а `==` — о **равенстве** (equality). Для своих классов `==` по умолчанию\n", "тоже сравнивает тождественность, но это можно изменить — в модуле 4 мы научим товары сравниваться по названию\n", "и цене." ], "id": "text-20" }, { "cell_type": "code", "metadata": {}, "source": [ "# is: тот же объект или нет\n", "twin = Product(\"Латте\", 250) # новый объект с теми же значениями\n", "print(same is latte)\n", "print(twin is latte)\n", "print(twin == latte) # пока == сравнивает тождественность\n", "print(twin.price == latte.price)" ], "execution_count": null, "outputs": [], "id": "is" }, { "cell_type": "markdown", "metadata": {}, "source": [ "Самое частое место для `is` — проверка на `None`: `if x is None:`. Значение `None` в программе одно, поэтому\n", "его сравнивают по тождественности.\n", "\n", "## Объекты в списках и словарях\n", "\n", "Список хранит не копии объектов, а ссылки на них. Если взять товар из списка и изменить, изменится тот же\n", "объект, на который ссылается переменная снаружи:" ], "id": "text-27" }, { "cell_type": "code", "metadata": {}, "source": [ "# Товар в меню и в переменной\n", "espresso = Product(\"Эспрессо\", 150)\n", "menu = [espresso, Product(\"Чай\", 120)]\n", "menu[0].price = 160\n", "print(espresso.price)\n", "print(menu[0] is espresso)" ], "execution_count": null, "outputs": [], "id": "in-list" }, { "cell_type": "markdown", "metadata": {}, "source": [ "Так же работает передача в функцию: функция получает **сам объект** и может его изменить." ], "id": "text-37" }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Упражнение 1. Подорожание\n", "\n", "Напишите функцию `raise_prices(products, amount)`: она увеличивает цену каждого товара из списка `products`\n", "на `amount` рублей. Функция меняет сами товары и ничего не возвращает.\n", "\n", "
Подсказка 1\n", "\n", "Цикл по списку и `p.price = p.price + amount` для каждого товара.\n", "\n", "
" ], "id": "raise-prices-task" }, { "cell_type": "code", "metadata": {}, "source": [ "def raise_prices(products, amount):\n", " ..." ], "execution_count": null, "outputs": [], "id": "raise-prices" }, { "cell_type": "code", "metadata": {}, "source": [ "# Проверка упражнения 1 — выполните после своего решения\n", "def test_changes():\n", " \"цены товаров выросли на amount\"\n", " tea, raf = Product(\"Чай\", 120), Product(\"Раф\", 260)\n", " products = [tea, raf]\n", " raise_prices(products, 15)\n", " assert tea.price != 120, \"цена чая не изменилась — меняйте атрибут price у каждого товара: p.price = p.price + amount\"\n", " assert (tea.price, raf.price) == (135, 275), f\"после raise_prices(…, 15) цены {tea.price} и {raf.price}, а нужно 135 и 275\"\n", "\n", "\n", "def test_same_objects():\n", " \"в списке остались те же объекты\"\n", " tea = Product(\"Чай\", 120)\n", " products = [tea]\n", " raise_prices(products, 10)\n", " assert len(products) == 1 and products[0] is tea, \"функция заменила товары в списке другими объектами — меняйте цену у самих товаров\"\n", "\n", "\n", "def test_returns_nothing():\n", " \"функция ничего не возвращает\"\n", " got = raise_prices([Product(\"Чай\", 120)], 10)\n", " assert got is None, f\"функция вернула {got!r}, а должна только изменить товары\"\n", "\n", "_check(test_changes, test_same_objects, test_returns_nothing)" ], "execution_count": null, "outputs": [], "id": "raise-prices-check" }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Решение\n", "\n", "```python\n", "def raise_prices(products, amount):\n", " for p in products:\n", " p.price = p.price + amount\n", "```\n", "\n", "
" ], "id": "raise-prices-solution" }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Упражнение 2. Найти товар\n", "\n", "Напишите функцию `find(products, name)`: она возвращает **сам товар** из списка с таким названием, а если\n", "его нет — `None`.\n", "\n", "
Подсказка 1\n", "\n", "В цикле: если `p.name == name` — `return p`; после цикла — `return None`.\n", "\n", "
" ], "id": "find-task" }, { "cell_type": "code", "metadata": {}, "source": [ "def find(products, name):\n", " ..." ], "execution_count": null, "outputs": [], "id": "find" }, { "cell_type": "code", "metadata": {}, "source": [ "# Проверка упражнения 2 — выполните после своего решения\n", "def test_found():\n", " \"возвращает сам товар из списка\"\n", " tea, raf = Product(\"Чай\", 120), Product(\"Раф\", 260)\n", " got = find([tea, raf], \"Раф\")\n", " assert got is not None, \"find(…, \\\"Раф\\\") вернула None, а раф в списке есть\"\n", " assert not isinstance(got, (int, str)), f\"find вернула {got!r}, а нужен сам товар — экземпляр Product\"\n", " assert got is raf, \"find вернула не тот объект, что лежит в списке: верните p, а не новый Product\"\n", "\n", "\n", "def test_missing():\n", " \"нет товара — None\"\n", " got = find([Product(\"Чай\", 120)], \"Какао\")\n", " assert got is None, f\"для товара, которого нет, find вернула {got!r}, а нужно None\"\n", "\n", "_check(test_found, test_missing)" ], "execution_count": null, "outputs": [], "id": "find-check" }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Решение\n", "\n", "```python\n", "def find(products, name):\n", " for p in products:\n", " if p.name == name:\n", " return p\n", " return None\n", "```\n", "\n", "
" ], "id": "find-solution" }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Вопрос.** `menu` — список из двух товаров, второй — чай за 120 ₽. Что напечатает код?\n", "\n", "```python\n", "tea = menu[1]\n", "tea.price = 100\n", "print(menu[1].price)\n", "```\n", "\n", "- `100`\n", "- `120` — старую цену\n", "- ошибку: товар нельзя менять, пока он в списке\n", "\n", "
Ответ\n", "\n", "`100`\n", "\n", "`tea = menu[1]` не копирует товар, а даёт объекту из списка второе имя: в `menu[1]` и в `tea` один и тот же объект. Изменение через `tea` видно и через список.\n", "\n", "
" ], "id": "quiz-54" }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Нужна копия — создайте новый объект\n", "\n", "Чтобы получить независимый объект, его создают заново — вызовом класса с теми же значениями. Тогда у копии\n", "своя судьба:" ], "id": "text-69" }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Упражнение 3. Сезонный напиток\n", "\n", "В `latte` — товар «Латте» за 220 ₽. Создайте **отдельный** товар `pumpkin` с теми же атрибутами, затем\n", "поменяйте ему название на `\"Тыквенный латте\"` и цену на 290. Исходный `latte` меняться не должен.\n", "\n", "
Подсказка 1\n", "\n", "`pumpkin = Product(latte.name, latte.price)` — новый объект; потом меняйте его атрибуты.\n", "\n", "
" ], "id": "copy-task" }, { "cell_type": "code", "metadata": {}, "source": [ "latte = Product(\"Латте\", 220)\n", "pumpkin = ..." ], "execution_count": null, "outputs": [], "id": "copy" }, { "cell_type": "code", "metadata": {}, "source": [ "# Проверка упражнения 3 — выполните после своего решения\n", "def test_separate():\n", " \"pumpkin — отдельный объект Product\"\n", " assert isinstance(pumpkin, Product), f\"pumpkin — это {type(pumpkin).__name__}, а нужен экземпляр Product\"\n", " assert pumpkin is not latte, \"pumpkin и latte — один и тот же объект; создайте новый вызовом Product(…)\"\n", "\n", "\n", "def test_values():\n", " \"у pumpkin новое название и цена, latte не изменился\"\n", " assert isinstance(pumpkin, Product), \"сначала создайте pumpkin\"\n", " assert (latte.name, latte.price) == (\"Латте\", 220), f\"исходный латте изменился: {latte.name}, {latte.price} — меняйте только pumpkin\"\n", " assert (pumpkin.name, pumpkin.price) == (\"Тыквенный латте\", 290), f\"у pumpkin {pumpkin.name!r}, {pumpkin.price!r}\"\n", "\n", "_check(test_separate, test_values, names=[\"pumpkin\"])" ], "execution_count": null, "outputs": [], "id": "copy-check" }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Решение\n", "\n", "```python\n", "latte = Product(\"Латте\", 220)\n", "pumpkin = Product(latte.name, latte.price)\n", "pumpkin.name = \"Тыквенный латте\"\n", "pumpkin.price = 290\n", "```\n", "\n", "
" ], "id": "copy-solution" }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Изменяемое значение по умолчанию\n", "\n", "Та же история со ссылками прячется в значениях по умолчанию. Список, словарь и экземпляры ваших классов —\n", "**изменяемые** (mutable) объекты: их можно поменять, не создавая новый объект. Числа, строки и кортежи —\n", "**неизменяемые** (immutable). Значение по умолчанию вычисляется **один раз**,\n", "когда объявляется функция, а не при каждом вызове. Если это список, все вызовы без аргумента получат один и\n", "тот же список:" ], "id": "text-81" }, { "cell_type": "code", "metadata": {}, "source": [ "# Два заказа с одним списком\n", "class Ticket:\n", " def __init__(self, customer, items=[]): # ошибка: один список на все вызовы\n", " self.customer = customer\n", " self.items = items\n", "\n", "\n", "anna = Ticket(\"Анна\")\n", "boris = Ticket(\"Борис\")\n", "anna.items.append(\"Латте\")\n", "print(boris.items)\n", "print(anna.items is boris.items)" ], "execution_count": null, "outputs": [], "id": "default-bug" }, { "cell_type": "markdown", "metadata": {}, "source": [ "> **Типичная ошибка: изменяемое значение по умолчанию: items=[].**\n", ">\n", "> `def __init__(self, customer, items=[])` — ловушка: пустой список создан один раз, и все заказы без явного\n", "> `items` делят его. Правильно — значение по умолчанию `None`, а список создаётся внутри метода:\n", "> `if items is None: items = []`." ], "id": "component-92" }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Упражнение 4. Починить доставку\n", "\n", "В заготовке — класс `Delivery` (доставка заказа) с ошибкой из демонстрации: заметки курьеру `notes` у всех\n", "доставок без явного списка общие. Исправьте класс: у каждой доставки свой список `notes`. Если список передан\n", "при создании, доставка хранит **его копию** `list(notes)` — чтобы её заметки не меняли чужой список.\n", "\n", "
Подсказка 1\n", "\n", "Значение по умолчанию — `None`; в `__init__` проверьте его через `is None`.\n", "\n", "
" ], "id": "fix-default-task" }, { "cell_type": "code", "metadata": {}, "source": [ "class Delivery:\n", " def __init__(self, address, notes=[]):\n", " self.address = address\n", " self.notes = notes" ], "execution_count": null, "outputs": [], "id": "fix-default" }, { "cell_type": "code", "metadata": {}, "source": [ "# Проверка упражнения 4 — выполните после своего решения\n", "def test_own_lists():\n", " \"у доставок без notes — свои пустые списки\"\n", " a, b = Delivery(\"Лесная, 5\"), Delivery(\"Садовая, 12\")\n", " assert a.notes == [] and b.notes == [], f\"у новых доставок notes = {a.notes} и {b.notes}, а нужно []\"\n", " a.notes.append(\"домофон не работает\")\n", " assert b.notes == [], \"заметка одной доставки появилась у другой — у доставок общий список; значение по умолчанию — None, список создаётся в __init__\"\n", "\n", "\n", "def test_given():\n", " \"переданный список копируется\"\n", " notes = [\"позвонить заранее\"]\n", " d = Delivery(\"Лесная, 5\", notes)\n", " assert d.notes == [\"позвонить заранее\"], f\"у доставки с заметками notes = {d.notes}\"\n", " d.notes.append(\"оставить у двери\")\n", " assert notes == [\"позвонить заранее\"], \"доставка изменила чужой список — храните его копию: list(notes)\"\n", "\n", "_check(test_own_lists, test_given)" ], "execution_count": null, "outputs": [], "id": "fix-default-check" }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Решение\n", "\n", "```python\n", "class Delivery:\n", " def __init__(self, address, notes=None):\n", " self.address = address\n", " if notes is None:\n", " self.notes = []\n", " else:\n", " self.notes = list(notes)\n", "```\n", "\n", "
" ], "id": "fix-default-solution" }, { "cell_type": "markdown", "metadata": {}, "source": [ "Запомните главное: присваивание и передача в функцию не копируют объекты. Копия появляется, только когда вы\n", "создаёте новый объект сами." ], "id": "text-105" } ], "metadata": { "kernelspec": { "display_name": "Python 3", "language": "python", "name": "python3" }, "language_info": { "name": "python" }, "colab": { "provenance": [] } }, "nbformat": 4, "nbformat_minor": 5 }