python_pd/03_collections/02_comprehensions.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",
    "- цикл ```for``` (Обязательная часть)\n",
    "- условие фильтрации\n",
    "- условие изменения\n",
    "\n",
    "Цикл является обязательной частью включения, а оба условия не обязательны. Они могут присутствовать или отсутствовать в зависимости от задачи. Условие фильтрации отвечает за то какие элементы попадут в итоговый список, а какие будут отброшены, т.е. фильтрует значения по определенному условию. Условие изменения преобразует элементы по какому-либо правилу и заданному условию. \n",
    "\n",
    "<img src=\"image/comprehensions.png\" align=\"center\">\n",
    "\n",
    "Все конструкции включений имеют свой эквивалент в виде \"стандартной\" конструкции цикла.\n",
    "\n",
    "## Включения в список (```list comprehensions```)\n",
    "\n",
    "Включения в список или ```list comprehensions``` используются для создания списков. Эти конструкции записываются внутри квадратных скобок. Самая простая конструкция включения в список или спискового включения содержит только цикл. Она выглядит следующим образом."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "source": [
    "a = [i for i in range(5)]\n",
    "print(f'{a = }')"
   ],
   "cell_type": "code",
   "metadata": {},
   "execution_count": 1,
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "a = [0, 1, 2, 3, 4]\n"
     ]
    }
   ]
  },
  {
   "source": [
    "Создавать список чисел таким образом не совсем правильно. Гораздо более короче будет сразу преобразовать объект ```range``` в список."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "a = [0, 1, 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "a = list(range(5))\n",
    "print(f'{a = }')"
   ]
  },
  {
   "source": [
    "Однако с помощью такой конструкции можно легко создать список, заполненный, например, нулями. Обратите внимание, что здесь используется нижнее подчеркивание вместо переменной ```i```, т.к. она нам не нужна."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "a = [0, 0, 0, 0, 0]\n"
     ]
    }
   ],
   "source": [
    "a = [0 for _ in range(5)]\n",
    "print(f'{a = }')"
   ]
  },
  {
   "source": [
    "Это простейшее включение будет эквивалентно обычной конструкции цикла, где в теле цикла будет добавляться новый элемент списка."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "a = [0, 1, 2, 3, 4]\n"
     ]
    }
   ],
   "source": [
    "a = []\n",
    "for i in range(5):\n",
    "    a.append(i)\n",
    "print(f'{a = }')"
   ]
  },
  {
   "source": [
    "Добавляя условную конструкцию справой стороны от цикла появляется возможность фильтрации элементов, которые попадут в итоговую коллекцию. Выражения в операторе условия могут быть разной сложности, в том числе их можно объединять с помощью логических операторов. \n",
    "\n",
    "Ниже приведен пример поиска всех строк в которых не менее трех уникальных гласных букв."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "a = ['сake is a lie']\n"
     ]
    }
   ],
   "source": [
    "words = ['spam', 'foo', 'python', 'bar', 'monty', 'сake is a lie']\n",
    "\n",
    "# множество гласных букв\n",
    "vowel_letters = set('eyuioa')\n",
    "\n",
    "# в условии вычисляется пересечение множества гласных букв и множества букв в строке\n",
    "a = [i for i in words if len(set(i) & vowel_letters) >= 3]\n",
    "print(f'{a = }')"
   ]
  },
  {
   "source": [
    "В полном виде включение с условием фильтрации будет выглядеть следующим образом."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "a = ['сake is a lie']\n"
     ]
    }
   ],
   "source": [
    "a = []\n",
    "for i in words:\n",
    "    if len(set(i) & vowel_letters) >= 3:\n",
    "        a.append(i)\n",
    "\n",
    "print(f'{a = }')"
   ]
  },
  {
   "source": [
    "Условие слева от цикла отвечает за совершения заданных действий над элементами последовательности. Оно позволяет вычислять элементы последовательности непосредственно в момент создания коллекции.\n",
    "\n",
    "В качестве примера рассмотрим построение [кривой дракона](https://en.wikipedia.org/wiki/Dragon_curve) - одной из фрактальных кривых. Для ее построения будем использовать [L-системы](https://en.wikipedia.org/wiki/L-system) - довольно простой инструмент для построения самоподобных структур. [Вот](https://codegolf.stackexchange.com/questions/100562/draw-a-dragon-curve) примеры рисования кривой дракона на разных языках программирования."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "0: fx\n1: fx+yf+\n2: fx+yf++-fx-yf+\n3: fx+yf++-fx-yf++-fx+yf+--fx-yf+\n4: fx+yf++-fx-yf++-fx+yf+--fx-yf++-fx+yf++-fx-yf+--fx+yf+--fx-yf+\n"
     ]
    }
   ],
   "source": [
    "# начальная строка\n",
    "s = 'fx'\n",
    "# неизменяемые символы\n",
    "const = 'f+-'\n",
    "# правила замены\n",
    "d = {\n",
    "    'x': 'x+yf+',\n",
    "    'y': '-fx-y',\n",
    "}\n",
    "\n",
    "print(f'{0}: {s}')\n",
    "# первые 4 итерации\n",
    "for i in range(1, 5):\n",
    "    # посимвольный перебор строки\n",
    "    # если символ можно заменить, он заменяется\n",
    "    s = ''.join([d[c] if c in d else c for c in s])\n",
    "    print(f'{i}: {s}')"
   ]
  },
  {
   "source": [
    "Добавив визуализацию к этому списковому включению, можно получить такие картинки.\n",
    "\n",
    "<img src=\"image/dragon_curve.png\">\n",
    "\n",
    "Это включение можно заменить полным вариантом."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "new_s = 'fx+yf++-fx-yf++-fx+yf+--fx-yf++-fx+yf++-fx-yf+--fx+yf+--fx-yf++-fx+yf++-fx-yf++-fx+yf+--fx-yf+--fx+yf++-fx-yf+--fx+yf+--fx-yf+'\n"
     ]
    }
   ],
   "source": [
    "new_s = ''\n",
    "for c in s:\n",
    "    if c in d:\n",
    "        new_s += d[c]\n",
    "    else:\n",
    "        new_s += c\n",
    "\n",
    "print(f'{new_s = }')"
   ]
  },
  {
   "source": [
    "В право части может находиться одно выражение без условного оператора. \n",
    "В этом случае это выражение будет применяться ко всем элементам, \n",
    "прошедшим фильтрацию, если она есть.\n",
    "\n",
    "В этом примере строка должна быть размножена до определенной длины."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "lemonlemonlemonlem\n"
     ]
    }
   ],
   "source": [
    "s = 'lemon'\n",
    "\n",
    "a = ''.join([s[i % len(s)] for i in range(18)])\n",
    "print(a)"
   ]
  },
  {
   "source": [
    "Условие фильтрации и условие изменения можно использовать совместно."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "a = [(900, 'Harshad number'), (902, 'Harshad number'), (910, 'Nivenmorphic number'), (912, 'Nivenmorphic number'), (915, 'Nivenmorphic number'), (918, 'Nivenmorphic number'), (935, 'Harshad number'), (936, 'Harshad number')]\n"
     ]
    }
   ],
   "source": [
    "n = 950\n",
    "harshad = 'Harshad number'\n",
    "nivenmorphic = 'Nivenmorphic number'\n",
    "a = [(i, nivenmorphic) if str(i)[-len(str(b)):] == str(b) else (i, harshad) for i in range(900, n) if not i % (b:=sum(int(j) for j in list(str(i))))]\n",
    "print(f'{a = }')"
   ]
  },
  {
   "source": [
    "Это эквивалентно"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "a = [(900, 'Harshad number'), (902, 'Harshad number'), (910, 'Nivenmorphic number'), (912, 'Nivenmorphic number'), (915, 'Nivenmorphic number'), (918, 'Nivenmorphic number'), (935, 'Harshad number'), (936, 'Harshad number')]\n"
     ]
    }
   ],
   "source": [
    "a = []\n",
    "for i in range(900, n):\n",
    "    sum_d = sum(int(j) for j in list(str(i)))\n",
    "    if not i % sum_d:  # условие фильтрации\n",
    "        str_dum = str(sum_d)\n",
    "        if str(i)[-len(str_dum):] == str_dum:  # условие изменения\n",
    "            a.append((i, nivenmorphic))\n",
    "        else:\n",
    "            a.append((i, harshad))\n",
    "print(f'{a = }')"
   ]
  },
  {
   "source": [
    "Списковые включения могут быть вложенные. Простым примером будет создание единичной матрицы - матрицы, где на главной диагонали находятся единицы, а в других позициях нули.\n",
    "\n",
    "Не стоит злоупотреблять такими конструкциями. Если итоговая строка получается слишком большой, ее стоит переписать в стандартной форме."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "e = [[1, 0, 0, 0, 0], [0, 1, 0, 0, 0], [0, 0, 1, 0, 0], [0, 0, 0, 1, 0], [0, 0, 0, 0, 1]]\n"
     ]
    }
   ],
   "source": [
    "n = 5  # размер матрицы\n",
    "e = [[0 if i != j else 1 for j in range(n)] for i in range(n)]\n",
    "print(f'{e = }')"
   ]
  },
  {
   "source": [
    "Обратите внимание, что здесь внешним циклом считается последнее выражение ```for i in range(n)```, а внутренним ```for j in range(n)```, т.е. порядок выполнения идет справа-налево.\n",
    "\n",
    "Такая конструкция будет эквивалентна одному вложенному циклу."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "e = [[1, 0, 0, 0, 0], [0, 1, 0, 0, 0], [0, 0, 1, 0, 0], [0, 0, 0, 1, 0], [0, 0, 0, 0, 1]]\n"
     ]
    }
   ],
   "source": [
    "e = []\n",
    "for i in range(n):\n",
    "    # создание списка для хранения элементов строки матрицы\n",
    "    lstr = []\n",
    "    for j in range(n):\n",
    "        if i != j:\n",
    "            lstr.append(0)\n",
    "        else:\n",
    "            lstr.append(1)\n",
    "    # добавление строки к итоговой матрице\n",
    "    e.append(lstr)\n",
    "print(f'{e = }')"
   ]
  },
  {
   "source": [
    "Или в комбинированном виде (так удобно \"укорачивать\" вложенные циклы):"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "e = [[1, 0, 0, 0, 0], [0, 1, 0, 0, 0], [0, 0, 1, 0, 0], [0, 0, 0, 1, 0], [0, 0, 0, 0, 1]]\n"
     ]
    }
   ],
   "source": [
    "e = []\n",
    "for i in range(n):\n",
    "    e.append([0 if i != j else 1 for j in range(n)])\n",
    "print(f'{e = }')"
   ]
  },
  {
   "source": [
    "Еще один пример вложенных включений - это транспонирование матрицы."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "a = [[1, 5, 9], [2, 6, 0], [3, 7, 1], [4, 8, 2]]\n"
     ]
    }
   ],
   "source": [
    "matrix = [\n",
    "    [1, 2, 3, 4], \n",
    "    [5, 6, 7, 8], \n",
    "    [9, 0, 1, 2],\n",
    "]\n",
    "\n",
    "a = [[xs[j] for xs in matrix] for j in range(len(matrix[0]))]\n",
    "print(f'{a = }')"
   ]
  },
  {
   "source": [
    "Помимо вложенности возможно итерирование по нескольким переменным.\n",
    "\n",
    "В качестве примера рассмотрим декартово произведение двух коллекций (список чисел и строка). Декартово произведение должно содержать кортежи из двух элементов. Элемент из первой коллекции стоит на первом месте, а элемент из второй на втором. Длина итогового списка должна быть равна произведению длин первой и второй коллекций."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "c = [(1, 'a'), (1, 'b'), (1, 'c'), (1, 'd'), (2, 'a'), (2, 'b'), (2, 'c'), (2, 'd'), (3, 'a'), (3, 'b'), (3, 'c'), (3, 'd')]\nlen(c) = 12\nlen(a) * len(b) = 12\n"
     ]
    }
   ],
   "source": [
    "a = [1, 2, 3]\n",
    "b = 'abcd'\n",
    "\n",
    "c = [(i, j) for i in a for j in b]\n",
    "print(f'{c = }')\n",
    "print(f'{len(c) = }')\n",
    "print(f'{len(a) * len(b) = }')"
   ]
  },
  {
   "source": [
    "c = []\n",
    "for i in a:\n",
    "    for j in b:\n",
    "        c.append((i, j))\n",
    "print(f'{c = }')"
   ],
   "cell_type": "code",
   "metadata": {},
   "execution_count": 17,
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "c = [(1, 'a'), (1, 'b'), (1, 'c'), (1, 'd'), (2, 'a'), (2, 'b'), (2, 'c'), (2, 'd'), (3, 'a'), (3, 'b'), (3, 'c'), (3, 'd')]\n"
     ]
    }
   ]
  },
  {
   "source": [
    "Обратите внимание, что внешним считается цикл, который идет первым, т.е. ```for i in a``` во включении будет внешним, а ```for j in b``` - вложенным. Порядок в таких вложенных циклах идет слева-направо. Эти отличаются обычные *включения со вложенными циклами* от *вложенных включений*.\n",
    "\n",
    "В примерах выше циклы проходились по двум независимым коллекциям. Во вложенных циклах можно итерироваться по коллекциям, полученным из внешнего цикла. Таким примером будет \"расплющивание\" вложенной коллекции."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2]\n"
     ]
    }
   ],
   "source": [
    "matrix = [\n",
    "    [1, 2, 3, 4], \n",
    "    [5, 6, 7, 8],\n",
    "    [9, 0, 1, 2],\n",
    "]\n",
    "a = [i for row in matrix for i in row]\n",
    "print(f'{a = }')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "a = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2]\n"
     ]
    }
   ],
   "source": [
    "a = []\n",
    "for row in matrix:\n",
    "    for i in row:\n",
    "        a.append(i)\n",
    "print(f'{a = }')"
   ]
  },
  {
   "source": [
    "Еще одним интересным примером \"расплющить\" список с глубиной = 2 служит использование встроенной функции ```sum```. Подробнее о работе этого примера читайте в [обсуждении на stackoverflow](https://stackoverflow.com/questions/33541947/what-does-the-built-in-function-sum-do-with-sumlist/33542054#33542054)."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "sum(matrix, []) = [1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2]\n"
     ]
    }
   ],
   "source": [
    "print(f'{sum(matrix, []) = }')"
   ]
  },
  {
   "source": [
    "## Включения в словарь (```dict comprehensions```)\n",
    "\n",
    "Конструкция включений в словарь полностью эквивалентна включениям в список. Разница состоит только в том, что здесь можно оперировать ключами и значениями.\n",
    "\n",
    "Ниже приведен пример создания словаря, где ключами выступают нечетные номера символов, а значениями сами символы."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "d = {97: 'a', 99: 'c', 101: 'e', 103: 'g', 105: 'i', 107: 'k', 109: 'm', 111: 'o', 113: 'q', 115: 's', 117: 'u', 119: 'w', 121: 'y'}\n"
     ]
    }
   ],
   "source": [
    "d = {i: chr(i) for i in range(97, 123, 2)}\n",
    "print(f'{d = }')"
   ]
  },
  {
   "source": [
    "## Включения в множество (```set comprehensions```)\n",
    "\n",
    "Включения во множество отличаются от прочих только литералами. Они должны быть заключены в фигурные скобки."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "a = {0, 1, 2, 3, 4}\n"
     ]
    }
   ],
   "source": [
    "a = {i for i in range(5)}\n",
    "print(f'{a = }')"
   ]
  },
  {
   "source": [
    "Вложенные включения могут быть разного вида и расположены в разных местах, в том числе в условных выражениях.\n",
    "\n",
    "В качестве такого примера можно использовать вычисления списка простых чисел с помощью [решета Эратосфена](https://en.wikipedia.org/wiki/Sieve_of_Eratosthenes). \n",
    "\n",
    "В первом цикле идет перебор всех чисел, которые фильтруются по определенному условию. Это условие проверяет находится ли число во множестве составных чисел. Это множество в свою очередь строится как другое включение."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "[2, 3, 5, 7, 11, 13, 17, 19, 23, 29]\n"
     ]
    }
   ],
   "source": [
    "n = 30\n",
    "a = [i for i in range(2, n+1) if i not in {j for k in range(2, n//2) for j in range(2*k, n+1, k)}]\n",
    "print(a)"
   ]
  },
  {
   "source": [
    "## Включения в кортеж\n",
    "\n",
    "Включений в кортеж в чистом виде в Python нет. нельзя просто так взять и написать включение в круглых скобках. Это приведет к созданию объекта-генератора, а не кортежа. Такие объекты будут рассмотрены отдельно."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "a = <generator object <genexpr> at 0x00000162F9F58890>\ntype(a) = <class 'generator'>\n"
     ]
    }
   ],
   "source": [
    "a = (i for i in range(5))\n",
    "print(f'{a = }')\n",
    "print(f'{type(a) = }')"
   ]
  },
  {
   "source": [
    "Для создания кортежа с помощью включения необходимо использовать функцию ```tuple```. Но и в этом случае это не будет чистым включением, т.к. сначала будет создан генератор который затем будет преобразован в кортеж. Самостоятельно убедитесь в этом с помощью модуля ```dis```."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "source": [
    "tuple(i for i in range(5))"
   ],
   "cell_type": "code",
   "metadata": {},
   "execution_count": 25,
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "(0, 1, 2, 3, 4)"
      ]
     },
     "metadata": {},
     "execution_count": 25
    }
   ]
  },
  {
   "source": [
    "# Полезные ссылки\n",
    "\n",
    "- [Документация по list comprehensions](https://docs.python.org/3/tutorial/datastructures.html#list-comprehensions)\n",
    "- [When to Use a List Comprehension in Python](https://realpython.com/list-comprehension-python/)\n",
    "- [Статья, где проводятся аналогии между Exal и SQL](https://lerner.co.il/2015/07/16/want-to-understand-pythons-comprehensions-think-like-an-accountant/)\n",
    "- [Статья, где наглядно демонстрируется синтаксис включений](https://treyhunner.com/2015/12/python-list-comprehensions-now-in-color/)\n",
    "- [Статья о включениях (на русском)](https://habr.com/ru/post/320288/)\n",
    "- [Что функция делает функция ```sum(list, [])```?](https://stackoverflow.com/questions/33541947/what-does-the-built-in-function-sum-do-with-sumlist/33542054#33542054)"
   ],
   "cell_type": "markdown",
   "metadata": {}
  }
 ]
}