python_pd/06_classes/05_magic.ipynb

{
 "metadata": {
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.0"
  },
  "orig_nbformat": 2,
  "kernelspec": {
   "name": "python3",
   "display_name": "Python 3.9.0 64-bit ('.venv')"
  },
  "interpreter": {
   "hash": "178cad48488a45b94c2e1acb3bfd8ec03d0e926b0801a270a439a0363b59c19a"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2,
 "cells": [
  {
   "cell_type": "markdown",
   "source": [
    "# \"Магические\" методы\r\n",
    "\r\n",
    "В Python многие объекты имеют так называемые «магические» атрибуты и\r\n",
    "методы. Они имеют специальный формат имени, а именно, оно начинается и\r\n",
    "заканчивается двумя подчеркиваниями. За это их еще называют\r\n",
    "дандер-атрибутами. Вот некоторые из них:\r\n",
    "\r\n",
    "- `__doc__` - хранит документацию класса, и используется при вызове\r\n",
    "функции `help`;\r\n",
    "- `__name__` - содержит имя класса;\r\n",
    "- `__modle__` - содержит строку с именем модуля, или `'__main__'` если\r\n",
    "модуль был запущен, а не импортирован;\r\n",
    "- `__bases__` - содержит кортеж базовых классов, в котором всегда будет\r\n",
    "элемент `<class 'object'>`;\r\n",
    "- `__dict__` – словарь со всеми атрибутами класса;\r\n",
    "- `__class__` - содержит ссылку на объект класса текущего объекта.\r\n",
    "\r\n",
    "## Строковое представление\r\n",
    "\r\n",
    "Подробнее рассмотрим специальные методы для управления строковым\r\n",
    "представлением объекта.\r\n",
    "\r\n",
    "Когда вы пытаетесь распечатать в консоли экземпляр какого-либо класса,\r\n",
    "то, скорее всего, получите неудовлетворительный результат. По умолчанию\r\n",
    "выводится только строка, содержащая имя класса и его уникальный\r\n",
    "идентификатор."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "source": [
    "class Point:\r\n",
    "    def __init__(self, x, y) -> None:\r\n",
    "        self.x = x\r\n",
    "        self.y = y\r\n",
    "\r\n",
    "point = Point(0, 0)\r\n",
    "print(f'{point = }')"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "point = <__main__.Point object at 0x0000014B8478B640>\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "Для более удобно представления объекта в виде строки существуют\r\n",
    "дандер-методы `__repr__` и `__str__`. Метод `__str__` используется при\r\n",
    "распечатке объекта через функцию `print` и `str` и предназначен для\r\n",
    "восприятия человеком, т.е. его результат должен быть в первую очередь\r\n",
    "удобочитаемым."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "source": [
    "class Point:\r\n",
    "    def __init__(self, x, y) -> None:\r\n",
    "        self.x = x\r\n",
    "        self.y = y\r\n",
    "    \r\n",
    "    def __str__(self):\r\n",
    "        return f'({self.x}, {self.y})'\r\n",
    "\r\n",
    "point = Point(0, 0)\r\n",
    "print(point)\r\n",
    "print(f'{str(point) = }')"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "(0, 0)\n",
      "str(point) = '(0, 0)'\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "В случае с методом `__repr__` идея состоит в том, что его результат\r\n",
    "должен быть, прежде всего, однозначным. Его результат в основном\r\n",
    "используется разработчиками и для отладки. При реализации этого метода\r\n",
    "стоит ориентироваться на то, чтобы его результат можно было скопировать\r\n",
    "и вставить в консоль и исполнить как фрагмент Python кода, который\r\n",
    "вернет объект нужного класса. Также для этого метода есть специальная\r\n",
    "функция `repr()`. Этот метод используется в f-строках. "
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "source": [
    "class Point:\r\n",
    "    def __init__(self, x, y) -> None:\r\n",
    "        self.x = x\r\n",
    "        self.y = y\r\n",
    "    \r\n",
    "    def __str__(self):\r\n",
    "        return f'({self.x}, {self.y})'\r\n",
    "    \r\n",
    "    def __repr__(self):\r\n",
    "        return f'{self.__class__.__name__}({self.x}, {self.y})'\r\n",
    "\r\n",
    "point = Point(0, 0)\r\n",
    "print(point)\r\n",
    "print(f'{str(point) = }')\r\n",
    "print(f'{point = }')"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "(0, 0)\n",
      "str(point) = '(0, 0)'\n",
      "point = Point(0, 0)\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "Методы `__repr__` и `__str__` имеют еще некоторые различия, с которыми\r\n",
    "можно ознакомиться в документации. В заключение стоит порекомендовать\r\n",
    "реализовывать хотя бы метод `__repr__` в своих классах, даже если он не\r\n",
    "будет восстанавливать полное состояние объекта. Даже если опустить\r\n",
    "реализацию `__str__`, то при его отсутствии будет вызван `__repr__`."
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Создание экземпляра\r\n",
    "\r\n",
    "Создание экземпляра происходит в момент выполнения инструкции\r\n",
    "`obj = Class()`. В Python создание экземпляра происходит в два шага.\r\n",
    "Первым происходит создание непосредственно объекта экземпляра заданного\r\n",
    "класса, после чего этот экземпляр инициализируется. Рассмотрим подробнее\r\n",
    "эти шаги.\r\n",
    "\r\n",
    "За создание нового объекта отвечает метод `__new__`. Этот метод\r\n",
    "статический, это говорит о том, что первым аргументом он принимает\r\n",
    "объект класса, однако применять соответствующий декоратор не требуется.\r\n",
    "Он первым вызывается при исполнении инструкции `obj = Class()`.\r\n",
    "Результатом выполнения `__new__` должен быть объект, обычно типа\r\n",
    "`Class`. Следом за методом создания объекта экземпляра, но до\r\n",
    "возвращения нового экземпляра пользователю, вызывается метод `__init__`,\r\n",
    "который отвечает за инициализацию атрибутов экземпляра. Он является\r\n",
    "методом экземпляра и первым аргументом принимает объект экземпляра.\r\n",
    "Метод `__init__` возвращает `None`, любой отличный результат выполнения\r\n",
    "будет порождать исключение `TypeError`. Рассмотрим на примере."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "source": [
    "class Mayuri:\r\n",
    "    def __new__(cls):\r\n",
    "        print('Сотрудник лабораториии 002')\r\n",
    "        return super().__new__(cls)\r\n",
    "    \r\n",
    "    def __init__(self):\r\n",
    "        print('tutturu')\r\n",
    "\r\n",
    "\r\n",
    "mayuri = Mayuri()"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Сотрудник лабораториии 002\n",
      "tutturu\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "Здесь при создании экземпляра `mayuri = Mayuri()` происходит сначала\r\n",
    "вызов сначала `__new__`, затем `__init__`, что можно увидеть при выводе\r\n",
    "сообщений. По своей сути конструкция `mayuri = Mayuri()` будет\r\n",
    "эквивалентна:"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "source": [
    "mayuri = Mayuri.__new__(Mayuri)\r\n",
    "mayuri.__init__()"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Сотрудник лабораториии 002\n",
      "tutturu\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "В большинстве случаев вам не нужно переопределять метод `__new__`.\r\n",
    "В основном он нужен, когда вы хотите контролировать непосредственно\r\n",
    "создание экземпляра, например, при реализации неизменяемых типов\r\n",
    "(`str`, `int` и другие), а также различных паттернов, например,\r\n",
    "синглтон (одиночка). Ниже привиден пример такого шаблона.\r\n",
    "\r\n",
    "Суть этого шаблона в том, что мы переопределяем метод `__new__` для\r\n",
    "проверки того, был ли создан экземпляр. В случае, если ранее экземпляр\r\n",
    "уже создавался, повторного создания не происходит, а возвращается тот же\r\n",
    "объект. Это удобно, когда в процессе работы программы нужно работать с\r\n",
    "одним экземпляром, а хранить его в дополнительной переменной не очень\r\n",
    "удобно."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "source": [
    "class Singleton:\r\n",
    "    # атрибут для хранения экземпляра\r\n",
    "    # определим его как \"приватный\" по стандарту именования\r\n",
    "    __instance = None\r\n",
    "\r\n",
    "    def __new__(cls, *args, **kwargs):\r\n",
    "        # проверяем был ли создан экземпляр ранее\r\n",
    "        if not cls.__instance:\r\n",
    "            # если нет, создаем новый и запоминаем\r\n",
    "            cls.__instance = object.__new__(cls, *args, **kwargs)\r\n",
    "        # возвращаем сохраненный экземпляр\r\n",
    "        return cls.__instance\r\n",
    "\r\n",
    "\r\n",
    "s1 = Singleton()\r\n",
    "s2 = Singleton()\r\n",
    "print(f'{s1 is s2 = }')"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "s1 is s2 = True\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "Обычно переопределять метод `__new__` не принято, но иногда это\r\n",
    "требуется, если вы пишете API или модифицируете создание классов или\r\n",
    "экземпляров или абстрагируете что-либо с помощью классов.\r\n",
    "\r\n",
    "Интересное применение метода `__new__` можно найти в фреймворке Django,\r\n",
    "например, в\r\n",
    "[реализации модели (Осторожно! Необъяснимая магия!)](https://github.com/django/django/blob/ee46722cb9c860abec4d370adff052d0c1622d34/django/db/models/base.py#L72)"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Поиск атрибутов\r\n",
    "\r\n",
    "Многие люди, переходящие на Python с других языков, жалуются, что ему не\r\n",
    "хватает истинной инкапсуляции для классов; то есть невозможно определить\r\n",
    "частные атрибуты с помощью общедоступных методов (геттеров и сеттеров).\r\n",
    "На самом деле это не так. Python выполняет большую часть инкапсуляции\r\n",
    "с помощью «магии», а не явных модификаторов для методов или атрибутов.\r\n",
    "Одним из таких инструментов является механизм свойств о котором мы\r\n",
    "поговорим в следующих главах. Сейчас же рассмотрим более глубогий или\r\n",
    "\"магичествие\" методы управление поиском и доступом к атрибутам.\r\n",
    "\r\n",
    "Для поиска и получения доступа к атрибутам в Python предусмотрен ряд\r\n",
    "магических метов:\r\n",
    "- `__getattr__(self, name)`\r\n",
    "- `__setattr__(self, name, value)`\r\n",
    "- `__delattr__(self, name)`\r\n",
    "- `__getattribute__(self, name)`\r\n",
    "\r\n",
    "Рассмотрим их более подробно. В примере класс `HolyGrail` содержит\r\n",
    "только один атрибут с установленным значением. Магические методы, он\r\n",
    "унаследовал от базового класса `object`, поэтому их поведение\r\n",
    "стандартно. При обращении к атрибуту `shrubbery` будет возвращено его\r\n",
    "значение, а обращение к несуществующим атрибам будет вызывать\r\n",
    "исключение `AttributeError`."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "source": [
    "class HolyGrail:\r\n",
    "    def __init__(self):\r\n",
    "        self.shrubbery = 1\r\n",
    "\r\n",
    "hg = HolyGrail()\r\n",
    "print(f'{hg.shrubbery = }')\r\n",
    "print(f'{hg.holy_hand_grenade = }')"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "hg.shrubbery = 1\n"
     ]
    },
    {
     "output_type": "error",
     "ename": "AttributeError",
     "evalue": "'HolyGrail' object has no attribute 'holy_hand_grenade'",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-13-cb8ca860106a>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      5\u001b[0m \u001b[0mhg\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mHolyGrail\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      6\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34mf'{hg.shrubbery = }'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 7\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34mf'{hg.holy_hand_grenade = }'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m: 'HolyGrail' object has no attribute 'holy_hand_grenade'"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "Добавим к этому кассу метод `__getattr__`. Он отвечает за поиск\r\n",
    "атрибутов, которые еще не были объявлены. Python будет неявно вызывать\r\n",
    "метод `__getattr__` всякий раз, когда вы запросите атрибут, который еще\r\n",
    "не был определен. В Python есть аналог этого метода в виде функции\r\n",
    "`getattr(object, name, default)`, которая под копотом вызывает\r\n",
    "`__getattr__`, но дополнительно умеет возвращать значение по умолчанию.\r\n",
    "\r\n",
    "В примере мы переопределили этот метод и реализовали\r\n",
    "автоматическое добавление запрашиваемых атрибутов со значением по\r\n",
    "умолчанию. Обратите внимание, что при обращении к атрибуту `shrubbery`\r\n",
    "и повторному обращению к `holy_hand_grenade` метод `__getattr__`\r\n",
    "вызываться не будет."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "source": [
    "class HolyGrail:\r\n",
    "    def __init__(self):\r\n",
    "        self.shrubbery = 1\r\n",
    "\r\n",
    "    def __getattr__(self, name):\r\n",
    "        default_value = 42\r\n",
    "        print(f'Попытка доступа к атрибуту {name}')\r\n",
    "        if name not in self.__dict__:\r\n",
    "            self.__dict__[name] = default_value\r\n",
    "        return default_value\r\n",
    "\r\n",
    "\r\n",
    "hg = HolyGrail()\r\n",
    "print(f'{hg.holy_hand_grenade = }')\r\n",
    "print(f'{hg.__dict__ = }')\r\n",
    "print(f'{hg.shrubbery = }')"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Попытка доступа к атрибуту holy_hand_grenade\n",
      "hg.holy_hand_grenade = 42\n",
      "hg.__dict__ = {'shrubbery': 1, 'holy_hand_grenade': 42}\n",
      "hg.shrubbery = 1\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "Если метод `__getattr__` вызывается при попытке чтения атрибута, то\r\n",
    "метод `__setattr__(self, name, value)` нужен для записи, т.е.\r\n",
    "вызывается в момент исполнения инструкции `obj.name = value`. Этот\r\n",
    "метод также вызывается неявно и имеет аналог в виде функции\r\n",
    "`setattr(object, name, value)`.\r\n",
    "\r\n",
    "Пример демонстрирует простейшую реализацию такого метода. Обратите\r\n",
    "внимание, что метод `__setattr__` вызывается и при создании атрбутов в\r\n",
    "методе `__init__`. Будте аккуратны с использованием этих методов, так\r\n",
    "как довольно легко получить бесконечную рекурсию."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "source": [
    "class HolyGrail:\r\n",
    "    def __init__(self):\r\n",
    "        self.shrubbery = 1\r\n",
    "\r\n",
    "    def __setattr__(self, name, value):\r\n",
    "        self.__dict__[name] = value\r\n",
    "        print(f'Атрибут {name} добавлен со значением {value}')\r\n",
    "\r\n",
    "\r\n",
    "hg = HolyGrail()\r\n",
    "print(f'{hg.__dict__ = }')\r\n",
    "\r\n",
    "hg.holy_hand_grenade = 42\r\n",
    "print(f'{hg.holy_hand_grenade = }')\r\n",
    "print(f'{hg.__dict__ = }')"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Атрибут shrubbery добавлен со значением 1\n",
      "hg.__dict__ = {'shrubbery': 1}\n",
      "Атрибут holy_hand_grenade добавлен со значением 42\n",
      "hg.holy_hand_grenade = 42\n",
      "hg.__dict__ = {'shrubbery': 1, 'holy_hand_grenade': 42}\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "Метод `__delattr__(self, name)` предназначен для модификации процесса\r\n",
    "удаления атрибута и вызывается при использовании конструкции\r\n",
    "`del obj.name`.\r\n",
    "\r\n",
    "В Python предоставляются гибкие возможности управления доступом, об этом\r\n",
    "говорит наличие еще одного метода для обращения к атрибутам\r\n",
    "`__getattribute__(self, name)`. В общих чертах его суть аналогична\r\n",
    "методу `__getattr__`. Однако есть ряд существенных отличий.\r\n",
    "\r\n",
    "Если класс реализует метод `__getattribute__`, Python вызывает этот\r\n",
    "метод для каждого атрибута независимо от того, существует он или нет.\r\n",
    "В этом и заключается его отличие от `__getattr__`. Одним из применениев\r\n",
    "этого метода является контроль доступа к атрибутам класса, т.е.\r\n",
    "реализация своего сокрятия.\r\n",
    "\r\n",
    "Реализуем эту возможность для класса `HolyGrail`. Будем считать все\r\n",
    "атрибуты, начинающиеся с префикса `'holy_'` приватными, и запретим к\r\n",
    "ним доступ из вне."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "source": [
    "class HolyGrail:\r\n",
    "    def __init__(self):\r\n",
    "        self.shrubbery = 1\r\n",
    "        self.holy_hand_grenade = 42\r\n",
    "\r\n",
    "    def __getattribute__(self, name: str):\r\n",
    "        prefix = 'holy_'\r\n",
    "        if name.startswith(prefix):\r\n",
    "            raise AttributeError(f'Объект {self} не имеет атрибута {name}')\r\n",
    "        return super().__getattribute__(name)\r\n",
    "\r\n",
    "hg = HolyGrail()\r\n",
    "print(f'{hg.shrubbery = }')\r\n",
    "print(f'{hg.holy_hand_grenade = }')"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "hg.shrubbery = 1\n"
     ]
    },
    {
     "output_type": "error",
     "ename": "AttributeError",
     "evalue": "Объект <__main__.HolyGrail object at 0x0000014B84DC8E50> не имеет атрибута holy_hand_grenade",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-22-461127dc3557>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m     12\u001b[0m \u001b[0mhg\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mHolyGrail\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     13\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34mf'{hg.shrubbery = }'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 14\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34mf'{hg.holy_hand_grenade = }'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;32m<ipython-input-22-461127dc3557>\u001b[0m in \u001b[0;36m__getattribute__\u001b[1;34m(self, name)\u001b[0m\n\u001b[0;32m      7\u001b[0m         \u001b[0mprefix\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34m'holy_'\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      8\u001b[0m         \u001b[1;32mif\u001b[0m \u001b[0mname\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mstartswith\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mprefix\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 9\u001b[1;33m             \u001b[1;32mraise\u001b[0m \u001b[0mAttributeError\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34mf'Объект {self} не имеет атрибута {name}'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m     10\u001b[0m         \u001b[1;32mreturn\u001b[0m \u001b[0msuper\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m__getattribute__\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mname\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     11\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mAttributeError\u001b[0m: Объект <__main__.HolyGrail object at 0x0000014B84DC8E50> не имеет атрибута holy_hand_grenade"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "Обратите внимание, что после проверки мы переиспользуем реализацию\r\n",
    "метода `__getattribute__` родителя класса. Этот момент очень важен для\r\n",
    "безопасного использования этого метода, иначе легко получить\r\n",
    "бесконечную рекурсию.\r\n",
    "\r\n",
    "Если класс реализует оба метода `__getattribute__` и `__getattr__`, то\r\n",
    "первым будет вызван `__getattribute__`. Если он вернет исключение\r\n",
    "`AttributeError`, то оно будет подавлено и будет вызван метод\r\n",
    "`__getattr__`."
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Операторы сравнения\r\n",
    "\r\n",
    "В Python все операции реализованы с помощью магических методов. Операции\r\n",
    "сравнения не исключение. Каждый класс может реализовать следующий набор\r\n",
    "методов для поддержки всех возможных операций сравнения:\r\n",
    "- `__eq__(self, other)` - оператор `==`\r\n",
    "- `__ne__(self, other)` - оператор `!=`\r\n",
    "- `__lt__(self, other)` - оператор `<`\r\n",
    "- `__gt__(self, other)` - оператор `>`\r\n",
    "- `__le__(self, other)` - оператор `<=`\r\n",
    "- `__ge__(self, other)` - оператор `>=`\r\n",
    "\r\n",
    "Для упрощения реализации всех этих методов существует декоратор класса\r\n",
    "`functools.total_ordering`. На основании метода `__eq__` и одного из\r\n",
    "методов `__lt__`, `__le__`, `__gt__`, или `__ge__`, реализованных в\r\n",
    "классе, он автоматически реализует все остальные методы."
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Арифметические операторы и не только\r\n",
    "\r\n",
    "- `__invert__(self)` - оператор `~` инвертирования знака\r\n",
    "- `__neg__(self)` - унарный минус\r\n",
    "- `__pos__(self)` - унарный плюс\r\n",
    "- `__round__(self, n)` - округление с помощью функции `round()`\r\n",
    "- `__add__(self, other)` - сложение\r\n",
    "- `__radd__(self, other)` - правое сложение\r\n",
    "- `__sub__(self, other)` - вычитание\r\n",
    "- `__mul__(self, other)` - умножение\r\n",
    "- `__rmul__(self, other)` - правое умножение\r\n",
    "- `__div__(self, other)` - деление\r\n",
    "- `__mod__(self, other)` - оператор `%` остатка от деления\r\n",
    "- `__or__(self, other)` - логический оператор `|`\r\n",
    "- `__abs__` - модуль числа, функция `abs()`\r\n",
    "\r\n",
    "Поддержка классом таких методов является реализацией протокола числа,\r\n",
    "речь о которых пойдет в следующей главе.\r\n",
    "Подробнее о таких методах читайте в\r\n",
    "[документации](https://docs.python.org/3/reference/datamodel.html#emulating-numeric-types)"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Копирование\r\n",
    "\r\n",
    "- `__copy__` - используется функцией `copy()` из модуля `copy`\r\n",
    "- `__deepcopy` - используется функцией `deepcopy()` из модуля `copy`"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Другие полезные \"магические\" методы\r\n",
    "\r\n",
    "- `__call__` - оператор круглые скобки\r\n",
    "- `__contains__` - оператор `in`\r\n",
    "- `__bool__` - преобразоание объекта в тип `bool`\r\n",
    "- `__hash__` - вычисление хеша"
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "# Полезные ссылки\r\n",
    "\r\n",
    "- [Официальная документация о методе `__init__`](https://docs.python.org/3/reference/datamodel.html#object.__new__)\r\n",
    "- [Unifying types and classes in Python 2.2](https://www.python.org/download/releases/2.2/descrintro/)\r\n",
    "- [Why is `__init__()` always called after `__new__()`?](https://stackoverflow.com/questions/674304/why-is-init-always-called-after-new)\r\n",
    "- [Зачем нужен `__new__` и каково его практическое применение?](https://ru.stackoverflow.com/questions/1025187/%D0%97%D0%B0%D1%87%D0%B5%D0%BC-%D0%BD%D1%83%D0%B6%D0%B5%D0%BD-new-%D0%B8-%D0%BA%D0%B0%D0%BA%D0%BE%D0%B2%D0%BE-%D0%B5%D0%B3%D0%BE-%D0%BF%D1%80%D0%B0%D0%BA%D1%82%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%BE%D0%B5-%D0%BF%D1%80%D0%B8%D0%BC%D0%B5%D0%BD%D0%B5%D0%BD%D0%B8%D0%B5)\r\n",
    "- [When to use `__new__` vs. `__init__`?](https://mail.python.org/pipermail/tutor/2008-April/061426.html)\r\n",
    "- [В двух словах о том, как работают метаклассы](https://twitter.com/1st1/status/1160956824822194178)\r\n",
    "- [Python: `__new__` magic method explained](https://howto.lintel.in/python-__new__-magic-method-explained/)\r\n",
    "- [Инстанцирование в Python](https://habr.com/ru/post/480022/)\r\n",
    "- [`functools.total_ordering`](https://docs.python.org/3/library/functools.html)\r\n",
    "- [A Guide to Python's Magic Methods](https://rszalski.github.io/magicmethods/)\r\n",
    "- [Difference between `__getattr__` vs `__getattribute__`](https://stackoverflow.com/questions/3278077/difference-between-getattr-vs-getattribute)\r\n",
    "- [Пользовательские атрибуты в Python](https://habr.com/ru/post/137415/)\r\n"
   ],
   "metadata": {}
  }
 ]
}