python_pd/03_collections/04_iter.ipynb

{
 "metadata": {
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.0-final"
  },
  "orig_nbformat": 2,
  "kernelspec": {
   "name": "python3",
   "display_name": "Python 3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2,
 "cells": [
  {
   "source": [
    "# Итераторы\n",
    "\n",
    "## Итерируемый объект\n",
    "\n",
    "В Python термины \"итерируемый объект\", \"итератор\" и \"генератор\" имеют разный смысл. \n",
    "\n",
    "Итерируемый объект -- это любой объект который реализует специальный метод обращения по индексу ```__getitem__``` или метод получения итератора ```__iter__```. Метод ```__getitem__``` относится к так называемому протоколу последовательности, а метод ```__iter__``` - к протоколу итератора. Таким образом, если объект реализует один из этих протоколов, то он является итерируемым объектом. Подробнее протоколы в Python будут рассмотрены в разделе \"Классы\". Если метод ```__iter__``` не реализован, то метод ```__getitem__``` должен принимать индексы начиная с нуля. В Python итерируемыми объектами являются все базовые коллекции (```list```, ```dict```, ```set```, ```tuple```). Итерируемыми объектами могут выступать не только структуры данных. Например, файлы также могут являться итерируемым объектом и порождать итератор для перебора строк.\n",
    "\n",
    "Метод ```__getitem__``` отвечает за обращение к элементу коллекции по индексу или ключу. Он вызывается всякий раз, когда используется оператор квадратных скобок. Также он возвращает исключение ```IndexError``` когда переданный индекс лежит вне диапазона индексов последовательности или ```KeyError``` когда переданного ключа нет в коллекции.\n",
    "\n",
    "Стоит упомянуть, что методы, которые начинаются и заканчиваются на два нижних подчеркивания, называются дандер-методы или \"магические\" методы. Подробно их работа будет рассмотрена в соответствующем разделе главы о классах.\n",
    "\n",
    "Возвращаясь к стандартным коллекциям, рассмотрим какие методы есть в каждой из них. Списки и кортежи -- это индексируемые последовательности и они реализуют метод ```__getitem__```, кроме того у них есть и метод ```__iter__```. Для проверки воспользуемся встроенной функцией ```hasattr``` она принимает какой-либо объект в качестве первого аргумента и название атрибута в качестве второго аргумента. Затем она возвращает ```True``` если атрибут есть у объекта и ```False``` в противном случае."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "hasattr(foo, \"__getitem__\") = True\nhasattr(foo, \"__iter__\") = True\n"
     ]
    }
   ],
   "source": [
    "foo = [1, 2, 3]\n",
    "\n",
    "print(f'{hasattr(foo, \"__getitem__\") = }')\n",
    "print(f'{hasattr(foo, \"__iter__\") = }')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "hasattr(bar, \"__getitem__\") = True\nhasattr(bar, \"__iter__\") = True\n"
     ]
    }
   ],
   "source": [
    "bar = tuple(foo)\n",
    "print(f'{hasattr(bar, \"__getitem__\") = }')\n",
    "print(f'{hasattr(bar, \"__iter__\") = }')"
   ]
  },
  {
   "source": [
    "Словари также реализуют оба метода, но в качестве индексов у них выступают ключи."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "source": [
    "baz = {'a': 'Douglas Adams', 'b': 42}\n",
    "print(f'{hasattr(baz, \"__getitem__\") = }')\n",
    "print(f'{hasattr(baz, \"__iter__\") = }')"
   ],
   "cell_type": "code",
   "metadata": {},
   "execution_count": 4,
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "hasattr(baz, \"__getitem__\") = True\nhasattr(baz, \"__iter__\") = True\n"
     ]
    }
   ]
  },
  {
   "source": [
    "Множества -- это не индексируемая коллекция, это означает, что у множеств нет метода ```__getitem__```, однако они являются итерируемыми объектами за счет реализации метода ```__iter__```."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "hasattr(quux, \"__getitem__\") = False\nhasattr(quux, \"__iter__\") = True\n"
     ]
    }
   ],
   "source": [
    "quux = set(foo)\n",
    "print(f'{hasattr(quux, \"__getitem__\") = }')\n",
    "print(f'{hasattr(quux, \"__iter__\") = }')"
   ]
  },
  {
   "source": [
    "Реализовать собственный итерируемый объект не составляет особого труда. Этот процесс подробно будет описан в главе о классах.\n",
    "\n",
    "## Итератор\n",
    "\n",
    "Итераторы в Python это специальные объекты, получаемые с помощью специального метода ```__iter__``` или встроенной функции ```iter```, которая вызывает соответствующий метод.\n",
    "\n",
    "В Python для того, чтобы объект соответствовал объекту итератору необходимо, чтобы он реализовал протокол итератора. Это некоторое соглашение, описывающее условия, при которых объект можно считать итератором. Этот протокол требует, чтобы объект реализовывал два метода ```__iter__``` и ```__next__```. Метод ```__iter__``` предназначен для конструирования итератора и должен возвращать итератор. Метод ```__next__``` используется для вычисления следующего значения. Вызывать эти методы напрямую нет необходимости, для этого используются встроенные функции ```iter``` для вызова ```__iter__``` и ```next``` для ```__next__```.\n",
    "\n",
    "Так встроенные коллекции не являются итераторами, но его из них можно получить."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "bar_iter = <list_iterator object at 0x000002E0AF7D2BE0>\ntype(bar_iter) = <class 'list_iterator'>\n-------------------------\n0: 1\n1: 2\n2: 3\n"
     ]
    },
    {
     "output_type": "error",
     "ename": "StopIteration",
     "evalue": "",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mStopIteration\u001b[0m                             Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-7-1fd125614c61>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      9\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'1:'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mnext\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mbar_iter\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m     10\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'2:'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mnext\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mbar_iter\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m---> 11\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'3:'\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mnext\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mbar_iter\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m  \u001b[1;31m# StopIteration\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mStopIteration\u001b[0m: "
     ]
    }
   ],
   "source": [
    "bar = [1, 2, 3]\n",
    "bar_iter = iter(bar)\n",
    "print(f'{bar_iter = }')\n",
    "print(f'{type(bar_iter) = }')\n",
    "print('-' * 25)\n",
    "\n",
    "# функция next возвращает следующий элемент\n",
    "print('0:', next(bar_iter))\n",
    "print('1:', next(bar_iter))\n",
    "print('2:', next(bar_iter))\n",
    "\n",
    "# Все следующие попытки вызвать next будут приводить к появлению \n",
    "# исключения StopIteration, т.к. итератор закончился \n",
    "print('3:', next(bar_iter))  # StopIteration"
   ]
  },
  {
   "source": [
    "Обратите внимание что, когда функция ```next``` возвращает последний элемент последовательности, последующий вызов этой функции вернет исключение ```StopIteration```, которое говорит о том, что в итераторе закончились элементы. Таким образом, итератор исчерпаем, т. е. после того, как он был использован один раз, повторное использование невозможно. При дальнейшем вызове функции ```next``` будет всегда возникать исключение ```StopIteration```.\n",
    "\n",
    "Итераторы сами по себе всегда являются итерируемыми объектами, т. е. из них можно получить итератор, потому как они реализуют метод ```__iter__```. В большинстве случаем этот метод возвращает сам объект итератора. Стоит обратить внимание, что возвращается именно ссылка."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "xyzzy is plugh = False\nxyzzy is xyzzy_iter = True\n-------------------------\n(1) значение из xyzzy: foo\n(2) значение из xyzzy_iter: bar\n(3) значение из xyzzy_iter: baz\n(4) значение из xyzzy: quux\n-------------------------\n(5) значение из plugh: foo\n"
     ]
    }
   ],
   "source": [
    "metavariables = {\n",
    "    'foo': 'first canonical metavariable', \n",
    "    'bar': 'second canonical metavariable', \n",
    "    'baz': 'canonical third metavariable',\n",
    "    'quux': 'canonical fourth metavariable',\n",
    "    'eggs': 'only in Python',\n",
    "}\n",
    "\n",
    "# итератор на основе словаря\n",
    "xyzzy = iter(metavariables)\n",
    "plugh = iter(metavariables)\n",
    "# итератор из итератора\n",
    "xyzzy_iter = iter(xyzzy)\n",
    "\n",
    "print(f'{xyzzy is plugh = }')  # имена указывают на разные объекты, итераторы не связаны\n",
    "print(f'{xyzzy is xyzzy_iter = }')  # имена указывают на один объект\n",
    "print('-' * 25)\n",
    "print(f'(1) значение из xyzzy: {next(xyzzy)}')\n",
    "print(f'(2) значение из xyzzy_iter: {next(xyzzy_iter)}')  # значения не начинаются сначала\n",
    "print(f'(3) значение из xyzzy_iter: {next(xyzzy_iter)}')\n",
    "print(f'(4) значение из xyzzy: {next(xyzzy)}')\n",
    "print('-' * 25)\n",
    "print(f'(5) значение из plugh: {next(plugh)}')  # другой итератор"
   ]
  },
  {
   "source": [
    "В некоторых других случаях поведение будет другим. Например, для функций ```map```, ```zip``` и ```filter``` получение итератора от их результата будут одинаковы. Это связано с тем, что результат этих функций уже является итератором."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "foo is bar = True\n"
     ]
    }
   ],
   "source": [
    "foo = map(int, '1234')\n",
    "foo_iter = iter(foo)\n",
    "print(f'{foo is foo_iter = }')"
   ]
  },
  {
   "source": [
    "Основным достоинством итераторов является их ленивость. Это означает, что каждое новое значение вычисляется по запросу, а не храниться в памяти заранее."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Размер объекта: 89095144\nРазмер итератора: 32\n"
     ]
    }
   ],
   "source": [
    "foo = [i for i in range(10_000_000)]\n",
    "foo_iter = iter(foo)\n",
    "print(f'Размер объекта: {foo.__sizeof__()}')\n",
    "print(f'Размер итератора: {foo_iter.__sizeof__()}')"
   ]
  },
  {
   "source": [
    "На основе итераторов построен цикл ```for```. Перед началом работы он неявно создает итератор на основе коллекции. И затем использует его для перебора элементов с помощью функции ```next```. Цикл ```for``` можно переписать, используя цикл ```while```."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "next(foo_iter) = 1\nnext(foo_iter) = 2\nnext(foo_iter) = 3\n"
     ]
    }
   ],
   "source": [
    "foo = [1, 2, 3]\n",
    "\n",
    "foo_iter = iter(foo)\n",
    "while True:\n",
    "    try:\n",
    "        print(f'{next(foo_iter) = }')\n",
    "    except StopIteration:\n",
    "        break"
   ]
  },
  {
   "source": [
    "Этот цикл будет эквивалентен стандартному циклу ```for```."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "i = 1\ni = 2\ni = 3\n"
     ]
    }
   ],
   "source": [
    "for i in [1, 2, 3]:\n",
    "    print(f'{i = }')"
   ]
  },
  {
   "source": [
    "Помимо того, что итераторы исчерпаемы, они могут быть бесконечными. Например, функция ```count``` из модуля ```itertools``` возвращает бесконечный итератор. Она аналогична ```range```. Возможности модуля ```itertools``` будут рассмотрены в следующем разделе."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "i = 0\ni = 1\ni = 2\ni = 3\ni = 4\ni = 5\n"
     ]
    }
   ],
   "source": [
    "from itertools import count\n",
    "\n",
    "k = 0\n",
    "for i in count():\n",
    "    # это условие нужно для принудительного завершения, \n",
    "    # т.к. count() бесконечный\n",
    "    if k > 5:\n",
    "        break\n",
    "    print(f'{i = }')\n",
    "    k += 1"
   ]
  },
  {
   "source": [
    "Итераторы можно преобразовать в коллекции, применяя соответствующие им функции. В этом случае итератор полностью выполнится."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "bar = [1, 2, 3, 4]\nfoo_iter = <list_iterator object at 0x000001E5993A0760>\n"
     ]
    },
    {
     "output_type": "error",
     "ename": "StopIteration",
     "evalue": "",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mStopIteration\u001b[0m                             Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-3-20d166507cf8>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      5\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34mf'{bar = }'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      6\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34mf'{foo_iter = }'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 7\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34mf'{next(foo_iter) = }'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mStopIteration\u001b[0m: "
     ]
    }
   ],
   "source": [
    "foo = [1, 2, 3, 4]\n",
    "foo_iter = iter(foo)\n",
    "\n",
    "bar = list(foo_iter)\n",
    "print(f'{bar = }')\n",
    "print(f'{foo_iter = }')\n",
    "print(f'{next(foo_iter) = }')"
   ]
  },
  {
   "source": [
    "В этом заключается одна особенность. Не стоит пытаться преобразовать в коллекцию бесконечный итератор, т.е. не стоит выполнять следующий код:\n",
    "\n",
    "```python\n",
    "list(count())\n",
    "```\n",
    "\n",
    "### Операции с итераторами\n",
    "\n",
    "Итераторы поддерживают только две операции: \n",
    "- создание итератора с помощью ```iter```;\n",
    "- получение следующего значение с помощью ```next```.\n",
    "\n",
    "Больше никакие операции нельзя выполнять с ними. Итераторы не имеют длины, нельзя проверить элемент на вхождение в итератор и т.д."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "output_type": "error",
     "ename": "TypeError",
     "evalue": "object of type 'list_iterator' has no len()",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-1-ea6469df2850>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[0mfoo_iter\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0miter\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mfoo\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 4\u001b[1;33m \u001b[0mlen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mfoo_iter\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: object of type 'list_iterator' has no len()"
     ]
    }
   ],
   "source": [
    "foo = [1, 2, 3, 4]\n",
    "foo_iter = iter(foo)\n",
    "\n",
    "len(foo_iter)"
   ]
  },
  {
   "source": [
    "## Объект ```range```\n",
    "\n",
    "Объекты диапазона или ```range``` объекты не являются итераторами или генераторами."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "foo = range(0, 5)\ntype(foo) = <class 'range'>\n"
     ]
    }
   ],
   "source": [
    "foo = range(5)\n",
    "print(f'{foo = }')\n",
    "print(f'{type(foo) = }')"
   ]
  },
  {
   "source": [
    "С ними можно выполнять все те же операции, что и с коллекциями."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(f'{len(foo) = }')\n",
    "print(f'{2 in foo = }')\n",
    "print(f'{foo[-1] = }')"
   ]
  },
  {
   "source": [
    "Кроме этого, они имеют ряд специфических атрибутов:"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "foo.start = 0\nfoo.stop = 5\nfoo.step = 1\n"
     ]
    }
   ],
   "source": [
    "print(f'{foo.start = }')\n",
    "print(f'{foo.stop = }')\n",
    "print(f'{foo.step = }')"
   ]
  },
  {
   "source": [
    "```range``` объекты можно переиспользовать, они не исчерпываются как итераторы и генераторы."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "0\n1\n2\n3\n4\n[0, 1, 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "bar = range(5)\n",
    "\n",
    "for i in bar:\n",
    "    print(i)\n",
    "\n",
    "print(list(bar))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "metadata": {},
     "execution_count": 7
    }
   ],
   "source": [
    "baz = range(5)\n",
    "iter(baz) is baz"
   ]
  },
  {
   "source": [
    "# Выражения-генераторы (```generator expressions```)\n",
    "\n",
    "С точки зрения реализации, генератор в Python - это специальная языковая конструкция, которую можно реализовать двумя способами: как функцию или как генераторное выражение. В результате вызова функции или вычисления выражения получается объект типа ```generator```.\n",
    "\n",
    "Функции генераторы будут рассмотрены позднее. Сейчас остановимся только на генераторных выражения или ```generator expressions```.\n",
    "\n",
    "Генератор по сути является частным случаем итератора. Объект-генератор также реализует протокол итератора, т. е. методы ```__iter__``` и ```__next__```. С этой точки зрения, в Python любой генератор является итератором, но не наоборот.\n",
    "\n",
    "Концептуально, итератор — это механизм поэлементного обхода данных, а генератор позволяет отложено (лениво) создавать результат при итерации. Генератор может создавать результат на основе какого-то алгоритма или брать элементы из источника данных (коллекция, файлы, сетевое подключения и т.д.) и изменять их.\n",
    "\n",
    "Генераторные выражения записываются аналогично включениям за исключением скобок. В генераторных выражениях используются круглые скобки."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "foo = <generator object <genexpr> at 0x00000202DC350580>\ntype(foo) = <class 'generator'>\nfoo.__sizeof__() = 96\n"
     ]
    }
   ],
   "source": [
    "foo = (i for i in range(5))\n",
    "print(f'{foo = }')\n",
    "print(f'{type(foo) = }')\n",
    "print(f'{foo.__sizeof__() = }')"
   ]
  },
  {
   "source": [
    "Генераторы, как и итераторы, исчерпаемы, т.е. их нельзя использовать повторно."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "a = [0, 1, 2, 3, 4]\nb = []\nc = []\n"
     ]
    }
   ],
   "source": [
    "a = list(foo)\n",
    "b = list(foo)\n",
    "c = list(foo)\n",
    "\n",
    "print(f'{a = }')\n",
    "print(f'{b = }')\n",
    "print(f'{c = }')"
   ]
  },
  {
   "source": [
    "# Связь между итерируемыми объектами, итераторами и генераторами\n",
    "\n",
    "Для более легкого понимания всех вышеописанных объектов их связи изображены на схеме.\n",
    "\n",
    "<img src=\"image/gen_iter.png\">\n",
    "\n",
    "В таблице приведены сравнительные характеристики этих понятий.\n",
    "\n",
    "| Свойство                         | Последовательность | Итерируемый объект                 | Итератор              | Генератор |\n",
    "|----------------------------------|--------------------|------------------------------------|-----------------------|-----------|\n",
    "| Хранение всех элементов в памяти | +                  | - (+ для последовательностей)      | -                     | -         |\n",
    "| Вычисление нового значения       | -                  | - (+ для генераторов)              | - (+ для генераторов) | +         |\n",
    "| Одноразовое использование        | -                  | - (+ для итераторов и генераторов) | +                     | +         |\n",
    "| Бесконечные                      | -                  | - (+ для итераторов и генераторов) | +                     | +         |\n",
    "| Длина                            | +                  | + (- для итераторов и генераторов) | -                     | -         |\n",
    "| Индексация                       | +                  | + (- для итераторов и генераторов) | -                     | -         |\n",
    "| Проверка на вхождение (```in```) | +                  | + (- для итераторов и генераторов) | -                     | -         |"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "source": [
    "# Полезные ссылки\n",
    "\n",
    "- [Документация по итераторам](https://docs.python.org/3/tutorial/classes.html#iterators)\n",
    "- [Обсуждение отличий в терминах \"итерируемый объект\", \"итератор\" и \"итерация\"](https://stackoverflow.com/questions/9884132/what-exactly-are-iterator-iterable-and-iteration)\n",
    "- [Почему нельзя вызвать next() от range объекта?](https://stackoverflow.com/questions/13092267/if-range-is-a-generator-in-python-3-3-why-can-i-not-call-next-on-a-range)\n",
    "- Статья [range не является итератором](https://treyhunner.com/2018/02/python-range-is-not-an-iterator/)\n",
    "- [В чем разница между генераторами и итераторами](https://stackoverflow.com/questions/2776829/difference-between-pythons-generators-and-iterators)\n",
    "- [Итерируемые объекты, итераторы и генераторы](https://nvie.com/posts/iterators-vs-generators/)\n",
    "- [Метапеременные](https://ru.wikipedia.org/wiki/%D0%9C%D0%B5%D1%82%D0%B0%D0%BF%D0%B5%D1%80%D0%B5%D0%BC%D0%B5%D0%BD%D0%BD%D0%B0%D1%8F)"
   ],
   "cell_type": "markdown",
   "metadata": {}
  }
 ]
}