07_Classes.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Классы"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Variables, Lists, Dictionaries etc in python is a object. Without getting into the theory part of Object Oriented Programming, explanation of the concepts will be done along this tutorial."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Чтобы создать класс, нужно использовать ключевое слово `class` и название класса"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Cat:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**pass** in python means do nothing. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Мы создали пустой класс (без член-данных (полей) и член-функций (методов) )  \n",
    "Чтобы теперь создать `instance` класса (объект типа `Cat`), нужно просто написать название класса и круглые скобки"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [],
   "source": [
    "pussy = Cat()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Обратите внимание на разницу между _объектом класса_ и _классом_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "__main__.Cat"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(pussy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 241,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "type"
      ]
     },
     "execution_count": 241,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(Cat)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Попробуем добавить в наш класс данных, так называемые _поля_ или _атрибуты_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 250,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Cat:\n",
    "    name = \"Musya\"\n",
    "    gender = \"F\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 243,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Musya F\n"
     ]
    }
   ],
   "source": [
    "pussy = Cat()\n",
    "print(pussy.name, pussy.gender)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 244,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Barsik M\n"
     ]
    }
   ],
   "source": [
    "pussy.name = \"Barsik\"\n",
    "pussy.gender = \"M\"\n",
    "\n",
    "print(pussy.name, pussy.gender)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 251,
   "metadata": {},
   "outputs": [],
   "source": [
    "malecat = Cat()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 253,
   "metadata": {},
   "outputs": [],
   "source": [
    "Cat.name = 'Kuzya'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 254,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Kuzya'"
      ]
     },
     "execution_count": 254,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "malecat.name"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Теперь добавим наш первый _метод_ (член-функцию). Они добавляются как обычные функции, за тем исключением, что первый аргумент каждой из них, ссылка на объект класса `self`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 259,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Cat:\n",
    "    name = \"Musya\"\n",
    "    gender = \"F\"\n",
    "    \n",
    "    def meow(self):\n",
    "        print('MEOW!')\n",
    "        \n",
    "    def speak(self):\n",
    "        self.meow()\n",
    "        print('My name is {}'.format(self.name))\n",
    "        \n",
    "    def change_gender(self):\n",
    "        self.gender = 'M' if self.gender == 'F' else 'F'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 260,
   "metadata": {},
   "outputs": [],
   "source": [
    "pussy = Cat()\n",
    "malecat = Cat()\n",
    "\n",
    "pussy.name = 'Musya'\n",
    "malecat.name = 'Barsik'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 263,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MEOW!\n",
      "My name is Musya\n",
      "MEOW!\n",
      "My name is Barsik\n"
     ]
    }
   ],
   "source": [
    "pussy.speak() # speak(pussy)\n",
    "malecat.speak()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 276,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "M\n"
     ]
    }
   ],
   "source": [
    "pussy.change_gender()\n",
    "print(pussy.gender)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Есть такая полезная вещь как _конструктор_. Это специальный метод, который вызывается при создании объекта. Для того чтобы определить его в нашем классе, достаточно добавить метод со специальным названием `__init__`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 283,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Cat:\n",
    "    \n",
    "    # Обратите внимание, член-данные не обязательно указывать в начале класса. В данном примере они создаются в функции __init__\n",
    "    \n",
    "    def __init__(self, name, gender):\n",
    "        self.name = name\n",
    "        self.gender = gender\n",
    "    \n",
    "    def meow(self):\n",
    "        print('MEOW!')\n",
    "    \n",
    "    def speak(self):\n",
    "        print('Meow! My name is {}'.format(self.name))\n",
    "        \n",
    "    def change_gender(self):\n",
    "        self.gender = 'M' if self.gender == 'F' else 'F'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 286,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "MEOW!\n"
     ]
    }
   ],
   "source": [
    "pussy = Cat('Barsik', 'M')\n",
    "Cat.meow(pussy) # pussy.meow()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 279,
   "metadata": {},
   "outputs": [],
   "source": [
    "pussy = Cat('Musya', 'F')\n",
    "male = Cat('Barsik', 'M')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 280,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Meow! My name is Musya\n",
      "Meow! My name is Barsik\n"
     ]
    }
   ],
   "source": [
    "pussy.speak()\n",
    "male.speak()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Примеры использования классов в стандартной библиотеке"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import Counter\n",
    "\n",
    "stats = Counter([1,2,3,4,5])\n",
    "\n",
    "from csv import writer\n",
    "\n",
    "reader = writer(open('some.txt', 'w'))\n",
    "\n",
    "try:\n",
    "    print(1 / 0)\n",
    "except ZeroDivisionError as e: # ZeroDivisionError is a class, e is an object of class\n",
    "    print(e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Перейдем к более сложным примерам.  \n",
    "Попробуем создать класс, описывающий колоду карт _(Fluent Python, by Luciano Ramalho)_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Для начала создадим класс самой игральной карты"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Card:\n",
    "    def __init__(self, rank, suit):\n",
    "        self.rank = rank\n",
    "        self.suit = suit"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "metadata": {},
   "outputs": [],
   "source": [
    "class CardDeck:\n",
    "    ranks = [str(n) for n in range(2, 11)] + list('JQKA')\n",
    "    suits = 'spades diamonds clubs hearts'.split()\n",
    "    \n",
    "    def __init__(self):\n",
    "        self.cards = [Card(rank, suit) for suit in self.suits\n",
    "                                       for rank in self.ranks]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 287,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 of spades\n",
      "A of spades\n",
      "K of diamonds\n",
      "Q of clubs\n",
      "J of hearts\n"
     ]
    }
   ],
   "source": [
    "deck = CardDeck()\n",
    "\n",
    "for card in deck.cards[::12]:\n",
    "    print(card.rank, 'of', card.suit)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 177,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'<__main__.Card object at 0x7fe0252367b8>'"
      ]
     },
     "execution_count": 177,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str(deck.cards[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python позволяет вам во время описания класса, описать то, как он будет взаимодействовать с большинством встроенных конструкций и функций. Например когда вы делаете `str(3 + 3)`, у объекта класса числа вызывается специальный метод `__str__`, который генерирует строковое представление. Когда вы берете элемент списка по индексу, вызывается метод `__getitem__`, с параметром `key` - индексом элемента, давайте немного изменим наш класс карты"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 288,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Card:\n",
    "    def __init__(self, rank, suit):\n",
    "        self.rank = rank\n",
    "        self.suit = suit\n",
    "        \n",
    "    def __str__(self):\n",
    "        return '{} of {}'.format(self.rank, self.suit)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 289,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 of spades\n",
      "A of spades\n",
      "K of diamonds\n",
      "Q of clubs\n",
      "J of hearts\n"
     ]
    }
   ],
   "source": [
    "deck = CardDeck()\n",
    "\n",
    "for card in deck.cards[::12]:\n",
    "    print(card) # print неявно оборачивает все что вы ему подали в функцию str"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Самое время вспомнить про функцию `len()` !"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 298,
   "metadata": {},
   "outputs": [],
   "source": [
    "class CardDeck:\n",
    "    ranks = [str(n) for n in range(2, 11)] + list('JQKA')\n",
    "    suits = 'spades diamonds clubs hearts'.split()\n",
    "    \n",
    "    def __init__(self):\n",
    "        self.cards = [Card(rank, suit) for suit in self.suits\n",
    "                                       for rank in self.ranks]\n",
    "        \n",
    "    def __len__(self):\n",
    "        return len(self.cards)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 300,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "52\n"
     ]
    }
   ],
   "source": [
    "deck = CardDeck()\n",
    "\n",
    "print(len(deck))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 301,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'CardDeck' object does not support indexing",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-301-ebbb75ae00f7>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mdeck\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: 'CardDeck' object does not support indexing"
     ]
    }
   ],
   "source": [
    "deck[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 316,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Getitem\n",
    "\n",
    "class CardDeck:\n",
    "    ranks = [str(n) for n in range(2, 11)] + list('JQKA')\n",
    "    suits = 'spades diamonds clubs hearts'.split()\n",
    "    \n",
    "    def __init__(self):\n",
    "        self.cards = [Card(rank, suit) for suit in self.suits\n",
    "                                       for rank in self.ranks]\n",
    "        \n",
    "    def __len__(self):\n",
    "        return len(self.cards)\n",
    "    \n",
    "    def __getitem__(self, key):\n",
    "        return self.cards[key]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 303,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5 of spades\n"
     ]
    }
   ],
   "source": [
    "deck = CardDeck()\n",
    "\n",
    "print(deck[3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 313,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Q of clubs\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "\n",
    "card = random.choice(deck)\n",
    "print(card)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 314,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 of spades\n",
      "3 of spades\n",
      "4 of spades\n",
      "5 of spades\n",
      "6 of spades\n",
      "7 of spades\n",
      "8 of spades\n",
      "9 of spades\n",
      "10 of spades\n",
      "J of spades\n",
      "Q of spades\n",
      "K of spades\n",
      "A of spades\n",
      "2 of diamonds\n",
      "3 of diamonds\n",
      "4 of diamonds\n",
      "5 of diamonds\n",
      "6 of diamonds\n",
      "7 of diamonds\n",
      "8 of diamonds\n",
      "9 of diamonds\n",
      "10 of diamonds\n",
      "J of diamonds\n",
      "Q of diamonds\n",
      "K of diamonds\n",
      "A of diamonds\n",
      "2 of clubs\n",
      "3 of clubs\n",
      "4 of clubs\n",
      "5 of clubs\n",
      "6 of clubs\n",
      "7 of clubs\n",
      "8 of clubs\n",
      "9 of clubs\n",
      "10 of clubs\n",
      "J of clubs\n",
      "Q of clubs\n",
      "K of clubs\n",
      "A of clubs\n",
      "2 of hearts\n",
      "3 of hearts\n",
      "4 of hearts\n",
      "5 of hearts\n",
      "6 of hearts\n",
      "7 of hearts\n",
      "8 of hearts\n",
      "9 of hearts\n",
      "10 of hearts\n",
      "J of hearts\n",
      "Q of hearts\n",
      "K of hearts\n",
      "A of hearts\n"
     ]
    }
   ],
   "source": [
    "for card in deck:\n",
    "    print(card.rank)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Полный список переопределяемых \"magic\" методов можно найти здесь https://docs.python.org/3/reference/datamodel.html#basic-customization"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Воспользовавшись функцией из пакета collections, которая позволяет создавать СИ-подобные структуры (структуры данных с именноваными аттрибутами), мы могли бы чуть облегчить себе жизнь, избавившись от одного класса"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 214,
   "metadata": {},
   "outputs": [],
   "source": [
    "from collections import namedtuple\n",
    "\n",
    "Card = namedtuple('Card', ['rank', 'suit'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 323,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Animal:\n",
    "    voice = 'Bark'\n",
    "    \n",
    "    def __init__(self, name):\n",
    "        self.name = name\n",
    "    \n",
    "    def say(self):\n",
    "        print(self.voice)\n",
    "        \n",
    "class Cat(Animal):\n",
    "    voice = 'Meow'\n",
    "    \n",
    "class Dog(Animal):\n",
    "    voice = 'Woof'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 324,
   "metadata": {},
   "outputs": [],
   "source": [
    "pussy = Cat('Musya')\n",
    "dog = Dog('Layka')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 325,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Meow\n",
      "Woof\n"
     ]
    }
   ],
   "source": [
    "pussy.say()\n",
    "dog.say()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 326,
   "metadata": {},
   "outputs": [],
   "source": [
    "def talk_with_animal(animal: Animal):\n",
    "    print('Hello', animal.name)\n",
    "    animal.say()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 327,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello Musya\n",
      "Meow\n"
     ]
    }
   ],
   "source": [
    "talk_with_animal(pussy)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 328,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello Layka\n",
      "Woof\n"
     ]
    }
   ],
   "source": [
    "talk_with_animal(dog)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 237,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ValueError, IndexError, ZeroDivisionError"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 240,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You can't divide by zero!\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    1 / 0\n",
    "except ZeroDivisionError as e:\n",
    "    print('You can\\'t divide by zero!')\n",
    "except Exception as e:\n",
    "    print('Unknown')"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "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.6.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}