Seminars/02-code-org/code-org.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# `Практикум по программированию на языке Python`\n",
    "<br>\n",
    "\n",
    "## `Занятие 2: Функции, модули, классы. Итераторы и генераторы`\n",
    "<br><br>\n",
    "\n",
    "### `Роман Ищенко (sir.rois@yandex.ru)`\n",
    "\n",
    "#### `Москва, 2023`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `Организация кода`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Функции, модули, классы позволяют организовать и структурировать код, избежать повторяющихся фрагментов.\n",
    "\n",
    "Кроме того:\n",
    "- упростить отладку\n",
    "- упростить создание тестов\n",
    "- улучшить «понимаемость» кода"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Функции range и enumerate`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "r = range(2, 10, 3)\n",
    "print(type(r))\n",
    "\n",
    "for e in r:\n",
    "    print(e, end=' ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for index, element in enumerate(list('abcdef')):\n",
    "    print(index, element, end='   ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Функция zip`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "z = zip([1, 2, 3], 'abc')\n",
    "print(type(z))\n",
    "\n",
    "for a, b in z:\n",
    "    print(a, b, end='  ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for e in zip('abcdef', 'abc'):\n",
    "    print(e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for a, b, c, d in zip('abc', [1,2,3], [True, False, None], 'xyzа'):\n",
    "    print(a, b, c, d)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Определение собственных функций`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def function(arg_1, arg_2=None):\n",
    "    \"\"\"Factorial function\"\"\"\n",
    "    print(arg_1, arg_2)\n",
    "\n",
    "function(10)\n",
    "function(10, 20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Функция - это тоже объект, её имя - просто символическая ссылка:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f = function\n",
    "f(10)\n",
    "\n",
    "print(function is f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `Определение собственных функций`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "У функции есть атрибуты, например: `__doc__` или `__dict__` (список атрибутов функции)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(dir(f)[: 4], len(dir(f)))\n",
    "f.__doc__"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# del f.my_attr\n",
    "print(f.__dict__)\n",
    "f.my_attr = 0\n",
    "print(f.__dict__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Определение собственных функций`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "retval = f(10)\n",
    "print(retval)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def factorial(n):\n",
    "    return n * factorial(n - 1) if n > 1 else 1  # recursion\n",
    "\n",
    "print(factorial(1))\n",
    "print(factorial(2))\n",
    "print(factorial(4))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `Глубина рекурсии`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "При достижении глубины вызовов, заданной в системе, программа выбросит исключение `RecursionError`\n",
    "\n",
    "Заданную глубину рекурсии можно узнать и изменить, если есть такая необходимость."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "print(sys.getrecursionlimit())\n",
    "\n",
    "sys.setrecursionlimit(1000)\n",
    "print(sys.getrecursionlimit())\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Передача аргументов в функцию`\n",
    "\n",
    "Параметры в Python всегда передаются по ссылке"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def function(scalar, lst):\n",
    "    scalar += 10\n",
    "    print(f'Scalar in function: {scalar}')\n",
    "\n",
    "    lst.append(None)\n",
    "    print(f'List in function: {lst}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s, l = 5, []\n",
    "function(s, l)\n",
    "\n",
    "print(s, l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `Передача аргументов в функцию`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Использовать изменяемые объекты в качестве значений по умолчанию опасно и не нужно"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def func_1(list_of_items, my_set=set()):\n",
    "    final_list = list()\n",
    "    for item in list_of_items:\n",
    "        if item not in my_set:\n",
    "            my_set.add(item)\n",
    "            final_list.append(item)\n",
    "    return final_list\n",
    "\n",
    "my_list = [1, 2, 3]\n",
    "print(func_1(my_list))\n",
    "print(func_1(my_list))\n",
    "my_list"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Передача аргументов в функцию`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f(a, *args):\n",
    "    print(type(args))\n",
    "    print([v for v in [a] + list(args)])\n",
    "    \n",
    "f(10, 2, 6, 8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f(*args, a):\n",
    "    print([v for v in [a] + list(args)])\n",
    "    print()\n",
    "\n",
    "f(2, 6, 8, a=10)\n",
    "f(2, 3, 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f(a, *args, **kw):\n",
    "    print(type(kw))\n",
    "    print([v for v in [a] + list(args) + [(k, v) for k, v in kw.items()]])\n",
    "\n",
    "f(2, *(6, 8), **{'arg1': 1, 'arg2': 2})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def test(a, *args, b, c=100, **kw):\n",
    "    print([v for v in [a] + list(args) + [b] + [c] + [(k, v) for k, v in kw.items()]])\n",
    "\n",
    "test(1, 2, 3, b=10, d=1000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Спецификация позиционности параметров`\n",
    "\n",
    "- Начиная с версии 3.8 в Python появилась возможность явно запрещать передачу параметров по имени или позиции\n",
    "- Мотивация - дать возможность запрета именованных параметров там, где это нужно (это позволяет эмулировать C-подобные функции)\n",
    "- Часть встроенных функций самого языка и раньше имели такое свойство, например, `math.exp`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "#help(math.exp) -> ... exp(x, /) ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(math.exp(5))\n",
    "#print(math.exp(x=5)) -> TypeError: math.exp() takes no keyword arguments"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Синтаксис заголовка функции:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def func(positional_only_parameters, /, positional_or_keyword_parameters, *, keyword_only_parameters): pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def f(a, b, /, c, *, d): pass\n",
    "#f(1, 2, 3, 4) -> TypeError: func() takes 3 positional arguments but 4 were given\n",
    "#f(a=1, b=2, c=3, d=4) -> TypeError: func() got some positional-only arguments passed as keyword arguments: 'a, b'\n",
    "f(1, 2, 4, d=3) # OK\n",
    "f(1, 2, d=4, c=3) # OK"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Области видимости переменных`\n",
    "\n",
    "В Python есть 4 основных уровня видимости:\n",
    "\n",
    "- Встроенная (buildins) - на этом уровне находятся все встроенные объекты (функции, классы исключений и т.п.)<br><br>\n",
    "- Глобальная в рамках модуля (global) - всё, что определяется в коде модуля на верхнем уровне<br><br>\n",
    "- Объемлющей функции (enclosed) - всё, что определено в функции верхнего уровня<br><br>\n",
    "- Локальной функции (local) - всё, что определено в функции нижнего уровня\n",
    "\n",
    "<br><br>\n",
    "Есть ещё области видимости совсем локализованные, например, списковых включений и т.п."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Правило разрешения области видимости LEGB при чтении`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def outer_func(x):\n",
    "    def inner_func(x):\n",
    "        return len(x)\n",
    "    return inner_func(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(outer_func([1, 2]))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "Кто определил имя `len`?\n",
    "\n",
    "- на уровне вложенной функции такого имени нет, смотрим выше\n",
    "- на уровне объемлющей функции такого имени нет, смотрим выше\n",
    "- на уровне модуля такого имени нет, смотрим выше\n",
    "- на уровне builtins такое имя есть, используем его"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `На builtins можно посмотреть`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import builtins\n",
    "\n",
    "counter = 0\n",
    "lst = []\n",
    "for name in dir(builtins):\n",
    "    if name[0].islower():\n",
    "        lst.append(name)\n",
    "        counter += 1\n",
    "    \n",
    "    if counter == 5:\n",
    "        break\n",
    "\n",
    "lst"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "Кстати, то же самое можно сделать более pythonic кодом:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list(filter(lambda x: x[0].islower(), dir(builtins)))[: 5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Локальные и глобальные переменные`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 2\n",
    "def func():\n",
    "    print('Inside: ', x)  # read\n",
    "    \n",
    "func()\n",
    "print('Outside: ', x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 2\n",
    "def func():\n",
    "    x += 1  # write\n",
    "    print('Inside: ', x)\n",
    "    \n",
    "func()  # UnboundLocalError: local variable 'x' referenced before assignment\n",
    "print('Outside: ', x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 2\n",
    "def func():\n",
    "    x = 3\n",
    "    x += 1\n",
    "    print('Inside: ', x)\n",
    "    \n",
    "func()\n",
    "print('Outside: ', x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Ключевое слово global`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 2\n",
    "def func():\n",
    "    global x\n",
    "    x += 1  # write\n",
    "    print('Inside: ', x)\n",
    "    \n",
    "func()\n",
    "print('Outside: ', x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 2\n",
    "def func(x):\n",
    "    x += 1\n",
    "    print('Inside: ', x)\n",
    "    return x\n",
    "    \n",
    "x = func(x)\n",
    "print('Outside: ', x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Ключевое слово nonlocal`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 0\n",
    "def out_func():\n",
    "    b = 10\n",
    "    def mid_func():\n",
    "        c = 20\n",
    "        def in_func():\n",
    "            global a\n",
    "            a += 100\n",
    "            \n",
    "            nonlocal c\n",
    "            c += 100\n",
    "            \n",
    "            nonlocal b\n",
    "            b += 100\n",
    "\n",
    "            print(a, b, c)\n",
    "            \n",
    "        in_func()\n",
    "    mid_func()\n",
    "\n",
    "out_func()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "__Главный вывод:__ не надо злоупотреблять побочными эффектами при работе с переменными верхних уровней"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Пример вложенных функций: замыкания`\n",
    "\n",
    "- В большинстве случаев вложенные функции не нужны, плоская иерархия будет и проще, и понятнее\n",
    "- Одно из исключений - фабричные функции (замыкания)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def function_creator(n):\n",
    "    def function(x):\n",
    "        return x ** n\n",
    "\n",
    "    return function\n",
    "\n",
    "f5 = function_creator(5)\n",
    "f5(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Объект-функция, на который ссылается `f`, хранит в себе значение `n`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Анонимные функции`\n",
    "\n",
    "- `def` - не единственный способ объявления функции\n",
    "- `lambda` создаёт анонимную (lambda) функцию\n",
    "\n",
    "\n",
    "Такие функции часто используются там, где синтаксически нельзя записать определение через `def`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def func(x): return x ** 2\n",
    "func(6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lambda_func = lambda x: x ** 2  # should be an expression\n",
    "lambda_func(6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def func(x): print(x)\n",
    "func(6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lambda_func = lambda x: print(x ** 2)  # as print is function in Python 3.*\n",
    "lambda_func(6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Встроенная функция sorted`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lst = [5, 2, 7, -9, -1]\n",
    "\n",
    "print(sorted(lst))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def abs_comparator(x):\n",
    "    return abs(x)\n",
    "\n",
    "print(sorted(lst, key=abs_comparator))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(sorted(lst, key=lambda x: abs(x)))\n",
    "print(sorted(lst, key=abs))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `Встроенная функция sorted`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Более сложный пример"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lst = [(1, 0), (1, 1), (1, 2), (0, 3), (2, 1)]\n",
    "print(sorted(lst))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(sorted(lst, key=lambda x: x[1])) # сортировка по второму элементу\n",
    "print(sorted(lst, key=lambda x: x[0] * x[1], reverse=True)) # сортировка по убыванию произведения"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "\n",
    "### `Встроенная функция filter`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lst = [5, 2, 7, -9, -1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f = filter(lambda x: x < 0, lst)  # True condition\n",
    "type(f)  # iterator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list(f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Встроенная функция map`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lst = [(1, 0), (1, 1), (1, 2), (0, 3), (2, 1)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "m = map(lambda x: x[0] * x [1], lst)\n",
    "type(m)  # iterator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list(m)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Ещё раз сравним два подхода`\n",
    "\n",
    "Напишем функцию скалярного произведения в императивном и функциональном стилях:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def dot_product_imp(v, w):\n",
    "    result = 0\n",
    "    for i in range(len(v)):\n",
    "        result += v[i] * w[i]\n",
    "    return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dot_product_func = lambda v, w: sum(map(lambda x: x[0] * x[1], zip(v, w)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(dot_product_imp([1, 2, 3], [4, 5, 6]))\n",
    "print(dot_product_func([1, 2, 3], [4, 5, 6]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Функция reduce`\n",
    "\n",
    "`functools` - стандартный модуль с другими функциями высшего порядка.\n",
    "\n",
    "Рассмотрим пока только функцию `reduce`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from functools import reduce\n",
    "\n",
    "lst = list(range(1, 10))\n",
    "\n",
    "reduce(lambda x, y: x * y, lst)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Итераторы`\n",
    "\n",
    "- __Итерабельный объект (iterable)__ - источник данных для итерирования\n",
    "- __Итератор (iterator)__ - объект-абстракция, извлекающий из источника элемент за элементом и знающий только о том объекте, на котором он в текущий момент остановился\n",
    "\n",
    "\n",
    "- Итераторы используются для итерирования по последовательностям, при этом:\n",
    "    - последовательности могут быть неиндексируемыми (например, `set`)\n",
    "    - в процессе работы элементы могут фильтроваться или преобразовываться\n",
    "    - итераторы работают лениво\n",
    "\n",
    "\n",
    "- В Python для итераторов есть две встроенные функции:\n",
    "    - `iter(x: iterable)` - создаёт итератор для переданной последовательности\n",
    "    - `next(it: iterator)` - выполняет шаг итерации для переданного итератора"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Итераторы`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "r = iter([1, 2, 3])\n",
    "\n",
    "print(next(r), next(r), next(r))\n",
    "#next(r) -> StopIteration\n",
    "\n",
    "print(type(r))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Итераторы можно получать вызовами стандартных функций:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "r = enumerate([1, 2, 3])\n",
    "print(type(r))\n",
    "\n",
    "print(next(r), next(r), next(r))\n",
    "#next(r) -> StopIteration"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Итераторы и цикл for`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Цикл `for` использует итераторы вместо индексов. Как выглядит `for` снаружи:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for e in {1, 2, 3}:\n",
    "    print(e, end=' ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Как он работает на самом деле:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "iterator = iter({1, 2, 3})\n",
    "while True:\n",
    "    try:\n",
    "        i = next(iterator)\n",
    "        print(i, end=' ')\n",
    "    except StopIteration:\n",
    "        break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Итераторы`\n",
    "\n",
    "Примеры встроенных функций, возвращающих итераторы:\n",
    "\n",
    "- `enumerate`\n",
    "- `zip`\n",
    "- `open`\n",
    "- `reversed`\n",
    "- `map` (похож на генератор, но метод `send` не реализует)\n",
    "- `filter`\n",
    "\n",
    "Вызов `iter` от итератора вернет тот же самый итератор:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "i = iter([1, 2, 3])\n",
    "\n",
    "print(next(i), next(iter(i)), next(i))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Генераторы`\n",
    "\n",
    "- __Генератор__ - подтип итератора\n",
    "- В генераторе есть внутреннее изменяемое состояние в виде локальных переменных, которое он хранит автоматически\n",
    "- В генератор можно посылать данные между итерациями (метод `send`)\n",
    "- Генераторы можно создавать с помощью генераторных выражений или описывать функциями, в которых `return` заменяется на `yield`\n",
    "\n",
    "Пример генератора, полученного с помощью выражения:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gen = (x**2 for x in range(5))\n",
    "\n",
    "print(next(gen), next(gen))\n",
    "print(type(gen))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Ключевое слово yield`\n",
    "\n",
    "- `yield` - это слово, по смыслу похожее на `return`<br><br>\n",
    "- Но используется в функциях, возвращающих генераторы<br><br>\n",
    "- При вызове такой функции тело не выполняется, функция только возвращает генератор<br><br>\n",
    "- В первых запуск функция будет выполняться от начала и до `yield`<br><br>\n",
    "- После выхода состояние функции сохраняется<br><br>\n",
    "- На следующий вызов будет проводиться итерация цикла и возвращаться следующее значение<br><br>\n",
    "- И так далее, пока не кончится цикл каждого `yield` в теле функции<br><br>\n",
    "- После этого генератор станет пустым"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Пример функции-генератора`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_range(n):\n",
    "    yield 'You really want to run this generator?'\n",
    "\n",
    "    i = -1\n",
    "    while i < n:\n",
    "        i += 1\n",
    "        yield i"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gen = my_range(3)\n",
    "while True:\n",
    "    try:\n",
    "        print(next(gen), end='   ')\n",
    "    except StopIteration:  # we want to catch this type of exceptions\n",
    "        break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for e in my_range(3):\n",
    "    print(e, end='   ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Генераторы и метод send`\n",
    "\n",
    "- Выражение `yield x` выполняет две вещи:\n",
    "    1. Возвращает вызывающему генератор коду значение `x`\n",
    "    2. Возвращает на уровне кода генератора значение `None`\n",
    "\n",
    "\n",
    "- Расширенный протокол генератора содержит метод `send`, получающий на вход произвольный объект `y`\n",
    "- В случае вызова `send(y)` выполняется то же, что и при `next`, но `yield` вернет на уровне кода генератора не `None`, а `y`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def create_gen():\n",
    "    for x in range(5):\n",
    "        y = yield x\n",
    "        print(f'y = {y}', end='   ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "gen = create_gen()\n",
    "\n",
    "print(next(gen), end=' | ')\n",
    "print(next(gen), end=' | ')\n",
    "\n",
    "print(gen.send(10), end=' | ')\n",
    "print(next(gen), end=' | ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Итераторы и функция range`\n",
    "\n",
    "Результат работы `range` не является итератором, хотя и выполняет его роль:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('__next__' in dir(zip([], [])))\n",
    "print('__next__' in dir(range(3)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Особенности объектов__ `range`:\n",
    "- как и итераторы, выполняются лениво\n",
    "- являются неизменяемыми (могут быть ключами словаря)\n",
    "- имеют полезные атрибуты (`len`, `index`, `__getitem__`)\n",
    "- по ним можно итерироваться многократно"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Модуль itertools`\n",
    "\n",
    "- Модуль представляет собой набор инструментов для работы с итераторами и последовательностями<br><br>\n",
    "- Содержит три основных типа итераторов:<br><br>\n",
    "    - бесконечные итераторы\n",
    "    - конечные итераторы\n",
    "    - комбинаторные итераторы<br><br>\n",
    "\n",
    "- Позволяет эффективно решать небольшие задачи вида:<br><br>\n",
    "    - итерирование по бесконечному потоку\n",
    "    - слияние в один список вложенных списков\n",
    "    - генерация комбинаторного перебора сочетаний элементов последовательности\n",
    "    - аккумуляция и агрегация данных внутри последовательности"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Модуль itertools: примеры`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from itertools import count\n",
    "\n",
    "for i in count(start=0):\n",
    "    print(i, end='  ')\n",
    "    if i == 5:\n",
    "        break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from itertools import cycle\n",
    " \n",
    "count = 0\n",
    "for item in cycle('XYZ'):\n",
    "    if count > 4:\n",
    "        break\n",
    "    print(item, end='  ')\n",
    "    count += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Модуль itertools: примеры`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from itertools import accumulate\n",
    "\n",
    "for i in accumulate(range(1, 6), lambda x, y: x * y):\n",
    "    print(i, end='  ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from itertools import chain\n",
    "\n",
    "for i in chain([1, 2], [3], [4]):\n",
    "    print(i, end='  ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### `Модуль itertools: примеры`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from itertools import groupby\n",
    " \n",
    "vehicles = [('Ford', 'Taurus'), ('Dodge', 'Durango'),\n",
    "            ('Chevrolet', 'Cobalt'), ('Ford', 'F150'),\n",
    "            ('Dodge', 'Charger'), ('Ford', 'GT')]\n",
    " \n",
    "sorted_vehicles = sorted(vehicles)\n",
    " \n",
    "for key, group in groupby(sorted_vehicles, lambda x: x[0]):\n",
    "    for maker, model in group:\n",
    "        print('{model} is made by {maker}'.format(model=model, maker=maker))\n",
    "    \n",
    "    print (\"**** END OF THE GROUP ***\\n\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `Модуль itertools: примеры`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from itertools import product, permutations, combinations\n",
    "print (list(product(\"AB\", repeat=2)))\n",
    "print (list(permutations(\"ABC\")))\n",
    "print (list(combinations(\"ABC\", 2)))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `Модули`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Любой файл с расширением `.py` является модулем\n",
    "\n",
    "Оператор `import` импортирует модуль и создаёт ссылку на модуль в текущей области видимости:\n",
    "- ищет в sys.path имя\n",
    "- компилирует в байт-код (если версия уже неактуальна)\n",
    "- выполняет код (только первый раз)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import itertools\n",
    "\n",
    "import itertools as it\n",
    "\n",
    "from itertools import product as prd\n",
    "\n",
    "# from itertools import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Так как модули тоже объекты, у них тоже есть атрибуты"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import itertools\n",
    "print(itertools.__name__)\n",
    "\n",
    "# print(my_module.__path__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `Модули`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "У модулей, переданных на выполнение интерпретатору, `__name__ == '__main__'`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "if __name__ == '__main__':\n",
    "    # Код, выполняющийся только если именно этот модуль передан интерпретатору\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Если модуль нужно перезагрузить принудительно\n",
    "from importlib import reload\n",
    "reload(itertools)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `Классы`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Класс объявлется с помощью ключевого слова `class`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MyClass:\n",
    "    def __init__(self, value):\n",
    "        self.value = value\n",
    "\n",
    "    def get_value(self):\n",
    "        return self.value\n",
    "\n",
    "my_obj = MyClass(2)\n",
    "print(my_obj.get_value())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Каждый объект экземпляра наследует атрибуты класса и  приобретает свое собственное пространство имен"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `Функция __init__`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Главное: `__init__` - не конструктор! Она ничего не создаёт и не возвращает\n",
    "\n",
    "- Созданием объекта занимается функция `__new__`, переопределять которую без необходимости не надо\n",
    "\n",
    "- `__init__` получает на вход готовый объект и инициализирует его атрибуты\n",
    "\n",
    "В отличие от C++, атрибуты можно добавлять/удалять на ходу:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Cls:\n",
    "    pass\n",
    "\n",
    "cls = Cls()\n",
    "cls.field = 'field'\n",
    "print(cls.field)\n",
    "\n",
    "del cls.field\n",
    "print(cls.field)  # AttributeError: 'Cls' object has no attribute 'field'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `Параметр self`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Метод класса отличается от обычной функции только наличием объекта `self` в качестве первого аргумента\n",
    "\n",
    "- Это то же самое, что происходит в C++/Java (там аналогом `self` является указатель/ссылка `this`)\n",
    "\n",
    "- Название `self` является общим соглашением, но можно использовать и другое (не надо!)\n",
    "\n",
    "- Метод класса, не получающий на вход `self` является _статическим_\n",
    "\n",
    "- Статические методы часто используются для специализированного создания объектов класса\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `Доступ к атрибутам`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Для работы с атрибутами есть функции `getattr`, `setattr` и `delattr`\n",
    "- Их основное преимущество - оперирование именами атрибутов в виде строк"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cls = Cls()\n",
    "\n",
    "setattr(cls, 'some_attr', 'some')\n",
    "\n",
    "print(getattr(cls, 'some_attr'))\n",
    "\n",
    "delattr(cls, 'some_attr')\n",
    "\n",
    "print(getattr(cls, 'some_attr'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `Class magic methods (магические методы)`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Магические методы придают объекту класса определённые свойства\n",
    "\n",
    "- Такие методы получают `self` вызываются интерпретатором неявно\n",
    "\n",
    "- Например, операторы — это магические методы\n",
    "\n",
    "Рассмотрим несколько примеров:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Cls:\n",
    "    def __init__(self):  # initialize object\n",
    "        self.name = 'Some class'\n",
    "    \n",
    "    def __repr__(self):  # str for printing object\n",
    "        return 'Class: {}'.format(self.name)\n",
    "    \n",
    "    def __call__(self, counter):  # call == operator() in C++\n",
    "        return self.name * counter\n",
    "\n",
    "cls = Cls()\n",
    "print(cls)\n",
    "print(cls(2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `Class magic methods`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "Ещё примеры магических методов:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Cls():\n",
    "    def __add__(self, other): pass # x + other\n",
    "\n",
    "    def __sub__(self, other): pass # x - other\n",
    "\n",
    "    def __mul__(self, value): pass # x * value\n",
    "\n",
    "    def __rmul__(self, value): pass # value * x\n",
    "\n",
    "    def __int__(self): pass # int(x)\n",
    "\n",
    "    def __getitem__(self, index): pass # x[index]\n",
    "\n",
    "    def __setitem__(self, index, value): pass # x[index] = value"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `Class magic methods`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Как выбирается метод при наличии парного, например, `__add__` и `__radd__` для `x + y`:\n",
    "\n",
    "1. ищется `x.__add__()`\n",
    "2. если нашёлся этот метод, то он и вызывается\n",
    "3. если выполнился успешно, то всё\n",
    "4. если `x.__add__()` не нашёлся или вернул специальный объект `NotImplemented` («не знаю я, что с вашим `y` делать!»), ищется метод `y.__radd__()`\n",
    "5. и, наконец, если последний нашёлся — выполняется, если нет — `TypeError`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class ClsLeft:\n",
    "    def __add__(self, add):\n",
    "        print(f'__add__ у {self.__class__.__name__}')\n",
    "        return NotImplemented\n",
    "\n",
    "\n",
    "class ClsRight:\n",
    "    def __radd__(self, add):\n",
    "        print(f'__radd__ у {self.__class__.__name__}')\n",
    "        return ClsRight()\n",
    "\n",
    "\n",
    "ClsLeft() + ClsRight()\n",
    "print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `Ещё об атрибутах`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Протокол свойств позволяет направлять операции чтения, записи и удаления для отдельных атрибутов отдельным функциям и методам\n",
    "\n",
    "`attribute = property(fget, fset, fdel, doc)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Cls():\n",
    "    def __init__(self):\n",
    "        self._value = 0\n",
    "\n",
    "    def getValue(self):\n",
    "        print(f'Getting value')\n",
    "        return self._value\n",
    "\n",
    "    def setValue(self, val):\n",
    "        print(f'Setting value to {val}')\n",
    "        self._value = val\n",
    "\n",
    "    value = property(getValue, setValue, None, 'VALUE')\n",
    "\n",
    "\n",
    "cls = Cls()\n",
    "\n",
    "print(cls.value)\n",
    "\n",
    "cls.value = 10\n",
    "print(cls.value)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### `Итератор`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Класс, который должен поддерживать магические методы `__iter__` и `__next__`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class iter_example:\n",
    "\n",
    "    def __init__(self, cnt):\n",
    "        self.max = cnt\n",
    "\n",
    "    def __iter__(self):\n",
    "        self.curr = 0\n",
    "        return self\n",
    "\n",
    "    def __next__(self):\n",
    "        if self.curr < self.max:\n",
    "            self.curr += 1\n",
    "            return self.curr ** 2\n",
    "\n",
    "        raise StopIteration\n",
    "\n",
    "\n",
    "a = iter(iter_example(5))\n",
    "print(*list(a))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "## `Спасибо за внимание!`"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Python 3.9.9 ('msu_lectures-6nA09vt2')",
   "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.9.9"
  },
  "vscode": {
   "interpreter": {
    "hash": "06ae1688a657068b40a9224ec4e20356cf323c84e074c6adaf35ac25262d8e06"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}