lect04. Functions/Functions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Центр непрерывного образования\n",
    "\n",
    "# Программа «Python для автоматизации и анализа данных»\n",
    "\n",
    "Неделя 4 - 1\n",
    "\n",
    "*Ян Пиле, НИУ ВШЭ*  \n",
    "\n",
    "# Устройство функций в Python. Написание простейших функций. Lambda-функции. Функция map(). Написание сложных функций. Декораторы, Генераторы, Рекурсия."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Что такое функция в Python?\n",
    "\n",
    "По своей сути функции в Python практически ничем не отличаются от функций из других языков программирования. Функцией называют именованный фрагмент программного кода, к которому можно обратиться из другого места вашей программы (но есть lambda-функции, у которых нет имени, о них будет рассказано в конце урока). Как правило, функции создаются для работы с данными, которые передаются ей в качестве аргументов, также функция может формировать некоторое возвращаемое значение. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Объявляя функцию, нужно следовать определенным правилам:\n",
    "\n",
    "Объявление происходит с помощью ключевого слова **def**, за ним идёт имя функции и круглые скобки ().\n",
    "\n",
    "**Аргументы**, передаваемые в функцию, должны находится в круглых скобках. Там же можно определить их значения по умолчанию, указав их после знака равно.\n",
    "\n",
    "Перед основным содержимым желательно включить **строку документации** (docstring), которая обычно описывает назначение  и основные принципы работы функции.\n",
    "\n",
    "**Тело функции** начинается после знака двоеточия. Важно не забыть об отступах.\n",
    "\n",
    "Чтобы выйти из функции в Python, используют оператор **return [значение]**. Если оператор опущен, будет возвращено значение None.\n",
    "\n",
    "Функцию можно объявить где угодно: внутри модуля, класса или другой функции. Если она объявляет внутри класса, то называется методом класса и вызывается так: *class_name.function()*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['1', '2', '3', '4']"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(map(str,[1,2,3,4]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "def Имя(аргументы):\n",
    "    '''\n",
    "    Документация\n",
    "    '''\n",
    "    Тело (инструкции)\n",
    "    return None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "from scipy.stats import ttest_ind\n",
    "ttest_ind??"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 5]"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted([3,2,1,5])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None [1, 2, 3, 5]\n"
     ]
    }
   ],
   "source": [
    "l = lst.sort()\n",
    "\n",
    "print(l, lst)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "На самом деле мы уже использовали огромное количество функций и методов (str(), float(), .add(), .count() и так далее). \n",
    "\n",
    "Попробуем самостоятельно реализовать функцию, складывающую два числа и выводящую результат на печать:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "def summarize(a:int, \n",
    "              b:int) -> int:\n",
    "    \n",
    "#     print(summ)\n",
    "    return a + b\n",
    "     # вернёт None (Для любителей С++ это +- то же самое, что return 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "summarize(1,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x is None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'avv'"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "summarize('a','vv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'avv'"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Теперь эту функцию в любом месте кода можно вызвать:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "aaa = ['a', 'b']\n",
    "x = summarize(*aaa)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ab'"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Написать функцию для вычисления дисперсии значений в списке\n",
    "\n",
    "## $\\sigma^2 = \\frac{1}{N} \\sum{(x_i - avg(x))^2} = \\frac{1}{N} \\sum{x_i^2} - (\\frac{1}{N}\\sum{x_i})^2$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "l = [1,2,3,4,5,6,7]\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.var??"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.0"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.var(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len([])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.6666666666666667"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "variance(my_list = [1,2,3,4], is_unbiased = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "def variance(my_list, is_unbiased = False):\n",
    "    '''\n",
    "    Calculates variance of list values\n",
    "    \n",
    "    my_list: list of numbers\n",
    "    is_unbiased: bool - True if N-1 is used for variance calculation\n",
    "                        False if N is used\n",
    "    \n",
    "    return: sigma_squared -> float\n",
    "    '''\n",
    "    assert isinstance(is_unbiased, bool)\n",
    "    \n",
    "    length = len(my_list)\n",
    "    if length <= 1:\n",
    "        return 0\n",
    "    mean = sum(my_list)/length # среднее\n",
    "    \n",
    "    sum_of_squares = sum([(x - mean)**2 for x in my_list]) #сумма квадратов отклонений\n",
    "    \n",
    "    \n",
    "    sigma_squared = sum_of_squares/(length - int(is_unbiased)) # Хитро придумано в аудитории)\n",
    "    return sigma_squared"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "NoneType"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "А еще можно подать функцию в качестве аргумента для другой функции или записать ее в переменную:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "non-default argument follows default argument (<ipython-input-25-537130a82e59>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-25-537130a82e59>\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m    def summ(b = 2, a):\u001b[0m\n\u001b[0m             ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m non-default argument follows default argument\n"
     ]
    }
   ],
   "source": [
    "def summ(b = 2, a):\n",
    "    summ = a + b\n",
    "    return summ # вернёт сумму\n",
    "\n",
    "c = summ(4, 3) # переменная c будет равна возвращаемому значению\n",
    "\n",
    "\n",
    "print(c)\n",
    "print(summ(2)) # можно передать значения в аргументы другой функции\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "def summ(a ='string'):\n",
    "    a = a+'dfghjmk,'\n",
    "    return a.swapcase()\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'STRINGDFGHJMK,'"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "summ()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "При описании функции в *Python 3* можно задать аргументы с какими-либо начальными значениями, такие аргументы являются \"необязательными\". Вначале нужно описывать обязательные параметры, а после них – необязательные.\n",
    "При вызове функции не обязательно указывать значения \"необязательных\" параметров (спасибо, кэп). Если мы хотим изменить значение аргумента, не меняя начальные значения других аргументов, можно обращаться к нему по ключу."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\n",
    "# (str, 'fdgshj')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isinstance('456', str)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "ename": "AssertionError",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAssertionError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-38-1de76dd60f7e>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      5\u001b[0m     \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mthird\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      6\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 7\u001b[0;31m \u001b[0mexample\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\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-38-1de76dd60f7e>\u001b[0m in \u001b[0;36mexample\u001b[0;34m(first, second, third)\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mexample\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfirst\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0msecond\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m3\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mthird\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;36m5\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;32massert\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfirst\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mstr\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m     \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfirst\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m     \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0msecond\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m     \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mthird\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mAssertionError\u001b[0m: "
     ]
    }
   ],
   "source": [
    "def example(first, second=3, third=5):\n",
    "    assert isinstance(first, str)\n",
    "    print(first)\n",
    "    print(second)\n",
    "    print(third)\n",
    "    \n",
    "example(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "my string\n",
      "3\n",
      "dfgh\n"
     ]
    }
   ],
   "source": [
    "example('my string', third ='dfgh')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re\n",
    "re.split??"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "А еще функция может быть пустой и ничего не делать. Выглядит это так:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "def foo(a: int, b:int):\n",
    "    #TODO\n",
    "    '''\n",
    "    \n",
    "    '''\n",
    "    pass\n",
    "    #Оператор-заглушка, равноценный отсутствию операции."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "NoneType"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def foo2(z):\n",
    "    x = foo(z[0], z[1])\n",
    "    \n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 68, 74, 59]"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = {1,4,5,74,68,59,2,3,4}\n",
    "list(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "А что если параметров у функции несколько, но только мы не знаем, сколько. Например, мы хотим складывать числа, которые пользователь вводит с клавиатуры, но мы заранее не знаем, сколько чисел он собирается ввести. Уже несколько раз мы упоминали такое понятие, как \"распаковка\" списков, кортежей и словарей (когда записывается что-то в духе \\*list_name или \\*\\*dictionary_name). "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Напоминание:\n",
    "Если мы хотим сожержимое двух списков положить в третий список или содержимое двух словарей положить в третий словарь, на помощь нам приходит так называемый \"звездочный синтаксис\":"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5, 6]"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list1 = [1,2,3]\n",
    "list2 = (4,5,6)\n",
    "\n",
    "list3 = [*list1,*list2] ##положили все элементы обоих списков в третий\n",
    "list3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3\n"
     ]
    }
   ],
   "source": [
    "print(*map(str,[1,2,3]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 43 5 7\n"
     ]
    }
   ],
   "source": [
    "print(1,2,3,43,5,7)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 1 2 3 4 5 6 7 8 9\n"
     ]
    }
   ],
   "source": [
    "print(*range(10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "f g h j\n"
     ]
    }
   ],
   "source": [
    "a = 'fghj'\n",
    "print(*a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "dict1 = {'a':1,'b':2,'c':3}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a b c\n"
     ]
    }
   ],
   "source": [
    "print(*dict1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 4 5 6 7 8 654\n"
     ]
    }
   ],
   "source": [
    "print(1,2,3,4,5,6,7,8,654)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 4, 'b': 2, 'c': 3, 'e': 5, 'f': 6}"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict1 = {'a':1,'b':2,'c':3}\n",
    "dict2 = {'a':4,'e':5,'f':6}\n",
    "\n",
    "dict3 = {**dict1,**dict2} ##положили все элементы обоих словарей в третий\n",
    "dict3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Точно таким же образом можно что-то указать \"в явном виде\", а что-то распаковать из структуры (например, вы хотите дописать в новый список числа 3 и 4):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[3, 4, [0, 1, 2]]\n",
      "[3, 4, 0, 1, 2]\n"
     ]
    }
   ],
   "source": [
    "list1 = [0,1,2]\n",
    "print([3,4,list1]) # тут элементом стал сам список\n",
    "print([3,4,*list1]) # а тут мы элементы списка распаковали"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### В функции точно так же можно подавать несколько аргументов!\n",
    "Даже если вы заранее не знаете, сколько их будет. Вспомните, например, функцию print(). Она умеет давать ответ и при одном аргументе, и при двух и при любом N."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sum: 35\n"
     ]
    }
   ],
   "source": [
    "def adder(x, y, z):\n",
    "    print(\"sum:\",x + y + z)\n",
    "\n",
    "adder(10, 12, 13)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3\n"
     ]
    }
   ],
   "source": [
    "print(1,2,3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### \\*args и \\*\\*kwargs спешат на помощь\n",
    "В Python можно передать переменное количество аргументов двумя способами:\n",
    "\n",
    "* \\*args для неименованных аргументов;\n",
    "* \\*\\*kwargs для именованных аргументов.\n",
    "Мы используем \\*args и \\*\\*kwargs в качестве аргумента, когда заранее не известно, сколько значений мы хотим передать функции."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### \\*args\n",
    "Как было сказано, \\*args нужен, когда мы хотим передать неизвестное количество неименованных аргументов. Если поставить * перед именем, это имя будет принимать не один аргумент, а несколько. Аргументы передаются как кортеж и доступны внутри функции под тем же именем, что и имя параметра, только без *."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nums = (1,2,3,4,5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "# a,b,c,d,e = [1,2,3,4,5]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sum:  8\n",
      "Sum:  22\n",
      "Sum:  17\n"
     ]
    }
   ],
   "source": [
    "def adder(*nums):\n",
    "    summ = 0\n",
    "#     print(type(nums))\n",
    "    for n in nums:\n",
    "        summ += n\n",
    "\n",
    "    print(\"Sum: \", summ)\n",
    "\n",
    "adder(3, 5)\n",
    "adder(4, 5, 6, 7)\n",
    "adder(1, 2, 3, 5, 6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sum:  8\n"
     ]
    }
   ],
   "source": [
    "adder(3,5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### \\*\\*kwargs\n",
    "По аналогии с \\*args мы используем \\*\\*kwargs для передачи переменного количества именованных аргументов. Схоже с \\*args, если поставить ** перед именем, это имя будет принимать любое количество именованных аргументов. Кортеж/словарь из нескольких переданных аргументов будет доступен под этим именем. Например:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a': 1, 'b': 2, 'c': 4}"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "dict(a=1, b=2, c=4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "Data type of argument:  <class 'dict'>\n",
      "Firstname is Yoko\n",
      "Lastname is Ono\n",
      "Age is 87\n",
      "Phone is 1234567890\n",
      "There's a firstname\n",
      "\n",
      "Data type of argument:  <class 'dict'>\n",
      "Firstname is John\n",
      "Lastname is Lennon\n",
      "Email is johnlennon@nomail.com\n",
      "Country is UK\n",
      "Age is 40\n",
      "Phone is 9876543210\n",
      "There's a firstname\n"
     ]
    }
   ],
   "source": [
    "def intro(**data):\n",
    "    print(\"\\nData type of argument: \",type(data))\n",
    "\n",
    "    for key, value in data.items():\n",
    "        print(\"{} is {}\".format(key, value))\n",
    "    \n",
    "    if 'Firstname' in data:\n",
    "        print('There\\'s a firstname')\n",
    "\n",
    "intro(Firstname=\"Yoko\", Lastname=\"Ono\", Age=87, Phone=1234567890)\n",
    "intro(Firstname=\"John\", Lastname=\"Lennon\", Email=\"johnlennon@nomail.com\", Country=\"UK\", Age=40, Phone=9876543210)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'data' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-48-c5d84736ba45>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mdata\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'data' is not defined"
     ]
    }
   ],
   "source": [
    "data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В этом случае у нас есть функция **intro()** с параметром \\*\\*data. В функцию мы передали два словаря разной длины. Затем внутри функции мы прошлись в цикле по словарям, чтобы вывести их содержимое."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Локальные и глобальные переменные aka Области видимости\n",
    "\n",
    "#### Локальные переменные\n",
    "Для создания переменных, обладающих локальной областью видимости, необходимо всего лишь поместить их в отдельный блок кода, изолированный от остальной программы. Например, у нас таким свойством обладают все переменные, которые мы прежде использовали в функциях, например:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "35\n"
     ]
    },
    {
     "ename": "NameError",
     "evalue": "name 'output2' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-50-c0f17a2c8e92>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      7\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      8\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mf\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\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----> 9\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0moutput2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'output2' is not defined"
     ]
    }
   ],
   "source": [
    "output = 34\n",
    "\n",
    "def f(x):\n",
    "#     output = x+1\n",
    "    output2 = x + output\n",
    "    return output2\n",
    "\n",
    "print(f(1))\n",
    "print(output2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Функция у нас сработала, а вот переменную за пределами функции мы не видим. А что если мы попробуем изнутри функции использовать переменную, определенную вовне?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11\n"
     ]
    }
   ],
   "source": [
    "def foo(z):\n",
    "    print(tt)\n",
    "    return None\n",
    "\n",
    "tt = 11\n",
    "\n",
    "foo(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Сработало! Более того - все переменные, объявленные \"в более широкой области видимости\" всегда доступны \"в более узкой области видимости\". Попробуем завернуть несколько функций друг в друга и взглянуть на значения:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4300355936"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "id(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100 4341409216\n",
      "200 4341412416\n",
      "100 4341409216\n",
      "100\n",
      "250 4341414016\n"
     ]
    }
   ],
   "source": [
    "x = 250\n",
    "\n",
    "def f1():\n",
    "    x =  100 \n",
    "    print(x, id(x))\n",
    "    \n",
    "    def f2():\n",
    "        x = 200\n",
    "        print(x, id(x))\n",
    "    f2()\n",
    "    print(x, id(x))\n",
    "    return x\n",
    "print(f1())\n",
    "print(x, id(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [],
   "source": [
    "id??"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Выведено было значение с \"самого высокого уровня\"."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Если нам все-таки нужно использовать значение переменной \"изнутри\" функции, можно сказать , что мы объявляем глобальную переменную. Для этого используется выражение **global**\n",
    "\n",
    "(Разобраться с ошибкой)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "local 1 value\n",
      "global value\n",
      "local 2 value\n",
      "local 1 value\n",
      "local 2 value\n"
     ]
    }
   ],
   "source": [
    "def f():\n",
    "    s = \"local 1 value\"\n",
    "    print(s)\n",
    "    def ff():\n",
    "        global s\n",
    "        print(s)\n",
    "        s = \"local 2 value\"\n",
    "        print(s)\n",
    "    ff()\n",
    "    print(s)\n",
    "\n",
    "\n",
    "s = \"global value\" \n",
    "f()\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Здесь мы вызвали функцию и она перезаписала нам значение в переменную s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В Python 3 есть еще один тип переменных, который позволяет использовать значение внутри областей видимости, но не выносить их в глобальную область. Это так называемые **nonlocal** переменные."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "before ff Frankfurt am Maine\n",
      "Before calling g: Munich\n",
      "Calling g now:\n",
      "After calling g: Zurich\n",
      "after ff Frankfurt am Maine\n",
      "'city' in main: Stuttgart\n"
     ]
    }
   ],
   "source": [
    "def f():\n",
    "    city = \"Frankfurt am Maine\"\n",
    "    def ff():\n",
    "        city = \"Munich\"\n",
    "        def g():\n",
    "            nonlocal city\n",
    "            city = \"Zurich\"\n",
    "        print(\"Before calling g: \" + city)\n",
    "        print(\"Calling g now:\")\n",
    "        g()\n",
    "        print(\"After calling g: \" + city)\n",
    "    print('before ff', city)\n",
    "    ff()\n",
    "    print('after ff', city)\n",
    "    \n",
    "    \n",
    "city = \"Stuttgart\"\n",
    "f()\n",
    "print(\"'city' in main: \" + city)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Видно, что в глобальную область видимости Цюрих не доехал, но в локальной он переехал со 1го уровня вложенности в функцию f :)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Lambda-функции\n",
    "Это особый вид функций, которые объявляются с помощью ключевого слова **lambda** вместо **def**:\n",
    "Лямбда-функции принимают любое количество аргументов, но не могут содержать несколько выражений и всегда возвращают только одно значение.\n",
    "В программировании на **Python** можно обойтись без анонимных функций, которые по сути являются обычными, но без имени и с ограничением в одно выражение. Однако их использование в нужных местах упрощает написание и восприятие кода. Пишется так:\n",
    "\n",
    "* lambda arguments: expression\n",
    "\n",
    "arguments - аргументы, expression - выражение, возвращающее значение.\n",
    "\n",
    "Пример (lambda функция, которая добавляет к переданному аргументу 1 и возвращает результат):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4, 5, 6, 7, 8]"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "add_1 = lambda x: [i for i in range(x + 1)]\n",
    "(lambda x: list(range(x + 1)))(8) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 4, 9, 9, 25]"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(map(lambda x: x**2, \n",
    "         [1,2,3,3,5]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f(x):\n",
    "    return x**2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function __main__.<lambda>(x)>"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import math\n",
    "lambda x: math.sqrt(f(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4, 5, 6, 7, 8]"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "add_1(8)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "А если мы вдруг решили сложить два числа, то это тоже можно сделать с помощью лямбда-функции:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n"
     ]
    }
   ],
   "source": [
    "# add_2 = lambda x, y: x + y\n",
    "print((lambda x, y: x + y)(3,4))\n",
    "# add_2(3, 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1], [1, 2], [1, 2, 3], [1, 2, 3, 4], [1, 2, 3, 4, 5], [1, 2, 3, 4, 5, 6]]"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import math\n",
    "lst = [1,2,3,4,5,6]\n",
    "list(map(lambda ff: list(range(1,ff+1)),\n",
    "         lst))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Заработало! А если по-другому назвать аргументы?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "def aa(x):\n",
    "    if x>0:\n",
    "        return x+5\n",
    "    else:\n",
    "        return 'foo'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "add_2 = lambda f123, er45: f123 + er45\n",
    "add_2(3, 4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Во всех трех примерах мы все-таки присвоили имя каждой из функций. Давайте попробуем вызвать функцию по-настоящему анонимно. Аргументы передаются в скобках после скобок, содержащих определение lambda функции"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(lambda x, y: x * y)(3, 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "По сути, лямбда-функции умеют все, что и обычные функции, только они обязаны возвращать всего одно значение. \n",
    "* Они умеют работать с разными типами данных (Строками, например)\n",
    "* Можно вызывать функцию без параметров\n",
    "* Параметрам функции можно задать значения по умолчанию"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = True\n",
    "1 if x is False else 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[['ololo'], ['ololo'], 2, 3, ['ololo'], 3]"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(map(lambda x: x if x > 0 else ['ololo'], \n",
    "         [-1,0,2,3,-5,3]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Ха-Ха-Ха-'"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Со строками\n",
    "(lambda x, y: x * y)(\"Ха-\",3)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ПерваяВторая'"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(lambda x: x + y)(\"Первая\",\"Вторая\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3]"
      ]
     },
     "execution_count": 128,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# А вот тут без аргументов\n",
    "(lambda: [0,1,2,3])()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'35'"
      ]
     },
     "execution_count": 129,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# А тут есть значения по умолчанию\n",
    "(lambda x=3, y = 5: str(x) + str(y))()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Здесь в качестве первого аргумента пришел список, а второй использовался по умолчанию\n",
    "# На выходе должны получить первый элемент первого списка + 3\n",
    "(lambda x,y=3: x[0] + y)([1,2,3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "6\n",
      "6\n",
      "6\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "print((lambda x, y, z: x + y + z)(1, 2, 3)) # Три аргумента\n",
    "\n",
    "print((lambda x, y, z=3: x + y + z)(1, 2)) # Три аргумента и у одного default-значение\n",
    "\n",
    "print((lambda x, y, z=3: x + y + z)(1, y=2)) # Три аргумента, у одного default-значение и один мы передали \"по имени\"\n",
    "\n",
    "print((lambda *args: sum(args))(1,2,3)) # Передали кортеж аргументов и сложили\n",
    "\n",
    "print((lambda **kwargs: sum(kwargs.values()))(one=1, two=2, three=3)) # Передали словарь аргументов и сложили"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[5, 6, 66, 2, 7, 52, 3, 4, 34]"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ls = [2,3,4,5,6,7,34,52,66]\n",
    "\n",
    "sorted(ls, key = lambda x: x%5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 0\n",
    "y = 3\n",
    "\n",
    "1 if x > 1 else (3 if y ==3 else 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 0, 1, 0, 1, 0, 1, 1, 1]"
      ]
     },
     "execution_count": 131,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(map(lambda x: 1 if x%2==0 else 0, ls))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('foo', 's')"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def my_foo(x):\n",
    "    if x>0:\n",
    "        return 1\n",
    "    elif x<0:\n",
    "        return 'Not ok'\n",
    "    else:\n",
    "        return ('foo','s')\n",
    "\n",
    "my_foo(0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Напоминание о map"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Лямбда-функции очень часто применяются для преобразования каких-то коллекций. Для этого lambda-функции можно подавать в функцию map. Мы с вами уже множество раз использовали map, например, для преобразования списков. Давайте возьмем список и возведем все его элементы в квадрат с помощью map и lambda-функции."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 27, 64, 216]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = [1,3,4,6]\n",
    "def to_str(x):\n",
    "    return str(x)\n",
    "list(map(lambda x: x**3, a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1.533193836262976"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2.275665004746159,\n",
       " 24.77772884781554,\n",
       " 15.230535679219289,\n",
       " 3.27195267083832,\n",
       " 42.84087455484725,\n",
       " -9.524948760492148]"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(map(lambda x: np.random.normal(loc = x, scale = 20),\n",
    "    [12,3,4,5,6,7]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['2', '3', '4']"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import re\n",
    "re.findall(r'\\d',str(234))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1.0"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from math import cos, pi, sin\n",
    "cos(pi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Напишем функцию для \"Приближенного интегрирования\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "to_integrate - функция от х, которую мы собираемся интегрировать"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 11 µs, sys: 14 µs, total: 25 µs\n",
      "Wall time: 28.8 µs\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "from math import cos, sin"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [],
   "source": [
    "def to_integrate(x):\n",
    "    return 28*x**3 -7*x + cos(x)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[<matplotlib.lines.Line2D at 0x7feaba9dd340>]"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAXcAAAD4CAYAAAAXUaZHAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjIsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+WH4yJAAAgAElEQVR4nO3deXxcdb3/8dcna/cl3fd9oQvdYgtFUShLQbSoFMsFrFgseisXuHoVUH+uVeTeyxVU1ErFImsRkIos1oBaBNqmtKVLWhqaLumWdE+TZpt8fn/kFEObNtM2kzMzeT8fjzzmzPeck/l8c9p3Tr5z5nzN3RERkeSSEnYBIiLS+BTuIiJJSOEuIpKEFO4iIklI4S4ikoTSwi4AoHPnzt6/f/+wyxARSSgrVqzY6+5d6lsXF+Hev39/cnNzwy5DRCShmNnWk63TsIyISBJSuIuIJCGFu4hIElK4i4gkoQbD3cyGmdmqOl+Hzex2M8sys8Vmtil47Fhnn7vMLN/MNprZ5bHtgoiIHK/BcHf3je4+1t3HAhOAMuA54E4gx92HADnBc8xsBDADGAlMBR40s9QY1S8iIvU43WGZKcB77r4VmAYsCNoXAFcHy9OAJ929wt0LgHxgYmMUKyIi0TndcJ8BPBEsd3P3XQDBY9egvRewvc4+hUHbB5jZbDPLNbPc4uLi0yxDRCTxPfzPAl7dsCcm3zvqcDezDOCTwNMNbVpP2wk3jXf3ee6e7e7ZXbrU+wErEZGktftQOT9+aQMvrtkdk+9/OmfuVwBvu/uxXzN7zKwHQPBYFLQXAn3q7Ncb2Hm2hYqIJJNfvJZPTY1z25QhMfn+pxPu1/GvIRmARcDMYHkm8Hyd9hlmlmlmA4AhwLKzLVREJFkUHijjyeXbmJ7dhz5ZrWLyGlHdW8bMWgGXArfUab4HWGhms4BtwHQAd19nZguB9UA1MMfdI41atYhIAvv5q/kYxq0XD47Za0QV7u5eBnQ6rm0ftVfP1Lf9XGDuWVcnIpJktu4r5ekVhdwwqS89O7SM2evoE6oiIk3o/pxNpKUYcy6K3Vk7KNxFRJpMftER/rhyBzee14+u7VrE9LUU7iIiTeT+nE20SE/lSx8bFPPXUriLiDSBjbtLeOGdncyc3J/ObTJj/noKdxGRJvB/i9+ldUYasz8ysEleT+EuIhJj7xQe5OV1u/nChwfQsXVGk7ymwl1EJMb++5WNdGyVzhc/MqDJXlPhLiISQ//M38uSTXuZc9Fg2rZIb7LXVbiLiMSIu3PvKxvp0b4FN5zXr0lfW+EuIhIjr6zbw+rtB7njkqG0SG/aOYsU7iIiMRCpcf7nLxsZ1KU1nx5/wpQWMadwFxGJgWffLiS/6Ahfu2wYaalNH7UKdxGRRlZeFeGnf93Eub3bM3VU91BqULiLiDSyx5ZuY8fBo3xj6nDM6pucLvYU7iIijehIRTW/eC2fCwZ34oLBnUOrQ+EuItKIfv3399hfWsnXLx8eah0KdxGRRrLncDm/WbKZT4zpyZg+HUKtReEuItJI7vvLu0RqnP+6bFjYpSjcRUQaw8bdJTy9YjufO78/fTvFZtLr06FwFxFpBPe8lEfrzDS+EuPp86IVVbibWQcz+4OZbTCzPDM738yyzGyxmW0KHjvW2f4uM8s3s41mdnnsyhcRCd8b+Xt5bWMxX7locJPd0rch0Z653w+87O7DgTFAHnAnkOPuQ4Cc4DlmNgKYAYwEpgIPmlnT3lRBRKSJ1NQ4P3opj14dWjJzcv+wy3lfg+FuZu2AC4H5AO5e6e4HgWnAgmCzBcDVwfI04El3r3D3AiAfmNjYhYuIxINFq3eydsdhvnZ5098c7FSiOXMfCBQDD5vZSjN7yMxaA93cfRdA8Ng12L4XsL3O/oVB2weY2WwzyzWz3OLi4rPqhIhIGMqrIvz3KxsZ2bMd08Y0/c3BTiWacE8DxgO/dPdxQCnBEMxJ1PdZWz+hwX2eu2e7e3aXLl2iKlZEJJ787o0t7Dh4lLuvPIeUlHBuM3Ay0YR7IVDo7kuD53+gNuz3mFkPgOCxqM72fers3xvY2TjliojEh+KSCn7+aj5ThncN9TYDJ9NguLv7bmC7mR27Kn8KsB5YBMwM2mYCzwfLi4AZZpZpZgOAIcCyRq1aRCRk9y1+l/KqCHd//JywS6lXWpTb3Qo8ZmYZwGbgJmp/MSw0s1nANmA6gLuvM7OF1P4CqAbmuHuk0SsXEQnJ+p2HeWr5Nj4/eQCDurQJu5x6RRXu7r4KyK5n1ZSTbD8XmHsWdYmIxCV35wcvrKddy3RumzIk7HJOSp9QFRE5DYvX7+HNzfu445KhtG+VHnY5J6VwFxGJUmV1DT96MY/BXdvwb5P6hl3OKSncRUSi9MibW9iyr4xvffwc0kOYF/V0xHd1IiJxYt+RCu7P2cTHhnXhY8O6NrxDyBTuIiJR+N/F71JWGeFbcXrp4/EU7iIiDVi74xBPLNvG587vx+CubcMuJyoKdxGRU3B3vrNoHVmtMrj9kqFhlxM1hbuIyCk8t3IHK7Ye4BtXDKd9y/i99PF4CncRkZMoKa/iRy9uYGyfDlwzvnfY5ZyWaG8/ICLS7DyQs4l9pRXMn5kdd3d9bIjO3EVE6pFfVMLD/9zCtRP6MKZPh7DLOW0KdxGR47g73120nlYZqXx96rCGd4hDCncRkeO8sm43r+fv5T8vHUqnNplhl3NGFO4iInWUVlTz/T+tZ3j3ttxwXr+wyzljCncRkToeyNnEzkPl/PDqUaTF+f1jTiVxKxcRaWQbd5cw//UCrs3uTXb/rLDLOSsKdxERat9E/dYf19CmRRp3XpEY9485FYW7iAjwhxWFLN9ygLuvOIes1hlhl3PWFO4i0uwdKK3kxy9tILtfR66ZkFifRD2ZqMLdzLaY2RozW2VmuUFblpktNrNNwWPHOtvfZWb5ZrbRzC6PVfEiIo3h3lc2cOhoFT/81KiE+yTqyZzOmftF7j7W3Y9NlH0nkOPuQ4Cc4DlmNgKYAYwEpgIPmllqI9YsItJoVmw9wBPLtjPrwwMY3r1d2OU0mrMZlpkGLAiWFwBX12l/0t0r3L0AyAcmnsXriIjERFWkhm8+t4ae7Vtw25QhYZfTqKINdwf+YmYrzGx20NbN3XcBBI/H5p3qBWyvs29h0PYBZjbbzHLNLLe4uPjMqhcROQvz/rGZDbtL+N60UbTOTK77KEbbmwvcfaeZdQUWm9mGU2xb34CVn9DgPg+YB5CdnX3CehGRWCrYW8r9OZu4cnR3Lh3RLexyGl1UZ+7uvjN4LAKeo3aYZY+Z9QAIHouCzQuBPnV27w3sbKyCRUTOlrtz17PvkJmWwnc/MTLscmKiwXA3s9Zm1vbYMnAZsBZYBMwMNpsJPB8sLwJmmFmmmQ0AhgDLGrtwEZEztTB3O29t3s/dV55D13Ytwi4nJqIZlukGPGdmx7Z/3N1fNrPlwEIzmwVsA6YDuPs6M1sIrAeqgTnuHolJ9SIip6mopJy5f85j4oAsPpvdp+EdElSD4e7um4Ex9bTvA6acZJ+5wNyzrk5EpJF970/rKa+u4cefHp0017TXR59QFZFmIydvD39+Zxe3XjSYQV3ahF1OTCncRaRZOFxexbf+uJZh3dpyy0cHhV1OzCXXhZ0iIifx4xfz2HO4nAevH09GWvKf1yZ/D0Wk2VuyqZgnlm3nixcOZFzfjg3vkAQU7iKS1I5UVHPnM2sY2KU1d1wyNOxymoyGZUQkqf34xTx2HjrKH740mRbpzecehjpzF5Gk9Ub+Xh5buo2bPzyACf2ax3DMMQp3EUlKpRXVfP2ZdxjQuTVfvWxY2OU0OQ3LiEhS+snLG9hx8CgLbzm/WQ3HHKMzdxFJOm/k7+WRN7fy+cn9+VD/rLDLCYXCXUSSyqGjVXzt6dUM7NKar18+POxyQqNhGRFJKt9btI49JRU88+XJtMxofsMxx+jMXUSSxktrdvHsyh3MuWgwY/t0CLucUCncRSQpFJWUc/dzaxjdqz23Xjw47HJCp3AXkYTn7tz1zBpKKyP832fHkJ6qaNNPQEQS3lPLt5OzoYhvTB3O4K5twy4nLijcRSShbdtXxg9eWM/5Aztx0+T+YZcTNxTuIpKwqiI1/MeTK0lJMf57+rlJPbPS6dKlkCKSsB7I2cSq7Qf5+b+No3fHVmGXE1eiPnM3s1QzW2lmLwTPs8xssZltCh471tn2LjPLN7ONZnZ5LAoXkebtrc37+Plr+Uyf0Jurzu0Zdjlx53SGZW4D8uo8vxPIcfchQE7wHDMbAcwARgJTgQfNrPl+kkBEGt2hsirueGoV/bJa8d1Pjgy7nLgUVbibWW/g48BDdZqnAQuC5QXA1XXan3T3CncvAPKBiY1Trog0d+7OXc+9Q3FJBffPGEfrTI0u1yfaM/efAl8Hauq0dXP3XQDBY9egvRewvc52hUHbB5jZbDPLNbPc4uLi0y5cRJqnp3MLeXHNbr562TDGNPNPoZ5Kg+FuZlcBRe6+IsrvWd/b1X5Cg/s8d8929+wuXbpE+a1FpDnbXHyE7yxax+RBnbjlwoFhlxPXovl75gLgk2Z2JdACaGdmjwJ7zKyHu+8ysx5AUbB9IdCnzv69gZ2NWbSIND/lVRHmPL6SFukp3HftWF322IAGz9zd/S537+3u/al9o/RVd78BWATMDDabCTwfLC8CZphZppkNAIYAyxq9chFpVr7/wnrydh3mvmvH0r19i7DLiXtn807EPcBCM5sFbAOmA7j7OjNbCKwHqoE57h4560pFpNlatHonjy/dxi0fHchFw7s2vINg7icMhze57Oxsz83NDbsMEYlDBXtLueqBJQzv0Y4nZ5+nm4LVYWYr3D27vnX6KYlI3CqvijDnsbdJT0vhZ9eNU7CfBl0gKiJx64d/Xs/6XYeZPzObnh1ahl1OQtGvQRGJS39avZNH39rGLRcOZMo53cIuJ+Eo3EUk7uQXlfCNZ95hfN8OfO3yYWGXk5AU7iISV0rKq5j9+xW0ykjlwesnaJz9DGnMXUTihrvz9T+8w9Z9ZTw6a5KuZz8L+pUoInHjN0s289La3dw5dTjnD+oUdjkJTeEuInHhjff2cs9LG7hydHdu/siAsMtJeAp3EQndrkNHufXxlQzo3Jp7rxmDme4bc7YU7iISqvKqCF9+9G3KqyL8+sYJtNH92RuFfooiEhp355vPrWXV9oP86obxDO7aNuySkobO3EUkNPNfL+CZtwu5bcoQpo7qEXY5SUXhLiKhWLKpmB+9mMflI7tx25QhYZeTdBTuItLktuwt5SuPr2Rot7aaeCNGFO4i0qRKyqu4+ZFcUgx+87lsTXAdI/qpikiTidQ4dzy1ioK9pfx+1kT6ZLUKu6SkpTN3EWkyP34xj7/mFfHdT4xg8qDOYZeT1BTuItIkHn1rKw+9XsBNF/TnxvP7h11O0lO4i0jM/f3dYr6zaB0XD+/Ktz4+IuxymgWFu4jE1MbdJXzlsbcZ2q0tD1w3jlRdGdMkGgx3M2thZsvMbLWZrTOz7wXtWWa22Mw2BY8d6+xzl5nlm9lGM7s8lh0QkfhVXFLBF363nJYZqfz289m6tUATiubMvQK42N3HAGOBqWZ2HnAnkOPuQ4Cc4DlmNgKYAYwEpgIPmllqLIoXkfh1tDLCFx/JZX9pJfNnfoge7TUHalNqMNy91pHgaXrw5cA0YEHQvgC4OlieBjzp7hXuXgDkAxMbtWoRiWvVkRpufWIlqwsP8tMZYxndu33YJTU7UY25m1mqma0CioDF7r4U6ObuuwCCx67B5r2A7XV2Lwzajv+es80s18xyi4uLz6YPIhJH3J1vP7+Ov+bt4fufHMnlI7uHXVKzFFW4u3vE3ccCvYGJZjbqFJvX926J1/M957l7trtnd+nSJbpqRSTu/ezVfJ5Yto05Fw3SJY8hOq2rZdz9IPA3asfS95hZD4DgsSjYrBDoU2e33sDOs65UROLeU8u3cd/id/n0+F587bJhYZfTrEVztUwXM+sQLLcELgE2AIuAmcFmM4Hng+VFwAwzyzSzAcAQYFljFy4i8eXVDXu4+7m1XDi0Cz/5zLmaTSlk0VyX1ANYEFzxkgIsdPcXzOxNYKGZzQK2AdMB3H2dmS0E1gPVwBx3j8SmfBGJB29vO8Ccx1ZyTo+2PHj9eNJT9RGasJn7CcPhTS47O9tzc3PDLkNEzkDersN89tdv0rF1Bk9/6Xy6tm0RdknNhpmtcPfs+tbp16uInLEte0u5cf4yWmWk8eisSQr2OKJwF5EzsuvQUa5/aCmRmhoevVm37403+iywiJy2fUcquOGhpRw6WsUTXzxPE1vHIZ25i8hpKSmv4vMPL6fwwFEempmtT5/GKYW7iESttKKazz+8nLxdh3nw+vGcN7BT2CXJSWhYRkSiUlZZzU2/W86q7Qf52XXjmHJOt7BLklPQmbuINOhoZYSbF+SSu2U///fZsVw5ukfYJUkDdOYuIqdUXhVh9u9zeXPzPu67dgyfHNMz7JIkCjpzF5GTqqiO8OVHV7Bk015+8plz+dS43mGXJFFSuItIvcqrInz50bd5bWMxP/rUaK7N7tPwThI3NCwjIic4Wlk7FLNk017mfmoU/zapb9glyWlSuIvIB5RWVDNrwXKWFuzn3mvO1Rl7glK4i8j7SsqruOnh5azcfpCffnYs08aeMImaJAiFu4gAcKisis89vIx1Ow7xs+vG6XLHBKdwFxGKSyqY+dtl5Bcd4Zc3TODSEfqAUqJTuIs0c9v3l3Hj/KXsOVzBb2Zm89GhmtM4GSjcRZqxd/eUcOP8pZRX1fDozZOY0K9j2CVJI1G4izRTK7cd4KbfLScjNYWFt5zPsO66bW8yUbiLNENLNhVzy+9X0KVtJo/OmqSJNpJQg59QNbM+ZvaameWZ2Tozuy1ozzKzxWa2KXjsWGefu8ws38w2mtnlseyAiJyeZ1YUctPDy+mb1Yqnv3S+gj1JRXP7gWrgq+5+DnAeMMfMRgB3AjnuPgTICZ4TrJsBjASmAg+aWWosiheR6Lk7P8vZxFefXs2kgVks1GTWSa3BcHf3Xe7+drBcAuQBvYBpwIJgswXA1cHyNOBJd69w9wIgH5jY2IWLSPSqIjXc9ewa/nfxu3x6fC8e/vxE2rVID7ssiaHTGnM3s/7AOGAp0M3dd0HtLwAz6xps1gt4q85uhUHb8d9rNjAboG9f3bdCJFZKK6r598fe5u/vFnPrxYP5z0uHYmZhlyUxFnW4m1kb4Bngdnc/fIp/HPWt8BMa3OcB8wCys7NPWC8iZ2/3oXJufmQ5ebtK+PGnR3PdRJ1INRdRhbuZpVMb7I+5+7NB8x4z6xGctfcAioL2QqDunYZ6Azsbq2ARic7q7Qf54iO5lFVGeGhmNhcN69rwTpI0orlaxoD5QJ6731dn1SJgZrA8E3i+TvsMM8s0swHAEGBZ45UsIg1ZtHon1/76TTLTU3j23ycr2JuhaM7cLwBuBNaY2aqg7W7gHmChmc0CtgHTAdx9nZktBNZTe6XNHHePNHrlInKCmhrnpzmbeCBnExP7Z/HLG8bTqU1m2GVJCBoMd3d/nfrH0QGmnGSfucDcs6hLRE5TWWU1//X0O/x5zS6mT+jN3E+NJiNNk601V/qEqkgS2LK3lFt+v4JNRSV888pzuPkjA3RFTDOncBdJcDl5e7j9qVWkphgLvjCRjwzRXR1F4S6SsGpqnPtzNnF/ziZG9mzHr26YoFsJyPsU7iIJ6FBZFXcsXMWrG4r4zPjezP3UKFqk6y4f8i8Kd5EEs3LbAb7y+EqKSsr5wdWjuGFSX42vywkU7iIJwt2Z/3oB97y0ge7tW/D0lyYztk+HsMuSOKVwF0kAB8sq+drTq/lrXhGXj+zGvdeMoX1L3fhLTk7hLhLncrfs5z+eWMneI5V89xMjmDm5v4ZhpEEKd5E4VRWp4YGcTfzitXz6ZLXimS9PZnTv9mGXJQlC4S4ShzYXH+GOp1axuvAQ0yf05jufHEmbTP13lejpX4tIHHF3nli2nR+8sJ7M9BR+ef14rhjdI+yyJAEp3EXixJ7D5dz97BpyNhTx4cGd+Z/pY+jeXtPgyZlRuIuEzN155u0dfP9P66iM1PDtq0Zw0+T+pKToTVM5cwp3kRDtPlTOXc++w2sbi/lQ/47ce80YBnRuHXZZkgQU7iIhcHcW5m7nh3/OoypSw3c+MYKZ5+tsXRqPwl2kieUXlXD3c2tZVrCfiQOyuPcz59JfZ+vSyBTuIk2kvCrCg6/l88u/v0erjDR+8pnRTJ/QR2frEhMKd5Em8Eb+Xr75x7UU7C3l6rE9+dZVI+is6e8khhTuIjG04+BRfvTnPP68Zhf9OrXi97M0mYY0jQbD3cx+C1wFFLn7qKAtC3gK6A9sAa519wPBuruAWUAE+A93fyUmlYvEsfKqCPP+sZkH/5aPO9xxyVBu+ehA3XNdmkw0s+f+Dph6XNudQI67DwFygueY2QhgBjAy2OdBM9O/Zmk23J2X1+7mkvv+zn2L3+Xi4V3J+epHue2SIQp2aVINnrm7+z/MrP9xzdOAjwXLC4C/Ad8I2p909wqgwMzygYnAm41Trkj8Wr39IHNfzGNZwX6GdmvD4zdPYvLgzmGXJc3UmY65d3P3XQDuvsvMugbtvYC36mxXGLSdwMxmA7MB+vbte4ZliIRv+/4y7n1lI39avZPObTL4wdWjuO5DfUhLjeYPY5HYaOw3VOu7psvr29Dd5wHzALKzs+vdRiSe7S+t5MHX8nnkza2kpMCtFw/mlo8O0t0bJS6c6b/CPWbWIzhr7wEUBe2FQJ862/UGdp5NgSLx5tDRKuYv2cz81wsoq4pwzfjefPWyYbrJl8SVMw33RcBM4J7g8fk67Y+b2X1AT2AIsOxsixSJB0cqqvndPwuY94/NHC6v5srR3bn9kqEM7dY27NJEThDNpZBPUPvmaWczKwS+Q22oLzSzWcA2YDqAu68zs4XAeqAamOPukRjVLtIkSsqrePStbfxmyWb2l1ZyyTlduePSoYzsqVmRJH5Fc7XMdSdZNeUk288F5p5NUSLx4EBpJQ//s4DfvbGFw+XVXDi0C3dcMoRxfTuGXZpIg/TOj8hx9hwu56Elm3ls6TbKKiNcPrIbcy4azLm9O4RdmkjUFO4igXU7DzF/SQF/emcnkRrnk2N68u8XDdaYuiQkhbs0azU1zt/fLeY3Szbzxnv7aJWRyvWT+vGFCwbQt1OrsMsTOWMKd2mWDh2t4pkVhTz61lY27y2le7sW3HnFcK77UF/at0oPuzyRs6Zwl2Zl7Y5DPPrWVv64agflVTWM69uBn352LFeO7kFGmj5RKslD4S5J73B5FS+s3sVTudtZvf0gLdNT+dS4Xlw/qR+jeulyRklOCndJSjU1ztKC/Tydu50X1+6ivKqGIV3b8O2rRnDNhN60b6mhF0luCndJKvlFR1i0agd/XLWTbfvLaJuZxqfH9+ba7D6M6d0eM01pJ82Dwl0S3u5D5fxp9U6eX72DtTsOk2Jw/qBO3H7JEK4Y1YOWGbqPujQ/CndJSIUHynh57W5eXrubFdsO4A5jerfn21eN4BPn9qBrO93ES5o3hbskBHfnveIj/GX9Hl5eu5t3Cg8BMLx7W26fMpRPjOnBwC5tQq5SJH4o3CVuVVRHWFawn5y8Il7dUMS2/WVA7Rn6N6YO54pR3enfuXXIVYrEJ4W7xA13p2BvKa/n72XJpr28kb+X0soImWkpXDC4M7MvHMjFw7vSs0PLsEsViXsKdwnVnsPlLC3YzxtBoO84eBSAPlktmTauF1OGd2XyoM56U1TkNCncpcm4O4UHjrKsYD/LCvaztGAfW/bVDrW0bZHG5EGd+NLHBnHhkM7066ThFpGzoXCXmDlaGeGdwoOs3H6Qt7ceYOX2gxSXVADQvmU6H+qfxfWT+jFpYBYjerTThNIijUjhLo2itKKavF2HWbPjEGt2HGLdjsPkFx8hUlM793n/Tq34yODOjOvbgQn9shjevS0pKfpAkUisKNzltFRHati6v4yNu0vYsLuEjbsPs3F3CVv3l+G1OU7nNpmM7tWOy0Z2Y2yfDozt04FObTLDLVykmVG4ywncnb1HKtm2v5Qte8t4r/hI8FXK1n2lVEVqUzzFoH+n1pzTox1Xj+vFqJ7tGd27PV3bZupj/iIhU7g3Q+7OvtJKdh48ys6DR9lxsJydB4+yfX8Z24Kvssp/zWuelmL069SKQV3acOmIbgzq0oZh3doypFsbWqTrKhaReBSzcDezqcD9QCrwkLvfE6vXktrALqmoZv+RSvaVVrDvSCX7SivZd6SC4pIK9hyuYE9JOUWHa59XRmo+sH/L9FR6dWxJv6xWnD+oE/2yWtGvU2v6dmpF36xWpOvNTpGEEpNwN7NU4BfApUAhsNzMFrn7+sZ8nSPBm3hpKUZ6agppqUZaSgrpqUZaagppKVb7dWw5WJ9ihDps4O5U1ziV1TVUVNdQUR2hvOpfj2WV1ZRVRCirinC0spqyyghHyqs5UlHN4eCxpLyKQ0erOFRWxcGjtcvH3rw8XrsWaXRt14Ju7TKZNCCLLu0y6d6uBb06tKRnh5b06tCSDq3SNZQikkRideY+Ech3980AZvYkMA1o1HDPLzrC9F+9eUb7pqUYqUH4p9RdttrlFDPMIMXs/V8GBmBwLALNDHfHARxqguVIjVNT40TcidTUtldFaqiOONU1Ne+PWZ+uFukptMlMp22LNNpkptGhVfr7wdyhZQbtW6aT1TqDTm0y6NQ6k05tMshqnaGhE5FmKFbh3gvYXud5ITCp7gZmNhuYDdC3b98zepGBXVrz+1kTqY4E4VnzwRCtrvEPrIsEX7XL/1ofqXFq/F/rIzW1IV3jjgehXeP8K8gBHBzHgrRPCcLfDFIt+IVx7DEF0lJSyEhLef+vjPRUIyMthcy0VDLTUshMr11ukZ5Cy/Q0WmWk0iojlZYZqbTKqA1zTQMnItGKVbjX9/f9B05X3X0eMA8gOzv7jE5l27VI5yNDupzJriIiSS1Wp4KFQJ86z3sDO2P0WiIicpxYhftyYIiZDTCzDGAGsChGryUiIseJybCMu1eb2VeAV6i9FPrEI/QAAAOtSURBVPK37r4uFq8lIiInitl17u7+IvBirL6/iIicnC6/EBFJQgp3EZEkpHAXEUlCCncRkSRk7mf2UfhGLcKsGNh6Ft+iM7C3kcoJWzL1BZKrP8nUF0iu/iRTXyD6/vRz93o/yRkX4X62zCzX3bPDrqMxJFNfILn6k0x9geTqTzL1BRqnPxqWERFJQgp3EZEklCzhPi/sAhpRMvUFkqs/ydQXSK7+JFNfoBH6kxRj7iIi8kHJcuYuIiJ1KNxFRJJQwoS7mU01s41mlm9md9az3szsgWD9O2Y2Pow6oxVFfz5mZofMbFXw9f/CqDMaZvZbMysys7UnWZ8wxyaKviTMcQEwsz5m9pqZ5ZnZOjO7rZ5tEuL4RNmXhDk+ZtbCzJaZ2eqgP9+rZ5szPzbuHvdf1N42+D1gIJABrAZGHLfNlcBL1M4CdR6wNOy6z7I/HwNeCLvWKPtzITAeWHuS9Yl0bBrqS8Icl6DeHsD4YLkt8G6i/t+Jsi8Jc3yCn3ebYDkdWAqc11jHJlHO3N+fcNvdK4FjE27XNQ14xGu9BXQwsx5NXWiUoulPwnD3fwD7T7FJwhybKPqSUNx9l7u/HSyXAHnUznFcV0Icnyj7kjCCn/eR4Gl68HX8FS5nfGwSJdzrm3D7+IMazTbxItpazw/+ZHvJzEY2TWkxkUjHJhoJeVzMrD8wjtozxLoS7vicoi+QQMfHzFLNbBVQBCx290Y7NjGbrKORNTjhdpTbxItoan2b2vtGHDGzK4E/AkNiXllsJNKxaUhCHhczawM8A9zu7oePX13PLnF7fBroS0IdH3ePAGPNrAPwnJmNcve67/ec8bFJlDP3aCbcTqRJuRus1d0PH/uTzWtntUo3s85NV2KjSqRjc0qJeFzMLJ3aMHzM3Z+tZ5OEOT4N9SURjw+Aux8E/gZMPW7VGR+bRAn3aCbcXgR8Lnh3+TzgkLvvaupCo9Rgf8ysu5lZsDyR2mO1r8krbRyJdGxOKdGOS1DrfCDP3e87yWYJcXyi6UsiHR8z6xKcsWNmLYFLgA3HbXbGxyYhhmX8JBNum9mXgvW/ona+1iuBfKAMuCmsehsSZX+uAb5sZtXAUWCGB2+fxxsze4LaqxQ6m1kh8B1q3xxKuGMTRV8S5rgELgBuBNYEY7sAdwN9IeGOTzR9SaTj0wNYYGap1P4SWujuLzRWrun2AyIiSShRhmVEROQ0KNxFRJKQwl1EJAkp3EVEkpDCXUQkCSncRUSSkMJdRCQJ/X/DlgMbZWj/EQAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "\n",
    "\n",
    "plt.plot(np.arange(0,3,0.05),\n",
    "        np.vectorize(to_integrate)(np.arange(0,3,0.05))   \n",
    "        )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Разбиваем наш интервал интегрирования на N промежутков"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0,\n",
       " 0.2,\n",
       " 0.4,\n",
       " 0.6000000000000001,\n",
       " 0.8,\n",
       " 1.0,\n",
       " 1.2,\n",
       " 1.4,\n",
       " 1.5999999999999999,\n",
       " 1.7999999999999998,\n",
       " 2]"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def split_interval(a,b, N):\n",
    "    step = (b-a)/N\n",
    "    lst = [a]\n",
    "    for i in range(N-1):\n",
    "        lst.append(lst[-1]+step)\n",
    "    lst.append(b)\n",
    "    return lst\n",
    "\n",
    "split_interval(0,2,10)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10.000000000000002\n"
     ]
    }
   ],
   "source": [
    "# 0, 10, 45\n",
    "step = 10/46\n",
    "s = 0\n",
    "for i in range(46):\n",
    "    s+=step\n",
    "    \n",
    "print(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'my_new_var' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-112-0484fe0d0cf1>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmy_new_var\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      2\u001b[0m \u001b[0mmy_new_var\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'my_new_var' is not defined"
     ]
    }
   ],
   "source": [
    "print(my_new_var)\n",
    "my_new_var = 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Интегрируем функцию \"по методу Трапеций\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [],
   "source": [
    "del split_interval"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "def integrate(function, a = 0, b=2, N = 10000):\n",
    "    step = (b-a)/N\n",
    "    function_values = [function(i) for i in split_interval(a,b,N)]\n",
    "    trapeze = []\n",
    "    for i in range(1, N+1):\n",
    "        trapeze.append((function_values[i]+function_values[i-1])*step/2)\n",
    "    return sum(trapeze)\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "98.90929854376637"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "integrate(to_integrate, a = 0, b=2, N = 10000)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [],
   "source": [
    "def integral(x):\n",
    "    return 28*x**4/4 -7*x**2/2 + sin(x)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "98.90929742682569"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "integral(2)-integral(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(98.90929742682569, 1.0995631252639896e-12)"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from scipy.integrate import quad\n",
    "quad(to_integrate,0,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Как зависит точность от количества интервалов."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['1', '2', '3', '4', '6', '3_4', '6', '3_3_5', '7_7_7', '8_7_6']"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Список\n",
    "a = [1,2,3,4,6,34,6,335,777,876]\n",
    "\n",
    "# Функция, которая возвращает число, цифры которого разделены символом _ и превращены в строку\n",
    "import re\n",
    "\n",
    "def to_str(x):\n",
    "    return '_'.join(re.findall(r'\\d',str(x)))\n",
    "\n",
    "list(map(to_str,a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Обнулим в списке все числа, не кратные 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 3, 0, 6]"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = [1,3,4,6]\n",
    "list(map(lambda x: x if x % 3 == 0 else 0, a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Заметим, что в if здесь используется тот же синтаксис, что был в списковых включениях и генераторах списков."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "А еще есть прекрасная функция для фильтрации списков, которая работает аналогично map. Называется она filter. Пусть мы хотим отфильтровать все числа меньше 4 из списка. С помощью цикла это можно сделать вот так:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numbers = [1,2,3,4,5]\n",
    "numbers_under_4 = []\n",
    "for number in numbers:\n",
    "    if number < 4:\n",
    "        numbers_under_4.append(number)\n",
    "numbers_under_4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "А с помощью спискового включения вот так:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3]"
      ]
     },
     "execution_count": 118,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numbers = [1,2,3,4,5]\n",
    "numbers_under_4 = [number for number in numbers if number < 4]\n",
    "numbers_under_4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "А чудо-функция filter сработает вот так:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3]"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "numbers = [1,2,3,4,5]\n",
    "numbers_under_4 = list(filter(lambda x: x < 4, numbers))\n",
    "numbers_under_4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Видно, что синтаксис такой же, как и у map. первый аргумент - функция, которую надо применять, а второй - коллекция, на которую надо применять. Но как и для map, функция возвращает итератор, поэтому, чтобы получить список, его нужно обернуть функцией list."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Напоминание про генераторы списков"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "generator"
      ]
     },
     "execution_count": 164,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = (i**2 for i in range(10))\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "metadata": {},
   "outputs": [
    {
     "ename": "StopIteration",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mStopIteration\u001b[0m                             Traceback (most recent call last)",
      "\u001b[0;32m/var/folders/t5/3hn40ss10rz402rc6dg3_jqm0000gp/T/ipykernel_47576/3485793935.py\u001b[0m in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mnext\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mStopIteration\u001b[0m: "
     ]
    }
   ],
   "source": [
    "next(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Задачка 1: Напишите функцию для вычисления факториала данного числа без рекурсии \n",
    "### (что бы это ни было :)    )\n",
    "\n",
    "Ввод: 3\n",
    "\n",
    "Вывод: 6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(1,1):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "def factorial(N):\n",
    "#Ваше решение\n",
    "    fact = 1\n",
    "    for i in range(1,N+1):\n",
    "        fact*=i\n",
    "    return fact"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "24"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "factorial(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Рекурсия\n",
    "\n",
    "Рекурсия — это техника в Computer Science, когда функция вызывает сама себя. Самый известный пример — вычисление факториала n! = n * n — 1 * n -2 * … 2 *1. Зная, что 0! = 1, факториал можно записать следующим образом:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [],
   "source": [
    "def factorial(n):\n",
    "    if n != 0:\n",
    "        return n * factorial(n-1)\n",
    "    else:\n",
    "        return 1\n",
    "\n",
    "# В этой реализации есть некоторые проблемы, но мы поговорим об этом потом :)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "120"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "factorial(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Каждый раз, когда функция вызывает себя и сохраняет некоторую память. Таким образом, рекурсивная функция может содержать гораздо больше памяти, чем традиционная функция. Python останавливает вызовы функций после глубины в 1000 вызовов. Если вы запустите этот пример, получите ошибку."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "def factorial(n):\n",
    "    if n == 1:\n",
    "        return 1\n",
    "    else:\n",
    "        return n * factorial(n-1)\n",
    "\n",
    "# print(factorial(3000))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'gfsahjk'"
      ]
     },
     "execution_count": 181,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 'gfsahjk'\n",
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'gfsahjk'"
      ]
     },
     "execution_count": 182,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "_"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "А еще таким же образом можно вычислять N-ое число Фибоначчи (они как раз задаются рекурсивно).\n",
    "Заодно здесь мы видим, что выражений return может быть несколько (для различных условий)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fibonacci_rec(n):\n",
    "    if n in (1, 2):\n",
    "        return 1\n",
    "    return fibonacci_rec(n - 1) + fibonacci_rec(n - 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "102334155"
      ]
     },
     "execution_count": 131,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fibonacci(40)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fibonacci(n):\n",
    "    if n in (1, 2):\n",
    "        return 1\n",
    "    f1 = 1\n",
    "    f2 = 1\n",
    "    for _ in range(n-2):\n",
    "        f3 = f1 + f2 \n",
    "        f1 = f2\n",
    "        f2 = f3\n",
    "    return f3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "from time import time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1664382752.741942"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8.405293703079224"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "start = time()\n",
    "x = fibonacci_rec(38)\n",
    "end = time()\n",
    "\n",
    "end - start"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7.176399230957031e-05"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "start = time()\n",
    "x = fibonacci(38)\n",
    "end = time()\n",
    "\n",
    "end - start"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ololo'"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# fibonacci(10)\n",
    "'ololo'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Рекурсивно посчитать сумму чисел от 1 до N\n",
    "\n",
    "Вход: N\n",
    "\n",
    "Выход: sum(1,2,3,...,N)\n",
    "\n",
    "\n",
    "Вход: 3\n",
    "\n",
    "Выход: 6"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "def summe(n):\n",
    "    if n == 0:\n",
    "        return 0\n",
    "    return n + summe(n - 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "55"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "summe(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Рекурсивно проверить, является ли строка палиндромом\n",
    "\n",
    "Вход: ололо\n",
    "\n",
    "Выход: True\n",
    "\n",
    "\n",
    "Вход: You shall not pass!\n",
    "\n",
    "Выход: False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 'ололо'\n",
    "x[::-1] == x[:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def IsPalindrome(S):\n",
    "    if len(S) <= 1:\n",
    "        return True\n",
    "    else:\n",
    "        return S[0] == S[-1] and IsPalindrome(S[1:-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "IsPalindrome('ололо')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Очень полезный пример про рекурсию\n",
    "### Быстрое возведение в степень\n",
    "\n",
    "Одним из полезных применений рекурсии является алгоритм быстрого возведения в степень. Если вычислять степень числа a в степень N при помощи простого цикла, то понадобится n-1 умножение. Но можно решить все это быстрее, воспользовавшись рекуррентными соотношениями:\n",
    "\n",
    "Для нечетных N: \\begin{eqnarray} a^n = a^{n-1}a \\end{eqnarray} \n",
    "\n",
    "Для четных N: \\begin{eqnarray} a^n = (a^{n/2})^2 \\end{eqnarray}\n",
    "\n",
    "Это позволяет записать алгоритм, который будет выполнять не более чем за: \\begin{eqnarray} 2*log_2(n) \\end{eqnarray} умножений"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "def power(a, n):\n",
    "    if n == 0:\n",
    "        return 1\n",
    "    elif n % 2 == 1:\n",
    "        return power(a, n - 1) * a\n",
    "    else:\n",
    "        return power(a, n // 2) ** 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def foo(x):\n",
    "    if isinstance(x, str) is True:\n",
    "        return x.upper()\n",
    "    if isinstance(x, int) is True:\n",
    "        return x**4\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1048576"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "power(2,20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Возврат нескольких значений\n",
    "\n",
    "Нужно упомянуть еще один факт: по команде return функция может возвращать несколько значений. Например вот функция, которая умеет выводить сумму и разность двух аргументов функции:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n",
      "3\n",
      "1 2\n"
     ]
    }
   ],
   "source": [
    "def sum_diff(a,b):\n",
    "    return a+b, a-b\n",
    "\n",
    "summ, diff = sum_diff(4,1)\n",
    "print(summ)\n",
    "print(diff)\n",
    "\n",
    "x,y = (1,2)\n",
    "print(x,y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "x, y, z = 0, 0, 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### [Генераторы](https://habr.com/ru/articles/320288/)\n",
    "Мы уже сталкивались с понятием генератора (специального способа создания итераторов). Мы уже делали их с помощью генераторов списков (пишется списковое включение в круглых скобках). Есть еще один способ создания генераторов - через написание функций с последующей заменой выражения return на yield. Давайте посмотрим:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [],
   "source": [
    "int_generator = (i**2 for i in range(10000))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(int_generator)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [],
   "source": [
    "def createGenerator():\n",
    "    mylist = range(3)\n",
    "    for i in mylist:\n",
    "        yield i*i"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = createGenerator()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.09520785288629108"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 - (1 - 0.001)**100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "function"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(createGenerator)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'generator'>\n",
      "0\n",
      "1\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "mygenerator = createGenerator()\n",
    "print(type(mygenerator))\n",
    "for i in mygenerator:\n",
    "     print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "4\n"
     ]
    },
    {
     "ename": "StopIteration",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mStopIteration\u001b[0m                             Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-30-ff8caed7d22f>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnext\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmygenerator\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      4\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnext\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmygenerator\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----> 5\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnext\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mmygenerator\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;31mStopIteration\u001b[0m: "
     ]
    }
   ],
   "source": [
    "mygenerator = createGenerator()\n",
    "print(next(mygenerator))\n",
    "print(next(mygenerator))\n",
    "print(next(mygenerator))\n",
    "print(next(mygenerator))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В данном случае пример бесполезный, но это удобно, если вы знаете, что функция вернёт большой набор значений, который надо будет прочитать только один раз.\n",
    "\n",
    "Чтобы освоить yield, вы должны понимать, что когда вы вызываете функцию, код внутри тела функции не исполняется. Функция только возвращает объект-генератор — немного мудрёно :-)\n",
    "\n",
    "Ваш код будет вызываться каждый раз, когда for обращается к генератору.\n",
    "\n",
    "Теперь трудная часть:\n",
    "\n",
    "В первый запуск вашей функции, она будет исполняться от начала до того момента, когда она наткнётся на yield — тогда она вернёт первое значение из цикла. На каждый следующий вызов будет происходить ещё одна итерация написанного вами цикла, возвращаться будет следующее значение — и так пока значения не кончатся.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Например можно написать генератор бесконечной последовательности, который будет вызывать элемент в тот момент, когда будет выполнять с ним какие-то действия:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [],
   "source": [
    "def infinite_sequence():\n",
    "    num = 0\n",
    "    while True:\n",
    "        yield num\n",
    "        num += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "function"
      ]
     },
     "execution_count": 149,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(infinite_sequence)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "gen = infinite_sequence()\n",
    "\n",
    "print(next(gen))\n",
    "print(next(gen))\n",
    "print(next(gen))\n",
    "print(next(gen))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Давайте вернемся к числам Фибоначчи и будем генерировать их с помощью генератора"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {},
   "outputs": [],
   "source": [
    "def fib(n):\n",
    "    a, b = 0, 1\n",
    "    for _ in range(n):\n",
    "        yield a\n",
    "        a, b = b, a + b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 2 \n",
    "b = 3\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "13815510.557964273"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "math.log(1000000)*1000000"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [],
   "source": [
    "a,b = b,a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "1\n",
      "2\n",
      "3\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "a = fib(10)\n",
    "print(next(a))\n",
    "print(next(a))\n",
    "print(next(a))\n",
    "print(next(a))\n",
    "print(next(a))\n",
    "print(next(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Тут мы использовали еще одну классную конструкцию: for _ in collection. Это означает, что переменную из collection нам использовать не нужно - просто нужно выполнить операцию столько раз, сколько в коллекции элементов. Это что-то вроде конвенции (Если не хотим использовать переменную из collection, то при проходе в цикле for стандартное i, например, заменяется на _. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Также этот символ может быть использован для того, чтобы достать последнее значение из интерпретатора:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5+5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Ожидаемо это 10\n",
    "_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# а еще с ним можно производить стандартные операции\n",
    "_+1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# А тут в _ уже перезаписалось 11\n",
    "_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# А еще можно присвоить это значение новой переменной!\n",
    "x = _\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Декораторы\n",
    "Декораторы — это, по сути, \"обёртки\", которые дают нам возможность изменить поведение функции, не изменяя её код.\n",
    "Звучит мудрёно. Посмотрим на пример:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_shiny_new_decorator(function_to_decorate):\n",
    "    # Внутри себя декоратор определяет функцию-\"обёртку\". Она будет обёрнута вокруг декорируемой,\n",
    "    # получая возможность исполнять произвольный код до и после неё.\n",
    "    def the_wrapper_around_the_original_function():\n",
    "        print(\"Я - код, который отработает до вызова функции\")\n",
    "        function_to_decorate() # Сама функция\n",
    "        print(\"А я - код, срабатывающий после\")\n",
    "    # Вернём эту функцию\n",
    "    return the_wrapper_around_the_original_function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Я простая одинокая функция, ты ведь не посмеешь меня изменять?\n"
     ]
    }
   ],
   "source": [
    "def stand_alone_function():\n",
    "    print(\"Я простая одинокая функция, ты ведь не посмеешь меня изменять?\")\n",
    "\n",
    "stand_alone_function()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Я - код, который отработает до вызова функции\n",
      "Я простая одинокая функция, ты ведь не посмеешь меня изменять?\n",
      "А я - код, срабатывающий после\n"
     ]
    }
   ],
   "source": [
    "# Однако, чтобы изменить её поведение, мы можем декорировать её, то есть просто передать декоратору,\n",
    "# который обернет исходную функцию в любой код, который нам потребуется, и вернёт новую,\n",
    "# готовую к использованию функцию:\n",
    "stand_alone_function_decorated = my_shiny_new_decorator(stand_alone_function)\n",
    "stand_alone_function_decorated()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Я простая одинокая функция, ты ведь не посмеешь меня изменять?\n"
     ]
    }
   ],
   "source": [
    "stand_alone_function()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Декораторы могут быть использованы для расширения возможностей функций из сторонних библиотек (код которых мы не можем изменять), или для упрощения отладки (мы не хотим изменять код, который ещё не устоялся).\n",
    "\n",
    "Также полезно использовать декораторы для расширения различных функций одним и тем же кодом, без повторного его переписывания каждый раз."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Пример 1. Декоратор для вычисления времени работы функции:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "466853.605137296"
      ]
     },
     "execution_count": 157,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import time\n",
    "time.perf_counter()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Декоратор 1\n",
    "def benchmark(func):\n",
    "    \"\"\"\n",
    "    Декоратор, выводящий время, которое заняло\n",
    "    выполнение декорируемой функции.\n",
    "    \"\"\"\n",
    "    import time\n",
    "    def wrapper(*args, **kwargs):\n",
    "        t = time.perf_counter() # Засекли время начала выполнения\n",
    "        res = func(*args, **kwargs) # Запустили\n",
    "        print(func.__name__, time.perf_counter() - t) # Засекли время окончания исполнения и вывели время конца- время начала\n",
    "        return res\n",
    "    return wrapper\n",
    "\n",
    "# Декоратор 2\n",
    "def logging(func):\n",
    "    \"\"\"\n",
    "    Декоратор, который выводит вызовы функции.\n",
    "    \"\"\"\n",
    "    def wrapper(*args, **kwargs):\n",
    "        res = func(*args, **kwargs)\n",
    "        print(func.__name__, args, kwargs)\n",
    "        return res\n",
    "    return wrapper\n",
    "\n",
    "# Декоратор 3\n",
    "def counter(func):\n",
    "    \"\"\"\n",
    "    Декоратор, считающий и выводящий количество вызовов\n",
    "    декорируемой функции.\n",
    "    \"\"\"\n",
    "    def wrapper(*args, **kwargs):\n",
    "        wrapper.count += 1\n",
    "        res = func(*args, **kwargs)\n",
    "        print (\"{0} была вызвана: {1}x\".format(func.__name__, wrapper.count))\n",
    "        return res\n",
    "    wrapper.count = 0\n",
    "    return wrapper"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [],
   "source": [
    "@benchmark \n",
    "# @logging\n",
    "# @counter\n",
    "def reverse_string(string):\n",
    "    return ''.join(reversed(string))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [],
   "source": [
    "# reverse_string = benchmark(reverse_string)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "reverse_string 9.982000847230665e-06\n",
      "арозА упал ан алапу азор А\n"
     ]
    }
   ],
   "source": [
    "print(reverse_string(\"А роза упала на лапу Азора\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[Можно ли раздекорировать](https://stackoverflow.com/questions/1166118/how-to-strip-decorators-from-a-function-in-python)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Те же самые декораторы можно запустить для любой функции. Например, для функции, которая считает количество вхождений некоторого слова в текст романа Достоевского \"Идиот\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "get_random_idiot_word_count была вызвана: 1x\n",
      "wrapper ('whole',) {}\n",
      "wrapper 2.45085082300011\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "176"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import requests\n",
    "import re\n",
    "from random import randint\n",
    "@benchmark\n",
    "@logging\n",
    "@counter\n",
    "def get_random_idiot_word_count(word):\n",
    "    the_idiot_url = 'https://www.gutenberg.org/files/2638/2638-0.txt'\n",
    "\n",
    "    # Отправляем запрос в библиотеку Gutenberg и забираем текст\n",
    "    raw = requests.get(the_idiot_url).text\n",
    "    #Заменим в тексте все небуквенные символы на пробелы\n",
    "    processed_book = re.sub('[\\W]+' , ' ', raw).lower()\n",
    "    return len(re.findall(word.lower(),processed_book))\n",
    "\n",
    "get_random_idiot_word_count('whole')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 33 µs, sys: 1 µs, total: 34 µs\n",
      "Wall time: 36 µs\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "788657867364790503552363213932185062295135977687173263294742533244359449963403342920304284011984623904177212138919638830257642790242637105061926624952829931113462857270763317237396988943922445621451664240254033291864131227428294853277524242407573903240321257405579568660226031904170324062351700858796178922222789623703897374720000000000000000000000000000000000000000000000000"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "%%time\n",
    "### Решение 1\n",
    "\n",
    "def factorial(n):\n",
    "    f = 1\n",
    "    for i in range(2, n+1):\n",
    "        f = f * i\n",
    "    return f\n",
    "factorial(200)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Один из суперполезных способов использования декоратора – [мемоизация](https://ru.wikipedia.org/wiki/Мемоизация) aka кэширование. По сути, это способ \"переиспользовать\" предыдущие результаты вместо того, чтобы по 25 раз считать одно и то же. Рекомендую заглянуть [сюда](https://habr.com/ru/post/335866/)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [],
   "source": [
    "def memo(f):\n",
    "    \"\"\"\n",
    "    Запомнить результаты исполнения функции f, \n",
    "    чьи аргументы args должны быть хешируемыми.\n",
    "    \"\"\"\n",
    "    cache = {}\n",
    "    def fmemo(*args):\n",
    "        if args not in cache:\n",
    "            cache[args] = f(*args)\n",
    "        return cache[args]\n",
    "    fmemo.cache = cache\n",
    "    return fmemo\n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Иллюстрацию того, что мемоизация - суперполезная штука, можно произвести на примере расчета чисел Фибоначчи. Если вы программист, они вам, наверняка, уже оскомину набили, но мы все равно на них посмотрим."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "fib(40) = 102334155\n",
      "34.235381756000606\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "# @memo\n",
    "def fib(n):\n",
    "    if n < 2:\n",
    "        return n\n",
    "    return fib(n-2) + fib(n-1)\n",
    "\n",
    "# Какое число мы хотим посчитать\n",
    "x = 40\n",
    "\n",
    "t1 = time.perf_counter()\n",
    "print(f'fib({x}) =', fib(x))\n",
    "print(time.perf_counter() - t1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "28.9 секунд. Это ОЧЕНЬ долго. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "fib(40) = 102334155\n",
      "0.0006124369992903667\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "@memo\n",
    "def fib(n):\n",
    "    if n < 2:\n",
    "        return n\n",
    "    return fib(n-2) + fib(n-1)\n",
    "\n",
    "# Какое число мы хотим посчитать\n",
    "x = 40\n",
    "\n",
    "t1 = time.perf_counter()\n",
    "print(f'fib({x}) =', fib(x))\n",
    "print(time.perf_counter() - t1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Как вам ускорение? :)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.00310606797575"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t = time.perf_counter()\n",
    "time.sleep(2)\n",
    "time.perf_counter() - t"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "fib(40) = 102334155\n",
      "0.00014527999974234262\n"
     ]
    }
   ],
   "source": [
    "t1 = time.perf_counter()\n",
    "print(f'fib({x}) =', fib(x))\n",
    "print(time.perf_counter() - t1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Аннотация типов\n",
    "\n",
    "    int, str, bool, float, None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "metadata": {},
   "outputs": [],
   "source": [
    "price: int \n",
    "title: str\n",
    "    \n",
    "is_true: bool = True\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 184,
   "metadata": {},
   "outputs": [],
   "source": [
    "def indent_right(s: str, width: int) -> str:\n",
    "    return \" \"*max(0, width)+s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Что если составные типы? Что если функция возвращает разные типы?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 194,
   "metadata": {},
   "outputs": [],
   "source": [
    "def indent_right(s: str, width: int) -> str:\n",
    "    '''\n",
    "    Получает строку, добавляет width пробелов слева\n",
    "    '''\n",
    "    assert isinstance(s, str)\n",
    "    assert isinstance(width, int)\n",
    "    \n",
    "    return \" \"* max(0,width) + s "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 195,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import Optional, Union"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 199,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Неправильно\n",
    "amount: int\n",
    "amount = None\n",
    "\n",
    "# Правильно\n",
    "price: Optional[int]\n",
    "price = None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 201,
   "metadata": {},
   "outputs": [],
   "source": [
    "def indent_right(s: str, width: int) -> Optional[str]:\n",
    "    '''\n",
    "    Получает строку, добавляет width пробелов слева\n",
    "    '''\n",
    "    assert isinstance(s, str)\n",
    "    assert isinstance(width, int)\n",
    "    \n",
    "    return \" \"* max(0,width) + s if width >=0 else None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 208,
   "metadata": {},
   "outputs": [],
   "source": [
    "def hundreds(x: Union[int, float]) -> int:\n",
    "    return (int(x)//100)%10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "    Union[тип, None] == Optional[тип]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Описание коллекций"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List, Tuple, Dict, Any"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 211,
   "metadata": {},
   "outputs": [],
   "source": [
    "titles: List[str] = ['a','b','c']\n",
    "# Я наврал\n",
    "titles.append(1000)  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 215,
   "metadata": {},
   "outputs": [],
   "source": [
    "titles: List[Any]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 213,
   "metadata": {},
   "outputs": [],
   "source": [
    "titles = ['str', 1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 217,
   "metadata": {},
   "outputs": [],
   "source": [
    "prices: Tuple[int] = (1,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 218,
   "metadata": {},
   "outputs": [],
   "source": [
    "prices: Tuple[int, str] = (1,'my_element')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [],
   "source": [
    "book_authors: Dict[str,str] = {'Bradbury': 'Fahrenheit 451'}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [],
   "source": [
    "book_authors[1984] = 'Orwell'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'Bradbury': 'Fahrenheit 451', 1984: 'Orwell'}"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "book_authors"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 222,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import NoReturn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 223,
   "metadata": {},
   "outputs": [],
   "source": [
    "def foo() -> NoReturn:\n",
    "    while True:\n",
    "        pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Про [functools](https://docs.python.org/3/library/functools.html)"
   ]
  }
 ],
 "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.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}