Another_copy_of_ООП_питон.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/Sinrez/PythonProjects/blob/main/Another_copy_of_%D0%9E%D0%9E%D0%9F_%D0%BF%D0%B8%D1%82%D0%BE%D0%BD.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "m0fMdvd6HlhA"
      },
      "source": [
        "# Занятие 5. Объектно-ориентированное программирование в Python\n"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Что такое ООП?"
      ],
      "metadata": {
        "id": "vXAtu9f16Fx1"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Парадигма программирования** — совокупность идей и понятий, определяющих стиль написания компьютерных программ (подход к программированию).\n",
        "\n",
        "*NOTE: Есть запись вебинара по питону прошлого года с презентацией и более поверхностным описанием именно ООП, она будет в файлах записи соответствующего занятия. Это дополнительный материал который полностью покрывается в курсе, поэтому рекомендую его в случае если некоторые семантики не понятны и нужно чуть более простое объяснение идей ООП.*\n"
      ],
      "metadata": {
        "id": "qzJYg59S6yLI"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Парадигмы программирования:**\n",
        "- **императивное программирование** - последовательность команд, которые выполняются одна за другой\n",
        "- **процедурное программирование** - создание процедур и функций для сокращения дублирования кода\n",
        "- **декларативное программирование** - фокус на то \"что\" должна делать программа, а не \"как\" (примерно как SQL)\n",
        "- **функциональное программирование** - разбиение программы на функции, выход одной функции - выход другой\n",
        "- **структурное программирование** - веха в области программирования, структурировали основные элементы написания программ - последовательность, ветвление (if/else), цикл while, подпрограммы (функции)\n",
        "- **объектно-ориентированное программирование**"
      ],
      "metadata": {
        "id": "Xkuyxigi7sGw"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Объектно-ориентированное программирование** - парадигма программирования, основанная на представлении программы в виде совокупности взаимодействующих объектов со своими свойствами и поведениями, каждый из которых является экземпляром определённого класса, которые образуют иерархию наследования.\n",
        "\n",
        "**Основные термины в ООП:**\n",
        "- Класс\n",
        "- Объекты\n",
        "- Абстракция\n",
        "- Инкапсуляция\n",
        "- Наследование\n",
        "- Полиморфизм\n",
        "\n",
        "\n",
        "\n"
      ],
      "metadata": {
        "id": "px2ehBfw-KLf"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Объекты и классы"
      ],
      "metadata": {
        "id": "BMC8KSIf8B0T"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Основная идея ООП - выделить в программе отдельные сущности - объекты.\n",
        "\n",
        "**Примеры объектов из реальной жизни** - стол, чашка, человек, книга, здание и т.д.\n",
        "**Примеры объектов в программах** - пользователь, кнопка, сообщение.\n",
        "\n",
        "У объектов могут быть свои свойства, например, цвет, содержание или имя пользователя. Такие переменные (конкретные характеристики объекта) называются **атрибутами**.\n",
        "\n",
        "Возможные действия, например, \"отправить сообщение\", \"нанять сотрудника\", \"нажать кнопку\", называются **методами**. Это функции, которые описаны внутри объекта или класса. Они относятся к определенному объекту и позволяют взаимодействовать с ними или другими частями кода.\n",
        "\n",
        "Чтобы не создавать для каждого отдельного объекта свои методы (переиспользование кода), существуют классы.\n",
        "**Класс** — это «шаблон» для объекта, который описывает его атрибуты и методы Каждый объект — это экземпляр какого-нибудь класса.\n",
        "\n",
        "**Пример** - пишем систему учета сотрудников. Создадим класс \"Сотрудник\" с атрибутами: ФИО, должность, подразделение, руководитель, зарплата; и методами: \"перевести в другой отдел\", \"повысить зарплату\", \"сменить должность\", \"уволить\". Отдельный сотрудник, Вася Пупкин, является объектом - экземпляром класса \"Сотрудник\"."
      ],
      "metadata": {
        "id": "4VM3sUmn_AXl"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Абстракция"
      ],
      "metadata": {
        "id": "hrE9HrLK_GuI"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Абстрагирование — это способ выделить набор наиболее важных атрибутов и методов и исключить незначимые. Соответственно, абстракция — это использование всех таких характеристик для описания объекта. Важно представить объект минимальным набором полей и методов без ущерба для решаемой задачи.\n",
        "\n",
        "Пример: объекту класса «программист» вряд ли понадобятся свойства «умение готовить еду» или «любимый цвет». Они не влияют на его особенности как программиста. А вот «основной язык программирования» и «рабочие навыки» — важные свойства, без которых программиста не опишешь.\n",
        "\n",
        "Набор атрибутов и методов, доступный извне, работает как интерфейс для доступа к объекту. Через них к нему могут обращаться другие структуры данных, причем им не обязательно знать, как именно объект устроен внутри.\n",
        "\n"
      ],
      "metadata": {
        "id": "Uynr0X-X_LHF"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Инкапсуляция"
      ],
      "metadata": {
        "id": "OnditD-g_Pyk"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Каждый объект — независимая структура.** Он содержит в себе все, что ему нужно для работы. Если ему нужна какая-либо переменная, она будет описана в теле объекта, а не наружном коде. Это делает объекты более гибкими. Даже если внешний код перепишут, логика работы не изменится.\n",
        "\n",
        "Инкапсуляция позволяет спрятать от внешнего кода и других объектов детали реализации того или иного метода. Другим объектам не важно (и не нужно) знать как именно объект выполняет свою задачу, главное - что выполняет :)\n",
        "\n",
        "Таким образом, внутреннее устройство одного объекта закрыто от других: извне «видны» только значения атрибутов и результаты выполнения методов."
      ],
      "metadata": {
        "id": "oVy65Crc_RJX"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Наследование"
      ],
      "metadata": {
        "id": "aUSzkku8BAJ5"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Позволяет создавать классы и объекты, которые похожи друг на друга, но немного отличаются, например, имеют дополнительные атрибуты или другие методы. Более общий класс в таком случае становится «родителем», а более специфичный и подробный — «наследником».\n",
        "\n",
        "Например, класс \"сотрудник\" может иметь наследные классы \"программист\", \"аналитик\" и \"тестировщик\", каждый из которых имеет собственные методы, например, \"запрограммировать\", \"проанализировать\", \"протестировать\", а остальные методы и атрибуты класса \"сотрудник\" будут присутствовать во всех дочерних классах. И наш Вася Пупкин будет и экземпляром класса \"сотрудник\", и класса \"программист\".\n",
        "\n",
        "У одного \"родителя\" может быть несколько дочерних классов, у одного дочернего класса может быть и несколько родительских.\n",
        "\n",
        "Наследование позволяет создавать сложные схемы с четкой иерархией \"от общего к частному\". Это облегчает понимание и масштабирование кода. Не нужно много раз переписывать в разных объектах одни и те же свойства. Достаточно унаследовать эти объекты от одного \"родителя\", и родительские свойства применятся автоматически."
      ],
      "metadata": {
        "id": "4OywS9aYBDFa"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Полиморфизм"
      ],
      "metadata": {
        "id": "oOrMvc2RDck9"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Одинаковые методы разных классов могут выполнять задачи разными способами. Например, у \"сотрудника\" есть метод \"работать\". У \"программиста\" реализация этого метода будет означать написание кода, а у \"тестировщика\" — рассмотрение управленческих вопросов. Но глобально и то, и другое будет работой.\n",
        "\n",
        "Тут важны единый подход и договоренности между специалистами. Если метод называется delete, то он должен что-то удалять. Как именно — зависит от объекта, но заниматься такой метод должен именно удалением. Более того: если оговорено, что «удаляющий» метод называется delete, то не нужно для какого-то объекта называть его remove или иначе. Это вносит путаницу в код."
      ],
      "metadata": {
        "id": "gknaFCIADc7d"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---"
      ],
      "metadata": {
        "id": "Czcfs6ui_0yE"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qUsPA2zh8tvc"
      },
      "source": [
        "# ООП в Python"
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Объявление класса и экземпляра"
      ],
      "metadata": {
        "id": "nYKt3cfpOqMG"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "В Python объявление класса выполняется следующим образом:"
      ],
      "metadata": {
        "id": "dzJYh-_ACI8B"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7mwbk4sk8tvd"
      },
      "source": [
        "class MyLittleClass(object):  # название класса и родительский класс, родительский класс по умолчанию - object, его можно и не указывать\n",
        "#class MyLittleClass:\n",
        "    # Атрибут класса\n",
        "    color = \"blue\"\n",
        "\n",
        "    # Метод\n",
        "    def set_color(self, new_color):\n",
        "        self.color = new_color\n",
        "        print('set color to', color)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Создание объекта - экземпляра класса выглядит так:"
      ],
      "metadata": {
        "id": "FvCFgvBICTi5"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xak2eN558tvf"
      },
      "source": [
        "obj = MyLittleClass()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "type(obj)"
      ],
      "metadata": {
        "id": "ICwYtCfMqvaT",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ff0b51a4-48bd-49c6-8e80-a36b4ec16351"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "__main__.MyLittleClass"
            ]
          },
          "metadata": {},
          "execution_count": 13
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "id(obj)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "YKQ8EqYBPZsv",
        "outputId": "8196a2d1-3cf5-4183-cb65-40f2057cf47a"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "140261638843040"
            ]
          },
          "metadata": {},
          "execution_count": 14
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Обращение к атрибуту экземпляра выглядит следующим образом:"
      ],
      "metadata": {
        "id": "R2JLIMiiCpia"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "obj.color"
      ],
      "metadata": {
        "id": "u6o089eZCm4h",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "269a79c3-b538-4562-a357-bf6dfab82a18"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'blue'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Вызов метода экземпляра выглядит так:"
      ],
      "metadata": {
        "id": "tUaHwCf4CuVn"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "obj.set_color('red')\n",
        "obj.color"
      ],
      "metadata": {
        "id": "H-W9CDTFCmbv"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "V_XErrJi8tvg"
      },
      "source": [
        "**Почему `color` внутри объекта не поменялся?**\n",
        "\n",
        "Потому что обращение к атрибутам класса должно иметь форму `self.attribute_name`, а `color` в методе `set_color` -- просто локальная переменная :)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-a85FGS78tvh"
      },
      "source": [
        "class MyLittleClass2:\n",
        "    color = \"blue\"\n",
        "\n",
        "    def set_color(self, new_color):\n",
        "        self.color = new_color\n",
        "        print('set color to', self.color)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ik326jQ18tvi",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "fb6b7d68-d90c-43ba-9f46-5fa557cf27ef"
      },
      "source": [
        "obj = MyLittleClass2()\n",
        "obj.color"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'blue'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 17
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "obj.set_color('red')\n",
        "obj.color"
      ],
      "metadata": {
        "id": "wDbRqmcOFGAq",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 53
        },
        "outputId": "d9492cbc-9249-425d-93d9-5bb23310c439"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "set color to red\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'red'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 18
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "`self` - ссылка на \"себя\", на экземпляр класса, для которого хотим получить значение атрибута или вызвать метод. Является первым аргументом метода и используется внутри методов."
      ],
      "metadata": {
        "id": "cnjP70NqEcEL"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Можем ли мы напрямую поменять значение атрибута экземпляра?\n",
        "\n",
        "Можем, но это считается нехорошей практикой. Предпочтительнее писать т.н. методы-геттеры (для чтения значений атрибутов) и методы-сеттеры (для записи значений атрибутов)"
      ],
      "metadata": {
        "id": "UKOPmAXnEvMG"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7HDAwT0n8tvj",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "b140325d-732a-4dba-ca92-a69d7e1352d1"
      },
      "source": [
        "obj.color = 'green'\n",
        "obj.color"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'green'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 23
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Замечание** - в Python все является объектом, даже сам класс, поэтому важно разделять методы и атрибуты экземпляров класса и самого класса:"
      ],
      "metadata": {
        "id": "edl4FNGXFLdW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "MyLittleClass2.color"
      ],
      "metadata": {
        "id": "dUyKySTlFXOG",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "e837c2b4-936b-4335-e37e-70a157e81f2b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'blue'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 24
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "MyLittleClass2().color\n",
        "# obj = MyLittleClass2().color\n",
        "# obj.color"
      ],
      "metadata": {
        "id": "So8VAVkNFYE3",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "7a97bbef-77d4-454c-a922-8a233e7336c8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'blue'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 25
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Метод-конструктор"
      ],
      "metadata": {
        "id": "g2RBsWzbO-mK"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Чтобы каждый раз не устанавливать состояние (значения аргументов) экземпляра класса, можем воспользоваться **конструктором** - особым методом, который вызывается при создании экземпляра класса:"
      ],
      "metadata": {
        "id": "Tkof5ShdPDEm"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class MyLittleClass3:\n",
        "    color = \"blue\"\n",
        "\n",
        "    def __init__(self, name=None, color=None):\n",
        "        if color:\n",
        "            self.color = color\n",
        "        if name:\n",
        "            self.name = name\n",
        "\n",
        "    def set_color(self, new_color):\n",
        "        self.color = new_color\n",
        "        print('set color to', self.color)"
      ],
      "metadata": {
        "id": "yTI69f1KPchK"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "obj = MyLittleClass3(\"Walter\", \"White\")\n",
        "obj.color\n",
        "obj.name"
      ],
      "metadata": {
        "id": "XZ26t2h4PljM",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "0b32ce97-3475-492b-d2e7-9328766e4b0d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'Walter'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 29
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "obj = MyLittleClass3(\"Walter\")\n",
        "obj.color"
      ],
      "metadata": {
        "id": "UzM8QSiQL_1z",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "d1ed8cde-66bc-4496-bcc3-2d31e1dec210"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'blue'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 30
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "obj = MyLittleClass3(color = \"White\", name = 'Walter')\n",
        "obj.color"
      ],
      "metadata": {
        "id": "llxA6DufMeP3",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "d889224a-5328-4e15-8ccc-d2a65b0cfef8"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'White'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 33
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "obj.x = 10"
      ],
      "metadata": {
        "id": "DtBZik_vQWhq"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "obj.x"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "4bK1DGmXQY8M",
        "outputId": "3bb56503-ca86-4189-bccf-f62e423d5adc"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "10"
            ]
          },
          "metadata": {},
          "execution_count": 38
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "obj.name"
      ],
      "metadata": {
        "id": "rZbQHwH3uBPp",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "fadd016d-4810-4da5-c323-819b462dde08"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'Walter'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 34
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "obj.occupation ='test'"
      ],
      "metadata": {
        "id": "dQwRFuApamOk"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "MyLittleClass3.name = \"Igor\""
      ],
      "metadata": {
        "id": "pYI38PCkLZpw"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "obj.occupation"
      ],
      "metadata": {
        "id": "RYDQFxK3uRwx",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "01944907-d82d-4e68-8245-72392436ae22"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'test'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 40
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Динамичность атрибутов"
      ],
      "metadata": {
        "id": "zGxFo74ZPplK"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PIe8Vc4X8tvk"
      },
      "source": [
        "Мы также можем динамически определить атрибуты, которых вообще не было в определении класса:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "THNbsf8_8tvl",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7e750626-6cb3-443c-e1da-bb17a2d92d3a"
      },
      "source": [
        "obj.some_attribute = 42\n",
        "obj.some_attribute"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "42"
            ]
          },
          "metadata": {},
          "execution_count": 41
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "68Z7ar6J8tvm"
      },
      "source": [
        "Поговорим об аргументе `self` в определении метода. Когда мы вызываем метод как `obj.methodname()`, неявно первым аргументом передается ссылка на `obj` в качестве аргумента `self`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uSvwudNN8tvm"
      },
      "source": [
        "class MyLittleClass4:\n",
        "    def method_without_self(arg):\n",
        "        print(arg)\n",
        "\n",
        "    def method_with_self(self, arg):\n",
        "        print(arg)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "A2qvSIra8tvm",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "0f2d33a9-8995-4d06-d424-0e2608c6d2ea"
      },
      "source": [
        "obj = MyLittleClass4()\n",
        "obj.method_with_self('i am an argument')\n",
        "# obj.method_without_self('i am another argument') # здесь мы на самом деле передаем по два аргумента, self и arg"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "i am an argument\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "K98X82Tz8tvn"
      },
      "source": [
        "Как вызвать методы без `self`? Они не привязаны к экземпляру класса (потому что не имеют доступа к его локальным данным), зато привязаны к классу:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rQqFL-2z8tvn",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "282f9fd8-83ff-4bd8-bf76-9379353a63cd"
      },
      "source": [
        "MyLittleClass4.method_without_self('i am another argument') # а здесь мы передаем только один аргумент"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "i am another argument\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "E5jKxFNQ8tvo"
      },
      "source": [
        "Поскольку все является объектом, то можно и \"оторвать\" метод от экземпляра:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GKGqoPRw8tvo",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "5882475e-32c8-4801-8c6a-5ccc32287860"
      },
      "source": [
        "func = MyLittleClass4.method_without_self\n",
        "func(\"hello\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "hello\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AyFT2kgS8tvp",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 197
        },
        "outputId": "715ca256-5d1a-4e08-a136-ad6a611a5295"
      },
      "source": [
        "func2 = MyLittleClass4.method_with_self\n",
        "func2(\"hello\") # передаем один аргумент"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "TypeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-51-f24f4c94cf25>\u001b[0m in \u001b[0;36m<cell line: 2>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mfunc2\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mMyLittleClass4\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mmethod_with_self\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mfunc2\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"hello\"\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# передаем один аргумент\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m: MyLittleClass4.method_with_self() missing 1 required positional argument: 'arg'"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Получили ошибку, т.к. не передали объект для аргумента `self`."
      ],
      "metadata": {
        "id": "TPpq6-79F72s"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "W8w9YwHh8tvp",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e9c69864-0ceb-455d-a7a6-edaa5b52acad"
      },
      "source": [
        "obj = MyLittleClass4()\n",
        "func2(obj, \"hello\")"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "hello\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gcYz4_tw8tvq"
      },
      "source": [
        "А можем и наоборот привязать существующую функцию к объекту:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pL_qjxrV8tvq",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 179
        },
        "outputId": "5160ac2e-bea8-4b74-f723-0b7871eeac34"
      },
      "source": [
        "obj.get_color()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "AttributeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-53-78f1df7c55df>\u001b[0m in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mobj\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_color\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mAttributeError\u001b[0m: 'MyLittleClass4' object has no attribute 'get_color'"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tK0Tt1gf8tvr"
      },
      "source": [
        "def get_color_function(self):\n",
        "    return self.color"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "MyLittleClass4.get_color = get_color_function\n",
        "obj = MyLittleClass4()\n",
        "#obj.get_color()"
      ],
      "metadata": {
        "id": "1c5UXM1DGM-e"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ld9rbN5t8tvr"
      },
      "source": [
        "Ах да, цвета-то у нас нет. Не проблема - добавим атрибут `color` к экземпляру?"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ipimnuWx8tvr",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "fe18bbce-6b5b-42b6-bfac-0ca3669990ec"
      },
      "source": [
        "obj.color = 'pink'\n",
        "obj.get_color()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'pink'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 56
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Но сейчас атрибут `color` есть только у объекта `obj`, создадим новый объект и посмотрим есть ли у него атрибут `color`:"
      ],
      "metadata": {
        "id": "NrHb_ABjRIX-"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DIWap6XsGBKn",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 268
        },
        "outputId": "4252232e-0e32-4179-bf5f-fb0a2f5bdcb7"
      },
      "source": [
        "obj2 = MyLittleClass4()\n",
        "obj2.get_color()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "AttributeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-57-9cd63bb3ffb8>\u001b[0m in \u001b[0;36m<cell line: 2>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0mobj2\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mMyLittleClass4\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mobj2\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mget_color\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;32m<ipython-input-54-609aef6711c8>\u001b[0m in \u001b[0;36mget_color_function\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mget_color_function\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m     \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mcolor\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mAttributeError\u001b[0m: 'MyLittleClass4' object has no attribute 'color'"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Нужно добавить атрибут не к одному экземпляру класса, а ко всему классу:"
      ],
      "metadata": {
        "id": "2cDbGDkwGVh-"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "p_-Yi9W1GKoU",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "5e2d6506-0116-4678-d25a-9c772a438e6b"
      },
      "source": [
        "MyLittleClass4.color = 'green'\n",
        "obj3 = MyLittleClass4()\n",
        "obj3.get_color()"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'green'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 58
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yyUbYFSzI-iI",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "e2b0ab7b-e458-49eb-cd06-5986654eb7bb"
      },
      "source": [
        "obj3.color == MyLittleClass4.color"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "True"
            ]
          },
          "metadata": {},
          "execution_count": 59
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "obj.color"
      ],
      "metadata": {
        "id": "eYrAwfYzxZIS",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "9390d7c0-7da9-4a11-9f2c-da699a0a8765"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'pink'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 60
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "obj2.color"
      ],
      "metadata": {
        "id": "G-vC6P_oxeQh",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "0eb335ea-5d43-4ebc-b955-6ee09f1b87b7"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'green'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 61
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Функция `dir`"
      ],
      "metadata": {
        "id": "YkIi1KOXGdi0"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "n9Sf-XUO8tvs"
      },
      "source": [
        "Чтобы посмотреть методы и атрибуты любого объекта, можно воспользоваться функцией `dir`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ExBy9Dni8tvs",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "70ad890c-375a-41c0-9c86-ec6325d48a09"
      },
      "source": [
        "print(dir(obj3))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'color', 'get_color', 'method_with_self', 'method_without_self']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wMQGxhIpHral",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d68b401a-b12b-421b-9223-ebaec31b0d74"
      },
      "source": [
        "print(dir(MyLittleClass4))"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'color', 'get_color', 'method_with_self', 'method_without_self']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "obj3.extra = 17"
      ],
      "metadata": {
        "id": "synIfJ5GzED9"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(dir(obj3))"
      ],
      "metadata": {
        "id": "mpapyIzyzHJk",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "685ea9a3-1f74-4fbe-ed40-3e14db804a6c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'color', 'extra', 'get_color', 'method_with_self', 'method_without_self']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(dir(MyLittleClass4))"
      ],
      "metadata": {
        "id": "FUeS7Zy_zIM5",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "50a544fb-26f3-4f36-9bc4-063702249eae"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'color', 'get_color', 'method_with_self', 'method_without_self']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Чтобы оставить только методы в выдаваемом списке, воспользуемся функцией `getattr` (для получения занчения атрибута по переменной) и функцией `callable` (проверяет можем ли \"вызвать\" объект как функцию):"
      ],
      "metadata": {
        "id": "KtMf5FfZGkt-"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZdI_fHiW8tvs",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7e783b97-f606-44c1-936f-8f8500ff9689"
      },
      "source": [
        "print([name for name in dir(obj) if not callable(getattr(obj, name))])"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['__dict__', '__doc__', '__module__', '__weakref__', 'color']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "callable(obj3.color)"
      ],
      "metadata": {
        "id": "vGwI4MKJzoZs",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "f89a06aa-340c-4720-bd99-3949697994bc"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {},
          "execution_count": 68
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "dir(obj3.color)"
      ],
      "metadata": {
        "id": "Ehe7y7YlzuOC",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "46454e5a-781e-4727-9fa2-3049f5926d53"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "['__add__',\n",
              " '__class__',\n",
              " '__contains__',\n",
              " '__delattr__',\n",
              " '__dir__',\n",
              " '__doc__',\n",
              " '__eq__',\n",
              " '__format__',\n",
              " '__ge__',\n",
              " '__getattribute__',\n",
              " '__getitem__',\n",
              " '__getnewargs__',\n",
              " '__gt__',\n",
              " '__hash__',\n",
              " '__init__',\n",
              " '__init_subclass__',\n",
              " '__iter__',\n",
              " '__le__',\n",
              " '__len__',\n",
              " '__lt__',\n",
              " '__mod__',\n",
              " '__mul__',\n",
              " '__ne__',\n",
              " '__new__',\n",
              " '__reduce__',\n",
              " '__reduce_ex__',\n",
              " '__repr__',\n",
              " '__rmod__',\n",
              " '__rmul__',\n",
              " '__setattr__',\n",
              " '__sizeof__',\n",
              " '__str__',\n",
              " '__subclasshook__',\n",
              " 'capitalize',\n",
              " 'casefold',\n",
              " 'center',\n",
              " 'count',\n",
              " 'encode',\n",
              " 'endswith',\n",
              " 'expandtabs',\n",
              " 'find',\n",
              " 'format',\n",
              " 'format_map',\n",
              " 'index',\n",
              " 'isalnum',\n",
              " 'isalpha',\n",
              " 'isascii',\n",
              " 'isdecimal',\n",
              " 'isdigit',\n",
              " 'isidentifier',\n",
              " 'islower',\n",
              " 'isnumeric',\n",
              " 'isprintable',\n",
              " 'isspace',\n",
              " 'istitle',\n",
              " 'isupper',\n",
              " 'join',\n",
              " 'ljust',\n",
              " 'lower',\n",
              " 'lstrip',\n",
              " 'maketrans',\n",
              " 'partition',\n",
              " 'removeprefix',\n",
              " 'removesuffix',\n",
              " 'replace',\n",
              " 'rfind',\n",
              " 'rindex',\n",
              " 'rjust',\n",
              " 'rpartition',\n",
              " 'rsplit',\n",
              " 'rstrip',\n",
              " 'split',\n",
              " 'splitlines',\n",
              " 'startswith',\n",
              " 'strip',\n",
              " 'swapcase',\n",
              " 'title',\n",
              " 'translate',\n",
              " 'upper',\n",
              " 'zfill']"
            ]
          },
          "metadata": {},
          "execution_count": 69
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Переопределение класса"
      ],
      "metadata": {
        "id": "I3GbBdJJHXiX"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Что будет, если сначала создадим экземпляр класса, а затем переопределим его атрибут? Проверим:"
      ],
      "metadata": {
        "id": "ztBSh3HCG90b"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_4f7_qoPJ_yG"
      },
      "source": [
        "class MCLS:\n",
        "    attr1 = 'hello'"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "obj = MCLS()\n",
        "obj.attr1"
      ],
      "metadata": {
        "id": "W7Q1a3J_HL7m",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "f8750907-e302-45b1-b4c5-12d4a1b413cc"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'hello'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 71
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "MCLS.attr1 = \"Hola!\"\n",
        "obj.attr1"
      ],
      "metadata": {
        "id": "9OTegEor03_c",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "072fb688-ee97-4aeb-e612-c2f489fcd44e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'Hola!'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 72
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "class MCLS:\n",
        "    attr1 = 'bye'"
      ],
      "metadata": {
        "id": "NqWY4uXvHLUH"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "obj2 = MCLS()\n",
        "obj2.attr1"
      ],
      "metadata": {
        "id": "eYIHqR-uHPRX",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "64bf4f15-ec1d-4856-d5c0-ea5b82f37d99"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'bye'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 74
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "obj.attr1"
      ],
      "metadata": {
        "id": "OZwq0aW7HSFq",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "937d2d8b-fe23-4a97-9053-1af927023c32"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'Hola!'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 75
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "obj.__class__.attr1 = \"Aloha\""
      ],
      "metadata": {
        "id": "EyideOfM1rFi"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "obj.attr1"
      ],
      "metadata": {
        "id": "dfJ5x-8V1vaJ",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "51c0de70-f98e-4c9b-af23-2035bd8b7153"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'Aloha'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 77
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "MCLS = obj.__class__"
      ],
      "metadata": {
        "id": "M2aGhaf71zS6"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "del obj.__class__"
      ],
      "metadata": {
        "id": "cKIes-bq2U5j",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 179
        },
        "outputId": "9eee7e61-e53f-4fa4-cc6a-9e1eea23b91c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "TypeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-79-5dcea0709618>\u001b[0m in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;32mdel\u001b[0m \u001b[0mobj\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__class__\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m: can't delete __class__ attribute"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Методы и атрибуты по умолчанию"
      ],
      "metadata": {
        "id": "AaACvqbHHa3O"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Посмотрим какие методы и атрибуты создаются для класса и экземпляра по умолчанию. Для этого нам поможет функция `dir`:"
      ],
      "metadata": {
        "id": "ag-KQS8YU1fR"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FoaK__4b8tvt",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "12f3d36a-7218-4fa8-f50f-c171e86db069"
      },
      "source": [
        "help(dir)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Help on built-in function dir in module builtins:\n",
            "\n",
            "dir(...)\n",
            "    dir([object]) -> list of strings\n",
            "    \n",
            "    If called without an argument, return the names in the current scope.\n",
            "    Else, return an alphabetized list of names comprising (some of) the attributes\n",
            "    of the given object, and of attributes reachable from it.\n",
            "    If the object supplies a method named __dir__, it will be used; otherwise\n",
            "    the default dir() logic is used and returns:\n",
            "      for a module object: the module's attributes.\n",
            "      for a class object:  its attributes, and recursively the attributes\n",
            "        of its bases.\n",
            "      for any other object: its attributes, its class's attributes, and\n",
            "        recursively the attributes of its class's base classes.\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Создадим \"пустой\" класс:"
      ],
      "metadata": {
        "id": "NzJmlYEBH2H8"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5Vx7Lsxn8tvt"
      },
      "source": [
        "#class ClassWithNothing(object):\n",
        "class ClassWithNothing:\n",
        "    pass"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Создаем экземпляра \"пустого\" класса:"
      ],
      "metadata": {
        "id": "XBnN6ObkIEID"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "nobject = ClassWithNothing()"
      ],
      "metadata": {
        "id": "34P9XLQDHgY8"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Напишем простую функцию для вывода атрибутов и методов:"
      ],
      "metadata": {
        "id": "3_xKLnSdIIPV"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "def print_custom_attrs(obj=None):\n",
        "    if obj is None:\n",
        "        # в локальной области видимости!\n",
        "        attrs = dir()\n",
        "    else:\n",
        "        attrs = dir(obj)\n",
        "    print([name for name in attrs if not name.startswith('__')])  # Исключаем служебные методы"
      ],
      "metadata": {
        "id": "MEO2qc0WHia4"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zxbAVoLDNie4",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "fca0ff9b-5614-4f14-b1bd-75a0d3d07d16"
      },
      "source": [
        "help(str.startswith)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Help on method_descriptor:\n",
            "\n",
            "startswith(...)\n",
            "    S.startswith(prefix[, start[, end]]) -> bool\n",
            "    \n",
            "    Return True if S starts with the specified prefix, False otherwise.\n",
            "    With optional start, test S beginning at that position.\n",
            "    With optional end, stop comparing S at that position.\n",
            "    prefix can also be a tuple of strings to try.\n",
            "\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Посмотрим на работу функции `print_custom_attrs`:"
      ],
      "metadata": {
        "id": "1ia_w-F5IPy-"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print_custom_attrs(ClassWithNothing)"
      ],
      "metadata": {
        "id": "z45OHIFzHqJW",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1df6432f-9596-4390-c25b-fb6bd3207f56"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print_custom_attrs(nobject)"
      ],
      "metadata": {
        "id": "y_zG4jdbHfF_",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "d649aea2-6073-4c32-f126-50e21f8923ef"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZkvfvfIw8tvu",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "ce056355-4445-4890-eac3-f7cbdb1adaf7"
      },
      "source": [
        "nobject.my_instance_attribute = \"my value 2\"\n",
        "print_custom_attrs(nobject)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['my_instance_attribute']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "ClassWithNothing.my_attribute = 'my value'\n",
        "print_custom_attrs(ClassWithNothing)"
      ],
      "metadata": {
        "id": "qsEFyhgeIlqv",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a16732e8-793d-497b-e6e1-7bc13f08b347"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "['my_attribute']\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print_custom_attrs(nobject)"
      ],
      "metadata": {
        "id": "NquUKt9-3cpm"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Приватность атрибутов"
      ],
      "metadata": {
        "id": "C63rBf-xIW4i"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Во многих языках программирования можно регулировать доступ до атрибутов класса от внешнего кода и других классов. Обычно выделяют три уровня доступа:\n",
        "- публичный - атрибуты доступны как внутри класса, так и из наружнего кода\n",
        "- защищенный - атрибуты доступны внутри класса и для наследников класса\n",
        "- приватный - атрибуты доступны только внутри класса"
      ],
      "metadata": {
        "id": "7b_vCFaFJYad"
      }
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "svmbSvN18tvy"
      },
      "source": [
        "А есть ли в Python приватность атрибутов? Можем ли мы запретить читать и менять атрибуты объекта снаружи (внешним кодом)?"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_iuASScu8tvy"
      },
      "source": [
        "class VeryPrivateDataHolder:\n",
        "    not_secret = 0     # public\n",
        "    _secret = 1        # protected\n",
        "    __very_secret = 2  # private"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "mRYfzczI8tvy"
      },
      "source": [
        "obj = VeryPrivateDataHolder()"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "obj.not_secret"
      ],
      "metadata": {
        "id": "P5ZSyeW9Kye5",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a6d261f2-90da-4fdc-89d1-4c9431d45b16"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "0"
            ]
          },
          "metadata": {},
          "execution_count": 11
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "obj._secret"
      ],
      "metadata": {
        "id": "finNrT9CKv52",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "1db956cb-32c9-46a8-a842-af103b4df30e"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "1"
            ]
          },
          "metadata": {},
          "execution_count": 12
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "obj.__very_secret"
      ],
      "metadata": {
        "id": "biUg4WByKxkK",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 179
        },
        "outputId": "832d44ab-619f-4949-94ca-fd2c4de77c7d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "AttributeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-13-bc0a326e6db6>\u001b[0m in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mobj\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__very_secret\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mAttributeError\u001b[0m: 'VeryPrivateDataHolder' object has no attribute '__very_secret'"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bbciyFza8tvy"
      },
      "source": [
        "Казалось бы, в Python всё-таки есть приватность, но есть нюанс:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8CAL_QRy8tvy",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "79864242-14be-4272-ae7b-75e89d72ec0e"
      },
      "source": [
        "obj._VeryPrivateDataHolder__very_secret"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "2"
            ]
          },
          "metadata": {},
          "execution_count": 14
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Т.е. при желании все же можем получить доступ к \"приватным\" атрибутом, но делать так не рекомендуется, особенно не со своими классами!"
      ],
      "metadata": {
        "id": "17sN5LhkItL5"
      }
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pXLwM5g88tvz",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "26af40e7-286b-4386-f4dd-8a064ab5e2d4"
      },
      "source": [
        "obj._VeryPrivateDataHolder__very_secret = 'new secret'\n",
        "obj._VeryPrivateDataHolder__very_secret"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'new secret'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 15
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "k2oC_WE4PbjW",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 179
        },
        "outputId": "547f525a-4dca-4e4a-908f-4bafc126a0ea"
      },
      "source": [
        "VeryPrivateDataHolder.__very_secret"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "AttributeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-16-d29ba4079f4b>\u001b[0m in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mVeryPrivateDataHolder\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__very_secret\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mAttributeError\u001b[0m: type object 'VeryPrivateDataHolder' has no attribute '__very_secret'"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Наследование"
      ],
      "metadata": {
        "id": "_nwkm282NnE1"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Рассмотрим как работает наследование в Python с помощью следующих классов:"
      ],
      "metadata": {
        "id": "yJBRpQ-nNwtK"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Animal:  # неявно наследуется от класса object\n",
        "    some_value = \"animal\"\n",
        "\n",
        "    def __init__(self):\n",
        "        print(\"i am an animal\")\n",
        "\n",
        "    def speak(self):\n",
        "        raise NotImplementedError('i don\\'t know how to speak')  # ошибка, показывающая что метод еще не реализован"
      ],
      "metadata": {
        "id": "4Q1J9BqmN59a"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "class Cat(Animal):\n",
        "    some_value = \"cat\"\n",
        "\n",
        "    def __init__(self):\n",
        "        super().__init__()\n",
        "        print(\"i am a cat\")\n",
        "\n",
        "    def speak(self):\n",
        "        print('meoooow')"
      ],
      "metadata": {
        "id": "UZoLugjoOAM7"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "class Dog(Animal):\n",
        "    some_value = \"dog\"\n",
        "\n",
        "    def __init__(self):\n",
        "        super().__init__()\n",
        "        print(\"i am a dog\")"
      ],
      "metadata": {
        "id": "nOawrxOhOBrP"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "class Hedgehog(Animal):\n",
        "    def __init__(self):\n",
        "        super().__init__()\n",
        "        print(\"i am a hedgehog\")"
      ],
      "metadata": {
        "id": "c4GYd4F9Ntw7"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "animal = Animal()\n",
        "print(animal.some_value)\n",
        "animal.speak()"
      ],
      "metadata": {
        "id": "THacMee3NxRd",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 339
        },
        "outputId": "b56152b8-5dcc-4277-de85-5ac20f5fb350"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "i am an animal\n",
            "animal\n"
          ]
        },
        {
          "output_type": "error",
          "ename": "NotImplementedError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mNotImplementedError\u001b[0m                       Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-21-cfe177368ca9>\u001b[0m in \u001b[0;36m<cell line: 3>\u001b[0;34m()\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0manimal\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mAnimal\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      2\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0manimal\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0msome_value\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 3\u001b[0;31m \u001b[0manimal\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mspeak\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;32m<ipython-input-17-fac7d6eabe34>\u001b[0m in \u001b[0;36mspeak\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      7\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mspeak\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 8\u001b[0;31m         \u001b[0;32mraise\u001b[0m \u001b[0mNotImplementedError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'i don\\'t know how to speak'\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# ошибка, показывающая что метод еще не реализован\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mNotImplementedError\u001b[0m: i don't know how to speak"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "cat = Cat()"
      ],
      "metadata": {
        "id": "-cXPv8xvXe0m",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c7a7769d-b7ee-466a-c39f-65c3941e6ad4"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "i am an animal\n",
            "i am a cat\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "cat.some_value # переопределено"
      ],
      "metadata": {
        "id": "3gwKICmpCQ4b",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "a0ff5f3b-978b-4804-bff7-917b3266f267"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'cat'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 23
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "cat.speak()"
      ],
      "metadata": {
        "id": "T9AZV0xXCSfN",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "9ec85382-bf84-445e-eec8-58de59cd9a9f"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "meoooow\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "dog = Dog()"
      ],
      "metadata": {
        "id": "dd7WBjq0XgJ5",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "37543774-b41f-4179-f180-e3463ed1bf86"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "i am an animal\n",
            "i am a dog\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "dog.some_value # переопределено"
      ],
      "metadata": {
        "id": "USoFSSFfCvgu",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "a4760498-5098-4600-969a-31cf7288b8ef"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'dog'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 26
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "dog.speak()"
      ],
      "metadata": {
        "id": "vZNgGiF4CwqS",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 268
        },
        "outputId": "6f99ee29-301e-418b-c5ea-515a629e8fb0"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "NotImplementedError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mNotImplementedError\u001b[0m                       Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-27-35a36b50d121>\u001b[0m in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mdog\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mspeak\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;32m<ipython-input-17-fac7d6eabe34>\u001b[0m in \u001b[0;36mspeak\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      7\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mspeak\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 8\u001b[0;31m         \u001b[0;32mraise\u001b[0m \u001b[0mNotImplementedError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'i don\\'t know how to speak'\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# ошибка, показывающая что метод еще не реализован\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mNotImplementedError\u001b[0m: i don't know how to speak"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "hedgehog = Hedgehog()"
      ],
      "metadata": {
        "id": "Ixm_WBFLC_sv",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "b4d4f961-1ad2-4a31-d2bd-6fd3290f09d2"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "i am an animal\n",
            "i am a hedgehog\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "hedgehog.some_value"
      ],
      "metadata": {
        "id": "T3f630xBDDZ8",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 35
        },
        "outputId": "1eb251b5-8008-4bfa-e86d-8625ca1b58c3"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'animal'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 29
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "hedgehog.speak()"
      ],
      "metadata": {
        "id": "zPCUxdvODP98",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 268
        },
        "outputId": "48c633b0-50fc-4f46-9319-a3b3381fbd44"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "error",
          "ename": "NotImplementedError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mNotImplementedError\u001b[0m                       Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-30-3a474e511955>\u001b[0m in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mhedgehog\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mspeak\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;32m<ipython-input-17-fac7d6eabe34>\u001b[0m in \u001b[0;36mspeak\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      7\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mspeak\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 8\u001b[0;31m         \u001b[0;32mraise\u001b[0m \u001b[0mNotImplementedError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m'i don\\'t know how to speak'\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# ошибка, показывающая что метод еще не реализован\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mNotImplementedError\u001b[0m: i don't know how to speak"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Ромбовидное наследование возможно, но не делайте так, пожалуйста!"
      ],
      "metadata": {
        "id": "JfgQNmBsNxuW"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "#      Animal\n",
        "#    /       \\\n",
        "#  Cat       Dog\n",
        "#    \\       /\n",
        "#      CatDog"
      ],
      "metadata": {
        "id": "_OQul2rKRPYU"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "class CatDog(Cat, Dog):\n",
        "    def __init__(self):\n",
        "        super().__init__()\n",
        "        print(\"i am a CatDog!\")"
      ],
      "metadata": {
        "id": "C3O0wR3LN2Z9"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "catdog = CatDog()\n",
        "catdog.some_value"
      ],
      "metadata": {
        "id": "mkKBiyZsODGu",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 107
        },
        "outputId": "b1743325-e94b-454c-f1cd-dd0bd8f3d22c"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "i am an animal\n",
            "i am a dog\n",
            "i am a cat\n",
            "i am a CatDog!\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'cat'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 34
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Порядок перечисления родителей важен!"
      ],
      "metadata": {
        "id": "TFbElcmmOBjL"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class DogCat(Dog, Cat):  # теперь наоборот\n",
        "    def __init__(self):\n",
        "        super().__init__()\n",
        "        print(\"i am a CatDog!\")\n",
        "\n",
        "dogcat = DogCat()\n",
        "dogcat.some_value"
      ],
      "metadata": {
        "id": "eFUlsOS2OFTb",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 107
        },
        "outputId": "969d099d-5094-4528-bbce-4b80c6d4de37"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "i am an animal\n",
            "i am a cat\n",
            "i am a dog\n",
            "i am a CatDog!\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'dog'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 35
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Что с методами?"
      ],
      "metadata": {
        "id": "44IYzZofRc1s"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "CatDog.__mro__"
      ],
      "metadata": {
        "id": "bNVREkAsRgDl",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "c93e387d-5741-4d3d-b9dc-96b051e49685"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(__main__.CatDog, __main__.Cat, __main__.Dog, __main__.Animal, object)"
            ]
          },
          "metadata": {},
          "execution_count": 36
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "DogCat.__mro__"
      ],
      "metadata": {
        "id": "KLQcjmliEuHV",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "12771d83-7493-457e-e5c2-603ac9941298"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(__main__.DogCat, __main__.Dog, __main__.Cat, __main__.Animal, object)"
            ]
          },
          "metadata": {},
          "execution_count": 37
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "class A: pass\n",
        "class B(A): pass\n",
        "class C: pass\n",
        "class D(B, C): pass\n",
        "\n",
        "D.__mro__\n",
        "\n",
        "\n",
        "#  Object\\\n",
        "#  |.     |\n",
        "#  A.     |\n",
        "#  |.     |\n",
        "#  B     C\n",
        "#   \\   /\n",
        "#     D"
      ],
      "metadata": {
        "id": "GROiV3ECRhna",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "fa52588c-542f-47ce-b797-b0ee0cff5025"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(__main__.D, __main__.B, __main__.A, __main__.C, object)"
            ]
          },
          "metadata": {},
          "execution_count": 38
        }
      ]
    }
  ]
}