P419_04 Loops.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# P419 04 Циклы\n",
    "\n",
    "Автор: Шабанов Павел Александрович\n",
    "\n",
    "Email: pa.shabanov@gmail.com\n",
    "\n",
    "URLs: \n",
    "\n",
    "+ [Заметки по программированию в науках о Земле](http://progeoru.blogspot.ru/)\n",
    "\n",
    "+ [GitHub: PyLearn](https://github.com/whitehorn/pyLearn)\n",
    "\n",
    "+ [О циклах с сайта pythonWorld](https://pythonworld.ru/osnovy/cikly-for-i-while-operatory-break-i-continue-volshebnoe-slovo-else.html)\n",
    "\n",
    "Дата последнего обновления: **20.10.2018**\n",
    "\n",
    "<a id='up'></a>\n",
    "### План\n",
    "\n",
    "1. [Циклы](#cycles);\n",
    "    + [Цикл for](#for_cycle);\n",
    "        + [zip](#zip)\n",
    "        + [enumerate](#enumerate)        \n",
    "    + [Бесконечный цикл while или цикл с условием](#while_cycle)\n",
    "2. [Выход из цикла](#return)\n",
    "    + [Прерывание цикла **break**](#break);\n",
    "    + [Продолжение цикла **continue**](#continue)\n",
    "    \n",
    "3. [Вложенные циклы](#many+loops)\n",
    "\n",
    "### Цель: \n",
    "\n",
    "+ научиться пользоваться одной из основных управляющих конструкций python: циклами\n",
    "\n",
    "<a id='cycles'></a>\n",
    "## Циклы\n",
    "[Вверх](#up)\n",
    "\n",
    "Одним из базовых понятий программирования (в процедурном стиле и не только) является цикл. \n",
    "\n",
    "[Цикл](https://ru.wikipedia.org/wiki/%D0%A6%D0%B8%D0%BA%D0%BB_%28%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5%29) - это инструмент, позволяющий повторять какой-либо кусок кода много-много раз. Разумно использовать цикл столько раз, сколько это нужно для реализации алгоритма.\n",
    "\n",
    "Каждый повтор называется ещё итерацией.\n",
    "\n",
    "**Цикл (loop)** - это логический блок, конструкция-контейнер, в пределах которого осуществляется повторение всего кода, содержащегося внутри него. Повторение просходит столько раз, сколько это определено условием (цикл `while`), либо определённое заранее число раз (цикл `for`). \n",
    "\n",
    "Всё содержание цикла (\"тело цикла\") отделяется от строки, в которой объявлен цикл, четырьмя пробелами (правило 4 пробелов для вложенных структур). \n",
    "\n",
    "`Строка, в которой объявлен цикл, обязательно заканчивается двоеточием!`\n",
    "\n",
    "В python реализовано два вида циклов: \n",
    "\n",
    "+ конечные, с счётчиком (**for**);\n",
    "+ бесконечные (**while**). \n",
    "\n",
    "В первом случае известно количество повторений, шагов цикла или итераций (либо задаётся прямо, либо определяется длиной последовательности, которая используется для перебора). Во втором случае цикл будет повторять код бесконечно, если не будет выполнено условие выхода или не будет прервано пользователем вручную (это приведёт к остановке выполнения всей программы).\n",
    "\n",
    "<a id='for_cycle'></a>\n",
    "## Цикл for\n",
    "\n",
    "Цикл for имеет следующую конструкцию:\n",
    "\n",
    "**for <объект цикла> in <последовательность>**: \n",
    "\n",
    "**....тело цикла**\n",
    "\n",
    "Уже знакомый оператор вхождения **in** здесь работает в связке с for и позволяет перебрать все элементы последовательности. В конце условия цикла обязательно ставится двоеточие. Тело цикла должно быть вложенным, т.е. размещаться на 4 пробела правее от начала описания цикла (от позиции буквы \"f\" в for).\n",
    "\n",
    "> Обратите внимание, что даже в интерактивном режиме (консоль) необходимо делать 4 пробела при написании кода внутри цикла! IDLE и другие, работающие с python среды разработки (IDE), будут вам помогать делать это автоматически, но за правильностью отступов вложенных логических структур в коде нужно следить!\n",
    "\n",
    "`Важно помнить, что тело цикла должно быть, но может быть несколько циклов со своими телами!`\n",
    "\n",
    "Пустая строка не годится, нужен какой-либо код. Чтобы описать \"нулевой\" или пустой цикл, который будет корректно восприниматься интерпретатором python, нужно воспользоваться особой командой **pass**. \n",
    "\n",
    "Это  пустая функция, пустая операция или выражение, которое позволяет управляющим структурам (циклы и ветвление) иметь тело без дополнительного кода. Это удобно в случае разработки кода, когда точно есть потребность в конструкции, но конкретное наполнение пока не определено. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Тривиальный цикл\n",
    "for i in [1, 2]:\n",
    "    pass"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0|1|2|3|4|5|6|7|8|9|"
     ]
    }
   ],
   "source": [
    "a = list(range(10))   # список \n",
    "b = tuple(a)   # кортеж; функция tuple() возвращает кортеж от последовательности\n",
    "\n",
    "# Перебор элементов списка b\n",
    "#for j in b:\n",
    "    # j - переменная, в которую передаёся элемент последовательности списка b\n",
    "#    print(j)   # запятая подавляет перевод строки\n",
    "# Перебор элементов кортежа a\n",
    "for i in a:\n",
    "    print(i, end='|')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Перебирать в цикле можно только те типы данных, которые поддерживают итерационный механизм или итерации! Например, можно перебирать элементы списков, элементы строк, ключи в словарях, открытые объект-файлы. \n",
    "\n",
    "Нельзя перебирать в циклах числа, булевы переменные!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Так не надо, Ошибка\n",
      "Так не надо, Ошибка\n"
     ]
    }
   ],
   "source": [
    "try:\n",
    "    for x in False:\n",
    "        pass\n",
    "except:\n",
    "    print('Так не надо, Ошибка')\n",
    "\n",
    "try:\n",
    "    for y in 234:\n",
    "        pass\n",
    "except:\n",
    "    print('Так не надо, Ошибка')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Но можно перебирать `строки`, `множества`, `словари`, `numpy-массивы`, `pandas.DataFrames` и т.д."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "4\n",
      "5\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "# перебор элементов множества\n",
    "A = {1, 2, 4, 5, 6} \n",
    "for elem in A:\n",
    "    print(elem)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "M*y* *w*o*n*d*e*r*f*u*l* *s*t*r*i*n*g*!*"
     ]
    }
   ],
   "source": [
    "ss = 'My wonderful string!'\n",
    "for s in ss:\n",
    "    print(s, end='*')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В случае *словарей*, у которых элемент последовательности состоит не только из значения, а из связки **\"ключ:значение\"**, цикл for будет перебирать **ключи**. Чтобы узнать значения, соответствующие этим ключам, необходимо обратиться к словарю по ключу, используя квадратные скобки [].\n",
    "\n",
    "Так как словарь является неупорядоченной последовательностью, т.е. в нём нет строго правила следования элементов друг за другом, то и порядок возвращаемых ключей/значений не соответствует порядку их ввода при составлении словаря.   "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I\n",
      "one 1\n",
      "two 2\n",
      "three long\n",
      "II\n",
      "one 1\n",
      "two 2\n",
      "three long\n"
     ]
    }
   ],
   "source": [
    "c = {'one':1, 'two':2, 'three': 'long'}\n",
    "\n",
    "# Перебор ключей, значений словаря c\n",
    "print('I')\n",
    "for i in c:\n",
    "    # i - ключи!\n",
    "    print(i, c[i])\n",
    "    \n",
    "# Другой вариант\n",
    "print('II')\n",
    "for key in c.keys():\n",
    "    print(key, c[key])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='enumerate'></a>\n",
    "#### enumerate()\n",
    "[Вверх](#up)\n",
    "\n",
    "Одной из самых полезных функций при работе с циклами является встроенная функция **enumerate()**. Она применяется к последовательности и позволяет перебрать не только сами элементы последовательности, но и их индексы. Для этого указывается не одна переменная цикла (i в примере выше), а две, указанные через запятую: index, value.\n",
    "\n",
    "> **enumerate()** - функция, которая возвращает на каждом шаге цикла индекс и значение элемента последовательности, которая перебирается в цикле"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "windows linux mac sun unix 0 windows\n",
      "1 linux\n",
      "2 mac\n",
      "3 sun\n",
      "4 unix\n"
     ]
    }
   ],
   "source": [
    "c = ['windows', 'linux', 'mac', 'sun', 'unix']\n",
    "for i in c:\n",
    "    print(i, end=' ')\n",
    "\n",
    "for i, elem in enumerate(c):\n",
    "        print(i, elem)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 windows\n",
      "1 linux\n",
      "2 mac\n",
      "3 sun\n",
      "4 unix\n",
      "<class 'tuple'>\n"
     ]
    }
   ],
   "source": [
    "c = ['windows', 'linux', 'mac', 'sun', 'unix']\n",
    "\n",
    "for val in enumerate(c):\n",
    "        print(val[0], val[1])\n",
    "print('Val', type(val))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В неупорядоченных последовательностях, таких как множества, а также в словарях, функция **enumerate** выводит какие-то индексы, согласно выводу элементов из этих коллекций (так тоже можно назвать последовательности)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 False\n",
      "1 1\n",
      "2 4\n",
      "3 5\n",
      "4 6\n",
      "5 7\n",
      "6 -1\n",
      "<---------------->\n",
      "0 three\n",
      "1 one\n",
      "2 two\n"
     ]
    }
   ],
   "source": [
    "A = {1, 7, 4, 5, 5, 6, -1, False} \n",
    "for i, elem in enumerate(A):\n",
    "    print(i, elem)\n",
    "print('<---------------->')    \n",
    "dic = {'three': 'long', 'one':1, 'two':2, }\n",
    "for i, key in enumerate(dic):\n",
    "    print(i, key)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='zip'></a>\n",
    "#### zip()\n",
    "[Вверх](#up)\n",
    "\n",
    "Ещё одной полезной встроенной функцией при работе с циклами является функция **zip()**.\n",
    "\n",
    "**zip()** -  объединяет в кортежи элементы из последовательностей, переданных в качестве аргументов. Если последовательности имеют разные длины, то объединение произойдёт по минимуму из данных последовательностйей. \n",
    "\n",
    "`Это один из самых простых способов соединить несколько списков-векторов в матрично подобную стуктуру.`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'zip'>\n",
      "<class 'list'> 8 (1952, 1, 8)\n",
      "1950 0 -5\n",
      "1952 1 8\n",
      "1954 2 14\n",
      "1956 3 22\n",
      "1958 4 23\n",
      "1960 5 26\n",
      "1962 6 -1\n",
      "1964 7 11\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "\n",
    "N = 15\n",
    "a = list(range(1950, 1950+N, 2))  # длина 8\n",
    "b = list(range(N))   # длина 15\n",
    "c = [random.randint(-9, 37) for i in range(N)]   # длина 15\n",
    "\n",
    "e = zip(a, b, c)    # длина 8\n",
    "print(type(e))\n",
    "sar = list(e)\n",
    "\n",
    "print(type(sar), len(sar), sar[1][:])\n",
    "for year, val, val2 in sar:\n",
    "    print(year, val, val2)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Как видно, цикл for позволяет работать не только с одной переменной (вспомним, что она есть ссылка на объект), а с несколькими переменными на каждом шаге (итерации) цикла. Поясним это на примере вложенных списков."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Tom', 'Jerry'] - DOG\n",
      "[0, 1] - 2\n",
      "[True, False] - True\n",
      "Tom 0 True\n",
      "Jerry 1 False\n",
      "DOG 2 True\n",
      "DOG 3\n"
     ]
    }
   ],
   "source": [
    "a = ['Tom', 'Jerry', 'DOG']\n",
    "b = list(range(3))\n",
    "c = (True, False, True)\n",
    "ilist = [a, b, c]   # вложенный список: список, состящий из списков\n",
    "for *i, j in [a, b, c]:   # здесь i - число, строка или булева переменная\n",
    "    print(i, '-', j)\n",
    "#    print(k)\n",
    "    \n",
    "for i, j, k in zip(a, b, c):\n",
    "    print(i, j, k) \n",
    "\n",
    "print(i, len(i))\n",
    "#print('*'*20)\n",
    "    \n",
    "#for i in ilist:   # здесь i - список\n",
    "#    print(type(i), i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='while_cycle'></a>\n",
    "## Бесконечный цикл while или цикл с условием\n",
    "[Вверх](#up)\n",
    "\n",
    "Бесконечный цикл **while** в python имеет следующую конструкцию:\n",
    "\n",
    "`**while(<выражение>):**`\n",
    "\n",
    "`**....тело цикла**`\n",
    "\n",
    "На каждом шаге цикла выражение, стоящее в скобках, проверяется на равенство истине (True). Если оно истинно, то совершается ещё один шаг, ещё одна итерация цикла. Бесконечным такой цикл делает выражение, которое всегда соответствует истине True на любом шаге такого цикла.\n",
    "\n",
    "Обычно в качестве выражения в такой цикл помещают логическое условие: например, a > 10 (a > b; i < 10; d == 10). Но это может быть и просто переменная (ведь любой тип данных можно привести к логическому типу и сравнить на равенство Истине True). \n",
    "\n",
    "Соответственно, чтобы цикл не превратился в бесконечный, выражение цикла не должно быть константой, а некоторой переменной, управляемой внутри цикла. Так в случае выражения-условия a > 10 в теле цикла (участок кода, который охватывает цикл) значение переменной \"a\" должно изменяться и при определённых обстоятельствах стать меньше 10. Тогда такой код будет корректен, цикл не будет выполняться бесконечно, а интерпретатор покинет цикл в момент прекращения выполнения условия. \n",
    "\n",
    "Поэтому цикл **while** также называют **циклом с условием**."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "9\n",
      "8\n",
      "7\n",
      "6\n"
     ]
    }
   ],
   "source": [
    "a = 10\n",
    "while a > 5:\n",
    "    print(a)\n",
    "    a = a - 1\n",
    "    # a -= 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='return'></a>\n",
    "## Выход из цикла\n",
    "[Вверх](#up)\n",
    "\n",
    "Формально, цикл может состоять из операторов for или while и тела цикла (пустого в самом простом виде). Обе конструкции могут быть дополнены необязательными функциями **break** и **continue**\n",
    "\n",
    "<a id='break'></a>\n",
    "### break\n",
    "[Вверх](#up)\n",
    "\n",
    "Чтобы выйти из любого цикла в определённый момент (даже если выражение цикла while истинно) существует оператор **break**. Как только он выполняется, программа покидает текущий цикл и переходит в вышестоящую управляющую структуру (для одиночного цикла, это скорее всего возврат в основной поток исполнения программы; для вложенного цикла - возврат на итерацию вышерасположенного цикла и т.д.).\n",
    "\n",
    "<a id='break'></a>\n",
    "### continue\n",
    "[Вверх](#up)\n",
    "\n",
    "В противоположность функции **break**, функция **continue** которая позволяет не заканчивая всё тело цикла, перейти к следующей итерации цикла. Весь код, расположенный \"ниже\" строки с вызовом continue по порядку, будет игнорирован.\n",
    "\n",
    "Хотя такие конструкции и затрудняют разбор кода, они полезны, так как помогают прекратить выполнение ненужных участков тела цикла или итераций (а это время исполнения кода + экономия памяти). \n",
    "\n",
    "**Break** и **continue** чаще всего встречаются в блоках условных операторов (if-elif-else)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I. Succsess after 2 iterations\n"
     ]
    }
   ],
   "source": [
    "# Пример проверки случ. значения r больше данного порогового значения TR\n",
    "\n",
    "import random   # импорт модуля для работы со случайными числами\n",
    "\n",
    "TR = 0.7\n",
    "t = 0\n",
    "while True:\n",
    "    t += 2 \n",
    "    r = random.random()   # генерация псевдослучайного числа\n",
    "    if r >= TR:\n",
    "        print('I. Succsess after', t, 'iterations')\n",
    "        break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[101, 112, 7, 153, 9, 144, 196, 71, 169, 120, 117, 126, 135, 112, 189, 120, 20, 33, 187, 155]\n",
      "Number of invalid values: 46\n",
      "Spam list - 7th zero:  [2, 14, 56, 63, 65]\n",
      "Powered:  [10201, -999, 49, 23409, 81, -999, -999, 5041, 28561, -999, 13689, -999, 18225, -999, 35721, -999, -999, 1089, 34969, 24025]\n"
     ]
    }
   ],
   "source": [
    "# Пример замены нечётных элементов случайного списка целых чисел\n",
    "# на invalid значения, а также запись делящихся нацело на 7 \n",
    "# значений в список spam\n",
    "\n",
    "N = 100\n",
    "invalid = -999\n",
    "box = [random.randint(0, 200) for i in range(N)]\n",
    "spam = []\n",
    "\n",
    "print(box[:20])\n",
    "for i, val in enumerate(box):\n",
    "    if val % 2 == 0:\n",
    "        box[i] = invalid\n",
    "        continue\n",
    " #       print(lst[i])\n",
    "    if val % 7 == 0:\n",
    "        spam.append(i) \n",
    "    box[i] = val*val\n",
    "\n",
    "print('Number of invalid values: {}'.format(box.count(invalid)))\n",
    "print('Spam list - 7th zero: ', spam)\n",
    "print('Powered: ', box[:20])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<a id='many+loops'></a>\n",
    "## Вложенные циклы\n",
    "[Вверх](#up)\n",
    "\n",
    "Цикл, как управляющая конструкция выраженная 4 пробелами, может быть частью других управляющих конструций (скрипт, цикл, условие, функция и т.д.). В случае цикла в цикле говорят о вложенных циклах.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "18 Jun 1955\n",
      "18 Dec 1955\n",
      "18 Jun 1960\n",
      "18 Dec 1960\n",
      "18 Jun 1965\n",
      "18 Dec 1965\n",
      "18 Jun 1970\n",
      "18 Dec 1970\n",
      "18 Jun 1975\n",
      "18 Dec 1975\n",
      "18 Jun 1980\n",
      "18 Dec 1980\n",
      "18 Jun 1985\n",
      "18 Dec 1985\n",
      "18 Jun 1990\n",
      "18 Dec 1990\n",
      "18 Jun 1995\n",
      "18 Dec 1995\n",
      "18 Jun 2000\n",
      "18 Dec 2000\n",
      "18 Jun 2005\n",
      "18 Dec 2005\n",
      "18 Jun 2010\n",
      "18 Dec 2010\n",
      "['27-Dec-2014', '28-Dec-2014', '29-Dec-2014', '30-Dec-2014', '31-Dec-2014']\n"
     ]
    }
   ],
   "source": [
    "import calendar\n",
    "\n",
    "years = range(1955, 2015)\n",
    "\n",
    "dates = []\n",
    "for y in years:  # верхний цикл 1\n",
    "    for m in range(1, 13):  # средний цикл 2\n",
    "        mon = calendar.month_abbr[m]\n",
    "        weeksNum, days = calendar.monthrange(y, m)\n",
    "        for d in range(1, days+1):  # самый вложенный цикл 3\n",
    "            if (y % 5 == 0) and (m % 6 == 0) and (d == 18):\n",
    "                print(d, mon, y)\n",
    "            s = '{}-{}-{}'.format(d, mon, y)\n",
    "            dates.append(s)\n",
    "print(dates[-5:])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Вложенные циклы - слабое место python. Будучи интерпретируемым языком, выполнение множества вложенных повторяющихся участков кода оказывается тяжёлой задачей. В случае не сложных или слабо нагруженных задач, это может быть незаметно. Однако нужно понимать, что множество вложеннных циклов - это потенциально слабейшее место для времении исполнения скрипта."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "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.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}