{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python для сбора и анализа данных\n",
    "\n",
    "*Алла Тамбовцева, НИУ ВШЭ*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Генераторы списков (списковые включения)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В Python для создания новых списков на основе старых существуют удобные конструкции, которые называются генераторы списков или списковые включения (*list comprehensions*). Они позволяют написать код, более компактный и быстрый по сравнению с кодом с использованием цикла `for` и метода `.append()`. Вспомним, как мы создавали новый список на основе старого с помощью цикла. \n",
    "\n",
    "Пусть у нас есть список целых чисел `nums`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "nums = [1, 8, 23, 45, 67]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Создадим теперь пустой список `nums_sq` и заполним его квадратами чисел из `nums`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 64, 529, 2025, 4489]\n"
     ]
    }
   ],
   "source": [
    "nums_sq = [] \n",
    "for n in nums:\n",
    "    nums_sq.append(n ** 2)\n",
    "print(nums_sq) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Теперь рассмотрим решение той же задачи, но с помощью генераторов списков:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 64, 529, 2025, 4489]\n"
     ]
    }
   ],
   "source": [
    "nums_sq = [n ** 2 for n in nums] \n",
    "print(nums_sq) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Как устроен генератор списка? Во-первых, код для преобразований элементов старого списка записывается в квадратных скобках, так как мы создаем новый список. Во-вторых, мы пишем тот же код, что и в случае с циклом, но «раскручиваем» его с конца: сначала указываем, что за операцию надо выполнить, а потом – для каких элементов ее повторить. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Теперь давайте проверим, что код с генератором списка работает быстрее. В начале ячейки (это обязательно должна быть первая строка, если первой строкой будет идти что-то еще, даже комментарий, ничего не сработает) напишем «магическую строку `%%timeit`. «Магическая строка» – это официальное название, так называются строки кода в Jupyter, которые начинаются с `%%` и отвечают за режим исполнения ячейки в Jupyter Notebook. В данном случае команда `timeit` отвечает за измерение времени исполнения кода.\n",
    "\n",
    "Для примера возьмем какой-нибудь список побольше – создадим список из кубов целых чисел от 0 до 5000 включительно на основе `range()`. Сначала сделаем это с помощью цикла и `.append()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.47 ms ± 8 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "R = []\n",
    "for i in range(0, 5001):\n",
    "    R.append(i ** 3) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Выдача сообщает нам, что ячейка с кодом выше была запущена 7 раз по 1000 раз, и что среднее время выполнения кода за такое число прогонов равно 1.47 милисекундам, а стандартное отклонение равно 8 микросекундам (на каждой системе в разное время будут свои числа). Почему недостаточно прогнать код один раз? Потому что хочется получить более общие результаты, с учетом разных факторов. Каждую секунду на компьютере выполняется множество процессов, которые мы явно не видим, но которые влияют на время исполнения кода. Поэтому, запуская ячейку много раз, Jupyter пытается оценить скорость выполнения кода в разные моменты времени и вывести сводные характеристики результатов."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Теперь проделаем то же самое, но для генератора списка:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.29 ms ± 5.58 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n"
     ]
    }
   ],
   "source": [
    "%%timeit\n",
    "R = [i ** 3 for i in range(0, 5001)] "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Хотя результаты у всех получаются разные, в любом случае нетрудно заметить, что исполнение кода с генератором списка заняло меньше времени, чем исполнение кода с циклом."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Функция `enumerate()`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Прежде, чем разбираться с функцией-счетчиком `enumerate()`, давайте рассмотрим такую задачу. У нас есть список напитков `drinks`, и мы хотим выводить на экран номер (индекс) напитка и название напитка. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "drinks = ['tea', 'coffee', 'juice', 'milk'] "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Если решать задачу рационально, используя готовые методы на списках Python, решение будет выглядеть так:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 tea\n",
      "1 coffee\n",
      "2 juice\n",
      "3 milk\n"
     ]
    }
   ],
   "source": [
    "for d in drinks:\n",
    "    print(drinks.index(d), d)  # метод index()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Если бы мы забыли про существование метода `.index()`, нам пришлось бы создавать перечень индексов списка `drinks` самостоятельно, например, с помощью `range()`, а потом делать перебор по этим индексам в цикле:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 tea\n",
      "1 coffee\n",
      "2 juice\n",
      "3 milk\n"
     ]
    }
   ],
   "source": [
    "for i in range(0, len(drinks)):\n",
    "    print(i, drinks[i]) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Код выше технически верный, но не-питоновский и не очень рациональный. \n",
    "\n",
    "Теперь посмотрим на решение той же задачи с помощью функции `enumerate()`. Эта функция – счетчик, который позволяет нумеровать элементы в списке. Если мы попробуем применить эту функцию к списку `drinks` и посмотреть, что за результат нам вернется, мы увидим что-то странное:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<enumerate at 0x10dc97a50>"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "enumerate(drinks)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python сообщает нам, что это объект типа `enumerate`, он от нас скрыт, но хранится в ячейке памяти `0x10dc97a50`. Чтобы все же увидеть содержимое, можем преобразовать результат в список:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[(0, 'tea'), (1, 'coffee'), (2, 'juice'), (3, 'milk')]"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(enumerate(drinks))  # list of tuple"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Это список кортежей (*tuples*, о них поговорим позже), список пар, где на первом месте стоит индекс элемента, а на втором – сам элемент. Теперь мы сможем запустить цикл по такому списку:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 tea\n",
      "1 coffee\n",
      "2 juice\n",
      "3 milk\n"
     ]
    }
   ],
   "source": [
    "for i, d in enumerate(drinks):\n",
    "    print(i, d) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "После оператора `for` можно указывать несколько переменных, причем называться они могут, как угодно. Python в любом случае поймет, что `i` – это первый элемент в паре в списке, возвращаемом `enumerate()`, а `d` – это второй элемент. "
   ]
  }
 ],
 "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}