python_pd/03_collections/03_collections.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": [
    "# Модуль ```collections```\n",
    "\n",
    "## Именованные кортежи (```namedtuple```)\n",
    "\n",
    "У классических кортежей есть один недостаток. Для обращения к значению, находящемуся внутри него, нужно использовать индекс. Это не всегда удобно. Например, когда в кортеже хранится дата в формате ```date = (year, month, day)```, для получения значения года нужно обратиться по индексу ```date[0]```. Читаемость этого выражения не слишком высокая. Для его понимания нужно держать в голове порядок элементов кортежа и помнить, что по нулевому индексу находится год. Как развитие обычных кортежей были предложены именованные кортежи (см. [документацию](https://docs.python.org/3/library/collections.html#collections.namedtuple)) или тип ```namedtuple```. Они находятся в модуле ```collections``` стандартной библиотеки. Для начала их использования необходимо их импортировать. \n",
    "\n",
    "```python\n",
    "form collections import namedtuple\n",
    "``` \n",
    "\n",
    "Подробнее операция импорта будет рассмотрена в следующих разделах. \n",
    "\n",
    "Функция ```namedtuple``` принимает ряд аргументов. Ее сигнатура выглядит как ```namedtuple(typename, field_names, *, rename=False, defaults=None, module=None)```. Параметр ```typename``` должен быть строкой и определяет название типа создаваемого именованного кортежа. Набор полей задается с помощью параметра ```field_names```. Имена полей могут передаваться в качестве последовательности сток, например, ```['a', 'b']``` или ```('a', 'b')```, а также в одной строке, разделенные пробелом или запятой, например, ```'a b'``` или ```'a, b'```. ```defaults``` задает значение по умолчанию для всех полей кортежа."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Точка 0: point_0 = Point_2d(x=0, y=0)\nТочка 1: point_1 = Point_2d(x=1, y=2)\nТочка 2: point_2 = Point_2d(x=1, y=2)\nТип объекта 1: type(point_1) = <class '__main__.Point_2d'>\nТип объекта 2: type(point_2) = <class '__main__.Point_2d'>\n"
     ]
    }
   ],
   "source": [
    "from collections import namedtuple\n",
    "\n",
    "# создание типа именованного кортежа. Желательно, \n",
    "# чтобы имя переменной и имя в строке совпадали.\n",
    "Point_2d = namedtuple('Point_2d', ('x', 'y'), defaults=(0, 0))\n",
    "\n",
    "# объект со значениями по умолчанию\n",
    "point_0 = Point_2d()\n",
    "# значения можно передавать явно указывая именя\n",
    "point_1 = Point_2d(x=1, y=2)\n",
    "# можно передавать как позиционные, тогда первое \n",
    "# значение попадет в первый параметр и т.д.\n",
    "point_2 = Point_2d(1, 2)\n",
    "\n",
    "print(f'Точка 0: {point_0 = }')\n",
    "print(f'Точка 1: {point_1 = }')\n",
    "print(f'Точка 2: {point_2 = }')\n",
    "# тип объектов namedtuple будет совпадать со значением \n",
    "# параметра typename, в данном случае Point_2d\n",
    "print(f'Тип объекта 1: {type(point_1) = }')\n",
    "print(f'Тип объекта 2: {type(point_2) = }')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "point_1.x = 1, point_1.y = 2\npoint_1[0] = 1, point_1[1] = 2\nx = 1, y = 2\n"
     ]
    }
   ],
   "source": [
    "# доуступ к атрибутам namedtuple можно осуществлять через точку и имя атрибута\n",
    "print(f'{point_1.x = }, {point_1.y = }')\n",
    "# или через индекс\n",
    "print(f'{point_1[0] = }, {point_1[1] = }')\n",
    "\n",
    "x, y = point_1\n",
    "print(f'{x = }, {y = }')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "output_type": "error",
     "ename": "AttributeError",
     "evalue": "can't set attribute",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-3-48d79e967dcf>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;31m# namedtuple это кортеж, а значит неизменяемая коллекция\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mpoint_1\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mx\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m0\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mAttributeError\u001b[0m: can't set attribute"
     ]
    }
   ],
   "source": [
    "# namedtuple это кортеж, а значит неизменяемая коллекция\n",
    "point_1.x = 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "point_1 = Point_2d(x=1, y=2), point_3 = Point_2d(x=1, y=0)\n"
     ]
    }
   ],
   "source": [
    "# для изменения одного или нескольких атрибутов у namedtuple есть \n",
    "# метод _replace. На самом деле он не изменяет значение атрибута, \n",
    "# а создает новый объект на основе текущего\n",
    "point_3 = point_1._replace(y=0)\n",
    "print(f'{point_1 = }, {point_3 = }')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "p_1 = Point_2d(x=1, y=2), p_2 = Point_2d(x='x', y='y')\n"
     ]
    }
   ],
   "source": [
    "# создавать именованные кортежи можно с помощью метода _make. \n",
    "# Он принимает коллекцию. \n",
    "# Эквивалентно Point_2d(1, 2)\n",
    "p_1 = Point_2d._make([1, 2])\n",
    "# Эквивалентно Point_2d(x=1, y=2)\n",
    "p_2 = Point_2d._make({'x': 1, 'y': 2})\n",
    "\n",
    "print(f'{p_1 = }, {p_2 = }')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Преобразование namedtyple в словарь: point_1._asdict() = {'x': 1, 'y': 2}\nПреобразование namedtyple в кортеж: tuple(point_1) = (1, 2)\n"
     ]
    }
   ],
   "source": [
    "# Именованные кортежи легко можно преобразовать в словарь с \n",
    "# помощью метода _asdict\n",
    "print(f'Преобразование namedtyple в словарь: {point_1._asdict() = }')\n",
    "print(f'Преобразование namedtyple в кортеж: {tuple(point_1) = }')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "len(point_1) = 2\nvalue = 1\nvalue = 2\n"
     ]
    }
   ],
   "source": [
    "# namedtuple это коллекция, поэтому справедливы все операции, \n",
    "# характерные для коллекций.\n",
    "print(f'{len(point_1) = }')\n",
    "for value in point_1:\n",
    "    print(f'{value = }')"
   ]
  },
  {
   "source": [
    "Бывают ситуации когда необходимо создать новый тип именованного кортежа на основе уже существующего. Например, логично создать точку в трехмерном пространстве ```Point_3d``` на основе точки на двумерной плоскости ```Point_2d```. У этих двух типов есть одинаковый атрибуты ```x``` и ```y```. В этом случае писать два раза почти одну и ту же коллекцию атрибутов не хочется. Используя специальный атрибут ```_fields``` можно получить коллекцию атрибутов именованного кортежа. ```_fields``` рекомендуется использовать для создания нового типа именованного кортежа на основе существующего, если у них есть одинаковые атрибуты. С помощью этого атрибута можно создавать именованные кортежи на основе сразу нескольких других кортежей."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "point_1._fields = ('x', 'y')\n"
     ]
    }
   ],
   "source": [
    "print(f'{point_1._fields = }')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Point_3d = <class '__main__.Point_3d'>\nPoint_3d._fields = ('x', 'y', 'z')\np_1 = Point_3d(x=1, y=2, z=3)\ntype(p_1) = <class '__main__.Point_3d'>\n"
     ]
    }
   ],
   "source": [
    "Point_3d = namedtuple('Point_3d', Point_2d._fields + ('z', ), defaults=(0, 0, 0))\n",
    "\n",
    "p_1 = Point_3d(1, 2, 3)\n",
    "\n",
    "print(f'{Point_3d = }')\n",
    "print(f'{Point_3d._fields = }')\n",
    "print(f'{p_1 = }')\n",
    "print(f'{type(p_1) = }')"
   ]
  },
  {
   "source": [
    "## ```Counter```\n",
    "\n",
    "Для подсчета любых повторяющихся элементов в какой-либо коллекции существует класс ```Couter``` из модуля ```collections``` (см. [документацию](https://docs.python.org/3/library/collections.html#collections.Counter)). Итоговая коллекция очень похожа на словарь и доступ к элементам осуществляется по ключу. Ключом являются сами элементы коллекции, а значениями количество элементов в коллекции. Приятным бонусом его использования будет то, что итоговая коллекция будет отсортирована в порядке убывания их количества в строке. Ниже приведены далеко не все возможности ```Couter```, подробнее см. в [документации](https://docs.python.org/3/library/collections.html#collections.Counter)."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "count = Counter({' ': 4, 'e': 3, 'v': 2, 'G': 2, 'o': 2, 'n': 2, 'N': 1, 'r': 1, 'a': 1, 'i': 1, 'Y': 1, 'u': 1, 'U': 1, 'p': 1})\ncount[\"e\"] = 3\ncount[\" \"] = 4\ncount[\"p\"] = 1\ncount.most_common(4) = [(' ', 4), ('e', 3), ('v', 2), ('G', 2)]\nlist(count.elements()) = ['N', 'e', 'e', 'e', 'v', 'v', 'r', ' ', ' ', ' ', ' ', 'G', 'G', 'o', 'o', 'n', 'n', 'a', 'i', 'Y', 'u', 'U', 'p']\n"
     ]
    }
   ],
   "source": [
    "from collections import Counter\n",
    "\n",
    "s = 'Never Gonna Give You Up'\n",
    "\n",
    "count = Counter(s)\n",
    "print(f'{count = }')\n",
    "\n",
    "print(f'{count[\"e\"] = }')\n",
    "print(f'{count[\" \"] = }')\n",
    "print(f'{count[\"p\"] = }')\n",
    "\n",
    "print(f'{count.most_common(4) = }')\n",
    "print(f'{list(count.elements()) = }')"
   ]
  },
  {
   "source": [
    "## ```deque```\n",
    "\n",
    "```deque``` это реализация такой структуры данных как [двусторонняя очередь](https://en.wikipedia.org/wiki/Queue_(abstract_data_type)). Функция ```deque``` принимает коллекцию в качестве аргумента и один необязательный параметр ```maxlen```, который ограничивает длину очереди.\n",
    "\n",
    "Она позволяет реализовать:\n",
    "- ограниченную очередь (за счет дополнительного аргумента ```maxlen```);\n",
    "- очередь по принципу \"первый пришёл — первый вышел\" или FIFO (за счет методов ```popleft``` для удаления элемента с левой части очереди и ```append``` для добавления элемента в правую часть);\n",
    "- очередь по принципу \"последний пришёл — первый вышел\" или LIFO (за счет методов ```pop``` для удаления элемента с правой части очереди и ```append```).\n",
    "\n",
    "Реализация очереди с помощью ```deque``` гораздо эффективнее с точки зрения производительности нежели реализация очереди на основе списков. Поэтому если существует необходимость в этой структуре данных нужно использовать ```deque```, а не списки.\n",
    "\n",
    "Подробнее о доступных методах и подробных примерах см. в [документации](https://docs.python.org/3/library/collections.html#collections.deque)."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "d = deque([1, 2, 3, 4])\ntype(d) = <class 'collections.deque'>\nЭлемент с левого конца: left_item = 1\nЭлемент с правого конца: right_item = 4\nОчередь после добавления элементов: d = deque([196, 2, 3, 42])\n"
     ]
    }
   ],
   "source": [
    "from collections import deque\n",
    "\n",
    "d = deque([1, 2, 3, 4])\n",
    "print(f'{d = }')\n",
    "print(f'{type(d) = }')\n",
    "\n",
    "# Операции pop и popleft удаляют элемент из очереди и возвращают, \n",
    "# это позволяет работать с ним после удаления\n",
    "left_item = d.popleft()\n",
    "right_item = d.pop()\n",
    "print(f'Элемент с левого конца: {left_item = }')\n",
    "print(f'Элемент с правого конца: {right_item = }')\n",
    "\n",
    "# Можно добавлять элементы в любой конец\n",
    "d.append(42)\n",
    "d.appendleft(196)\n",
    "print(f'Очередь после добавления элементов: {d = }')"
   ]
  },
  {
   "source": [
    "## ```ChainMap```\n",
    "\n",
    "Очень часто встречаются ситуации, когда нужно объединить несколько словарей. Это можно сделать несколькими разными способами:\n",
    "- для Python < 3.9 ```{**a, **b}```;\n",
    "- для Python >= 3.9 ```a | b```;\n",
    "- использовать ```ChainMap```.\n",
    "\n",
    "Первые два способа создадут новый словарь в памяти на основе двух других. Для больших исходных словарей накладно создавать еще больший словарь с аналогичным содержимым. Для решения этой проблемы используется ```ChainMap```. Он позволяет объединить несколько словарей, не создавая новый. По факту он хранит только ссылки на исходные словари. Однако, его повеление полностью аналогично тому, как если бы мы произвели объединение словарей.\n",
    "\n",
    "Подробнее о возможностях ```ChainMap``` см. в [документации](https://docs.python.org/3/library/collections.html#collections.ChainMap)."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "cm_1 = ChainMap({'a': [1, 2, 3], 'b': [4, 5, 6]}, {'b': 42, 'c': 196}, {'b': 42, 'c': 196})\ntype(cm_1) = <class 'collections.ChainMap'>\nChainMap(d_1, d_2, d_3):\ncm_1[\"a\"] = [1, 2, 3]\ncm_1[\"b\"] = [4, 5, 6]\ncm_1[\"c\"] = 196\n-------------------------\nChainMap(d_3, d_2, d_1):\ncm_2[\"a\"] = [1, 2, 3]\ncm_2[\"b\"] = 42\ncm_2[\"c\"] = 196\n"
     ]
    }
   ],
   "source": [
    "from collections import ChainMap\n",
    "\n",
    "# словари, которые будем объединять\n",
    "# в некоторых из них есть одинаковые ключи\n",
    "d_1 = {\n",
    "    'a': [1, 2, 3],\n",
    "    'b': [4, 5, 6],\n",
    "}\n",
    "d_2 = {\n",
    "    'b': 42,\n",
    "    'c': 196,\n",
    "}\n",
    "d_3 = {\n",
    "    'd': ['dot', 'dump'],\n",
    "    'f': ['foo', 'fail'],\n",
    "}\n",
    "\n",
    "# Два разных ChainMap\n",
    "# Создавая ChainMap важен порядок словарей, как при их \n",
    "# объединении. Это повлияет на обновление повторяющихся ключей.\n",
    "cm_1 = ChainMap(d_1, d_2, d_2)\n",
    "cm_2 = ChainMap(d_3, d_2, d_1)\n",
    "print(f'{cm_1 = }')\n",
    "print(f'{type(cm_1) = }')\n",
    "\n",
    "print('ChainMap(d_1, d_2, d_3):')\n",
    "print(f'{cm_1[\"a\"] = }')\n",
    "print(f'{cm_1[\"b\"] = }')\n",
    "print(f'{cm_1[\"c\"] = }')\n",
    "print('-' * 25)\n",
    "print('ChainMap(d_3, d_2, d_1):')\n",
    "print(f'{cm_2[\"a\"] = }')\n",
    "print(f'{cm_2[\"b\"] = }')\n",
    "print(f'{cm_2[\"c\"] = }')"
   ]
  },
  {
   "source": [
    "Изменение исходных списков отражается на ```ChainMap``` и наоборот."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "cm_1 = ChainMap({'a': [1, 2, 3, 4], 'b': [4, 5, 6]}, {'b': 42, 'c': 196}, {'b': 42, 'c': 196})\ncm_1[\"a\"] = [1, 2, 3, 4]\ncm_1 = ChainMap({'a': [1, 2, 3, 4], 'b': [4, 5, 6], 'g': 0}, {'b': 42, 'c': 196}, {'b': 42, 'c': 196})\nd_1 = {'a': [1, 2, 3, 4], 'b': [4, 5, 6], 'g': 0}\n"
     ]
    }
   ],
   "source": [
    "d_1['a'].append(4)\n",
    "\n",
    "print(f'{cm_1 = }')\n",
    "print(f'{cm_1[\"a\"] = }')\n",
    "\n",
    "# добавление нового ключа и значения в ChainMap \n",
    "# привело к добавлению этого ключа в первый словарь\n",
    "cm_1['g'] = 0\n",
    "print(f'{cm_1 = }')\n",
    "print(f'{d_1 = }')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Объединение всех списков: (d_1 | d_2 | d_2).__sizeof__() = 216\nChainMap: cm_1.__sizeof__() = 32\n"
     ]
    }
   ],
   "source": [
    "print(f'Объединение всех списков: {(d_1 | d_2 | d_2).__sizeof__() = }')\n",
    "print(f'ChainMap: {cm_1.__sizeof__() = }')"
   ]
  },
  {
   "source": [
    "## ```defaultdict```\n",
    "\n",
    "Стандартные словари ```dict``` при обращении к несуществующему ключу возвращают исключение ```KeyError```. Это приводит к тому, что нужно постоянно проверять его наличие. В ситуациях, когда предполагается добавление отсутствующему ключу добавлять некоторое значение по умолчанию постоянное выполнение проверок не слишком продуктивно. \n",
    "\n",
    "```python\n",
    "# проверка наличия ключа\n",
    "if key in d:\n",
    "    value = d[key]\n",
    "else:\n",
    "    # добавление ключа со значением по умолчанию\n",
    "    d[key] = 0\n",
    "```\n",
    "\n",
    "Для таких ситуаций предусмотрена коллекция ```defaultdict```. Это словарь, который умеет автоматически задавать значение по умолчанию для несуществующих ключей. Функция ```defaultdict()``` принимает один необязательный аргумент - функцию, которая возвращает значение по умолчанию. Если вызывать ```defaultdict``` без аргмуентов, то его поведение будет аналогичным обычному ```dict```.\n",
    "\n",
    "Подробнее о возможностях ```defaultdict``` см. в [документации](https://docs.python.org/3/library/collections.html#collections.defaultdict)."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "d = defaultdict(None, {})\ntype(d) = <class 'collections.defaultdict'>\nd[\"a\"] = 5\n"
     ]
    },
    {
     "output_type": "error",
     "ename": "KeyError",
     "evalue": "'b'",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mKeyError\u001b[0m                                  Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-15-dbf58aad6baa>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      7\u001b[0m \u001b[0md\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;34m'a'\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;36m5\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      8\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34mf'{d[\"a\"] = }'\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 9\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34mf'{d[\"b\"] = }'\u001b[0m\u001b[1;33m)\u001b[0m  \u001b[1;31m# KeyError\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mKeyError\u001b[0m: 'b'"
     ]
    }
   ],
   "source": [
    "from collections import defaultdict\n",
    "\n",
    "d = defaultdict()\n",
    "print(f'{d = }')\n",
    "print(f'{type(d) = }')\n",
    "\n",
    "d['a'] = 5\n",
    "print(f'{d[\"a\"] = }')\n",
    "print(f'{d[\"b\"] = }')  # KeyError"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "int() = 0\nd = defaultdict(<class 'int'>, {})\ntype(d) = <class 'collections.defaultdict'>\nd[\"a\"] = 5\nd[\"b\"] = 0\nd[\"с\"] = 0\nd = defaultdict(<class 'int'>, {'a': 5, 'b': 0, 'с': 0})\n\"g\" in d = False\n\"c\" in d = False\nd[\"e\"] = 42\n"
     ]
    }
   ],
   "source": [
    "# вызов функции int без аргументов возвращает ноль\n",
    "print(f'{int() = }')\n",
    "\n",
    "# словарь со значением ноль по умолчанию\n",
    "d = defaultdict(int)\n",
    "print(f'{d = }')  # изначально словарь пуст\n",
    "print(f'{type(d) = }')\n",
    "\n",
    "d['a'] = 5\n",
    "print(f'{d[\"a\"] = }')\n",
    "print(f'{d[\"b\"] = }')  # 0\n",
    "print(f'{d[\"с\"] = }')  # 0\n",
    "# каждое новое обращение к несуществующему ключу добавляет его в словарь\n",
    "print(f'{d = }')\n",
    "\n",
    "# проверка на наличие ключа работает как обычно\n",
    "print(f'{\"g\" in d = }')\n",
    "print(f'{\"c\" in d = }')\n",
    "\n",
    "# можно сразу выполнять in-place операции даже с несуществующими ключами\n",
    "d['e'] += 42\n",
    "print(f'{d[\"e\"] = }')"
   ]
  },
  {
   "source": [
    "```defaultdict``` можно использовать для разных задач. Например, в ситуации, когда нужно создать дерево на основе словарей. В этом случае значением по умолчанию будет тот же ```defaultdict```."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "defaultdict(<function tree at 0x0000021A9127DAF0>, {})\ndefaultdict(<function tree at 0x0000021A9127DAF0>, {})\ndefaultdict(<function tree at 0x0000021A9127DAF0>, {})\ndf = defaultdict(<function tree at 0x0000021A9127DAF0>, {1: defaultdict(<function tree at 0x0000021A9127DAF0>, {2: defaultdict(<function tree at 0x0000021A9127DAF0>, {3: defaultdict(<function tree at 0x0000021A9127DAF0>, {})}), 4: defaultdict(<function tree at 0x0000021A9127DAF0>, {})})})\n"
     ]
    }
   ],
   "source": [
    "# фуекция для создания значения по умолчанию\n",
    "def tree():\n",
    "    # defaultdict с этой же функцией\n",
    "    return defaultdict(tree)\n",
    "\n",
    "# создание корневого узла\n",
    "df = defaultdict(tree)\n",
    "print(df[1])\n",
    "print(df[1][2][3])\n",
    "print(df[1][4])\n",
    "\n",
    "# в качестве листов дерева будут пустые словари\n",
    "print(f'{df = }')"
   ]
  },
  {
   "source": [
    "# Ссылки\n",
    "\n",
    "- [Документация](https://docs.python.org/3/library/collections.html)\n"
   ],
   "cell_type": "markdown",
   "metadata": {}
  }
 ]
}