lect6.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Лекция №6. Функциональное программирование\n",
    "\n",
    "*П.Н. Советов, РТУ МИРЭА*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Введение"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "До сих пор мы, в основном, явно указывали в программах на Питоне последовательность действий, содержащих присваивания и изменяемые данные. Это соответствует императивному подходу к программированию.\n",
    "\n",
    "В функциональном программировании, в противовес программированию императивному, основной операцией является применение функций к своим аргументам. Такие функции являются \"чистыми\" в математическом смысле, то есть результат их выполнения полностью определяется входными аргументами. В противоположность чистым функциям, вычисление функции, обладающей побочным эффектом, зависит неявным образом от окружения. Например, функция random из одноименного модуля стандартной библиотеки Питона использует в своей работе глобальную переменную.\n",
    "\n",
    "При анализе императивной программы программисту приходится в уме пошагово имитировать работу компьютера. В функциональном программировании используется более простая, чем в императивном программировании, подстановочная модель вычислений (выражения заменяются их результатами), которой программист может пользоваться умозрительно с большим удобством.\n",
    "\n",
    "Важным свойством программ, которое обеспечивается функциональным программированием, является компонуемость или сочетаемость — сложные программы строятся, свободно используя простые строительные блоки-функции, в духе блоков игрового конструктора. В Питоне компонуемость не всегда выдерживается. К примеру, мы не можем поместить обычный for или if внутрь некоторого выражения. Конечно, мы могли бы использовать списковое включение или тернарный if, но эти конструкции обладают рядом ограничений, то есть плохо компонуются.\n",
    "\n",
    "Остается вопрос, каким образом функциональные программы, без присваиваний и изменяемых данных, могут делать что-то полезное. При использовании функционального стиля программирования в таком языке, как Питон, предпочтительной является типовая архитектура системы под названием \"функциональное ядро и императивная оболочка\" (Functional core, imperative shell):\n",
    "\n",
    "1. Ключевые вычислительные задачи и задачи преобразования данных формируют функциональное ядро системы. Здесь применяются только чистые функции и неизменяемые типы данных.\n",
    "1. Работа с внешней средой, ввод/вывод, вспомогательные задачи организуются с помощью императивной оболочки."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Еще раз о пространствах имен и функциях"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В Питоне используется несколько пространств имен, вложенных друг в друга:\n",
    "\n",
    "1. Пространство имен модуля (globals), которое включает в себя пространство имен встроенных функций (builtins).\n",
    "1. Пространство имен объемлющих функций (nonlocal).\n",
    "1. Пространство имен текущей функции (locals).\n",
    "\n",
    "Переменная в функции может относиться только к одному из этих пространств имен. Рассмотрим следующий пример:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 42\n",
    "\n",
    "def f():\n",
    "    print(a)\n",
    "    a = 1\n",
    "    \n",
    "# Раскомментируйте, чтобы получить ошибку\n",
    "# f()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Компилятор Питона при трансляции функции руководствуется следующими правилами:\n",
    "1. Если `a` не используется в левой части присваивания, а также отсутствует в объемлющих функциях, то `a` трактуется, как элемент из globals.\n",
    "1. Если `a` не используется в левой части присваивания, но присутствует в объемлющей функции, то формируется nonlocal-ссылка на `a` из объемлющей функции.\n",
    "1. Если `a` присваивается некоторое значение, то `a` является элементом locals.\n",
    "\n",
    "В примере выше `a` трактуется, как локальная переменная, поэтому вызов print до присваивания приводит к ошибке. Разумеется, с помощью global или nonlocal (о нем будет сказано далее) можно явно указать, к какому пространству имен принадлежит `a`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "42\n"
     ]
    }
   ],
   "source": [
    "a = 42\n",
    "\n",
    "def f():\n",
    "    global a\n",
    "    print(a)\n",
    "    a = 1\n",
    "\n",
    "f()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Функции высшего порядка"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В Питоне функции являются объектами первого класса. Это означает, что функции можно использовать, как аргументы, возвращать из функций, а также записывать в переменные. Это позволяет использовать важнейший элемент функционального программирования — функции высшего порядка.\n",
    "\n",
    "Функция высшего порядка (ФВП), помимо значений других типов, использует функции в качестве своих аргументов/результата. В математике известны примеры ФВП. Это, например, производные и интегралы. В современном программировании без ФВП тоже трудно обойтись: даже на языке C стандартная функция сортировки qsort требует ссылки на функцию в качестве одного из своих аргументов.\n",
    "\n",
    "Ниже показан пример ФВП, которая принимает на вход функцию:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "11\n"
     ]
    }
   ],
   "source": [
    "def f(func, arg):\n",
    "    return func(arg)\n",
    "    \n",
    "def incr(x):\n",
    "    return x + 1\n",
    "    \n",
    "print(f(incr, 10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Пример ФВП, возвращающей функцию:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 10, 20, 30, 40, 50, 60, 70, 80, 90]"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def f(x):\n",
    "    def func(y):\n",
    "        return y * x\n",
    "    return func\n",
    "\n",
    "g = f(10)\n",
    "[g(x) for x in range(10)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Наконец, пример ФВП, получающей и возвращающей функцию:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'** ** ** ** ** ** ** ** ** **'"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def f(g, x):\n",
    "    def func(size):\n",
    "        return ' '.join([g(x) for i in range(size)])\n",
    "    return func\n",
    "\n",
    "def f1(x):\n",
    "    return '*' * x\n",
    "\n",
    "f2 = f(f1, 2)\n",
    "f2(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Замыкания"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Мы уже видели, что вложенные функции в Питоне могут использовать не только аргументы и локальные переменные, но также и свободные переменные — имена из объемлющих функций. Это возможно благодаря механизму лексического замыкания, при котором формируется специальный объект, включающий себя как ссылку на функцию, так и данные, которые функция использует из объемлющих функций.\n",
    "\n",
    "Рассмотрим следующий пример:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "15\n",
      "('y',)\n",
      "('x',)\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "def make_adder(x):\n",
    "    def adder(y):\n",
    "        # Замыкание, включающее в себя свободную переменную x\n",
    "        return x + y\n",
    "    return adder\n",
    "    \n",
    "f = make_adder(10)\n",
    "print(f(5))\n",
    "\n",
    "# Переменные adder\n",
    "print(f.__code__.co_varnames)\n",
    "# Свободные переменные adder\n",
    "print(f.__code__.co_freevars)\n",
    "# Значение x из захваченного окружения\n",
    "print(f.__closure__[0].cell_contents)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Для модификации захваченной свободной переменной необходимо явно указать с помощью ключевого слова nonlocal, что модифицируемая переменная не является локальной или глобальной, а относится к одной из объемлющих функций:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 1 0 2 1 0 2 1 0 2 1 0 2 1 0 2 "
     ]
    }
   ],
   "source": [
    "def make_counter(n):\n",
    "    i = 0\n",
    "    def counter():\n",
    "        nonlocal i # Необходимое указание, поскольку далее используется присваивание\n",
    "        i = i - 1 if i > 0 else n\n",
    "        return i\n",
    "    return counter\n",
    "\n",
    "counter = make_counter(2)\n",
    "\n",
    "for i in range(16):\n",
    "    print(counter(), end=' ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Анонимные функции"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Функциональный стиль программирования предполагает создание большого числа ФВП. При этом часто приходится создавать небольшие функции-аргументы, нужные только для одной сиюминутной задачи. В подобных случаях удобнее воспользоваться механизмом создания анонимных функций с помощью ключевого слова lambda.\n",
    "\n",
    "Определение\n",
    "\n",
    "```Python\n",
    "func = lambda аргументы: выражение\n",
    "```\n",
    "\n",
    "эквивалентно следующему:\n",
    "\n",
    "```Python\n",
    "def func(аргументы):\n",
    "    return выражение\n",
    "```\n",
    "\n",
    "Лямбда-выражение можно передать на вход или возвратить из ФВП, как показано ниже:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'** ** ** ** ** ** ** ** ** **'"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def f(g, x):\n",
    "    return lambda size: ' '.join([g(x) for i in range(size)])\n",
    "\n",
    "f(lambda x: '*' * x, 2)(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Еще один пример:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "65536"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def twice(f):\n",
    "    def g(x):\n",
    "        return f(f(x))\n",
    "    return g\n",
    "\n",
    "twice(twice(lambda x: x * x))(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Обратите внимание на ограничения lambda. В ее теле могут использоваться только те конструкции, которые доступны в качестве выражения, возвращаемого с помощью return."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Классическими в функциональном программировании являются функции map, filter и reduce. Они реализованы в Питоне, но для целей более близкого знакомства с ФВП далее приводится упрощенная реализация каждой их них.\n",
    "\n",
    "Функция map принимает на вход унарную функцию и список, а возвращает новый список, элементы которого являются результатами применения функции-аргумента к элементам исходного списка:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def my_map(func, lst):\n",
    "    res = []\n",
    "    for x in lst:\n",
    "        res.append(func(x))\n",
    "    return res\n",
    "\n",
    "my_map(lambda x: x * x, range(10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Функция filter принимает на вход унарный предикат и список, а возвращает новый список, элементы которого удовлетворяют предикату:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 3, 5, 7, 9]"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def my_filter(pred, lst):\n",
    "    res = []\n",
    "    for x in lst:\n",
    "        if pred(x):\n",
    "            res.append(x)\n",
    "    return res\n",
    "\n",
    "my_filter(lambda x: x % 2, range(10))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Функция reduce принимает на вход бинарную операцию и список, последовательно применяет операцию-аргумент, сводя список до единственного значения:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "45"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def my_reduce(func, lst):\n",
    "    x = lst[0]\n",
    "    for y in lst[1:]:\n",
    "        x = func(x, y)\n",
    "    return x\n",
    "\n",
    "my_reduce(lambda x, y: x + y, range(10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Вместо функций map и filter в Питоне предпочтительнее использовать уже знакомые нам списковые включения, а также генераторы, о которых будет говориться далее."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Статическая типизация и сопоставление с образцом"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В Питоне имеются средства постепенной типизации (gradual typing) на основе аннотаций типов. В обычном режиме выполнения программы эти аннотации не имеют эффекта, но они могут использоваться совместно со сторонними инструментами статической типизации, такими как mypy."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Начиная с версии 3.10 в Питоне существует конструкция сопоставления с образцом match/case. Ее можно рассматривать, как аналог switch/case из других языков, но главное достоинство match/case состоит в связывании отдельных элементов составных шаблонов с переменными.\n",
    "\n",
    "Общая схема match/case выглядит следующим образом:\n",
    "\n",
    "```\n",
    "match <вычисляемое выражение>\n",
    "    case <шаблон_1>:\n",
    "        блок\n",
    "    case <шаблон_2>:\n",
    "        ...\n",
    "    case <шаблон_n>:\n",
    "        блок\n",
    "```\n",
    "\n",
    "В качестве шаблонов могут выступать объекты различных, в том числе пользовательских, типов."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В примере ниже используются аннотации типов совместно с сопоставлением с образцом для реализаций типов-сумм. Это подход к программированию, используемый в таких языках, как ML и Haskell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "None\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "# Поиск по ключу в связном списке, где хранятся ключи и значения\n",
    "\n",
    "from typing import NamedTuple, assert_never\n",
    "\n",
    "class Node(NamedTuple):\n",
    "    key: str\n",
    "    val: int\n",
    "    tail: 'List' = None\n",
    "\n",
    "List = Node | None\n",
    "\n",
    "def lookup(lst: List, key: str):\n",
    "    match lst:\n",
    "        case Node(key=k, val=v) if k == key:\n",
    "            return v\n",
    "        case Node(tail=t):\n",
    "            return lookup(t, key)\n",
    "        case None:\n",
    "            return None\n",
    "        case _ as unreachable:\n",
    "            assert_never(unreachable)\n",
    "\n",
    "lst = Node('a', 1, Node('b', 2, Node('c', 3)))\n",
    "\n",
    "print(lookup(lst, 'a'))\n",
    "print(lookup(lst, 'z'))\n",
    "print(lookup(lst, 'c'))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Благодаря наличию `case _ as unreachable:` имеется возможность проверить статически исчерпание альтернатив при сопоставлении с образцом. Попробуйте убрать ветвь `case None` и убедитесь, что mypy сигнализирует в ответ об ошибке."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Дополнительная информация о match/case приведена в [документации](https://peps.python.org/pep-0636/)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Декораторы"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Декораторы синтаксически представляют собой аннотации, которые указываются перед аннотируемой функцией. Реализуются они с помощью ФВП, которая принимает на вход функцию и возвращает функцию.\n",
    "\n",
    "Декоратор функции выглядит следующим образом:\n",
    "\n",
    "```Python\n",
    "@decorator\n",
    "def f():\n",
    "    print('...')\n",
    "```    \n",
    "\n",
    "Что эквивалентно выражению\n",
    "\n",
    "```Python\n",
    "def f():\n",
    "    print('...')\n",
    "\n",
    "f = decorator(f)\n",
    "```\n",
    "\n",
    "Простой пример:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Декоратор сработал.\n",
      "Запуск функции.\n",
      "...\n"
     ]
    }
   ],
   "source": [
    "def decorator(f):\n",
    "    print('Декоратор сработал.')\n",
    "    return f\n",
    "\n",
    "@decorator\n",
    "def f():\n",
    "    print('...')\n",
    "\n",
    "print('Запуск функции.')\n",
    "f()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Еще один пример, с использованием ранее определенной функции twice, уже готовой к использованию в качестве декоратора:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "65536"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "@twice\n",
    "def f(x):\n",
    "    return x * x\n",
    "\n",
    "f(f(2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Пример с регистрацией вызовов функции:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Запуск функции fib(4)\n",
      "Запуск функции fib(3)\n",
      "Запуск функции fib(2)\n",
      "Запуск функции fib(1)\n",
      "Запуск функции fib(0)\n",
      "Запуск функции fib(1)\n",
      "Запуск функции fib(2)\n",
      "Запуск функции fib(1)\n",
      "Запуск функции fib(0)\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def call_tracer(f):\n",
    "    def g(x):\n",
    "        print('Запуск функции {}({})'.format(f.__name__, x))\n",
    "        return f(x)\n",
    "    return g\n",
    "\n",
    "@call_tracer\n",
    "def fib(n):\n",
    "    if n == 0:\n",
    "        return 0\n",
    "    elif n == 1:\n",
    "        return 1\n",
    "    else:\n",
    "        return fib(n - 1) + fib(n - 2)\n",
    "\n",
    "fib(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Декораторы могут иметь параметры, как показано в примере ниже:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Запуск\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "def decorator(x):\n",
    "    def func(f):\n",
    "        print(x)\n",
    "        return f\n",
    "    return func\n",
    "    \n",
    "@decorator('Запуск')\n",
    "def my_func(x):\n",
    "    print(x)\n",
    "    \n",
    "my_func(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Помимо декораторов функции существуют также декораторы класса, которые принимают на вход класс и возвращают класс."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Генераторы\n",
    "\n",
    "Генераторы представляют собой особый вид функций, внутри которых находится оператор yield. Этот оператор приостанавливает вычисления внутри функции, сохраняет текущее состояние этих вычислений и, аналогично return, осуществляет возврат в вызывающую функцию. При этом вычисления в генераторе можно возобновить сразу после последнего вызова yield.\n",
    "\n",
    "```Python\n",
    "def func():\n",
    "    ...\n",
    "    yield выражение\n",
    "    ...\n",
    "```\n",
    "\n",
    "Вызов функции-генератора осуществляется особым способом, с помощью функции next, как показано в примере ниже:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'generator'>\n",
      "Начало цикла:\n",
      "0\n",
      "...\n",
      "Следующая итерация:\n",
      "1\n",
      "...\n",
      "Следующая итерация:\n",
      "2\n",
      "...\n",
      "Следующая итерация:\n",
      "3\n",
      "...\n",
      "Следующая итерация:\n",
      "Выход из генератора по исключению\n"
     ]
    }
   ],
   "source": [
    "def countup(n):\n",
    "    print('Начало цикла:')\n",
    "    for i in range(n):\n",
    "        yield i\n",
    "        print('Следующая итерация:')\n",
    "\n",
    "# Создан объект генератора, ему передан аргумент,\n",
    "# но countup еще не начал работу\n",
    "c = countup(4)\n",
    "print(type(c))\n",
    "for i in range(4):\n",
    "    print(next(c)) # выполнение останавливается после yield i\n",
    "    print('...')\n",
    "try:\n",
    "    print(next(c))\n",
    "except StopIteration:\n",
    "    print('Выход из генератора по исключению')\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Генераторы поддерживают протокол итераторов:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Начало цикла:\n",
      "0 Следующая итерация:\n",
      "1 Следующая итерация:\n",
      "2 Следующая итерация:\n",
      "3 Следующая итерация:\n"
     ]
    }
   ],
   "source": [
    "for i in countup(4):\n",
    "    print(i, end=' ')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def gen():\n",
    "    for i in range(10):\n",
    "        yield i\n",
    "\n",
    "list(gen())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В следующем примере генерируются все возможные пароли, символы которых принадлежат некоторому алфавиту. Использование генератора позволяет упростить код и сделать его производительным, поскольку порождение паролей происходит по необходимости, без создания лишних структур данных."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Пароль найден\n"
     ]
    }
   ],
   "source": [
    "def gen_password(abc):\n",
    "    for a in abc:\n",
    "        for b in abc:\n",
    "            for c in abc:\n",
    "                for d in abc:\n",
    "                    yield f'{a}{b}{c}{d}'\n",
    "\n",
    "\n",
    "for p in gen_password('absp'):\n",
    "    if p == 'pass':\n",
    "        print('Пароль найден')\n",
    "        break"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Предположим, что мы хотим реализовать следующие вычисления:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0.0,\n",
       " 0.8414709848078965,\n",
       " 0.9092974268256817,\n",
       " 0.1411200080598672,\n",
       " 0.6569865987187891,\n",
       " 0.9893582466233818,\n",
       " 0.4121184852417566,\n",
       " 0.4201670368266409,\n",
       " 0.9906073556948704,\n",
       " 0.6502878401571168]"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "my_filter(lambda x: x >= 0, my_map(math.sin, list(range(10000))))[:10]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Здесь формируется большое количество промежуточных данных, от которых можно избавиться, если реализовать вычисления \"по необходимости\", с помощью генераторов.\n",
    "\n",
    "Ниже показан более эффективный вариант решения той же задачи с помощью генераторов:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0.0,\n",
       " 0.8414709848078965,\n",
       " 0.9092974268256817,\n",
       " 0.1411200080598672,\n",
       " 0.6569865987187891,\n",
       " 0.9893582466233818,\n",
       " 0.4121184852417566,\n",
       " 0.4201670368266409,\n",
       " 0.9906073556948704,\n",
       " 0.6502878401571168]"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Сгенерировать бесконечный поток чисел 0, 1, 2, ...\n",
    "def gen_count():\n",
    "    i = 0\n",
    "    while True:\n",
    "        yield i\n",
    "        i += 1\n",
    "\n",
    "def gen_map(func, gen):\n",
    "    for x in gen:\n",
    "        yield func(x)\n",
    "\n",
    "def gen_filter(pred, gen):\n",
    "    for x in gen:\n",
    "        if pred(x):\n",
    "            yield x\n",
    "\n",
    "# Возвратить список n первых сгенерированных элементов\n",
    "def take(n, gen):\n",
    "    return [next(gen) for i in range(n)]\n",
    "\n",
    "take(10, gen_filter(lambda x: x >= 0, gen_map(math.sin, gen_count())))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В Питоне существуют генераторы-выражения, которые действуют аналогично уже изученным нами списковым включениям, но явно не порождают список. Генераторы-выражения представляют собой простой синтаксис для описания небольших генераторов:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0, 1, 4, 9, 16, 25, 36, 49, 64, 81] <generator object <genexpr> at 0x0000018078F4EDD0> [0, 1, 4, 9, 16, 25, 36, 49, 64, 81]\n"
     ]
    }
   ],
   "source": [
    "lst = [i * i for i in range(10)]\n",
    "gen = (i * i for i in range(10)) # Генератор-выражение\n",
    "print(lst, gen, list(gen))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2025\n",
      "2025\n"
     ]
    }
   ],
   "source": [
    "print(sum((i ** 3 for i in range(10))))\n",
    "print(sum(i ** 3 for i in range(10))) # Скобки необязательны"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Неизменяемые типы данных"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В Питоне существует аналог изменяемого массива — уже хорошо знакомый нам кортеж. Действительно, элементы кортежа нельзя изменить:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('a', [50, 'c'])\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(1, 2, 42)"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t1 = (1, 2, 3)\n",
    "t2 = ('a', ['b', 'c'])\n",
    "# t1[2] = 42 Не сработает\n",
    "t2[1][0] = 50 # Сработает, поскольку ссылка на список не изменилась\n",
    "print(t2)\n",
    "\n",
    "def replace(tup, index, val):\n",
    "    '''\n",
    "    Замена элемента кортежа в функциональном стиле.\n",
    "    Возвращается новый кортеж.\n",
    "    '''\n",
    "    return tup[:index] + (val,) + tup[index + 1:]\n",
    "\n",
    "replace(t1, 2, 42)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Множество в Питоне является изменяемой структурой данных, поэтому не может, в частности, выступать в качестве ключа словаря. Имеется неизменяемый вариант множества — frozenset:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{frozenset({'a', 'b', 'c'}): 42}"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s1 = set(['a', 'b', 'c'])\n",
    "d = {}\n",
    "# d[s1] = 42 Не сработает\n",
    "s2 = frozenset(['a', 'b', 'c'])\n",
    "d[s2] = 42\n",
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В качестве неполного аналога словаря в Питоне выступает структура данных namedtuple (именованный кортеж):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ivan 20\n",
      "Person(name='Ivan', age=21)\n"
     ]
    }
   ],
   "source": [
    "from collections import namedtuple\n",
    "\n",
    "Person = namedtuple('Person', 'name age')\n",
    "p1 = Person(name='Ivan', age=20)\n",
    "print(p1.name, p1.age)\n",
    "# p1.age += 1 Не сработает\n",
    "print(p1._replace(age=p1.age + 1)) # Возвращен новый именованный кортеж"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Модуль functools"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Модуль functools содержит ряд полезных определений, которые используются для функций высшего порядка. В частности, там имеется уже рассмотренная выше функция reduce."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Декоратор lru_cache осуществляет запоминание (мемоизацию) вычислений чистой функции. Если функция была вызвана повторно с теми же аргументами, то результат будет взят из таблицы:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.5109138\n",
      "0.0013229000000003488\n"
     ]
    }
   ],
   "source": [
    "from timeit import timeit\n",
    "from functools import lru_cache\n",
    "\n",
    "fact1 = lambda n: n * fact1(n - 1) if n else 1\n",
    "\n",
    "@lru_cache\n",
    "def fact2(n):\n",
    "    return n * fact2(n - 1) if n else 1\n",
    "\n",
    "print(timeit(lambda: fact1(1000), number=1000))\n",
    "print(timeit(lambda: fact2(1000), number=1000))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Функция partial принимает на вход функцию и возвращает новую функцию, некоторые аргументы которой уже содержат конкретные значения:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100\n"
     ]
    }
   ],
   "source": [
    "from functools import partial\n",
    "\n",
    "def power(x, n):\n",
    "    return x ** n\n",
    "\n",
    "power2 = partial(power, n=2)\n",
    "# Эквивалентно power2 = lambda x: power(x, n=2)\n",
    "\n",
    "print(power2(10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Модуль itertools"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Модуль itertools предназначен для работы с итераторами (генераторами) в высокопроизводительном функциональном стиле."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Итератор chain группирует итераторы-аргументы для последовательного выполнения:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 4 a b c d 10 11 12 13 14 "
     ]
    }
   ],
   "source": [
    "from itertools import chain\n",
    "\n",
    "for i in chain(range(1, 5), \"abcd\", range(10, 15)):\n",
    "    print(i, end=' ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В itertools имеется ряд итераторов для операций из области комбинаторики:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('a', 'a')\n",
      "('a', 'b')\n",
      "('a', 'c')\n",
      "('a', 'd')\n",
      "('b', 'a')\n",
      "('b', 'b')\n",
      "('b', 'c')\n",
      "('b', 'd')\n",
      "('c', 'a')\n",
      "('c', 'b')\n",
      "('c', 'c')\n",
      "('c', 'd')\n",
      "('d', 'a')\n",
      "('d', 'b')\n",
      "('d', 'c')\n",
      "('d', 'd')\n"
     ]
    }
   ],
   "source": [
    "from itertools import product\n",
    "\n",
    "for i in product('abcd', repeat=2):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('a', 'b', 'c')\n",
      "('a', 'b', 'd')\n",
      "('a', 'c', 'd')\n",
      "('b', 'c', 'd')\n"
     ]
    }
   ],
   "source": [
    "from itertools import combinations\n",
    "\n",
    "for i in combinations('abcd', 3):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "('a', 'b')\n",
      "('a', 'c')\n",
      "('a', 'd')\n",
      "('b', 'a')\n",
      "('b', 'c')\n",
      "('b', 'd')\n",
      "('c', 'a')\n",
      "('c', 'b')\n",
      "('c', 'd')\n",
      "('d', 'a')\n",
      "('d', 'b')\n",
      "('d', 'c')\n"
     ]
    }
   ],
   "source": [
    "from itertools import permutations\n",
    "\n",
    "for i in permutations('abcd', 2):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Итератор count является расширенной версией реализованной выше функции gen_count, а islice позволяет сделать срез для итератора:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[5, 6, 7, 8, 9, 10, 11, 12, 13, 14]"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from itertools import count, islice\n",
    "\n",
    "list(islice((i for i in count(5)), 0, 10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Итератор groupby последовательно объединяет в группы элементы итератора-аргумента по заданному ключу."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[('A', 4), ('B', 3), ('C', 2), ('D', 1), ('A', 2), ('B', 3)]\n",
      "[(3, ['one', 'one', 'two']), (1, ['3', '3', '3'])]\n"
     ]
    }
   ],
   "source": [
    "from itertools import groupby\n",
    "\n",
    "# Ключом по умолчанию является сам элемент\n",
    "print([(k, len(list(g))) for k, g in groupby('AAAABBBCCDAABBB')])\n",
    "\n",
    "# Ключом является len\n",
    "print([(k, list(g)) for k, g in groupby(['one', 'one', 'two', '3', '3', '3'], key=len)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Библиотека NumPy"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Библиотека NumPy предназначена для вычислений на многомерных массивах. Она используется в качестве базовой в большом количестве библиотек для научных вычислений, в том числе для анализа данных и машинного обучения.\n",
    "\n",
    "Можно выделить следующие характерные черты NumPy:\n",
    "\n",
    "* Использование типизированных, однородных n-мерных массивов фиксированной длины.\n",
    "* Операции применяются сразу ко многим элементам массивов.\n",
    "* Поддерживается векторизация, что позволяет повысить производительность вычислений."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Во многих случаях код на Питоне можно ускорить, сократив его, то есть избавившись от низкоуровневых операций. Это верно и для NumPy. Компактный код вычислений на NumPy, в котором, в частности, отсутствуют циклы, может оказаться производительнее кода на обычном Питоне в десятки и даже сотни раз."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "36.632734722624065"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from timeit import timeit\n",
    "\n",
    "x, y = list(range(0, 1000)), list(range(0, 1000))\n",
    "\n",
    "def test1(x, y):\n",
    "    return [a * b for a, b in zip(x, y)]\n",
    "\n",
    "nx, ny = np.array(x), np.array(y)\n",
    "\n",
    "def test2(x, y): return x * y\n",
    "\n",
    "t1 = timeit(lambda: test1(x, y), number=1000)\n",
    "t2 = timeit(lambda: test2(nx, ny), number=1000)\n",
    "t1 / t2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Свойства массива"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'numpy.ndarray'>\n",
      "2\n",
      "(2, 3)\n",
      "6 24\n",
      "int32 4\n"
     ]
    }
   ],
   "source": [
    "a = np.array([[1, 2, 3], [4, 5, 6]])\n",
    "\n",
    "# Тип\n",
    "print(type(a))\n",
    "\n",
    "# Размерность\n",
    "print(a.ndim)\n",
    "\n",
    "# Форма\n",
    "print(a.shape)\n",
    "\n",
    "# Количество элементов\n",
    "print(a.size, a.nbytes)\n",
    "\n",
    "# Тип элементов\n",
    "print(a.dtype, a.itemsize)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Функции создания массива"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4]\n",
      "[[0 0]\n",
      " [0 0]]\n",
      "[1. 1. 1. 1.]\n",
      "[42 42 42]\n",
      "[ 2.70972276e-306  4.96759808e-310 -9.63197469e-196]\n",
      "[1 2 3 4 5 6 7 8 9]\n",
      "[0.  0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n",
      "[[1 0 0 0]\n",
      " [0 1 0 0]\n",
      " [0 0 1 0]\n",
      " [0 0 0 1]]\n",
      "[215  91 125 155]\n"
     ]
    }
   ],
   "source": [
    "# Создание на основе Python-данных\n",
    "py_a = (1, 2, 3, 4)\n",
    "print(np.array(py_a))\n",
    "\n",
    "# Заполнение нулями\n",
    "print(np.zeros(shape=(2, 2), dtype='int8'))\n",
    "\n",
    "# Заполнение единицами\n",
    "print(np.ones(shape=(4,), dtype='float'))\n",
    "\n",
    "# Заполнение значением\n",
    "print(np.full((3,), 42))\n",
    "\n",
    "# Без инициализации\n",
    "print(np.empty((3,)))\n",
    "\n",
    "# Интервал значений\n",
    "print(np.arange(1, 10))\n",
    "print(np.arange(0, 1, step=0.1))\n",
    "\n",
    "# Диагональная матрица\n",
    "print(np.identity(4, dtype=int))\n",
    "\n",
    "# Случайные значения\n",
    "print(np.random.randint(0, 255, (4,)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Операции над массивами"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Форма массива может быть изменена. Это не приводит к изменению самих данных массива:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0 1 2 3 4 5 6 7]\n",
      "[[0 1 2 3]\n",
      " [4 5 6 7]]\n",
      "[[0 1]\n",
      " [2 3]\n",
      " [4 5]\n",
      " [6 7]]\n",
      "[[[0 1]\n",
      "  [2 3]]\n",
      "\n",
      " [[4 5]\n",
      "  [6 7]]]\n"
     ]
    }
   ],
   "source": [
    "a = np.arange(8)\n",
    "print(a)\n",
    "print(a.reshape(2, 4))\n",
    "print(a.reshape(4, 2))\n",
    "print(a.reshape(2, 2, 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Транспонирование также не приводит к изменению данных:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[0 1 2 3]\n",
      " [4 5 6 7]]\n",
      "[[0 4]\n",
      " [1 5]\n",
      " [2 6]\n",
      " [3 7]]\n"
     ]
    }
   ],
   "source": [
    "print(a.reshape(2, 4))\n",
    "print(a.reshape(2, 4).T)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Операции выполняются поэлементно:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[10 20 30 40]\n",
      "[3 5 7 9]\n",
      "[ 2  6 12 20]\n",
      "[   1    8   81 1024]\n",
      "[ 0.84147098  0.90929743  0.14112001 -0.7568025 ]\n",
      "[-1 -2 -3 -4]\n",
      "[False False  True  True]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([1, 2, 3, 4])\n",
    "b = np.array([2, 3, 4, 5])\n",
    "\n",
    "print(a * 10)\n",
    "print(a + b)\n",
    "print(a * b)\n",
    "print(a ** b)\n",
    "print(np.sin(a))\n",
    "\n",
    "print(np.negative(a))\n",
    "print(a > 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "24\n",
      "4\n",
      "1\n",
      "[[1 2]\n",
      " [3 4]]\n",
      "[1 3]\n",
      "[2 4]\n"
     ]
    }
   ],
   "source": [
    "print(a.sum())\n",
    "print(a.prod())\n",
    "print(a.max())\n",
    "print(a.min())\n",
    "\n",
    "print(a.reshape(2, 2))\n",
    "print(a.reshape(2, 2).min(axis=1))\n",
    "print(a.reshape(2, 2).max(axis=1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В общем случае можно использовать операции свертки в духе reduce() из Питона:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "24\n"
     ]
    }
   ],
   "source": [
    "print(np.add.reduce(a))\n",
    "print(np.multiply.reduce(a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Функция where(массив_условий, массив_при_true, массив_при_false):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4]\n",
      "[ True False  True False]\n",
      "[1 0 3 0]\n"
     ]
    }
   ],
   "source": [
    "print(a)\n",
    "cond = np.arange(a.size) % 2 == 0\n",
    "print(cond)\n",
    "print(np.where(cond, a, 0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Способы индексации массивов"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Простая индексация:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 4\n",
      "[ 1  2  3 42]\n",
      "[1 2 3 4] int32\n"
     ]
    }
   ],
   "source": [
    "print(a[0], a[3])\n",
    "\n",
    "\n",
    "# Запись производится по ссылке, то есть модифицируется исходный массив\n",
    "a[3] = 42\n",
    "print(a)\n",
    "\n",
    "# Если типы элементов не совпадают, то значение \"обрезается\"\n",
    "a[3] = 4.2\n",
    "print(a, a.dtype)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "[[1 2]\n",
      " [3 4]]\n",
      "[1 2] 4\n",
      "3 2\n",
      "3 2\n"
     ]
    }
   ],
   "source": [
    "# Последний элемент\n",
    "print(a[-1])\n",
    "\n",
    "a1 = a.reshape(2, 2)\n",
    "print(a1)\n",
    "\n",
    "# Индексация производится от строк к столбцам\n",
    "print(a1[0], a1[1, -1])\n",
    "print(a1[1, 0], a1[0, 1])\n",
    "\n",
    "# Так тоже можно\n",
    "print(a1[1][0], a1[0][1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Срезы работают аналогично стандартным в Питоне, однако модифицируются исходные данные:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 3]\n",
      "[[1 2]\n",
      " [3 4]]\n",
      "[[2]\n",
      " [4]]\n",
      "[ 1 42  3  4]\n",
      "[[ 1 42]\n",
      " [ 3  4]]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([1, 2, 3, 4])\n",
    "a1 = a.reshape(2, 2)\n",
    "\n",
    "print(a[::2])\n",
    "\n",
    "print(a1)\n",
    "b = a1[:, 1:]\n",
    "print(b)\n",
    "\n",
    "# Заменили элемент и в исходных массивах\n",
    "b[0] = 42\n",
    "print(a)\n",
    "print(a1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Индексация с помощью массивов:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[ 0 10 20 30 40 50 60 70 80 90]\n",
      "[ 0 10 20 30]\n",
      "[60 70 80 90]\n",
      "[1. 1. 1. 1. 1.]\n"
     ]
    }
   ],
   "source": [
    "a = np.arange(0, 100, 10)\n",
    "print(a)\n",
    "print(a[[0, 1, 2, 3]])\n",
    "print(a[[-4, -3, -2, -1]])\n",
    "\n",
    "d = np.identity(5)\n",
    "idx = np.array([0, 1, 2, 3, 4])\n",
    "print(d[idx, idx])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Использование булева массива:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ True False False False False]\n",
      " [False  True False False False]\n",
      " [False False  True False False]\n",
      " [False False False  True False]\n",
      " [False False False False  True]]\n",
      "[1. 1. 1. 1. 1.]\n",
      "[0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]\n"
     ]
    }
   ],
   "source": [
    "bidx = d != 0\n",
    "print(bidx)\n",
    "print(d[bidx])\n",
    "print(d[d == 0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Литература\n",
    "\n",
    "Для продолжения знакомства с функциональным программированием рекомендуются следующие фундаментальные учебники:\n",
    "\n",
    "1. Абельсон Харольд, Сассман Джеральд Джей. \"Структура и Интерпретация Компьютерных Программ\".\n",
    "1. Пирс Бенджамин. \"Типы в языках программирования\".\n",
    "1. Окасаки Крис. \"Чисто функциональные структуры данных\"."
   ]
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "43afbf7b8c92a6397086dae0be21e5b6ecbdfbb1f0b6983c22cfbb740a73e7f5"
  },
  "kernelspec": {
   "display_name": "Python 3.10.2 64-bit",
   "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.11.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}