python_pd/06_classes/02_attr.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": [
    "# Атрибуты класса и экземпляра\n",
    "\n",
    "При объявлении класса создается новое пространство имен и используется как локальная область видимости (по аналогии с функциями), внутри которой могут объявляться переменные (атрибуты) и функции, которые называются методами и имеют немного отличный от обычных функций вид объявления. Таким образом все атрибуты можно разделить на несколько видов:\n",
    "- атрибуты данных:\n",
    "    - атрибуты класса;\n",
    "    - атрибуты экземпляры.\n",
    "- методы (о методах речь пойдет в следующем разделе).\n",
    "\n",
    "Содержание области видимости класса можно посмотреть с помощью функции ```dir```.\n",
    "\n",
    "Доступ к любым атрибутам осуществляется с помощью точечной нотации, синтаксис которой является стандартным для многих языков программирования.\n",
    "\n",
    "```python \n",
    "obj.attribute\n",
    "```\n",
    "\n",
    "Атрибутами выступают все имена, определенные в пространстве имен класса. Рассмотрим пример простейшего класса ```A```.\n",
    "\n",
    "## Атрибуты класса\n",
    "\n",
    "Атрибуты класса объявляются непосредственно внутри пространства имен класса, по аналогии с локальными переменными. В примере ниже класс ```A``` содержит один атрибут класса ```foo```.\n",
    "\n",
    "Все атрибуты являются ссылками на другие объекты. Здесь атрибут ```foo``` класса ```A``` ссылается на объект целого числа ```6174```."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "source": [
    "class A:\r\n",
    "    foo = 6174\r\n",
    "\r\n",
    "print(f'{A = }')\r\n",
    "print(f'До изменения: {A.foo = }')\r\n",
    "A.foo = 0\r\n",
    "print(f'После изменения: {A.foo = }')"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "A = <class '__main__.A'>\n",
      "До изменения: A.foo = 6174\n",
      "После изменения: A.foo = 0\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "Классы позволяют по-настоящему оценить динамическую природу Python. Он позволяет динамически, т.е. в процессе выполнения, создавать **любые** атрибуты."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "source": [
    "def get_attrs(obj):\r\n",
    "    \"\"\"Получение все атрибутов кроме 'магических'.\"\"\"\r\n",
    "    return [attr for attr in dir(obj) if not (attr.startswith(\"__\") and attr.endswith(\"__\"))]\r\n",
    "\r\n",
    "\r\n",
    "print(f'Состав исходной области видимости: {get_attrs(A)}')\r\n",
    "\r\n",
    "# динамически добавляем новый атрибут\r\n",
    "A.bar = 42\r\n",
    "\r\n",
    "print(f'Область видимости после добавления атрибута: {get_attrs(A)}')"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Состав исходной области видимости: ['foo']\n",
      "Область видимости после добавления атрибута: ['bar', 'foo']\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "Однако, обращение к несуществующему атрибуту влечет за собой появление\r\n",
    "исключения ```AttributeError```."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "source": [
    "class B:\r\n",
    "    pass\r\n",
    "\r\n",
    "\r\n",
    "print(B.attribute)"
   ],
   "outputs": [
    {
     "output_type": "error",
     "ename": "AttributeError",
     "evalue": "type object 'B' has no attribute 'attribute'",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-3-0aab6e430fa7>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      4\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 5\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mB\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mattribute\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: type object 'B' has no attribute 'attribute'"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "Экземпляр класса создается с использованием круглых скобок («вызов» класса). Подробнее механизм создания экземпляра класса будет рассмотрен в разделе о \"магических\" методах. \n",
    "\n",
    "Создаваемый экземпляр сразу связывается с именем, стоящим слева от знака равенства.\n",
    "\n",
    "Экземпляры класса имеют доступ к атрибутам класса. Для этого достаточно использовать точечную нотацию. Изменение таких атрибутов у класса ведет к их изменению в экземплярах, но **обратное не верно**. Далее мы поймем почему. "
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "source": [
    "a = A()\r\n",
    "b = A()\r\n",
    "\r\n",
    "print(f'(1) До изменения: {a.foo = }')\r\n",
    "print(f'(2) До изменения: {b.foo = }')\r\n",
    "\r\n",
    "A.foo = 6174\r\n",
    "\r\n",
    "print(f'(1) После изменения: {a.foo = }')\r\n",
    "print(f'(2) После изменения: {b.foo = }')"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "(1) До изменения: a.foo = 0\n",
      "(2) До изменения: b.foo = 0\n",
      "(1) После изменения: a.foo = 6174\n",
      "(2) После изменения: b.foo = 6174\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "Чтобы убедиться в доступности атрибутом можно воспользоваться функцией ```get_attrs```, реализованной выше."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "source": [
    "print(f'Атрибуты класса {A.__name__}: {get_attrs(A)}')\r\n",
    "\r\n",
    "print(f'Атрибуты экземпляра a: {get_attrs(a)}')\r\n",
    "print(f'Атрибуты экземпляра b: {get_attrs(b)}')"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Атрибуты класса A: ['bar', 'foo']\n",
      "Атрибуты экземпляра a: ['bar', 'foo']\n",
      "Атрибуты экземпляра b: ['bar', 'foo']\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "На самом деле здесь происходит небольшая магия. Непосредственно экземпляры класса не имеют атрибутов класса, т.е. экземпляры ```a``` и ```b``` не имеют атрибутов ```foo``` и ```bar```. Дело в том, что здесь работает механизм поиска атрибутов, о котором мы подробнее поговорим далее. Когда мы запрашиваем атрибут класса у экземпляра, т.е. пишем ```a.foo```, он ищет этот атрибут сначала в экземпляре, не найдя его, он перейдет на уровень выше - на уровень класса и будет искать его там.\n",
    "\n",
    "Для того, чтобы убедиться в этом проверим на что ссылаются эти атрибуты с помощью оператора ```is```."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "source": [
    "# все атрибуты ссылаются на один объект в памяти\r\n",
    "print(f'{A.foo is a.foo is b.foo = }')"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "A.foo is a.foo is b.foo = True\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "С тем, что атрибутов класса на самом деле нет в экземпляре, связана одна интересная особенность, о которой обязательно нужно помнить. Она может привести к различного рода ошибкам и некорректному поведения программы особенно у новичков. Дело в том, что при создании атрибутов экземпляра с таким же именем как у атрибута класса, первый \"загораживает\" второй. Это поведение аналогично поведения переменных в областях видимости разного уровня.\n",
    "\n",
    "В качестве примера попытаемся изменить значение атрибута класса ```foo``` через экземпляр ```b```. Для частоты эксперимента заменим значение атрибута ```b.foo``` на тоже самое значение, которое было ранее у всех остальных атрибутов, а именно ```6174```. Первое, что подумает новичок - ничего не произойдет. Однако, это не так. Подробно разберем происходящее здесь.\n",
    "\n",
    "Изначально класс ```A``` содержал атрибут класса ```foo```. У экземпляров этого атрибута не было. Они получали его значение через свой класс. \n",
    "\n",
    "<img src=\"image/attr_cls.png\">\n",
    "\n",
    "В ходе выполнения строки ```b.foo = 6174``` интерпретатор сначала выполнил поиск атрибута ```foo``` в экземпляре. Не найдя его, он создал этот атрибут внутри экземпляра со значением ```6174```. Обратите внимание, что при создании атрибута его поиск происходит только **в текущем** объекте. После выполнения этой строки будет существовать два **разных** атрибута ```foo```. Один в экземпляре ```b```, он будет атрибутом экземпляра, а другой в классе ```A```, он является атрибутом класса. Эти два атрибута ссылаются на *разные* объекты, поэтому оператор ```is``` возвращает ```False```. \n",
    "\n",
    "Особенности на этом не заканчиваются. Теперь при обращении ```b.foo``` будет возвращаться объект, связанный с этим атрибутом, а не с атрибутом ```A.foo```, т.е. атрибут экземпляра \"загородил\" собой атрибут класса. Это поведение полностью аналогично обычным переменным из разных областей видимости, например, локальные переменные с тем же именем, что и у глобальной переменной, \"загородят\" последнюю. Стоит отметить, что теперь атрибут ```b.foo``` никак не будет влиять на ```A.foo```, это **разные** объекты."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "source": [
    "print('Атрибуты до изменения:')\r\n",
    "print(f'{A.foo = }, {a.foo = }, {b.foo = }')\r\n",
    "print('-' * 25)\r\n",
    "\r\n",
    "# Заменяем на такое же значение, по ощущениям ничего не должно измениться.\r\n",
    "b.foo = 6174\r\n",
    "\r\n",
    "# Что-то пошло не так. Атрибут b.foo отличается от остальных\r\n",
    "print(f'{A.foo is a.foo is b.foo = }')\r\n",
    "print(f'{A.foo is b.foo = }')\r\n",
    "print(f'{a.foo is b.foo = }')"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Атрибуты до изменения:\n",
      "A.foo = 6174, a.foo = 6174, b.foo = 6174\n",
      "-------------------------\n",
      "A.foo is a.foo is b.foo = False\n",
      "A.foo is b.foo = False\n",
      "a.foo is b.foo = False\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "source": [
    "A.foo = 42\r\n",
    "\r\n",
    "print(f'{A.foo = }')\r\n",
    "print(f'{a.foo = }')\r\n",
    "print(f'{b.foo = }')  # Magic!!!"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "A.foo = 42\n",
      "a.foo = 42\n",
      "b.foo = 6174\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "До \"загороженного\" атрибута класса ```foo``` можно добраться из экземпляра. Для этого используется обходной путь. У экземпляра есть \"магический\" атрибут ```__class__```. Он хранить класс. \n",
    "\n",
    "<img src=\"image/attr_self.png\">"
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "source": [
    "print(f'{b.__class__.foo = }')\r\n",
    "print(f'{b.__class__.foo is b.foo = }')"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "b.__class__.foo = 42\n",
      "b.__class__.foo is b.foo = False\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "source": [
    "print(f'{a.__class__.foo = }')\r\n",
    "print(f'{a.__class__.foo is a.foo = }')\r\n",
    "\r\n",
    "a.foo = 0\r\n",
    "print(f'{a.foo = }')\r\n",
    "print(f'{a.__class__.foo = }')\r\n",
    "print(f'{a.__class__.foo is a.foo = }')"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "a.__class__.foo = 42\n",
      "a.__class__.foo is a.foo = True\n",
      "a.foo = 0\n",
      "a.__class__.foo = 42\n",
      "a.__class__.foo is a.foo = False\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "## Атрибуты экземпляра\n",
    "\n",
    "Экземпляр класса тоже может содержать атрибуты. Они называются атрибутами экземпляра. Эти атрибуты создаются и инициализируются в специальном методе ```__init__```. Этот метод всегда принимает в качестве первого аргумента ```self```. В качестве этого аргумента передается сам экземпляр. Более подробно работа методов будет рассмотрена в следующем разделе.\n",
    "\n",
    "Метод ```__init__``` только инициализирует экземпляр, т.е. создает атрибуты и заполняет их определенными значениями. Обратите внимание на то, что метод ```__init__``` не должен ничего возвращать, т.е. в нем нельзя размещать инструкцию ```return```."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "source": [
    "class A:\r\n",
    "    # метод инициализации экземпляра\r\n",
    "    def __init__(self, x, y):\r\n",
    "        \"\"\"\r\n",
    "        :param self: экземпляр текущего класса, обязательный аргумент\r\n",
    "        :type self: A\r\n",
    "        :param x: дополнительное значение для атрибута self.x\r\n",
    "        :param y: дополнительное значение для атрибута self.y\r\n",
    "        \"\"\"\r\n",
    "        self.x = x\r\n",
    "        self.y = y"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "К атрибутам экземпляра класс не имеет доступа. В этом можно убедиться с помощью функции ```get_attrs```. Область видимости класса ```A``` не содержит этих атрибутов."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "source": [
    "print(f'{get_attrs(A)}')"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "[]\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "Когда мы объявили метод инициализации экземпляра, его создание несколько измениться. Теперь при вызове класса необходимо передавать дополнительные аргументы ```x``` и ```y```. Обратите внимание, что аргумент ```self``` мы не передаем. Он передается автоматически.\n",
    "\n",
    "После создания и инициализации экземпляра атрибуты ```x``` и ```y``` появятся в его области видимости. При это они будут различны для разных экземпляров."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "source": [
    "a = A(1, 2)\r\n",
    "b = A(4, 5)\r\n",
    "\r\n",
    "print(f'{get_attrs(a)}')\r\n",
    "print(f'{get_attrs(b)}')"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "['x', 'y']\n",
      "['x', 'y']\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "source": [
    "print(f'{a.x = }, {a.y = }')\r\n",
    "print(f'{b.x = }, {b.y = }')\r\n",
    "\r\n",
    "print(f'{a.x is b.x = }, {a.y is b.y = }')"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "a.x = 1, a.y = 2\n",
      "b.x = 4, b.y = 5\n",
      "a.x is b.x = False, a.y is b.y = False\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "Изменение атрибута у одного из экземпляров никак не отражается на другом."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "source": [
    "a.x = 10\r\n",
    "print(f'{a.x = }, {a.y = }')\r\n",
    "print(f'{b.x = }, {b.y = }')"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "a.x = 10, a.y = 2\n",
      "b.x = 4, b.y = 5\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "Наличие атрибуток класса позволяет хранить одно общее состояние для всех создаваемых объектов. Одним из самых простых применений явялется глобальный счетчик."
   ],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "source": [
    "class Counter:\r\n",
    "    global_counter = 0\r\n",
    "    def __init__(self, initial=0):\r\n",
    "        self.counter = initial\r\n",
    "    \r\n",
    "    def increment(self):\r\n",
    "        self.counter += 1\r\n",
    "        self.__class__.global_counter += 1\r\n",
    "    \r\n",
    "    def get_local_counter(self):\r\n",
    "        return self.counter\r\n",
    "    \r\n",
    "    def get_global_counter(self):\r\n",
    "        return self.__class__.global_counter"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "source": [
    "x = Counter(5)\r\n",
    "x.increment()\r\n",
    "y = Counter(42)\r\n",
    "y.increment()\r\n",
    "y.increment()"
   ],
   "outputs": [],
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "source": [
    "print(f'{x.get_local_counter() = }')\r\n",
    "print(f'{x.global_counter = }')\r\n",
    "print(f'{y.get_local_counter() = }')\r\n",
    "print(f'{y.global_counter = }')"
   ],
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "6\n",
      "3\n",
      "44\n",
      "3\n"
     ]
    }
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "Также можно считать количество создаваемых объектов, контролировать создание экземпляров и т.д."
   ],
   "metadata": {}
  },
  {
   "cell_type": "markdown",
   "source": [
    "# Полезные ссылки"
   ],
   "metadata": {}
  }
 ]
}