python_tutorial_2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Мягкое введение в Python, часть 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В [предыдущем блокноте](https://github.com/avidale/weirdMath/blob/master/python_tutorial_1.ipynb) мы познакомились с типами данных в Python, узнали про переменные, списки, циклы и условия. \n",
    "\n",
    "В этом блокноте мы поговорим про"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "0fec5530-4223-4666-803f-c3d77a2270a7"
    }
   },
   "source": [
    "## 3. Функции, объекты и методы"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "df27e8f5-0aa6-421f-9ecf-6da802c4fd4a"
    }
   },
   "source": [
    "Что такое функция?\n",
    "\n",
    "В математике функция - это штуковина, которая берёт 1 или более элементов (<i>аргументов</i>) из какого-то множества, что-то с ними вытворяет, и возвращает 1 или более элементов какого-то другого (или того же) множества (<i>значений функции</i>).\n",
    "\n",
    "В программировании всё более гибко: функция может принимать сколько угодно аргументов (в том числе и 0), и возвращать сколько угодно значений (в том числе и 0).\n",
    "\n",
    "В Питоне функции объявляются ключевым словом <b>def</b>. Всё тело функции отделяется от основного кода <b>отступом</b> (tab). В конце функций может быть ключевое слово <b>return</b>, за которым следует то значение, которое функция вернёт во внешнюю среду.\n",
    "\n",
    "Ниже, например, функция, которая принимает один аргумент x, возводит его в куб, и возвращает этот куб."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "nbpresent": {
     "id": "15efa235-43a7-49b9-8dd1-07c0bc7929ea"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8 27 125\n"
     ]
    }
   ],
   "source": [
    "def cube(x):\n",
    "    # внутренность функции также определяется отступом\n",
    "    y = x*x*x\n",
    "    return y\n",
    "print(cube(2), cube(3), cube(5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "0c5572c4-c671-4353-8db8-f5aa0d9584ae"
    }
   },
   "source": [
    "Внутри функции можно делать что угодно. В частности, рекурсия - это функция, которая вызывает сама себя.\n",
    "\n",
    "Например, мы могли бы задать факториал индуктивно: $0! = 1$; $n! = (n-1)!\\times n$  $\\forall n > 0$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "nbpresent": {
     "id": "57191035-1ad7-430e-8672-5fe708f2f574"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 6 120\n"
     ]
    }
   ],
   "source": [
    "def factorial(n):\n",
    "    if n < 0:\n",
    "        return None #None - это специальный тип данных, чтобы обозначать НИЧТО. Примерно как Null.\n",
    "    elif n == 0:\n",
    "        return 1\n",
    "    else:\n",
    "        return factorial(n-1) * n \n",
    "print(factorial(0), factorial(3), factorial(5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Данная ячейка выполнится с ошибкой"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'sin' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-3-e418c9042724>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m()\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0msin\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m3.14\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      2\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mpower\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m10\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mNameError\u001b[0m: name 'sin' is not defined"
     ]
    }
   ],
   "source": [
    "print(sin(3.14))\n",
    "print(power(2, 10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Как я и предупреждал, она выполнилась с ошибкой.\n",
    "\n",
    "Такое случается. Такое случается довольно часто, даже если вы опытный программист. Это нормально.\n",
    "\n",
    "Полезно бывает читать весь текст, выплёвываемый при ошибке. Обычно он довольно детально объясняет её причину. Поняв её, ошибку легко пофиксить. Если понять её не удалось, текст ошибки стоит загуглить - где-то на stackowerflow кто-то с ней уже справился. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В жизни бывают ситуации, когда 100% предотвратить ошибку нельзя. Но даже в этом случае мы можем предусмотреть и <i>поймать</i> её."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Случилась ошибка NameError, но мы её поймали!\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    print(sin(3.14))\n",
    "    print(power(2, 10))\n",
    "except NameError as e:\n",
    "    print(\"Случилась ошибка NameError, но мы её поймали!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "be236613-a4a3-435b-a4f2-187e4444b5bb"
    }
   },
   "source": [
    "В Питоне есть большое количество математических функций. \n",
    "\n",
    "Однако, чтобы получить к ним доступ, нужно импортировать их из <b>библиотеки</b> по имени <b>numpy</b>.\n",
    "\n",
    "В Питоне библиотекой называется собрание функций, написанных программистами для какой-то цели. В отличие от SAS, Python создают тысячи различных сообществ. Некоторые из них поддерживают свои библиотеки, которые могут быть свободно скачаны (а иногда даже платно). В сборке Anaconda, которую вы установили, присутствует уже порядка сотни библиотек. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "04098eb7-0588-4eb5-abc1-6b25be53b594"
    }
   },
   "source": [
    "В ячейке ниже библиотека numpy подгружается в этот блокнот. Все функции, содержащиеся в ней, будут начинаться на приставку np."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "nbpresent": {
     "id": "e86e1ec6-fb13-4b0c-b8bd-df1c42973db4"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.00159265291649\n",
      "1024\n"
     ]
    }
   ],
   "source": [
    "import numpy as np # numpy  - это настоящее имя библиотеки, np - сокращение, которым мы будем пользоваться\n",
    "print(np.sin(3.14))\n",
    "print(np.power(2, 10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "1af42729-0761-4dc3-a000-2a62a90ea0ec"
    }
   },
   "source": [
    "Получить сведения о той или иной фунции можно в справке. Для вызова справки надо написать имя функции после двух знаков вопроса."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "nbpresent": {
     "id": "d6419a15-be78-4d01-a67f-c95bf95d88f8"
    }
   },
   "outputs": [],
   "source": [
    "??np.sin"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sin(x, /, out=None, *, where=True, casting='same_kind', order='K', dtype=None, subok=True[, signature, extobj])\n",
      "\n",
      "Trigonometric sine, element-wise.\n",
      "\n",
      "Parameters\n",
      "----------\n",
      "x : array_like\n",
      "    Angle, in radians (:math:`2 \\pi` rad equals 360 degrees).\n",
      "out : ndarray, None, or tuple of ndarray and None, optional\n",
      "    A location into which the result is stored. If provided, it must have\n",
      "    a shape that the inputs broadcast to. If not provided or `None`,\n",
      "    a freshly-allocated array is returned. A tuple (possible only as a\n",
      "    keyword argument) must have length equal to the number of outputs.\n",
      "where : array_like, optional\n",
      "    Values of True indicate to calculate the ufunc at that position, values\n",
      "    of False indicate to leave the value in the output alone.\n",
      "**kwargs\n",
      "    For other keyword-only arguments, see the\n",
      "    :ref:`ufunc docs <ufuncs.kwargs>`.\n",
      "\n",
      "Returns\n",
      "-------\n",
      "y : array_like\n",
      "    The sine of each element of x.\n",
      "\n",
      "See Also\n",
      "--------\n",
      "arcsin, sinh, cos\n",
      "\n",
      "Notes\n",
      "-----\n",
      "The sine is one of the fundamental functions of trigonometry (the\n",
      "mathematical study of triangles).  Consider a circle of radius 1\n",
      "centered on the origin.  A ray comes in from the :math:`+x` axis, makes\n",
      "an angle at the origin (measured counter-clockwise from that axis), and\n",
      "departs from the origin.  The :math:`y` coordinate of the outgoing\n",
      "ray's intersection with the unit circle is the sine of that angle.  It\n",
      "ranges from -1 for :math:`x=3\\pi / 2` to +1 for :math:`\\pi / 2.`  The\n",
      "function has zeroes where the angle is a multiple of :math:`\\pi`.\n",
      "Sines of angles between :math:`\\pi` and :math:`2\\pi` are negative.\n",
      "The numerous properties of the sine and related functions are included\n",
      "in any standard trigonometry text.\n",
      "\n",
      "Examples\n",
      "--------\n",
      "Print sine of one angle:\n",
      "\n",
      ">>> np.sin(np.pi/2.)\n",
      "1.0\n",
      "\n",
      "Print sines of an array of angles given in degrees:\n",
      "\n",
      ">>> np.sin(np.array((0., 30., 45., 60., 90.)) * np.pi / 180. )\n",
      "array([ 0.        ,  0.5       ,  0.70710678,  0.8660254 ,  1.        ])\n",
      "\n",
      "Plot the sine function:\n",
      "\n",
      ">>> import matplotlib.pylab as plt\n",
      ">>> x = np.linspace(-np.pi, np.pi, 201)\n",
      ">>> plt.plot(x, np.sin(x))\n",
      ">>> plt.xlabel('Angle [rad]')\n",
      ">>> plt.ylabel('sin(x)')\n",
      ">>> plt.axis('tight')\n",
      ">>> plt.show()\n"
     ]
    }
   ],
   "source": [
    "np.info(np.sin)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "c9ca6b25-2bc9-4082-9c3b-6dc48cdf38b0"
    }
   },
   "source": [
    "Функции могут принимать в качестве аргументов и возвращать не только числа, а что угодно - например, массивы.\n",
    "\n",
    "Функция len() определяет длину массива, а sum() возвращает сумму элементов.\n",
    "\n",
    "<b>Задание:</b>: напишите фунцию mysum, которая делает всё то же, что и sum, но не использует её."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "nbpresent": {
     "id": "20944415-6e5b-416f-9a07-51dbac84959c"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "def mysum(a):\n",
    "    # Содержание этой функции вам нужно изменить.\n",
    "    s = 0\n",
    "    return s\n",
    "print(mysum([1,2,3,4])) # правильный ответ должен быть 10\n",
    "print(mysum([1,20,300,4000])) # правильный ответ должен быть 4321"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Аргументы у функций можно указывать двумя способами: positional и keyword. В первом случае аргументы перечисляются через запятую, во втором -  передаются по имени с помощью знака равенства.\n",
    "\n",
    "У аргументов могут быть значения по умолчанию (они объявляются при создании функции). \n",
    "\n",
    "Обращаться к аргументам по имени особенно удобно, когда для некоторых из них нас устраивают дефолтные значения."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Для примера создадим функцию, которая \"создаёт кредиты\":"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Credit card', 0.28, None, 25000]\n",
      "['Cash loan', 0.25, 12, 100000]\n",
      "['Consumer finance', 0.35, 6, 25000]\n"
     ]
    }
   ],
   "source": [
    "def make_loan(loan_type = 'Credit card', interest_rate = 0.28\n",
    "              , duration = None, loan_amount = 25000):\n",
    "    return [loan_type, interest_rate, duration, loan_amount]\n",
    "\n",
    "print(make_loan()) # если аргументы не указывать, они принимают значения по умолчанию\n",
    "print(make_loan('Cash loan', 0.25, 12, 100000)) # если перечислять значения, они подставляются в аргумент с тем же номером\n",
    "print(make_loan('Consumer finance', duration = 6, interest_rate = 0.35)) # если называть аргументы по имени, номер не важен"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "def myprint(* args, ** kwargs):\n",
    "    for x in args:\n",
    "        print(x)\n",
    "myprint(1,2,3, a=4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "b36732b1-86ee-48be-b1de-75c7dfa68189"
    }
   },
   "source": [
    "Мы уже узнали, что функция ```range(b)``` создаёт последовательность целых чисел от 0 до b.\n",
    "\n",
    "Можно создать последовательность   от a до b, написав ```range(a,b)```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "nbpresent": {
     "id": "b24df9fa-263d-492e-b76c-e19a17a95c41"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "101\n",
      "102\n"
     ]
    }
   ],
   "source": [
    "for i in range(5):\n",
    "    print(i)\n",
    "for j in range(101, 103):\n",
    "    print(j)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Функции могут возвращать несколько значений"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(5, 6)\n",
      "5 6\n"
     ]
    }
   ],
   "source": [
    "def add_and_mul(x, y):\n",
    "    return x+y, x*y\n",
    "print(add_and_mul(2, 3))\n",
    "a, b = add_and_mul(2, 3)\n",
    "print(a, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "c249602a-f518-4360-ab85-a4f0a9d98305"
    }
   },
   "source": [
    "Любая хреновина в Питоне - это <i>объект</i>. Каждый объект принадлежит какому-то <i>классу</i>. Например, объекты 3 и 5 принадлежат классу \"целые числа\" (int), а объект [1,2,3,4,5] - классу \"списки\" (list).\n",
    "\n",
    "Узнать, какому классу принадлежит объект, можно, воспользовавшись функцией type()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "nbpresent": {
     "id": "5147a057-b32e-446a-b28b-e0473f474ec7"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'int'>\n",
      "<class 'str'>\n",
      "<class 'list'>\n"
     ]
    }
   ],
   "source": [
    "print(type(5))\n",
    "print(type(\"ololo\"))\n",
    "print(type([1,2,3]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'type'>\n"
     ]
    }
   ],
   "source": [
    "print(type(int))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "0ad7b2a4-4978-4f93-81c4-71bd81f002bd"
    }
   },
   "source": [
    "С каждым классом можно выполнять свои действия - например, числа можно умножать; и числа, и строки, и списки можно складывать; строки и списки можно индексировать (брать элементы по номеру).\n",
    "\n",
    "Кроме того, у каждого класса есть свои <i>свойства</i> (подобъекты) и <i>методы</i> (собственные функции). И те, и другие запускаются через точку.\n",
    "\n",
    "Например, метод lower() у текстовых строк - это функция, возвращающая эту строку в нижнем регистре. А метод append() у списков добавляет к ним новые элементы.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'a+b+c'"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'+'.join(list('abc'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['abc', 'def']"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"abc def\".split()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "nbpresent": {
     "id": "6818f011-5d5e-4c99-b978-3f865bf5f541"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "hello world!\n",
      "[3, 4, 5, 8]\n"
     ]
    }
   ],
   "source": [
    "print(\"Hello World!\".lower())\n",
    "\n",
    "a = [3,4,5]\n",
    "a.append(8)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "4523075e-f157-4e51-ada8-5656778230ff"
    }
   },
   "source": [
    "Понять, какие методы и свойства есть у объекта, можно с помощью функции dir().\n",
    "\n",
    "Методы, которые начинаются и заканчиваются на \"__\", являются \"техническими\", т.е. не предполагается, что юзер будет ими пользоваться в явном виде."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "nbpresent": {
     "id": "20ffe23a-7836-4858-8966-e2ee94c66ef3"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['__add__',\n",
       " '__class__',\n",
       " '__contains__',\n",
       " '__delattr__',\n",
       " '__delitem__',\n",
       " '__dir__',\n",
       " '__doc__',\n",
       " '__eq__',\n",
       " '__format__',\n",
       " '__ge__',\n",
       " '__getattribute__',\n",
       " '__getitem__',\n",
       " '__gt__',\n",
       " '__hash__',\n",
       " '__iadd__',\n",
       " '__imul__',\n",
       " '__init__',\n",
       " '__init_subclass__',\n",
       " '__iter__',\n",
       " '__le__',\n",
       " '__len__',\n",
       " '__lt__',\n",
       " '__mul__',\n",
       " '__ne__',\n",
       " '__new__',\n",
       " '__reduce__',\n",
       " '__reduce_ex__',\n",
       " '__repr__',\n",
       " '__reversed__',\n",
       " '__rmul__',\n",
       " '__setattr__',\n",
       " '__setitem__',\n",
       " '__sizeof__',\n",
       " '__str__',\n",
       " '__subclasshook__',\n",
       " 'append',\n",
       " 'clear',\n",
       " 'copy',\n",
       " 'count',\n",
       " 'extend',\n",
       " 'index',\n",
       " 'insert',\n",
       " 'pop',\n",
       " 'remove',\n",
       " 'reverse',\n",
       " 'sort']"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dir(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "nbpresent": {
     "id": "732ab7b4-71c0-46bd-86e8-269092f1eda0"
    }
   },
   "source": [
    "<b>Задание:</b>\n",
    "1. Узнайте, какому классу принадлежит значение выражения (2+2==5)\n",
    "2. Рассчитайте тангенс 0.55555"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Классы и их методы легко создавать самостоятельно."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A new animal has been created\n",
      "I am speaking\n",
      "Alan\n"
     ]
    }
   ],
   "source": [
    "class Animal:\n",
    "    # это первый метод\n",
    "    # У методов всегда есть первый, невидимый аргумент - self, ссылка на сам объект\n",
    "    def speak(self):\n",
    "        print(\"I am speaking\")\n",
    "    # это второй метод\n",
    "    def move(self):\n",
    "        print(\"I am moving\")\n",
    "    # этот метод у всех членов класса вызывается при создании\n",
    "    def __init__(self, name = \"Anonimous\"):\n",
    "        print(\"A new animal has been created\")\n",
    "        self.name = name\n",
    "\n",
    "# создание объекта определённого класса\n",
    "little_beast = Animal('Alan')\n",
    "little_beast.speak()\n",
    "print(little_beast.name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Можно взять какой-то из существующих классов (или даже несколько), и дополнить их чем-то своим."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "A new animal has been created\n",
      "\tA new dog has been created\n",
      "Bow-wow!\n",
      "I am moving\n"
     ]
    }
   ],
   "source": [
    "class Dog(Animal):\n",
    "    # часть методов можно переписать\n",
    "    def __init__(self, name):\n",
    "        # вызываем метод класса-родителя\n",
    "        super(Dog, self).__init__(name)\n",
    "        print(\"\\tA new dog has been created\")\n",
    "    def speak(self):\n",
    "        print(\"Bow-wow!\")\n",
    "chuppy = Dog(\"Chuppy\")\n",
    "chuppy.speak()\n",
    "chuppy.move()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Задание**. Напишите класс ```Cat``` c какими-нибудь кошачьими методами и свойствами"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "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.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}