lectures/02-functions.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Практикум по программированию на языке Python\n",
    "\n",
    "## <font color='lilac'>Занятие 2: Функции, итераторы и генераторы</font>\n",
    "\n",
    "#### Мурат Апишев (mel-lain@yandex.ru)\n",
    "#### Москва, 2025"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Функции range и enumerate</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'range'>\n",
      "2 5 8 "
     ]
    }
   ],
   "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": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 a   1 b   2 c   3 d   4 e   5 f   "
     ]
    }
   ],
   "source": [
    "for index, element in enumerate(list('abcdef')):\n",
    "    print(index, element, end='   ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Функция zip</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'zip'>\n",
      "1 a  2 b  3 c  "
     ]
    }
   ],
   "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": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('a', 'a')\n",
      "('b', 'b')\n",
      "('c', 'c')\n"
     ]
    }
   ],
   "source": [
    "for e in zip('abcdef', 'abc'):\n",
    "    print(e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a 1 True x\n",
      "b 2 False y\n",
      "c 3 None z\n"
     ]
    }
   ],
   "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": [
    "### <font color='lilac'>Определение собственных функций</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 None\n",
      "10 20\n"
     ]
    }
   ],
   "source": [
    "def function(arg_1, arg_2=None):\n",
    "    print(arg_1, arg_2)\n",
    "\n",
    "function(10)\n",
    "function(10, 20)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Функция - это тоже объект, её имя - просто символическая ссылка:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 None\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "f = function\n",
    "f(10)\n",
    "\n",
    "print(function is f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Определение собственных функций</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10 None\n",
      "None\n"
     ]
    }
   ],
   "source": [
    "retval = f(10)\n",
    "print(retval)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "24\n"
     ]
    }
   ],
   "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))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Передача аргументов в функцию</font>\n",
    "\n",
    "Параметры в Python всегда передаются по ссылке"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "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'Scalar in function: {lst}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Scalar in function: 15\n",
      "Scalar in function: [None]\n",
      "5 [None]\n"
     ]
    }
   ],
   "source": [
    "s, l = 5, []\n",
    "function(s, l)\n",
    "\n",
    "print(s, l)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Передача аргументов в функцию</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 225,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'tuple'>\n",
      "[10, 2, 6, 8]\n"
     ]
    }
   ],
   "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": 226,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10, 2, 6, 8]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "def f(*args, a):\n",
    "    print([v for v in [a] + list(args)])\n",
    "    print()\n",
    "\n",
    "f(2, 6, 8, a=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 227,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'dict'>\n",
      "[2, 6, 8, ('arg1', 1), ('arg2', 2)]\n"
     ]
    }
   ],
   "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": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Спецификация позиционности параметров</font>\n",
    "\n",
    "- Начиная с версии 3.8 в Python появилась возможность явно запрещать передачу параметров по имени или позиции\n",
    "- Мотивация - дать возможность запрета именованных параметров там, где это нужно (это позволяет эмулировать C-подобные функции)\n",
    "- Часть встроенных функций самого языка и раньше имели такое свойство, например, `math.exp`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "#help(math.exp) -> ... exp(x, /) ..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "148.4131591025766\n"
     ]
    }
   ],
   "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": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "def func(positional_only_parameters, /, positional_or_keyword_parameters, *, keyword_only_parameters): pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "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": [
    "### <font color='lilac'>Области видимости переменных</font>\n",
    "\n",
    "В Python есть 4 основных уровня видимости:\n",
    "\n",
    "- Встроенная (buildins) - на этом уровне находятся все встроенные объекты (функции, классы исключений и т.п.)\n",
    "- Глобальная в рамках модуля (global) - всё, что определяется в коде модуля на верхнем уровне\n",
    "- Объемлющей функции (enclosed) - всё, что определено в функции верхнего уровня\n",
    "- Локальной функции (local) - всё, что определено в функции нижнего уровня\n",
    "\n",
    "\n",
    "Есть ещё области видимости переменных циклов, списковых включений и т.п."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Правило разрешения области видимости LEGB при чтении</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "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": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n"
     ]
    }
   ],
   "source": [
    "print(outer_func([1, 2]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "Кто определил имя `len`?\n",
    "\n",
    "- на уровне вложенной функции такого имени нет, смотрим выше\n",
    "- на уровне объемлющей функции такого имени нет, смотрим выше\n",
    "- на уровне модуля такого имени нет, смотрим выше\n",
    "- на уровне builtins такое имя есть, используем его"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>На builtins можно посмотреть</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['abs', 'all', 'any', 'ascii', 'bin']"
      ]
     },
     "execution_count": 83,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['abs', 'all', 'any', 'ascii', 'bin']"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(filter(lambda x: x[0].islower(), dir(builtins)))[: 5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Локальные и глобальные переменные</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Inside:  2\n",
      "Outside:  2\n"
     ]
    }
   ],
   "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": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Inside:  4\n",
      "Outside:  2\n"
     ]
    }
   ],
   "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": [
    "### <font color='lilac'>Ключевое слово global</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Inside:  3\n",
      "Outside:  3\n"
     ]
    }
   ],
   "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": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Inside:  3\n",
      "Outside:  3\n"
     ]
    }
   ],
   "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": [
    "### <font color='lilac'>Ключевое слово nonlocal</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100 110 120\n"
     ]
    }
   ],
   "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": [
    "### <font color='lilac'>Пример вложенных функций: замыкания</font>\n",
    "\n",
    "- В большинстве случаев вложенные функции не нужны, плоская иерархия будет и проще, и понятнее\n",
    "- Одно из исключений - фабричные функции (замыкания)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "32"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def function_creator(n):\n",
    "    def function(x):\n",
    "        return x ** n\n",
    "\n",
    "    return function\n",
    "\n",
    "f = function_creator(5)\n",
    "f(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Объект-функция, на который ссылается `f`, хранит в себе значение `n`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Анонимные функции</font>\n",
    "\n",
    "- `def` - не единственный способ объявления функции\n",
    "- `lambda` создаёт анонимную (lambda) функцию\n",
    "\n",
    "\n",
    "Такие функции часто используются там, где синтаксически нельзя записать определение через `def`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "36"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def func(x): return x ** 2\n",
    "func(6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "36"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "lambda_func = lambda x: x ** 2  # should be an expression\n",
    "lambda_func(6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n"
     ]
    }
   ],
   "source": [
    "def func(x): print(x)\n",
    "func(6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "36\n"
     ]
    }
   ],
   "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": [
    "### <font color='lilac'>Встроенная функция sorted</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [],
   "source": [
    "lst = [5, 2, 7, -9, -1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[-1, 2, 5, 7, -9]\n"
     ]
    }
   ],
   "source": [
    "def abs_comparator(x):\n",
    "    return abs(x)\n",
    "\n",
    "print(sorted(lst, key=abs_comparator))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[-1, 2, 5, 7, -9]"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted(lst, key=lambda x: abs(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[-9, 7, 5, 2, -1]"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sorted(lst, key=lambda x: abs(x), reverse=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Встроенная функция filter</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 220,
   "metadata": {},
   "outputs": [],
   "source": [
    "lst = [5, 2, 7, -9, -1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 221,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "filter"
      ]
     },
     "execution_count": 221,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f = filter(lambda x: x < 0, lst)  # True condition\n",
    "type(f)  # iterator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 222,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[-9, -1]"
      ]
     },
     "execution_count": 222,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Встроенная функция map</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [],
   "source": [
    "lst = [5, 2, 7, -9, -1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "map"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m = map(lambda x: abs(x), lst)\n",
    "type(m)  # iterator"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[5, 2, 7, 9, 1]"
      ]
     },
     "execution_count": 125,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(m)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Ещё раз сравним два подхода</font>\n",
    "\n",
    "Напишем функцию скалярного произведения в императивном и функциональном стилях:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "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": 148,
   "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": 152,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "32\n",
      "32\n"
     ]
    }
   ],
   "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": [
    "### <font color='lilac'>Функция reduce</font>\n",
    "\n",
    "`functools` - стандартный модуль с другими функциями высшего порядка.\n",
    "\n",
    "Рассмотрим пока только функцию `reduce`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "362880"
      ]
     },
     "execution_count": 155,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "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": [
    "### <font color='lilac'>Итераторы</font>\n",
    "\n",
    "- __Итерабельный объект (iterable)__ - источник данных для итерирования\n",
    "- __Итератор (iterator)__ - объект-абстракция, извлекающий из источника элемент за элементом и знающий только о том объекте, на котором он в текущий момент остановился\n",
    "\n",
    "\n",
    "- Итераторы используются для итерирования по последовательностям, при этом:\n",
    "    - последовательности могут быть неиндексируемыми (например, `set`)\n",
    "    - в процессе работы элементы могут фильтроваться или преобразовываться\n",
    "    - итераторы работают лениво\n",
    "\n",
    "\n",
    "- В Python для итераторов есть две встроенные функции:\n",
    "    - `iter(x: iterable)` - создаёт итератор для переданной последовательности\n",
    "    - `next(x: iterator)` - выполняет шаг итерации для переданного итератора"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Итераторы</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3\n",
      "<class 'list_iterator'>\n"
     ]
    }
   ],
   "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": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(0, 1) (1, 2) (2, 3)\n"
     ]
    }
   ],
   "source": [
    "r = enumerate([1, 2, 3])\n",
    "\n",
    "print(next(r), next(r), next(r))\n",
    "#next(r) -> StopIteration"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Итераторы и цикл for</font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Цикл `for` использует итераторы вместо индексов. Как выглядит `for` снаружи:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 "
     ]
    }
   ],
   "source": [
    "for e in {1, 2, 3}:\n",
    "    print(e, end=' ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Как он работает на самом деле:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 "
     ]
    }
   ],
   "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": [
    "### <font color='lilac'>Итераторы</font>\n",
    "\n",
    "Примеры встроенных функций, возвращающих итераторы:\n",
    "\n",
    "- `enumerate`\n",
    "- `zip`\n",
    "- `open`\n",
    "- `reversed`\n",
    "- `map` (похож на генератор, но метод `send` не реализует)\n",
    "- `filter`\n",
    "\n",
    "Вызов `iter` от итератора вернет тот же самый итератор:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3\n"
     ]
    }
   ],
   "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": [
    "### <font color='lilac'>Генераторы</font>\n",
    "\n",
    "- __Генератор__ - подтип итератора\n",
    "- В генераторе есть внутреннее изменяемое состояние в виде локальных переменных, которое он хранит автоматически\n",
    "- В генератор можно посылать данные между итерациями (метод `send`)\n",
    "- Генераторы можно создавать с помощью генераторных выражений или описывать функциями, в которых `return` заменяется на `yield`\n",
    "\n",
    "Пример генератора, полученного с помощью выражения:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 1\n",
      "<class 'generator'>\n"
     ]
    }
   ],
   "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": [
    "### <font color='lilac'>Ключевое слово yield</font>\n",
    "\n",
    "- `yield` - это слово, по смыслу похожее на `return`\n",
    "- Но используется в функциях, возвращающих генераторы\n",
    "- При вызове такой функции тело не выполняется, функция только возвращает генератор\n",
    "- В первых запуск функция будет выполняться от начала и до `yield`\n",
    "- После выхода состояние функции сохраняется\n",
    "- На следующий вызов будет проводиться итерация цикла и возвращаться следующее значение\n",
    "- И так далее, пока не кончится цикл каждого `yield` в теле функции\n",
    "- После этого генератор станет пустым"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Пример функции-генератора</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "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": 57,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You really want to run this generator?   0   1   2   3   "
     ]
    }
   ],
   "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": 58,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You really want to run this generator?   0   1   2   3   "
     ]
    }
   ],
   "source": [
    "for e in my_range(3):\n",
    "    print(e, end='   ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Генераторы и метод send</font>\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": 104,
   "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": 105,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 | y = None   1 | y = 10   2 | y = None   3 | "
     ]
    }
   ],
   "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": [
    "### <font color='lilac'>Итераторы и функция range</font>\n",
    "\n",
    "Результат работы `range` не является итератором, хотя и выполняет его роль:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "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": [
    "### <font color='lilac'>Модуль itetools</font>\n",
    "\n",
    "- Модуль представляет собой набор инструментов для работы с итераторами и последовательностями\n",
    "- Содержит три основных типа итераторов:\n",
    "    - бесконечные итераторы\n",
    "    - конечные итераторы\n",
    "    - комбинаторные итераторы"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Позволяет эффективно решать небольшие задачи вида:\n",
    "    - итерирование по бесконечному потоку\n",
    "    - слияние в один список вложенных списков\n",
    "    - генерация комбинаторного перебора сочетаний элементов последовательности\n",
    "    - аккумуляция и агрегация данных внутри последовательности"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Модуль itetools: примеры</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 203,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0  1  2  3  4  5  "
     ]
    }
   ],
   "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": 205,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "X  Y  Z  X  Y  "
     ]
    }
   ],
   "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": [
    "### <font color='lilac'>Модуль itetools: примеры</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1  2  6  24  "
     ]
    }
   ],
   "source": [
    "from itertools import accumulate\n",
    "\n",
    "for i in accumulate(range(1, 5), lambda x, y: x * y):\n",
    "    print(i, end='  ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1  2  3  4  "
     ]
    }
   ],
   "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": [
    "### <font color='lilac'>Модуль itetools: примеры</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 215,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Cobalt is made by Chevrolet\n",
      "**** END OF THE GROUP ***\n",
      "\n",
      "Charger is made by Dodge\n",
      "Durango is made by Dodge\n",
      "**** END OF THE GROUP ***\n",
      "\n",
      "F150 is made by Ford\n",
      "GT is made by Ford\n",
      "Taurus is made by Ford\n",
      "**** END OF THE GROUP ***\n",
      "\n"
     ]
    }
   ],
   "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": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Аннотации типов</font>\n",
    "\n",
    "- Python - язык со строгой динамической типизацией\n",
    "- Динамическая типизация удобна при разработке, но может приводить к ошибкам при росте объёма и сложности кода\n",
    "- Для борьбы с этим можно использовать аннотирование функций (Python 3.5+) и переменных (Python 3.6+)\n",
    "- Существуют решения для статической проверки типов на основе аннотаций\n",
    "- Для аннотирования можно использовать doc-строки, это громоздкий и плохо подходящий для проверки способ"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "def print_1(obj: int):\n",
    "    \"\"\"\n",
    "    Parameters\n",
    "    ----------\n",
    "    x: int\n",
    "    -------\n",
    "    \"\"\"\n",
    "    print(obj)\n",
    "\n",
    "def print_2(obj: int) -> None:\n",
    "    print(obj)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Аннотации не делают типизацию статической, они играют только информационную роль:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "str\n",
      "str\n"
     ]
    }
   ],
   "source": [
    "print_1('str')\n",
    "print_2('str')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Аннотации типов</font>\n",
    "\n",
    "- Для аннотирования типов параметров `*args` и `**kwargs` можно указать тип одного элемента:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_print(*args: str, **kwargs: int) -> None:\n",
    "    print(args, kwargs)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Аннотация типов переменных производится аналогично (и тоже только для ниформирования):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "bool"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a: int = True\n",
    "type(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Аннотации типов</font>\n",
    "\n",
    "- Аннотировать можно не только простые, но и контейнерные типы\n",
    "- В Python 3.9 эта возможность поддерживается на уровне имен типов:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_print(obj: list[int]) -> None:\n",
    "    print(obj)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- До Python 3.9 такой синтаксис был недопустим, можно было только указать тип контейнера, без типа элементов:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "def my_print(obj: list) -> None:\n",
    "    print(obj)\n",
    "\n",
    "#def my_print(obj: list[int]):\n",
    "#TypeError: 'type' object is not subscriptable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- В лекциях будет использоваться аннотирование с generic-типами из модуля `typing`, чтобы код выполнялся на Python 3.8"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Аннотации типов</font>\n",
    "\n",
    "- Для полного аннотирования контейнерных типов можно использовать их Generic-версии модуль `typing`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import List\n",
    "\n",
    "def my_print(obj: list[int]) -> None:\n",
    "    print(obj)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Модуль `typing` содержит много полезных классов и полезен для аннотирования в т.ч. и в Python 3.9+\n",
    "- Аннотации типов функций и переменных будет рассматриваться подробнее и шире в дальнейших занятиях\n",
    "- Аннотирование в лекциях будет присутствовать в нужных местах, в прочих оно будет опускаться для краткости\n",
    "- На практике использование аннотаций типво во всём проекте является рекомендуемым подходом"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.12.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}