lect2.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Лекция №2. Простые скрипты\n",
    "\n",
    "*П.Н. Советов, РТУ МИРЭА*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "import io\n",
    "from graphviz import Digraph\n",
    "from railroad import Diagram, Optional, Choice, Sequence\n",
    "from IPython.display import SVG, display\n",
    "\n",
    "def show_diagram(d):\n",
    "    with io.StringIO() as f:\n",
    "        Diagram(d).writeSvg(f.write)\n",
    "        display(SVG(f.getvalue()))\n",
    "\n",
    "def edge(d, source, targets):\n",
    "    for target in targets.split():\n",
    "        d.edge(source, target)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Типы данных\n",
    "\n",
    "В Питоне значения различных типов являются объектами. Важно учитывать, что объекты передаются (при присваиваниях и использовании в качестве аргументов) по ссылке, а не копируются. Типы данных в Питоне делятся на изменяемые (mutable) и неизменяемые (immutable). У объекта изменяемого типа содержимое может быть модифицировано. \n",
    "\n",
    "На рисунке ниже показаны основные встроенные типы данных языка Питон."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/svg+xml": "<?xml version=\"1.0\" encoding=\"UTF-8\" standalone=\"no\"?>\n<!DOCTYPE svg PUBLIC \"-//W3C//DTD SVG 1.1//EN\"\n \"http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd\">\n<!-- Generated by graphviz version 2.49.3 (20211023.0002)\n -->\n<!-- Pages: 1 -->\n<svg width=\"822pt\" height=\"260pt\"\n viewBox=\"0.00 0.00 822.00 260.00\" xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\">\n<g id=\"graph0\" class=\"graph\" transform=\"scale(1 1) rotate(0) translate(4 256)\">\n<polygon fill=\"white\" stroke=\"transparent\" points=\"-4,4 -4,-256 818,-256 818,4 -4,4\"/>\n<!-- n1 -->\n<g id=\"node1\" class=\"node\">\n<title>n1</title>\n<polygon fill=\"none\" stroke=\"black\" points=\"701,-252 539,-252 539,-216 701,-216 701,-252\"/>\n<text text-anchor=\"middle\" x=\"620\" y=\"-230.3\" font-family=\"Times New Roman,serif\" font-size=\"14.00\">Иерархия типов данных</text>\n</g>\n<!-- n2 -->\n<g id=\"node2\" class=\"node\">\n<title>n2</title>\n<polygon fill=\"none\" stroke=\"black\" points=\"325,-180 183,-180 183,-144 325,-144 325,-180\"/>\n<text text-anchor=\"middle\" x=\"254\" y=\"-158.3\" font-family=\"Times New Roman,serif\" font-size=\"14.00\">Последовательности</text>\n</g>\n<!-- n1&#45;&gt;n2 -->\n<g id=\"edge1\" class=\"edge\">\n<title>n1&#45;&gt;n2</title>\n<path fill=\"none\" stroke=\"black\" d=\"M538.77,-217.46C478.13,-205.87 395.62,-190.09 335.02,-178.5\"/>\n<polygon fill=\"black\" stroke=\"black\" points=\"335.59,-175.04 325.11,-176.6 334.28,-181.92 335.59,-175.04\"/>\n</g>\n<!-- n5 -->\n<g id=\"node5\" class=\"node\">\n<title>n5</title>\n<polygon fill=\"none\" stroke=\"black\" points=\"516,-180 462,-180 462,-144 516,-144 516,-180\"/>\n<text text-anchor=\"middle\" x=\"489\" y=\"-158.3\" font-family=\"Times New Roman,serif\" font-size=\"14.00\">Числа</text>\n</g>\n<!-- n1&#45;&gt;n5 -->\n<g id=\"edge2\" class=\"edge\">\n<title>n1&#45;&gt;n5</title>\n<path fill=\"none\" stroke=\"black\" d=\"M587.95,-215.88C568.99,-205.74 544.91,-192.88 525.26,-182.37\"/>\n<polygon fill=\"black\" stroke=\"black\" points=\"526.76,-179.21 516.29,-177.58 523.46,-185.38 526.76,-179.21\"/>\n</g>\n<!-- n6 -->\n<g id=\"node6\" class=\"node\">\n<title>n6</title>\n<polygon fill=\"none\" stroke=\"black\" points=\"662.5,-180 577.5,-180 577.5,-144 662.5,-144 662.5,-180\"/>\n<text text-anchor=\"middle\" x=\"620\" y=\"-158.3\" font-family=\"Times New Roman,serif\" font-size=\"14.00\">Множества</text>\n</g>\n<!-- n1&#45;&gt;n6 -->\n<g id=\"edge3\" class=\"edge\">\n<title>n1&#45;&gt;n6</title>\n<path fill=\"none\" stroke=\"black\" d=\"M620,-215.7C620,-207.98 620,-198.71 620,-190.11\"/>\n<polygon fill=\"black\" stroke=\"black\" points=\"623.5,-190.1 620,-180.1 616.5,-190.1 623.5,-190.1\"/>\n</g>\n<!-- n7 -->\n<g id=\"node7\" class=\"node\">\n<title>n7</title>\n<ellipse fill=\"none\" stroke=\"black\" cx=\"711\" cy=\"-162\" rx=\"30.59\" ry=\"18\"/>\n<text text-anchor=\"middle\" x=\"711\" y=\"-158.3\" font-family=\"Times New Roman,serif\" font-size=\"14.00\">None</text>\n</g>\n<!-- n1&#45;&gt;n7 -->\n<g id=\"edge4\" class=\"edge\">\n<title>n1&#45;&gt;n7</title>\n<path fill=\"none\" stroke=\"black\" d=\"M642.49,-215.7C655.4,-205.77 671.65,-193.27 685.08,-182.94\"/>\n<polygon fill=\"black\" stroke=\"black\" points=\"687.24,-185.7 693.03,-176.82 682.97,-180.15 687.24,-185.7\"/>\n</g>\n<!-- n8 -->\n<g id=\"node8\" class=\"node\">\n<title>n8</title>\n<ellipse fill=\"none\" stroke=\"black\" cx=\"787\" cy=\"-162\" rx=\"27\" ry=\"18\"/>\n<text text-anchor=\"middle\" x=\"787\" y=\"-158.3\" font-family=\"Times New Roman,serif\" font-size=\"14.00\">dict</text>\n</g>\n<!-- n1&#45;&gt;n8 -->\n<g id=\"edge5\" class=\"edge\">\n<title>n1&#45;&gt;n8</title>\n<path fill=\"none\" stroke=\"black\" d=\"M663.93,-215.95C689.48,-205.85 722.23,-192.6 751,-180 752.8,-179.21 754.65,-178.38 756.51,-177.54\"/>\n<polygon fill=\"black\" stroke=\"black\" points=\"758.16,-180.64 765.77,-173.27 755.22,-174.28 758.16,-180.64\"/>\n</g>\n<!-- n3 -->\n<g id=\"node3\" class=\"node\">\n<title>n3</title>\n<polygon fill=\"none\" stroke=\"black\" points=\"172,-108 66,-108 66,-72 172,-72 172,-108\"/>\n<text text-anchor=\"middle\" x=\"119\" y=\"-86.3\" font-family=\"Times New Roman,serif\" font-size=\"14.00\">Неизменяемые</text>\n</g>\n<!-- n2&#45;&gt;n3 -->\n<g id=\"edge6\" class=\"edge\">\n<title>n2&#45;&gt;n3</title>\n<path fill=\"none\" stroke=\"black\" d=\"M220.98,-143.88C202.92,-134.51 180.35,-122.81 161.05,-112.8\"/>\n<polygon fill=\"black\" stroke=\"black\" points=\"162.64,-109.69 152.15,-108.19 159.42,-115.9 162.64,-109.69\"/>\n</g>\n<!-- n4 -->\n<g id=\"node4\" class=\"node\">\n<title>n4</title>\n<polygon fill=\"none\" stroke=\"black\" points=\"300,-108 208,-108 208,-72 300,-72 300,-108\"/>\n<text text-anchor=\"middle\" x=\"254\" y=\"-86.3\" font-family=\"Times New Roman,serif\" font-size=\"14.00\">Изменяемые</text>\n</g>\n<!-- n2&#45;&gt;n4 -->\n<g id=\"edge7\" class=\"edge\">\n<title>n2&#45;&gt;n4</title>\n<path fill=\"none\" stroke=\"black\" d=\"M254,-143.7C254,-135.98 254,-126.71 254,-118.11\"/>\n<polygon fill=\"black\" stroke=\"black\" points=\"257.5,-118.1 254,-108.1 250.5,-118.1 257.5,-118.1\"/>\n</g>\n<!-- n15 -->\n<g id=\"node15\" class=\"node\">\n<title>n15</title>\n<ellipse fill=\"none\" stroke=\"black\" cx=\"27\" cy=\"-18\" rx=\"27\" ry=\"18\"/>\n<text text-anchor=\"middle\" x=\"27\" y=\"-14.3\" font-family=\"Times New Roman,serif\" font-size=\"14.00\">str</text>\n</g>\n<!-- n3&#45;&gt;n15 -->\n<g id=\"edge14\" class=\"edge\">\n<title>n3&#45;&gt;n15</title>\n<path fill=\"none\" stroke=\"black\" d=\"M96.26,-71.7C82.95,-61.57 66.12,-48.76 52.38,-38.31\"/>\n<polygon fill=\"black\" stroke=\"black\" points=\"54.36,-35.42 44.29,-32.15 50.12,-40.99 54.36,-35.42\"/>\n</g>\n<!-- n16 -->\n<g id=\"node16\" class=\"node\">\n<title>n16</title>\n<ellipse fill=\"none\" stroke=\"black\" cx=\"101\" cy=\"-18\" rx=\"28.7\" ry=\"18\"/>\n<text text-anchor=\"middle\" x=\"101\" y=\"-14.3\" font-family=\"Times New Roman,serif\" font-size=\"14.00\">tuple</text>\n</g>\n<!-- n3&#45;&gt;n16 -->\n<g id=\"edge15\" class=\"edge\">\n<title>n3&#45;&gt;n16</title>\n<path fill=\"none\" stroke=\"black\" d=\"M114.55,-71.7C112.55,-63.9 110.13,-54.51 107.9,-45.83\"/>\n<polygon fill=\"black\" stroke=\"black\" points=\"111.28,-44.92 105.4,-36.1 104.5,-46.66 111.28,-44.92\"/>\n</g>\n<!-- n17 -->\n<g id=\"node17\" class=\"node\">\n<title>n17</title>\n<ellipse fill=\"none\" stroke=\"black\" cx=\"178\" cy=\"-18\" rx=\"30.59\" ry=\"18\"/>\n<text text-anchor=\"middle\" x=\"178\" y=\"-14.3\" font-family=\"Times New Roman,serif\" font-size=\"14.00\">bytes</text>\n</g>\n<!-- n3&#45;&gt;n17 -->\n<g id=\"edge16\" class=\"edge\">\n<title>n3&#45;&gt;n17</title>\n<path fill=\"none\" stroke=\"black\" d=\"M133.58,-71.7C141.05,-62.84 150.24,-51.93 158.33,-42.34\"/>\n<polygon fill=\"black\" stroke=\"black\" points=\"161.02,-44.57 164.79,-34.67 155.67,-40.06 161.02,-44.57\"/>\n</g>\n<!-- n18 -->\n<g id=\"node18\" class=\"node\">\n<title>n18</title>\n<ellipse fill=\"none\" stroke=\"black\" cx=\"254\" cy=\"-18\" rx=\"27\" ry=\"18\"/>\n<text text-anchor=\"middle\" x=\"254\" y=\"-14.3\" font-family=\"Times New Roman,serif\" font-size=\"14.00\">list</text>\n</g>\n<!-- n4&#45;&gt;n18 -->\n<g id=\"edge17\" class=\"edge\">\n<title>n4&#45;&gt;n18</title>\n<path fill=\"none\" stroke=\"black\" d=\"M254,-71.7C254,-63.98 254,-54.71 254,-46.11\"/>\n<polygon fill=\"black\" stroke=\"black\" points=\"257.5,-46.1 254,-36.1 250.5,-46.1 257.5,-46.1\"/>\n</g>\n<!-- n19 -->\n<g id=\"node19\" class=\"node\">\n<title>n19</title>\n<ellipse fill=\"none\" stroke=\"black\" cx=\"343\" cy=\"-18\" rx=\"44.39\" ry=\"18\"/>\n<text text-anchor=\"middle\" x=\"343\" y=\"-14.3\" font-family=\"Times New Roman,serif\" font-size=\"14.00\">bytearray</text>\n</g>\n<!-- n4&#45;&gt;n19 -->\n<g id=\"edge18\" class=\"edge\">\n<title>n4&#45;&gt;n19</title>\n<path fill=\"none\" stroke=\"black\" d=\"M276,-71.7C287.99,-62.26 302.94,-50.51 315.68,-40.49\"/>\n<polygon fill=\"black\" stroke=\"black\" points=\"317.97,-43.14 323.67,-34.2 313.65,-37.63 317.97,-43.14\"/>\n</g>\n<!-- n9 -->\n<g id=\"node9\" class=\"node\">\n<title>n9</title>\n<ellipse fill=\"none\" stroke=\"black\" cx=\"345\" cy=\"-90\" rx=\"27\" ry=\"18\"/>\n<text text-anchor=\"middle\" x=\"345\" y=\"-86.3\" font-family=\"Times New Roman,serif\" font-size=\"14.00\">int</text>\n</g>\n<!-- n5&#45;&gt;n9 -->\n<g id=\"edge8\" class=\"edge\">\n<title>n5&#45;&gt;n9</title>\n<path fill=\"none\" stroke=\"black\" d=\"M461.91,-147.83C437.35,-135.89 401.18,-118.31 375.58,-105.87\"/>\n<polygon fill=\"black\" stroke=\"black\" points=\"376.86,-102.6 366.34,-101.37 373.8,-108.89 376.86,-102.6\"/>\n</g>\n<!-- n10 -->\n<g id=\"node10\" class=\"node\">\n<title>n10</title>\n<ellipse fill=\"none\" stroke=\"black\" cx=\"417\" cy=\"-90\" rx=\"27.1\" ry=\"18\"/>\n<text text-anchor=\"middle\" x=\"417\" y=\"-86.3\" font-family=\"Times New Roman,serif\" font-size=\"14.00\">bool</text>\n</g>\n<!-- n5&#45;&gt;n10 -->\n<g id=\"edge9\" class=\"edge\">\n<title>n5&#45;&gt;n10</title>\n<path fill=\"none\" stroke=\"black\" d=\"M471.2,-143.7C461.51,-134.28 449.44,-122.53 439.14,-112.53\"/>\n<polygon fill=\"black\" stroke=\"black\" points=\"441.3,-109.74 431.69,-105.28 436.42,-114.76 441.3,-109.74\"/>\n</g>\n<!-- n11 -->\n<g id=\"node11\" class=\"node\">\n<title>n11</title>\n<ellipse fill=\"none\" stroke=\"black\" cx=\"489\" cy=\"-90\" rx=\"27\" ry=\"18\"/>\n<text text-anchor=\"middle\" x=\"489\" y=\"-86.3\" font-family=\"Times New Roman,serif\" font-size=\"14.00\">float</text>\n</g>\n<!-- n5&#45;&gt;n11 -->\n<g id=\"edge10\" class=\"edge\">\n<title>n5&#45;&gt;n11</title>\n<path fill=\"none\" stroke=\"black\" d=\"M489,-143.7C489,-135.98 489,-126.71 489,-118.11\"/>\n<polygon fill=\"black\" stroke=\"black\" points=\"492.5,-118.1 489,-108.1 485.5,-118.1 492.5,-118.1\"/>\n</g>\n<!-- n12 -->\n<g id=\"node12\" class=\"node\">\n<title>n12</title>\n<ellipse fill=\"none\" stroke=\"black\" cx=\"576\" cy=\"-90\" rx=\"42.49\" ry=\"18\"/>\n<text text-anchor=\"middle\" x=\"576\" y=\"-86.3\" font-family=\"Times New Roman,serif\" font-size=\"14.00\">complex</text>\n</g>\n<!-- n5&#45;&gt;n12 -->\n<g id=\"edge11\" class=\"edge\">\n<title>n5&#45;&gt;n12</title>\n<path fill=\"none\" stroke=\"black\" d=\"M510.51,-143.7C522.23,-134.26 536.84,-122.51 549.29,-112.49\"/>\n<polygon fill=\"black\" stroke=\"black\" points=\"551.51,-115.2 557.11,-106.2 547.12,-109.74 551.51,-115.2\"/>\n</g>\n<!-- n13 -->\n<g id=\"node13\" class=\"node\">\n<title>n13</title>\n<ellipse fill=\"none\" stroke=\"black\" cx=\"663\" cy=\"-90\" rx=\"27\" ry=\"18\"/>\n<text text-anchor=\"middle\" x=\"663\" y=\"-86.3\" font-family=\"Times New Roman,serif\" font-size=\"14.00\">set</text>\n</g>\n<!-- n6&#45;&gt;n13 -->\n<g id=\"edge12\" class=\"edge\">\n<title>n6&#45;&gt;n13</title>\n<path fill=\"none\" stroke=\"black\" d=\"M630.63,-143.7C635.78,-135.32 642.05,-125.1 647.71,-115.9\"/>\n<polygon fill=\"black\" stroke=\"black\" points=\"650.83,-117.5 653.08,-107.14 644.87,-113.83 650.83,-117.5\"/>\n</g>\n<!-- n14 -->\n<g id=\"node14\" class=\"node\">\n<title>n14</title>\n<ellipse fill=\"none\" stroke=\"black\" cx=\"752\" cy=\"-90\" rx=\"44.39\" ry=\"18\"/>\n<text text-anchor=\"middle\" x=\"752\" y=\"-86.3\" font-family=\"Times New Roman,serif\" font-size=\"14.00\">frozenset</text>\n</g>\n<!-- n6&#45;&gt;n14 -->\n<g id=\"edge13\" class=\"edge\">\n<title>n6&#45;&gt;n14</title>\n<path fill=\"none\" stroke=\"black\" d=\"M652.29,-143.88C672.01,-133.42 697.23,-120.04 717.37,-109.37\"/>\n<polygon fill=\"black\" stroke=\"black\" points=\"719.03,-112.45 726.22,-104.67 715.75,-106.26 719.03,-112.45\"/>\n</g>\n</g>\n</svg>\n",
      "text/plain": [
       "<graphviz.graphs.Digraph at 0x2abe6bfeed0>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d = Digraph()\n",
    "d.attr('node', shape='box')\n",
    "d.node('n1', 'Иерархия типов данных')\n",
    "d.node('n2', 'Последовательности')\n",
    "d.node('n3', 'Неизменяемые')\n",
    "d.node('n4', 'Изменяемые')\n",
    "d.node('n5', 'Числа')\n",
    "d.node('n6', 'Множества')\n",
    "d.attr('node', shape='oval')\n",
    "d.node('n7', 'None')\n",
    "d.node('n8', 'dict')\n",
    "d.node('n9', 'int')\n",
    "d.node('n10', 'bool')\n",
    "d.node('n11', 'float')\n",
    "d.node('n12', 'complex')\n",
    "d.node('n13', 'set')\n",
    "d.node('n14', 'frozenset')\n",
    "d.node('n15', 'str')\n",
    "d.node('n16', 'tuple')\n",
    "d.node('n17', 'bytes')\n",
    "d.node('n18', 'list')\n",
    "d.node('n19', 'bytearray')\n",
    "edge(d, 'n1', 'n2 n5 n6 n7 n8')\n",
    "edge(d, 'n2', 'n3 n4')\n",
    "edge(d, 'n5', 'n9 n10 n11 n12')\n",
    "edge(d, 'n6', 'n13 n14')\n",
    "edge(d, 'n3', 'n15 n16 n17')\n",
    "edge(d, 'n4', 'n18 n19')\n",
    "d"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "К изменяемым типам данных относятся:\n",
    "* список `list`,\n",
    "* словарь `dict`,\n",
    "* множество `set`,\n",
    "* байтовый массив `bytearray`.\n",
    "\n",
    "В Питоне некоторые типы данных имеют общее название — последовательности. Существует ряд общих операций, применимых для всех последовательностей: обращение по индексу, получение длины и другие.\n",
    "\n",
    "К типам-последовательностям относятся:\n",
    "* строка `str`,\n",
    "* список `list`,\n",
    "* кортеж `tuple`,\n",
    "* байтовая последовательность `bytes`,\n",
    "* байтовый массив `bytearray`.\n",
    "\n",
    "Для создания и преобразования объектов различных типов могут быть использованы встроенные функции. Ниже приведены некоторые примеры работы этих функций.\n",
    "\n",
    "```Python\n",
    "str(42) = '42'\n",
    "int('0123') = 123\n",
    "list('0123') = ['0', '1', '2', '3']\n",
    "tuple('0123') = ('0', '1', '2', '3')\n",
    "str([-1, 1]) = '[-1, 1]'\n",
    "tuple([-1, 1]) = (-1, 1)\n",
    "str((2, 4)) = '(2, 4)'\n",
    "list((2, 4)) = [2, 4]\n",
    "str({'a': 1, 'b': 2}) = \"{'a': 1, 'b': 2}\"\n",
    "list({'a': 1, 'b': 2}) = ['a', 'b']\n",
    "tuple({'a': 1, 'b': 2}) = ('a', 'b')\n",
    "```\n",
    "\n",
    "В практике прикладного программирования на Питоне среди упомянутых выше новых типов данных наиболее популярны строки, списки, кортежи и словари. Работу с этими типами данных нужно изучить в первую очередь.\n",
    "\n",
    "В Питоне есть средства для создания пользовательских типов данных. Кроме рассматриваемых здесь встроенных типов данных существуют прикладные типы данных, реализованные на уровне стандартной библиотеки."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ничто или None\n",
    "\n",
    "Тип `NoneType` имеет единственный элемент `None`, который обозначает отсутствие или необязательность значения. При вычислении условий `None` трактуется, как `False`.\n",
    "\n",
    "Функция, в которой явно не задано возвращаемое значение, возвращает `None`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'NoneType'>\n"
     ]
    }
   ],
   "source": [
    "def f():\n",
    "    pass\n",
    "\n",
    "print(type(f()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Обратите внимание, что в Питоне не разрешено использовать пустые блоки. Нужного эффекта, как показано выше, можно добиться с помощью ключевого слова `pass`.\n",
    "\n",
    "Для определения констант нет специального синтаксиса, но, по соглашению, имена переменных, используемых в качестве констант, записываются в верхнем регистре:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "MAX_SIZE = 100"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Строки\n",
    "\n",
    "Строки могут быть записаны различными способами:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "s1 = 'строка в одинарных кавычках'\n",
    "s2 = \"строка в двойных кавычках\"\n",
    "s3 = '''\n",
    "многострочный\n",
    "текст\n",
    "'''\n",
    "s4 = \"\"\"\n",
    "другой\n",
    "многострочный\n",
    "текст\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Строковой литерал с тройными кавычками можно также использовать для определения многострочного комментария.\n",
    "\n",
    "Строковой литерал в начале тела функции играет роль документации (docstring):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def some_function():\n",
    "    '''\n",
    "    Эта функция еще не реализована.\n",
    "    '''\n",
    "    return 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Документацию по выбранной функции можно получить с помощью `help()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function some_function in module __main__:\n",
      "\n",
      "some_function()\n",
      "    Эта функция еще не реализована.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(some_function)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function max in module builtins:\n",
      "\n",
      "max(...)\n",
      "    max(iterable, *[, default=obj, key=func]) -> value\n",
      "    max(arg1, arg2, *args, *[, key=func]) -> value\n",
      "    \n",
      "    With a single iterable argument, return its biggest item. The\n",
      "    default keyword-only argument specifies an object to return if\n",
      "    the provided iterable is empty.\n",
      "    With two or more arguments, return the largest argument.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(max)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Строки представляют собой последовательности значений Юникода. В Питоне отсутствует отдельный тип символа (char), вместо него используются строки единичной длины.\n",
    "\n",
    "Для получения символа по его коду и кода по символу имеются соответствующие функции:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 48\n"
     ]
    }
   ],
   "source": [
    "print(chr(48), ord('0'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "С использованием ключевого слова in можно проверить наличие заданной подстроки в строке:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'two' in 'one,two,tree'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'four' not in 'one,two,tree'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Важно помнить, что строку нельзя модифицировать:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "s = 'python'\n",
    "# s[0] = 'P' приведет к ошибке"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Вместо модификации текущей строки необходимо создать новую строку из уже имеющихся:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Python'"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'P' + s[1:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Срезы"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В примере выше использовалась очень популярная операция над последовательностями в Питоне — взятие среза.\n",
    "\n",
    "В срезе s[i:j] полученная подпоследовательность включает в себя элементы с индексами из $[i, j)$.\n",
    "\n",
    "Проиллюстрируем работу срезов на примерах:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ython'"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[1:] # от s[1] до s[len(s) - 1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'pyt'"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[:3] # от s[0] до s[2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Индекс -1 обозначает индекс последнего элемента последовательности. В общем случае обращение по отрицательному индексу `s[-i]` трактуется, как `s[len(s) - i]`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('n', 'ytho', 'ytho')"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[-1], s[-5:-1], s[len(s) - 5:len(s) - 1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ytho'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[1:-1] # от s[1] до s[len(s) - 2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'pto'"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[::2] # от s[0] до s[len(s) - 1] с шагом 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Для неизменяемой последовательности, примером которой является строка, определен ряд общих операций:\n",
    "\n",
    "| Операция         | Описание                                |\n",
    "|------------------|-----------------------------------------|\n",
    "|      x in s      | Проверка на наличие x в s             |\n",
    "|    x not in s    | Проверка на отсутствие x в s            |\n",
    "|      s1 + s2     | Соединение последовательностей          |\n",
    "| s * n            | Последовательность из n повторений s    |\n",
    "| s[i]             | Получение элемента по индексу           |\n",
    "| s[i:j], s[i:j:k] | Получение подпоследовательности (среза) |\n",
    "| len(s)           | Длина s                                 |\n",
    "| max(s), min(s)   | Максимальный/минимальный элемент в s    |\n",
    "| s.index(x)       | Индекс первого вхождения x в s          |\n",
    "| s.count(x)       | Количество вхождений x в s              |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Для экранирования специальных символов в Питоне используются знакомые программистам на C++ средства:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "first\n",
      "second\n"
     ]
    }
   ],
   "source": [
    "print('first\\nsecond')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "При необходимости, интерпретацию специальных символов можно отключить при использовании строкового литерала с префиксом r:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "first\\nsecond\n"
     ]
    }
   ],
   "source": [
    "print(r'first\\nsecond')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В функции `print` могут использоваться дополнительные именованные аргументы:\n",
    "* `sep` для разделения обычных аргументов заданной строкой,\n",
    "* `end` для указания окончания строки при выводе на экран. Позволяет выводить текст без перевода на новую строку."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "логин:пароль:почта\n",
      "начало...завершение\n"
     ]
    }
   ],
   "source": [
    "print('логин', 'пароль', 'почта', sep=':')\n",
    "print('начало', end='...')\n",
    "print('завершение')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В цикле `for`, помимо итератора `range()` может использоваться и значение типа последовательность, как показано в примере ниже."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "P Y T H O N "
     ]
    }
   ],
   "source": [
    "for c in s:\n",
    "    print(c.upper(), end=' ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Следует избегать построения длинных строк с помощью тяжеловесной операции `+` (конкатенации). Большей производительности можно достичь с помощью метода `join()`, как показано ниже:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'АБВГДЕЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯ'"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "alpha = range(ord('А'), ord('Я') + 1)\n",
    "''.join([chr(c) for c in alpha])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Описание других методов для работы со строками в Питоне можно найти в [официальной документации](https://docs.python.org/3/library/stdtypes.html#string-methods)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Форматирование строк"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В Питоне имеется несколько способов форматирования строк. В частности, поддерживается форматирование в стиле printf из С/C++, с использованием операции `%`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x: 42\n",
      "значения: python, 1.23\n"
     ]
    }
   ],
   "source": [
    "x = 42\n",
    "pi = 3.14159265359\n",
    "print('x: %d' % x)\n",
    "print('значения: %s, %.2f' % (s, 1.2345))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Также может использоваться строковой метод `format()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "значения: python, 42, 3.14\n",
      "значения: python, 42, 3.14\n"
     ]
    }
   ],
   "source": [
    "print('значения: {:s}, {:d}, {:.2f}'.format(s, x, pi))\n",
    "print('значения: {s:s}, {x:d}, {pi:.2f}'.format(s=s, x=x, pi=pi))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Все большую популярность приобретает еще один метод форматирования — с помощью f-строк:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "значения: python, 42, 3.14\n"
     ]
    }
   ],
   "source": [
    "print(f'значения: {s:s}, {x:d}, {pi:.2f}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В случае f-строк лучше не перегружать шаблон форматирования кодом на Питоне, поскольку это ухудшает читаемость программы.\n",
    "\n",
    "Подробности о языке форматирования строк приведены в [официальной документации](https://docs.python.org/3/library/string.html#formatstrings)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Списки\n",
    "\n",
    "Список в Питоне имеет обманчивое название. Это не связный список, а динамический массив, элементами которого могут выступать объекты произвольных типов.\n",
    "\n",
    "Важно учитывать, что списки являются изменяемыми и передаются по ссылке, а не по значению, как показано в примере ниже."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['список', [1, 2], [1, 2]]\n",
      "['список', [None, 2], [None, 2]]\n"
     ]
    }
   ],
   "source": [
    "s1 = [1, 2]\n",
    "s2 = ['список', s1, s1]\n",
    "print(s2)\n",
    "s1[0] = None\n",
    "print(s2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Рассмотренная в примере ситуация изображена на картинке ниже.\n",
    "\n",
    "![](images/list_objects.png)\n",
    "\n",
    "Попробуйте поэкспериментировать со списками с помощью сайта [pythontutor.com](http://pythontutor.com/).\n",
    "\n",
    "По возможности, следует использовать неизменяемые типы данных, поскольку, как видно в примере выше, модификация списка может привести к неожиданным результатам и ошибкам, которые, зачастую, трудно обнаружить. В частности, не следует модифицировать список в цикле прохода по элементам этого списка."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Для списков и других изменяемых последовательностей используются те же общие операции, что и для строк, а также иных неизменяемых последовательностей. Кроме того, существует ряд операций, специально предназначенных для изменяемых последовательностей:\n",
    "\n",
    "| Операция                           | Описание                                        |\n",
    "|------------------------------------|-------------------------------------------------|\n",
    "|              s[i] = x              | Заменить элемент по индексу                     |\n",
    "|    s1[i:j] = s2, s1[i:j:k] = s2    | Переписать срез              |\n",
    "| del s[i], del s[i:j], del s[i:j:k] | Удалить элемент или срез       |\n",
    "| s.append(x)                        | Добавить в конец s элемент x                    |\n",
    "| s.clear()                          | Удалить все элементы из s                       |\n",
    "| s[:], s.copy()                     | Получить копию s (копируются ссылки на объекты) |\n",
    "| s1 += s2, s1.extend(s2)            | Добавить к s1 последовательность s2             |\n",
    "| s.insert(i, x)                     | Вставить x в s по индексу                       |\n",
    "| s.pop(), s.pop(i)                           | Вытолкнуть последний элемент из s или по индексу              |\n",
    "| s.remove(x)                        | Удалить первое вхождение x из s                 |\n",
    "| s.reverse()                        | Обратить последовательность                     |\n",
    "\n",
    "Следующие операции над списком имеют вычислительную сложность O(1):\n",
    "* `s.append(x)`,\n",
    "* `s.pop()`,\n",
    "* `s[i]`,\n",
    "* `s[i] = x`,\n",
    "* `len(s)`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Списковые включения\n",
    "\n",
    "Списковые включения в Питоне представляют собой способ компактного описания порождения списка. Нотация вдохновлена математической записью для построения множества, а также языком программирования SETL.\n",
    "\n",
    "В математике множество квадратов чисел от 1 до 9 можно определить, как\n",
    "\n",
    "$$\n",
    "\\{n^2: \\forall n \\in N, 1 \\le n \\lt 10 \\}\n",
    "$$\n",
    "\n",
    "В Питоне список, который содержит приведенное выше множество чисел, можно описать следующим образом:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 4, 9, 16, 25, 36, 49, 64, 81]"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[n ** 2 for n in range(1, 10)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "При генерации списка можно указать дополнительное условие, как показано в примере ниже:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 4, 6, 8]"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Список четных чисел в заданном диапазоне\n",
    "[n for n in range(1, 10) if n % 2 == 0]"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Упрощенный шаблон спискового включения выглядит так:\n",
    "\n",
    "```Python\n",
    "[выражение for переменная in последовательность if условие]\n",
    "```\n",
    "\n",
    "Это соответствует следующему псевдокоду:\n",
    "\n",
    "```Python\n",
    "результат = []\n",
    "for переменная in последовательность:\n",
    "    if условие:\n",
    "        результат.append(выражение)\n",
    "```\n",
    "\n",
    "Реальный синтаксис спискового включения сложнее, поскольку допускает вложенность, которой иногда программисты злоупотребляют.\n",
    "\n",
    "Далее представлена железнодорожная диаграмма синтаксиса включения (`включение-for`). Этот синтаксис является общим для порождения списков, словарей и множеств."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/svg+xml": "<svg xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\" class=\"railroad-diagram\" height=\"100\" viewBox=\"0 0 772.5 100\" width=\"772.5\">\n<style>/* <![CDATA[ */\n\tsvg.railroad-diagram {\n\t\tbackground-color:hsl(30,20%,95%);\n\t}\n\tsvg.railroad-diagram path {\n\t\tstroke-width:3;\n\t\tstroke:black;\n\t\tfill:rgba(0,0,0,0);\n\t}\n\tsvg.railroad-diagram text {\n\t\tfont:bold 14px monospace;\n\t\ttext-anchor:middle;\n\t}\n\tsvg.railroad-diagram text.label{\n\t\ttext-anchor:start;\n\t}\n\tsvg.railroad-diagram text.comment{\n\t\tfont:italic 12px monospace;\n\t}\n\tsvg.railroad-diagram rect{\n\t\tstroke-width:3;\n\t\tstroke:black;\n\t\tfill:hsl(120,100%,90%);\n\t}\n\tsvg.railroad-diagram rect.group-box {\n\t\tstroke: gray;\n\t\tstroke-dasharray: 10 5;\n\t\tfill: none;\n\t}\n\n/* ]]> */\n</style><g transform=\"translate(.5 .5)\">\n<g>\n<path d=\"M20 59v20m10 -20v20m-10 -10h20\"/></g><path d=\"M40 69h10\"/><g>\n<path d=\"M50 69h0.0\"/><path d=\"M722.5 69h0.0\"/><g class=\"terminal \">\n<path d=\"M50.0 69h0.0\"/><path d=\"M146.5 69h0.0\"/><rect height=\"22\" rx=\"10\" ry=\"10\" width=\"96.5\" x=\"50\" y=\"58\"/><text x=\"98.25\" y=\"73\">выражение</text></g><path d=\"M146.5 69h10\"/><path d=\"M156.5 69h10\"/><g class=\"terminal \">\n<path d=\"M166.5 69h0.0\"/><path d=\"M212.0 69h0.0\"/><rect height=\"22\" rx=\"10\" ry=\"10\" width=\"45.5\" x=\"166.5\" y=\"58\"/><text x=\"189.25\" y=\"73\">for</text></g><path d=\"M212.0 69h10\"/><path d=\"M222.0 69h10\"/><g class=\"terminal \">\n<path d=\"M232.0 69h0.0\"/><path d=\"M328.5 69h0.0\"/><rect height=\"22\" rx=\"10\" ry=\"10\" width=\"96.5\" x=\"232\" y=\"58\"/><text x=\"280.25\" y=\"73\">выражение</text></g><path d=\"M328.5 69h10\"/><path d=\"M338.5 69h10\"/><g class=\"terminal \">\n<path d=\"M348.5 69h0.0\"/><path d=\"M385.5 69h0.0\"/><rect height=\"22\" rx=\"10\" ry=\"10\" width=\"37\" x=\"348.5\" y=\"58\"/><text x=\"367\" y=\"73\">in</text></g><path d=\"M385.5 69h10\"/><path d=\"M395.5 69h10\"/><g class=\"terminal \">\n<path d=\"M405.5 69h0.0\"/><path d=\"M502.0 69h0.0\"/><rect height=\"22\" rx=\"10\" ry=\"10\" width=\"96.5\" x=\"405.5\" y=\"58\"/><text x=\"453.75\" y=\"73\">выражение</text></g><path d=\"M502.0 69h10\"/><g>\n<path d=\"M512.0 69h0.0\"/><path d=\"M722.5 69h0.0\"/><path d=\"M512.0 69a10 10 0 0 0 10 -10v-29a10 10 0 0 1 10 -10\"/><g>\n<path d=\"M532.0 20h170.5\"/></g><path d=\"M702.5 20a10 10 0 0 1 10 10v29a10 10 0 0 0 10 10\"/><path d=\"M512.0 69h20\"/><g>\n<path d=\"M532.0 69h0.0\"/><path d=\"M702.5 69h0.0\"/><path d=\"M532.0 69a10 10 0 0 0 10 -10v-10a10 10 0 0 1 10 -10\"/><g class=\"terminal \">\n<path d=\"M552.0 39h0.0\"/><path d=\"M682.5 39h0.0\"/><rect height=\"22\" rx=\"10\" ry=\"10\" width=\"130.5\" x=\"552\" y=\"28\"/><text x=\"617.25\" y=\"43\">включение for</text></g><path d=\"M682.5 39a10 10 0 0 1 10 10v10a10 10 0 0 0 10 10\"/><path d=\"M532.0 69h20\"/><g class=\"terminal \">\n<path d=\"M552.0 69h4.25\"/><path d=\"M678.25 69h4.25\"/><rect height=\"22\" rx=\"10\" ry=\"10\" width=\"122\" x=\"556.25\" y=\"58\"/><text x=\"617.25\" y=\"73\">включение if</text></g><path d=\"M682.5 69h20\"/></g><path d=\"M702.5 69h20\"/></g></g><path d=\"M722.5 69h10\"/><path d=\"M 732.5 69 h 20 m -10 -10 v 20 m 10 -20 v 20\"/></g></svg>",
      "text/plain": [
       "<IPython.core.display.SVG object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "show_diagram(Sequence('выражение', 'for', 'выражение', 'in', 'выражение',\n",
    "             Optional(Choice(1, 'включение for', 'включение if'))))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Часть `включение if`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/svg+xml": "<svg xmlns=\"http://www.w3.org/2000/svg\" xmlns:xlink=\"http://www.w3.org/1999/xlink\" class=\"railroad-diagram\" height=\"100\" viewBox=\"0 0 474.0 100\" width=\"474.0\">\n<style>/* <![CDATA[ */\n\tsvg.railroad-diagram {\n\t\tbackground-color:hsl(30,20%,95%);\n\t}\n\tsvg.railroad-diagram path {\n\t\tstroke-width:3;\n\t\tstroke:black;\n\t\tfill:rgba(0,0,0,0);\n\t}\n\tsvg.railroad-diagram text {\n\t\tfont:bold 14px monospace;\n\t\ttext-anchor:middle;\n\t}\n\tsvg.railroad-diagram text.label{\n\t\ttext-anchor:start;\n\t}\n\tsvg.railroad-diagram text.comment{\n\t\tfont:italic 12px monospace;\n\t}\n\tsvg.railroad-diagram rect{\n\t\tstroke-width:3;\n\t\tstroke:black;\n\t\tfill:hsl(120,100%,90%);\n\t}\n\tsvg.railroad-diagram rect.group-box {\n\t\tstroke: gray;\n\t\tstroke-dasharray: 10 5;\n\t\tfill: none;\n\t}\n\n/* ]]> */\n</style><g transform=\"translate(.5 .5)\">\n<g>\n<path d=\"M20 59v20m10 -20v20m-10 -10h20\"/></g><path d=\"M40 69h10\"/><g>\n<path d=\"M50 69h0.0\"/><path d=\"M424.0 69h0.0\"/><g class=\"terminal \">\n<path d=\"M50.0 69h0.0\"/><path d=\"M87.0 69h0.0\"/><rect height=\"22\" rx=\"10\" ry=\"10\" width=\"37\" x=\"50\" y=\"58\"/><text x=\"68.5\" y=\"73\">if</text></g><path d=\"M87.0 69h10\"/><path d=\"M97.0 69h10\"/><g class=\"terminal \">\n<path d=\"M107.0 69h0.0\"/><path d=\"M203.5 69h0.0\"/><rect height=\"22\" rx=\"10\" ry=\"10\" width=\"96.5\" x=\"107\" y=\"58\"/><text x=\"155.25\" y=\"73\">выражение</text></g><path d=\"M203.5 69h10\"/><g>\n<path d=\"M213.5 69h0.0\"/><path d=\"M424.0 69h0.0\"/><path d=\"M213.5 69a10 10 0 0 0 10 -10v-29a10 10 0 0 1 10 -10\"/><g>\n<path d=\"M233.5 20h170.5\"/></g><path d=\"M404.0 20a10 10 0 0 1 10 10v29a10 10 0 0 0 10 10\"/><path d=\"M213.5 69h20\"/><g>\n<path d=\"M233.5 69h0.0\"/><path d=\"M404.0 69h0.0\"/><path d=\"M233.5 69a10 10 0 0 0 10 -10v-10a10 10 0 0 1 10 -10\"/><g class=\"terminal \">\n<path d=\"M253.5 39h0.0\"/><path d=\"M384.0 39h0.0\"/><rect height=\"22\" rx=\"10\" ry=\"10\" width=\"130.5\" x=\"253.5\" y=\"28\"/><text x=\"318.75\" y=\"43\">включение for</text></g><path d=\"M384.0 39a10 10 0 0 1 10 10v10a10 10 0 0 0 10 10\"/><path d=\"M233.5 69h20\"/><g class=\"terminal \">\n<path d=\"M253.5 69h4.25\"/><path d=\"M379.75 69h4.25\"/><rect height=\"22\" rx=\"10\" ry=\"10\" width=\"122\" x=\"257.75\" y=\"58\"/><text x=\"318.75\" y=\"73\">включение if</text></g><path d=\"M384.0 69h20\"/></g><path d=\"M404.0 69h20\"/></g></g><path d=\"M424.0 69h10\"/><path d=\"M 434.0 69 h 20 m -10 -10 v 20 m 10 -20 v 20\"/></g></svg>",
      "text/plain": [
       "<IPython.core.display.SVG object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "show_diagram(Sequence('if', 'выражение', Optional(Choice(1, 'включение for', 'включение if'))))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В Питоне отсутствует встроенный тип многомерного массива. Тем не менее, имитировать многомерный массив можно с помощью вкладывания обычных списков друг в друга, как показано в примере ниже."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "arr[0,0]=0 arr[0,1]=0 arr[0,2]=0 arr[0,3]=0 arr[0,4]=0 \n",
      "arr[1,0]=0 arr[1,1]=1 arr[1,2]=2 arr[1,3]=3 arr[1,4]=4 \n",
      "arr[2,0]=0 arr[2,1]=2 arr[2,2]=4 arr[2,3]=6 arr[2,4]=8 \n"
     ]
    }
   ],
   "source": [
    "arr = [[x * y for x in range(5)] for y in range(3)]\n",
    "for y in range(3):\n",
    "    for x in range(5):\n",
    "        print(f'arr[{y},{x}]={arr[y][x]}', end=' ')\n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Кортежи\n",
    "\n",
    "Кортеж является неизменяемым вариантом списка. Запись кортежа имеет особенности, как показано далее."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 2)"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Пустой кортеж\n",
    "() \n",
    "# Кортеж из одного элемента,\n",
    "# запятая нужна, чтобы отличать от выражения в скобках\n",
    "('single',) \n",
    "# Еще один кортеж\n",
    "(1, 2, [\"three\", 4])\n",
    "# Скобки можно опустить, важны запятые\n",
    "1, 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Последний из вышеприведенных примеров показывает, как в Питоне реализовано возвращение нескольких результатов из функции. Это делается с помощью кортежа:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3, -1) <class 'tuple'>\n"
     ]
    }
   ],
   "source": [
    "def addsub(x, y):\n",
    "    return x + y, x - y\n",
    "\n",
    "print(addsub(1, 2), type(addsub(1, 2)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "С помощью кортежей можно организовать множественное присваивание значений переменных:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python 30\n",
      "dynamic strong\n"
     ]
    }
   ],
   "source": [
    "data = ['Python', ('strong', 'dynamic'), 30]\n",
    "language, (ty1, ty2), value = data\n",
    "print(language, value)\n",
    "ty1, ty2 = ty2, ty1\n",
    "print(ty1, ty2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Множественное присваивание удобно использовать в цикле `for` с итератором `enumerate()`, позволяющим получить как индекс, так и значение для элементов последовательности:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0:a 1:b 2:c 3:d 4:e 5:f "
     ]
    }
   ],
   "source": [
    "for i, x in enumerate('abcdef'):\n",
    "    print(i, x, sep=':', end=' ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Словари\n",
    "\n",
    "Словарь в Питоне представляет собой изменяемую хеш-таблицу. Ключом в словаре может быть любое хешируемое значение (для которого можно использовать встроенную функцию `hash()`). На практике это означает, что ключом должен быть неизменяемый объект (элементы которого тоже неизменяемы), такой, например, как строка. \n",
    "\n",
    "Ниже показаны различные способы определения словаря: с помощью перечисление пар ключ-значения, с помощью аналога спискового включения для словарей и с помощью конструктора `dict`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'language': 'Python', 'score': 1.0}\n",
      "{'language': 'Python', 'score': 1.0}\n",
      "{'language': 'Python', 'score': 1.0}\n"
     ]
    }
   ],
   "source": [
    "{} # Пустой словарь\n",
    "print({'language':'Python', 'score': 1.0})\n",
    "print({k: v for k, v in [('language', 'Python'), ('score', 1.0)]})\n",
    "print(dict(language='Python', score=1.0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Следующие операции над словарем в Питоне имеют вычислительную сложность O(1):\n",
    "* `k in d`,\n",
    "* `d[k]`,\n",
    "* `d[k] = x`,\n",
    "* `del d[k]`.\n",
    "\n",
    "Порядок вставленных элементов по ключу в словаре в новых версиях языка (старше 3.6) сохраняется:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tree 3\n",
      "two 2\n",
      "one 1\n"
     ]
    }
   ],
   "source": [
    "d = {}\n",
    "d['tree'] = 3\n",
    "d['two'] = 2\n",
    "d['one'] = 1\n",
    "for k, v in d.items(): # аналог enumerate() для словаря\n",
    "    print(k, v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Обращение по несуществующему ключу в словаре вызывает ошибку (исключение). Метод `get()` удобно использовать в тех случаях, когда при обращении по новому ключу достаточно подставить значение по умолчанию, не изменяя словарь:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a 1 b 2 c 3 "
     ]
    }
   ],
   "source": [
    "d = dict(a=1, b=2)\n",
    "for k in 'abc':\n",
    "    print(k, d.get(k, 3), end=' ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Множества\n",
    "\n",
    "Тип множество понимается в математическом смысле — как коллекция неупорядоченных объектов. Задается множество, аналогично словарю, с помощью фигурных скобок, но без указания ключей. При это многие операции имеют названия, отличные от общих для типов-последовательностей:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Kaspersky', 'Yandex', 'MCST'} True {'Kaspersky', 'Yandex'}\n"
     ]
    }
   ],
   "source": [
    "firms = {'Yandex', 'Yandex', 'JetBrains', 'MCST'}\n",
    "set(['Yandex', 'JetBrains', 'MCST']) # еще один вариант определения множества\n",
    "firms.add('Kaspersky')\n",
    "firms.remove('JetBrains')\n",
    "print(firms, 'Kaspersky' in firms, {x for x in firms if 'a' in x})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Над типом множество поддерживаются также операции объединения, пересечения и другие операции, описание которых приведено в [официальной документации](https://docs.python.org/3/library/stdtypes.html#set-types-set-frozenset)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Идентичность объектов\n",
    "\n",
    "Как мы уже знаем, Питон оперирует объектами различных типов. Помимо типа и значения, каждый объект характеризуется уникальным числом — в реализации CPython это адрес объекта в памяти. Для получения адреса используется встроенная функция `id()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1, 2], [1, 2], [1, 2]] ['0x1da0018e400', '0x1da0018e400', '0x1da001e1400']\n"
     ]
    }
   ],
   "source": [
    "s1, s2 = [1, 2], [1, 2]\n",
    "s3 = [s1, s1, s2]\n",
    "print(s3, [hex(id(x)) for x in s3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "С помощью проверки адресов можно установить идентичность двух объектов. Для этого используется операция `x is y`, которая эквивалентна следующему выражению: `id(x) == id(y)`. При этом надо различать проверку на равенство (`==`) и на идентичность (`is`):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(True, False)"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s1 == s2, s1 is s2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В прикладных программах `is` наиболее часто используется для сравнения с `None`. Поскольку `None` является уникальным объектом, то принято писать `x is None` или `x is not None`, вместо `x == None` или `x != None`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Еще раз о функциях\n",
    "\n",
    "В Питоне аргументы функции передаются по ссылке, а не копируются при вызове функции. Аргументы и определенные внутри функции переменные попадают в локальную область видимости функции (`locals()`). \n",
    "\n",
    "Иногда возникает необходимость изменить глобальные данные из функции. Это можно сделать с помощью ключевого слова `global`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 3\n"
     ]
    }
   ],
   "source": [
    "Counter = 0\n",
    "\n",
    "def f():\n",
    "    # без этого объявления речь шла об увеличении локальной переменной\n",
    "    global Counter \n",
    "    Counter += 1\n",
    "    return Counter\n",
    "    \n",
    "print(f(), f(), f(), Counter)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "При этом использование `global`, как и в других языках, не является признаком хорошего тона. С помощью функций, классов и модулей в большинстве случаев удается обойтись без модификации глобальных объектов."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Вызывать функцию можно как с позиционными (тот вариант, который мы использовали ранее), так и с именованными аргументами:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Иван: 20, Михаил: 19\n"
     ]
    }
   ],
   "source": [
    "def f(name, age):\n",
    "    return f'{name}: {age}'\n",
    "    \n",
    "print(f('Иван', 20), f(name='Михаил', age=19), sep=', ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В функциях могут использоваться аргументы по умолчанию. Они располагаются после всех обязательных аргументов:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Иван: 20, Михаил: 19\n"
     ]
    }
   ],
   "source": [
    "def f(name, age=20):\n",
    "    return f'{name}: {age}'\n",
    "    \n",
    "print(f('Иван'), f(name='Михаил', age=19), sep=', ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Аргументы по умолчанию получают свои значения во время определения функции. В результате может сложиться проблемная ситуация, как в примере ниже:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[0, 1, 2, 3], [0, 1, 2, 3], [0, 1, 2, 3], [0, 1, 2, 3]]"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def f(lst=[]):\n",
    "    lst.append(len(lst))\n",
    "    return lst\n",
    "\n",
    "[f() for i in range(4)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Чтобы избежать неочевидного поведения аргументов, следует в качестве значений по умолчанию использовать неизменяемые объекты."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Переменные, заданные в списковых (и прочих) включениях, имеют время жизни, ограниченное включением:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "([0, 0, 0, 0], False)\n"
     ]
    }
   ],
   "source": [
    "def f():    \n",
    "    return [0 for i in range(4)], 'i' in locals()\n",
    "\n",
    "print(f())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Для установления времени жизни переменных, определенных в цикле `for`, используются более запутанные правила:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3, True, False)\n"
     ]
    }
   ],
   "source": [
    "def f():\n",
    "    for i in range(4):\n",
    "        pass\n",
    "    for j in range(0): # цикл не выполняется\n",
    "        pass\n",
    "    return i, 'i' in locals(), 'j' in locals()\n",
    "\n",
    "print(f())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Пример использования рассмотренных средств языка"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В программе ниже организован разбор формальной грамматики, представленной в БНФ, а также порождение случайных фраз по заданной грамматике.\n",
    "\n",
    "В нотации используются:\n",
    "* альтернативный выбор (`a | b`),\n",
    "* последовательность (`a b`), \n",
    "* рекурсия (`a = a | b`).\n",
    "\n",
    "Видите ли вы аналогию с ранее рассмотренными железнодорожными диаграммами?\n",
    "\n",
    "Постарайтесь самостоятельно разобраться, как работает эта программа. Описание неизвестных для вас методов и функций смотрите в официальной документации."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(7-5/z*(z/3-58555808+z-y)*19)\n",
      "((z))\n",
      "z\n",
      "((810-(392))-x+((4156+841)+49750))/((x))\n",
      "((y-z-(597)-3-8/x-(1)))\n",
      "6\n",
      "x\n",
      "z\n",
      "20\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "\n",
    "\n",
    "def parse_bnf(text):\n",
    "    '''\n",
    "    Преобразовать текстовую запись БНФ в словарь.\n",
    "    '''\n",
    "    grammar = {}\n",
    "    rules = [line.split('=') for line in text.strip().split('\\n')]\n",
    "    for name, body in rules:\n",
    "        grammar[name.strip()] = [alt.split() for alt in body.split('|')]\n",
    "    return grammar\n",
    "\n",
    "\n",
    "def generate_phrase(grammar, start):\n",
    "    '''\n",
    "    Сгенерировать случайную фразу.\n",
    "    '''\n",
    "    if start in grammar:\n",
    "        seq = random.choice(grammar[start])\n",
    "        return ''.join([generate_phrase(grammar, name) for name in seq])\n",
    "    return str(start)\n",
    "\n",
    "\n",
    "BNF = '''\n",
    "V = x | y | z\n",
    "D = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9\n",
    "N = D | D N\n",
    "O = + | - | * | /\n",
    "E = V | N | ( E ) | E O E\n",
    "'''\n",
    "\n",
    "for i in range(10):\n",
    "    print(generate_phrase(parse_bnf(BNF), 'E'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Работа с файлами\n",
    "\n",
    "В Питоне имеется встроенная функция `open()` для открытия файлов.\n",
    "\n",
    "Прочесть данные из файла:\n",
    "\n",
    "```Python\n",
    "f = open('data.txt', 'r')\n",
    "data = f.read()\n",
    "f.close()\n",
    "```\n",
    "\n",
    "Записать данные в файл:\n",
    "\n",
    "```Python\n",
    "f = open('data.txt', 'w')\n",
    "f.write(data)\n",
    "f.close()\n",
    "```\n",
    "\n",
    "Как и в C++, добавление 'b' к строкам 'r' или 'w' означает открытие файла в двоичном режиме.\n",
    "\n",
    "Чтобы не беспокоиться о закрытии файла удобно использовать менеджер контекста с помощью ключевого слова `with`:\n",
    "\n",
    "```Python\n",
    "with open('data.txt', 'r') as f:\n",
    "    data = f.read()\n",
    "```\n",
    "\n",
    "или\n",
    "\n",
    "```Python\n",
    "with open('data.txt', 'w') as f:\n",
    "    f.write(data)\n",
    "```\n",
    "\n",
    "Файл будет автоматически закрыт по выходу из блока `with`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Интерфейс командной строки\n",
    "\n",
    "Простые скрипты в Питоне обычно представляют собой собой программы, имеющие интерфейс командной строки.\n",
    "Аргументы, передаваемые на вход программы из командной строки, хранятся в списке `sys.argv`. Рассмотрим следующую программу:\n",
    "\n",
    "```Python\n",
    "import sys\n",
    "\n",
    "print(sys.argv)\n",
    "```\n",
    "\n",
    "Если вызвать ее из командной строки с помощью `python cli.py -o file.dat 123`, то будет получен следующий результат:\n",
    "\n",
    "```\n",
    "['cli.py', '-o', 'file.dat', '123']\n",
    "```\n",
    "\n",
    "Для удобного разбора опций командной строки имеется модуль `argparse`, описание которого приведено в [официальной документации](https://docs.python.org/3/library/argparse.html).\n",
    "\n",
    "Краткое руководство по хорошему стилю определения опций командной строки находится [здесь](https://nullprogram.com/blog/2020/08/01/) (англ.)."
   ]
  }
 ],
 "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.11.1"
  },
  "vscode": {
   "interpreter": {
    "hash": "61dfe9c682d93c0afd147a4694a60871cd02680c76d00a06359d9b0f9ffcab18"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}