lessons/lesson09/interactive_conspect.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Функции: избранные темы\n",
    "\n",
    "В предыдущих лекциях мы рассмотрели с вами простейшие [пользовательские функции в языке Python](../lesson7/interactive_conspect.ipynb) и более сложные конструкции, которые могут быть построены с помощью функций, к числе которым относятся [замыкания и декораторы](../lesson8/interactive_conspect.ipynb). В это лекции мы закончим обзор функций в Python, познакомившись с анонимными функциями, генераторными функциями и некоторыми встроенными функциями языка Python. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Анонимные функции\n",
    "\n",
    "Иногда возникает необходимости создания простых функций, чье тело состоит из единственного утверждения **return**. Такие функции обычно используются для обработки некоторых последовательностей по определенным правилам. Например, мы хотим посчитать среднее значение квадратов элементов некоторой числовой последовательности. Мы могли бы сделать это следующим образом:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "mean of elements' squares: 28.5\n"
     ]
    }
   ],
   "source": [
    "def get_squared_number(number: float) -> float:\n",
    "    return number ** 2\n",
    "\n",
    "\n",
    "sequence = list(range(10))\n",
    "\n",
    "square_mean = sum(map(get_squared_number, sequence))\n",
    "square_mean /= len(sequence)\n",
    "\n",
    "print(f\"mean of elements' squares: {square_mean}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Про функцию **map** мы поговорим чуть позже, сейчас сосредоточимся на другом. \n",
    "\n",
    "Данный подход может показаться избыточным, ведь нам пришлось создать целую функцию для банального возведения элементов в квадрат. Чтобы избежать подобного нагромождения однотипного кода, в Python поддерживаются анонимные функции, известные также как лямбда-выражения (название берет свое начало из формальной системы [лямбда-исчисления](https://neerc.ifmo.ru/wiki/index.php?title=%D0%9B%D1%8F%D0%BC%D0%B1%D0%B4%D0%B0-%D0%B8%D1%81%D1%87%D0%B8%D1%81%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5)). Лямбда-выражения - однострочные функции, тело которых состоит из простых выражений - возвращаемых значений.\n",
    "\n",
    "В обзем виде анонимные функции определяются следующим образом:\n",
    "\n",
    "```python\n",
    "lambda parameters: expression\n",
    "```\n",
    "\n",
    "Рассмотрим его подробнее:\n",
    "\n",
    "- **lambda** - ключевое слово, которое сообщает интерпретатору, что вы намереваетесь создать анонимную функцию;\n",
    "- **parameters** - список параметров лямбда-функции, разделенных запятыми; параметры лямбда-функции ничем не отличаются от параметров обычной функции: вы можете создавать анонимные функции с позиционными параметрами, параметрами со значениями по умолчанию, чисто именованные параметры, параметрами в формах *args, **kwargs;\n",
    "\n",
    "        Совет: несмотря на возможность использования различныъ форм параметров в лямбда-выражениях, стоит помнить, что анонимные функции - простые однострочные функции, выполняющие очень простые действия. Исходя из этого, стоит обходиться лишь позиционными параметрами и не переусложнять их.\n",
    "\n",
    "- **expression** - простое выражение, результат вычисления которого будет возвращен после вызова лямбда-функции;\n",
    "\n",
    "Теперь, вооружившись анонимными функциями, исправим приведенный выше пример:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "mean of elements' squares: 28.5\n"
     ]
    }
   ],
   "source": [
    "sequence = list(range(10))\n",
    "\n",
    "square_mean = sum(map(lambda x: x ** 2, sequence))\n",
    "square_mean /= len(sequence)\n",
    "\n",
    "print(f\"mean of elements' squares: {square_mean}\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Теперь наш код выглядит более аккуратно и более читабельно.\n",
    "\n",
    "Стоит обратить внимание, что тело лямбда-функции - это именно выражение. Лямбда-функция не может содержать утвержедний, типа присваивания, или составных утверждений, типа циклов - только выражение. Однако вы по-прежнему можете использовать простейшее ветвление с помощью тернарного оператора: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sequence: [0, 2, -1, 8, 5, -4, -4, -1, 7, -4]\n",
      "square_roots_sum = 9.124459975683667;\n"
     ]
    }
   ],
   "source": [
    "from random import randint\n",
    "from math import sqrt\n",
    "\n",
    "\n",
    "sequence = [randint(-9, 9) for _ in range(10)]\n",
    "\n",
    "print(f'sequence: {sequence}')\n",
    "\n",
    "square_roots_sum = sum(map(lambda x: sqrt(x) if x >= 0 else 0, sequence))\n",
    "print(f'{square_roots_sum = };')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Также выражение в теле лямбда-функции может обуславливаться на локальный контекст, т.е. при вычислении выражения могут быть использованы внешние для данной анонимной функции переменные. Так, в примере ниже, прдставлен код для осуществления нормализации входных данных, что может быть полезным в ряде прикладных задач, в частности в задачах машинного обучения:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sequence: [8, 4, 5, 3, 2, 4, -9, 7, -2, 8]\n",
      "sequence normalized: [1.0, 0.7647058823529411, 0.8235294117647058, 0.7058823529411765, 0.6470588235294118, 0.7647058823529411, 0.0, 0.9411764705882353, 0.4117647058823529, 1.0];\n"
     ]
    }
   ],
   "source": [
    "from random import randint\n",
    "\n",
    "sequence = [randint(-9, 9) for _ in range(10)]\n",
    "\n",
    "print(f'sequence: {sequence}')\n",
    "\n",
    "sequence_min, sequence_max = min(sequence), max(sequence)\n",
    "sequence_normalized = list(\n",
    "    map(\n",
    "        lambda x: (x - sequence_min) / (sequence_max - sequence_min),\n",
    "        sequence \n",
    "    )\n",
    ")\n",
    "\n",
    "print(f'sequence normalized: {sequence_normalized};')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Обращаю ваше внимание, что все примеры выше являются чисто учебными, в реальных задах подобного плана целесообразней было бы обойтись списковыми включениями, которые были разобраны ранее, а также генераторными выражениями, которые будут разобраны в следующем разделе:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "sequence: [-6, -5, 3, 3, 0, -3, -1, 8, 6, -4]\n",
      "sequence normalized: [0.0, 0.07142857142857142, 0.6428571428571429, 0.6428571428571429, 0.42857142857142855, 0.21428571428571427, 0.35714285714285715, 1.0, 0.8571428571428571, 0.14285714285714285];\n"
     ]
    }
   ],
   "source": [
    "from random import randint\n",
    "\n",
    "\n",
    "sequence = [randint(-9, 9) for _ in range(10)]\n",
    "\n",
    "print(f'sequence: {sequence}')\n",
    "\n",
    "sequence_min, sequence_max = min(sequence), max(sequence)\n",
    "sequence_normalized = [\n",
    "    (elem - sequence_min) / (sequence_max - sequence_min)\n",
    "    for elem in sequence\n",
    "]\n",
    "\n",
    "print(f'sequence normalized: {sequence_normalized};')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Однако, не стоит ставить крест на анонимных функциях, они по-прежнему могут быть полезными, например, для сортировки элементов по специальным правилам. Здесь позволю себе повторить пример, с сортировкой слов по их окончаниям, приведенный в одной из предыдущих лекций.\n",
    "\n",
    "Предположим, что у нас есть некоторый список доступных слов, и мы бы хотели сочинить стихи с их использованием. Не секрет, что для удачного стихосложения требуется, чтобы слова с определенной периодичностью имели одинаковые окончания (если вы не Даниил Хармс, разумеется). В этом случае, как программисты на языке Python, мы можем без труда сгруппировать слова по окончаниям, используя анонимные функции:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['storage', 'orange', 'apple', 'begin', 'sin', 'formation', 'vibration', 'station', 'glass', 'grass']\n"
     ]
    }
   ],
   "source": [
    "words = [\n",
    "    'apple', 'grass', 'station', 'begin', 'orange',\n",
    "    'sin', 'glass', 'storage', 'vibration', 'formation'\n",
    "]\n",
    "\n",
    "words_sorted = sorted(words, key=lambda x: x[::-1])\n",
    "\n",
    "print(words_sorted)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В завершении этого раздела лишний раз подчеркну, что использовании лямбда-функций обосновано только если необходимый функционал является очень простым. Не стоит оформлять в виде анонимной функции сложный и неинтуитивно понятный код. В этом случае стоит задуматься над реализацией отдельно функции."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Генераторные функции\n",
    "\n",
    "Изучая последовательности мы познакомились с итерируемыми объектами и итераторами. Также в предыдущих лекциях нами было установлено, что к итерируемым объектам относятся не только последовательности, но еще и списки, и словари. Сегодня мы рассмотрим еще один тип итерируемых объектов: генераторы. Создание которых можно осуществить посредством генераторных функций.\n",
    "\n",
    "Генераторная функция - это функция, тело которой содержит как минимуму одно выражение с ключевым словом **yeild**. При вызове генераторной функции, тело функции не выполняется сразу, а результат выполнения - специальный объект-генератор. Давайте проиллюстрируем сказанное простым примером:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import Generator\n",
    "\n",
    "\n",
    "def generate_123() -> Generator:\n",
    "    print('start generation')\n",
    "    \n",
    "    for i in range(1, 4):\n",
    "        print(f'generate: {i}')\n",
    "        yield i\n",
    "\n",
    "    print('end generation')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "function\n",
      "generator\n"
     ]
    }
   ],
   "source": [
    "generator = generate_123()\n",
    "\n",
    "print(type(generate_123).__name__)\n",
    "print(type(generator).__name__)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Как мы видим, генераторная функция имеет тип данных **function**, как и прочие пользовательские функции, которые мы видели до этого. Но возвращенный объект имеет новый для нас типа данных - **generator**. Давайте разберемся, что это такое.\n",
    "\n",
    "Генератор - это специальный объект, который фактически оборачивает тело генераторной функции, ее локальные переменные и текущую точку выполнения. Генератор является итерируемым объектом, а потому поддерживает вызов встроенной функции **next()**, которая обсуждалась ранее:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "start generation\n",
      "generate: 1\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(generator)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Во время вызова функции next(), генератор выполняет тело функции до тех пор, пока не встретит выражение с ключевым словом yeild. Если после слова yeild идет какое-либо выражение, генератор произведет значение этого выражения и \"вернет его вызывающей стороне\", после чего остановится, запомнит свое текущее состояние, после чего вернет управление над потоком выполнения вызывающей стороне. Если после yeild ничего нет, то генератор произведет None с сделает все то же самое. \n",
    "\n",
    "После очередного вызова next() генератор продолжит выполнение с того места, на котором он остановился в последний раз:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "generate: 2\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(generator)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "generate: 3\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(generator)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В данном примере мы создали генератор, который способен произвести числа от 1 до 3, т.е. наш генератор поддерживает всего 3 вызова функции next(). При попытки вызвать функцию next() с генератором, исчерпавшим свои значения, мы получим исключение типа StopIteration. Т.е. столкнемся с классическим поведением ограниченных итераторов:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "end generation\n"
     ]
    },
    {
     "ename": "StopIteration",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mStopIteration\u001b[0m                             Traceback (most recent call last)",
      "\u001b[1;32mc:\\Users\\MrWh1teF0x\\OneDrive\\Python_projects\\python_mipt_dafe\\lessons\\lesson9\\interactive_conspect.ipynb Cell 24\u001b[0m line \u001b[0;36m1\n\u001b[1;32m----> <a href='vscode-notebook-cell:/c%3A/Users/MrWh1teF0x/OneDrive/Python_projects/python_mipt_dafe/lessons/lesson9/interactive_conspect.ipynb#X32sZmlsZQ%3D%3D?line=0'>1</a>\u001b[0m \u001b[39mnext\u001b[39;49m(generator)\n",
      "\u001b[1;31mStopIteration\u001b[0m: "
     ]
    }
   ],
   "source": [
    "next(generator)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "После исчерпания генератор не может быть использован повторно. Однако мы можем создать новый генератор, используя нашу генераторную функцию. В таком контексте мы можем думать о генераторной функции, как о фабрике генераторов.\n",
    "\n",
    "Поскольку генераторы являются итерируемыми объектами, мы можем использовать их в циклах for, как показано ниже:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "start generation\n",
      "generate: 1\n",
      "get from generator: 1;\n",
      "generate: 2\n",
      "get from generator: 2;\n",
      "generate: 3\n",
      "get from generator: 3;\n",
      "end generation\n"
     ]
    }
   ],
   "source": [
    "generator = generate_123()\n",
    "\n",
    "for i in generator:\n",
    "    print(f'get from generator: {i};')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Также генераторная функция может содержать утверждение return. В этом случае, при достижении утверждения return генератором, будет возбуждаться исключение StopIteration, в качестве аргумента которого будет передано выражение, следующее за return. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import Generator\n",
    "\n",
    "\n",
    "def generate_even_digits() -> Generator:\n",
    "    num_curr = 0\n",
    "\n",
    "    while True:\n",
    "        if num_curr >= 10:\n",
    "            return 'numbers are exhausted'\n",
    "        \n",
    "        if num_curr % 2 == 0:\n",
    "            yield num_curr\n",
    "\n",
    "        num_curr += 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "ename": "StopIteration",
     "evalue": "numbers are exhausted",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mStopIteration\u001b[0m                             Traceback (most recent call last)",
      "\u001b[1;32mc:\\Users\\Michail\\Desktop\\mipt\\teaching\\python_mipt_dafe\\lessons\\lesson9\\interactive_conspect.ipynb Cell 29\u001b[0m line \u001b[0;36m8\n\u001b[0;32m      <a href='vscode-notebook-cell:/c%3A/Users/Michail/Desktop/mipt/teaching/python_mipt_dafe/lessons/lesson9/interactive_conspect.ipynb#Y132sZmlsZQ%3D%3D?line=5'>6</a>\u001b[0m \u001b[39mnext\u001b[39m(generator)\n\u001b[0;32m      <a href='vscode-notebook-cell:/c%3A/Users/Michail/Desktop/mipt/teaching/python_mipt_dafe/lessons/lesson9/interactive_conspect.ipynb#Y132sZmlsZQ%3D%3D?line=6'>7</a>\u001b[0m \u001b[39mnext\u001b[39m(generator)\n\u001b[1;32m----> <a href='vscode-notebook-cell:/c%3A/Users/Michail/Desktop/mipt/teaching/python_mipt_dafe/lessons/lesson9/interactive_conspect.ipynb#Y132sZmlsZQ%3D%3D?line=7'>8</a>\u001b[0m \u001b[39mnext\u001b[39;49m(generator)\n",
      "\u001b[1;31mStopIteration\u001b[0m: numbers are exhausted"
     ]
    }
   ],
   "source": [
    "generator = generate_even_digits()\n",
    "\n",
    "next(generator)\n",
    "next(generator)\n",
    "next(generator)\n",
    "next(generator)\n",
    "next(generator)\n",
    "next(generator)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import Generator\n",
    "\n",
    "\n",
    "def generate_pyramid_sequence(top_number: int) -> Generator:\n",
    "    if top_number <= 1:\n",
    "        raise ValueError('top number should be greater than 1')\n",
    "    \n",
    "    top_number = int(top_number)\n",
    "    \n",
    "    for i in range(1, top_number):\n",
    "        yield i\n",
    "\n",
    "    for i in range(top_number, 0, -1):\n",
    "        yield i"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Как настоящая фабрика, генераторная функция может иметь параметры, которые задаются теми же способами, что и параметры пользовательских функций."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 4 5 4 3 2 1 "
     ]
    }
   ],
   "source": [
    "for i in generate_pyramid_sequence(5):\n",
    "    print(i, end=' ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В данном примере мы создали генераторную функцию, которая строит \"пирамидальную\" последовательность. Генераторная функция принимает на вход один аргумент - целое положительное число, большее 1, и возвращает генератор, стоящий данную последовательность.\n",
    "\n",
    "Код из пример выше может быть упрощен с помощью использования специальной конструкции:\n",
    "\n",
    "```python\n",
    "yield from expression \n",
    "```\n",
    "\n",
    "В качестве expression должен выступать некоторый итерируемый объект. Данная конструкция порождает значения напрямую и итерируемого объекта и позволяет значительно упростить код."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import Generator\n",
    "\n",
    "\n",
    "def generate_pyramid_sequence(top_number: int) -> Generator:\n",
    "    if top_number <= 1:\n",
    "        raise ValueError('top number should be greater than 1')\n",
    "    \n",
    "    top_number = int(top_number)\n",
    "    \n",
    "    yield from range(1, top_number)\n",
    "    yield from range(top_number, 0, -1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 4 5 4 3 2 1 "
     ]
    }
   ],
   "source": [
    "for i in generate_pyramid_sequence(5):\n",
    "    print(i, end=' ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Тепрь давайте обсудим, зачем нам вообще нужны генераторы, ведь все, что мы делали выше, может быть сделано и без использования генераторных функций. На самом деле генераторы могут оказать очень полезными.\n",
    "\n",
    "Во-первых, в отличие от функций, которые возвращают коллекции элементов, генераторы могут быть наограниченными. Т.е. мы буквально можем создать генератор, способный порождать бесконечное число элементов. В качестве примера такого генератора, давайте напишем генератор, способный порождать арифметическую прогрессию:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "from typing import Generator\n",
    "\n",
    "\n",
    "def generate_arithmetic_progression(start=0, step=1) -> Generator:\n",
    "    current_member = start\n",
    "\n",
    "    while True:\n",
    "        yield current_member\n",
    "        current_member += step"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "member_1: 0;\n",
      "member_2: 2;\n",
      "member_3: 4;\n",
      "member_4: 6;\n",
      "member_5: 8;\n"
     ]
    }
   ],
   "source": [
    "progression_gen = generate_arithmetic_progression(step=2)\n",
    "\n",
    "for i in range(5):\n",
    "    print(f'member_{i + 1}: {next(progression_gen)};')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Подобное просто невозможно сделать с помощью функций, генерирующих последовательности, поскольку нам банально не зватит памяти для аллоцирования бесконечного числа элементов. Отсюда следует второе полезное качество генераторов. Генераторы вычисляются лениво. Т.е. очередное значение, порожденное генератором, будет рассчитано и аллоцировано только в момент непосредственного вызова. Генератора не предрассчитывает все пораждаемые элементы заранее, в отличие от функций, возвращающих коллекции.\n",
    "\n",
    "Это свойство может оказаться очень полезным при работе с большими объемами данных. Например, подобные генераторы могут быть использованы при порционной загрузке обучающих выборок при решении задач машинного обучения."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Генераторные выражения"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "По аналогии со списковыми и словарными включениями, вы можете создавать простые генераторы с помощью генераторных выражений. В качестве примера использования генераторных выражений, давайте вычислим сумму квадратов чисел от 0 до 9 с помощью списковых и генераторных включений:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "285"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# испоьзование спискового включения\n",
    "sum([i ** 2 for i in range(10)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "285"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# использование генераторного выражения\n",
    "sum(i ** 2 for i in range(10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Старайтесь использовать генераторные выражения для создания простых и обезличенных генераторов для мгновенного использования (например, для использования в функции sum, как в данном примере). При необходимости создания сложных генераторов и запутанной логикой, отдавайте предпочтение генераторным функциям."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Некоторые встроенные функции и итерируемые объекты"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### max() / min()\n",
    "\n",
    "Функции определения минимального и максимального значения среди переденных, или среди элементов некоторого итерируемого объекта. Также поддерживают аргумент key, для определения статистики по переданному ключу:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function max in module builtins:\n",
      "\n",
      "max(...)\n",
      "    max(iterable, *[, default=obj, key=func]) -> value\n",
      "    max(arg1, arg2, *args, *[, key=func]) -> value\n",
      "    \n",
      "    With a single iterable argument, return its biggest item. The\n",
      "    default keyword-only argument specifies an object to return if\n",
      "    the provided iterable is empty.\n",
      "    With two or more arguments, return the largest argument.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(max)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function min in module builtins:\n",
      "\n",
      "min(...)\n",
      "    min(iterable, *[, default=obj, key=func]) -> value\n",
      "    min(arg1, arg2, *args, *[, key=func]) -> value\n",
      "    \n",
      "    With a single iterable argument, return its smallest item. The\n",
      "    default keyword-only argument specifies an object to return if\n",
      "    the provided iterable is empty.\n",
      "    With two or more arguments, return the smallest argument.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(min)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "9\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "print(\n",
    "    max(range(5)),\n",
    "    max(1, 3, 5, 7, 9),\n",
    "    max(range(1, 10), key=lambda x: 5 - x),\n",
    "    sep='\\n'\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### any() / all()\n",
    "\n",
    "Функция all позволяет определить, принимают ли все элементы итерируемого объекта значение True в булевом контексте или нет. В случае если итерируемый объект пустой, функция вернет True. any возвращает True, если хотя бы один элемент итерируемого объект принимает значение True в булевом контексте. В случае если итерируемый объект пуст, функция вернет False."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function all in module builtins:\n",
      "\n",
      "all(iterable, /)\n",
      "    Return True if bool(x) is True for all values x in the iterable.\n",
      "    \n",
      "    If the iterable is empty, return True.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(all)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function any in module builtins:\n",
      "\n",
      "any(iterable, /)\n",
      "    Return True if bool(x) is True for any x in the iterable.\n",
      "    \n",
      "    If the iterable is empty, return False.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(any)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "print(\n",
    "    all(range(5)),\n",
    "    all([]),\n",
    "    sep='\\n'\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print(\n",
    "    any(range(5)),\n",
    "    any([]),\n",
    "    sep='\\n'\n",
    ")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### range()\n",
    "\n",
    "Мы очень часто работали c range, но только узнав о генераторах и итераторах мы готовы всерьез ее обсудить. range является специальным встроенным объектом. При использовании его в цикле for range возвращает генератор, пораждающий числа из заданного диапазона с заданным шагом, который по умолчанию равен 1. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "range\n"
     ]
    }
   ],
   "source": [
    "range_obj = range(1, 10, 2)\n",
    "\n",
    "print(type(range_obj).__name__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "3\n",
      "5\n",
      "7\n",
      "9\n"
     ]
    }
   ],
   "source": [
    "for i in range_obj:\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### enumerate()\n",
    "\n",
    "Мы также неоднократно встречались с enumerate, но понять суть ее работы мы можем только сейчас. Аналогично range enumerate является встроенным типом данных, позволяющих конструировать специальные объекты. При использовании этих объектов в циклах for, они возвращают генераторы, пораждающие пары вида <индекс, значение>."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "enumerate\n"
     ]
    }
   ],
   "source": [
    "enum = enumerate(range(5), start=1)\n",
    "\n",
    "print(type(enum).__name__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "elem_1: 0\n",
      "elem_2: 1\n",
      "elem_3: 2\n",
      "elem_4: 3\n",
      "elem_5: 4\n"
     ]
    }
   ],
   "source": [
    "for i, elem in enum:\n",
    "    print(f'elem_{i}: {elem}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### sum()\n",
    "\n",
    "Функция sum предназначена для суммирования всех элементов переданного итерируемого объекта. Причем аргумент start позволяет настроить тип и значения объекта, к которому будут прибавляться очередные значения."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function sum in module builtins:\n",
      "\n",
      "sum(iterable, /, start=0)\n",
      "    Return the sum of a 'start' value (default: 0) plus an iterable of numbers\n",
      "    \n",
      "    When the iterable is empty, return the start value.\n",
      "    This function is intended specifically for use with numeric values and may\n",
      "    reject non-numeric types.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(sum)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(range(5))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### map()\n",
    "\n",
    "Мы знакомы с объектом map из примеров выше. Объект map позволяет построить итерируемый объект, содержащий результат применения переданной функции, к переданным итерируемым объектам. Например, мы можем посчитать поэлементную разницу двух массивов:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "vector1: [4, -5, 4, -7, -3, -6, -10, -9, -10, -7];\n",
      "vector2: [-10, -3, 6, -9, 7, 4, 3, -1, 5, -8];\n",
      "map\n"
     ]
    }
   ],
   "source": [
    "from random import randint\n",
    "\n",
    "\n",
    "vector1 = [randint(-10, 10) for _ in range(10)]\n",
    "vector2 = [randint(-10, 10) for _ in range(10)]\n",
    "\n",
    "print(\n",
    "    f'vector1: {vector1};',\n",
    "    f'vector2: {vector2};',\n",
    "    sep='\\n'\n",
    ")\n",
    "\n",
    "differences = map(lambda x, y: x - y, vector1, vector2)\n",
    "\n",
    "print(type(differences).__name__)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "difference_1: 14;\n",
      "difference_2: -2;\n",
      "difference_3: -2;\n",
      "difference_4: 2;\n",
      "difference_5: -10;\n",
      "difference_6: -10;\n",
      "difference_7: -13;\n",
      "difference_8: -8;\n",
      "difference_9: -15;\n",
      "difference_10: 1;\n"
     ]
    }
   ],
   "source": [
    "for i, difference in enumerate(differences, start=1):\n",
    "    print(f'difference_{i}: {difference};')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "При несоответствии размеров итерируемых объектов, map обрежет все до длины кратчайшей последовательности. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "difference_0: 14;\n",
      "difference_1: -2;\n",
      "difference_2: -2;\n",
      "difference_3: 2;\n",
      "difference_4: -10;\n"
     ]
    }
   ],
   "source": [
    "for i, diff in enumerate(map(lambda x, y: x - y, vector1, vector2[:5])):\n",
    "    print(f'difference_{i}: {diff};')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### zip()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "zip позволяет получит итератор i-ый элементы которого - кортеж, содержащий i-е элементы переданных итерируемых объектов. При несоответствии длин итерируемых объектов, zip ведет себя подобно map, обрезая все по длине кратчайшей последовательности. \n",
    "\n",
    "Использование zip может быть проиллюстрировано вычислением манхеттенского расстояния между векторами:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "vector1: [7, 9, -4, -4, 4, -4, 0, -3, -4, -2];\n",
      "vector2: [-6, 7, 3, -4, -8, 3, -6, 2, 3, -3];\n"
     ]
    }
   ],
   "source": [
    "from random import randint\n",
    "\n",
    "\n",
    "vector1 = [randint(-10, 10) for _ in range(10)]\n",
    "vector2 = [randint(-10, 10) for _ in range(10)]\n",
    "\n",
    "print(\n",
    "    f'vector1: {vector1};',\n",
    "    f'vector2: {vector2};',\n",
    "    sep='\\n'\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "distance = 60\n"
     ]
    }
   ],
   "source": [
    "distance = sum(abs(x_1 - x_2) for x_1, x_2 in zip(vector1, vector2))\n",
    "\n",
    "print(f'{distance = }')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.12.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}