lect1.ipynb

{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Лекция №1. Введение\n",
    "\n",
    "*П.Н. Советов, РТУ МИРЭА*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "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()))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## О курсе\n",
    "\n",
    "Курс программирования на языке Питон предназначен для студентов второго курса бакалавриата, уже имеющих опыт использования языков C++, Java или C#, а также знакомых с базовыми алгоритмами и структурами данных.\n",
    "\n",
    "Акцент в курсе делается на основательном изучении языка Питон, а не на изучении популярных сегодня фреймворков. Последние за несколько лет могут устареть, поэтому полезнее иметь фундаментальную подготовку, которая позволит быстро сориентироваться и изучить актуальные библиотеки и технологии.\n",
    "\n",
    "Задачи по курсу делятся на 3 основных типа:\n",
    "\n",
    "1. Индивидуальные «скучные» задачи, которые генерируются (на Питоне!) процедурно для каждого студента в отдельности. Они являются обязательными к выполнению и решаются дома.\n",
    "1. Задачи для практических занятий.\n",
    "1. Творческие проекты, темы которых обсуждаются с преподавателями. "
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Зачем изучать Python?\n",
    "\n",
    "Современному программисту и так приходится иметь дело с большим количеством языков программирования. Поэтому для изучения очередного языка нужны какие-то веские причины.\n",
    "\n",
    "Питон является одним из самых популярных и востребованных языков программирования. Об этом говорит целый ряд рейтингов за 2022-2023 гг.\n",
    "\n",
    "* В индексе [TIOBE](https://www.tiobe.com/tiobe-index/) на январь 2023 года Питон находится на первом месте.\n",
    "* В рейтинге популярных языков программирования журнала [IEEE Spectrum](https://spectrum.ieee.org/top-programming-languages-2022) Питон находится на первом месте.\n",
    "* Среди используемых языков программирования в проектах [Github](https://octoverse.github.com/2022/top-programming-languages) Питон занимает второе место."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Можно выделить следующие причины популярности Питона:\n",
    "\n",
    "* Огромное количество библиотек для самых разных областей применения.\n",
    "* Возможность быстрого прототипирования приложений благодаря наличию в языке динамической типизации, автоматического управления памятью («сборка мусора»), а также благодаря свободной поддержке различных стилей программирования.\n",
    "* Легкость обучения основам языка и высокая читаемость кода. Не просто так синтаксис Питона сравнивают с «исполняемым псевдокодом».\n",
    "\n",
    "Питон широко применяется в проектах, связанных с машинным обучением и обработкой естественного языка. На [сайте](https://www.tensorflow.org/about/case-studies) популярной библиотеки для глубокого обучения TensorFlow приведены примеры использования Питона крупнейшими мировыми компаниями. Питон популярен в области анализа и визуализации данных, где используются такие известные библиотеки, как Pandas и Matplotlib.\n",
    "\n",
    "![](images/blackhole.jpg)\n",
    "\n",
    "*Изображение черной дыры в центре галактики M87 получено с помощью Питона*\n",
    "\n",
    "Первое изображение черной дыры астрофизики получили с помощью инструментов, реализованных на Питоне. При этом [использовались](https://numpy.org/case-studies/blackhole-image/) популярные библиотеки NumPy и SciPy.\n",
    "\n",
    "Еще одной естественной областью применения Питона является разработка веб-приложений, а также извлечение данных из веб-страниц (web scrapers, web crawlers). Фреймворки Flask и Django пользуется известностью среди веб-разработчиков.\n",
    "\n",
    "Питон пользуется популярностью в задачах системного администрирования и DevOps, а также для автоматизации тестирования. На Питоне разработана система управления конфигурациями [Ansible](https://en.wikipedia.org/wiki/Ansible_(software)) и реализовано [автоматическое тестирование](https://github.com/ghc/ghc/commit/e5063a042c9a1701ea7273da7bacb530d5c077d3) для языка Haskell.\n",
    "\n",
    "В разработке компьютерных игр Питон также используется достаточно широко. Среди известных проектов с существенной долей кода на языке Питон можно вспомнить, например, [EVE Online](https://www.eveonline.com/ru/article/stackless-python-2.7) и [World of Tanks](https://habr.com/ru/company/wargaming/blog/272265/).\n",
    "\n",
    "Как в играх, так и в более серьезных приложениях Питон часто играет роль встроенного языка для расширения функциональности программы. Питон встроен в популярные графические редакторы Gimp, Inkscape и Blender, а также в такое музыкальное ПО, как Ableton Live и Reaper.\n",
    "\n",
    "Наконец, язык Питон сегодня является одним из самых популярных языков для обучения программированию. В этой роли он используется как в школах, так и в университетах."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Что собой представляет Python\n",
    "\n",
    "Среди русскоязычных разработчиков (и в этом тексте) одинаково употребляется и «Питон», и «Пайтон». При этом название языка никак не связано со змеями. Здесь лучше обратиться к истории создания Питона.\n",
    "\n",
    "Автором языка является голландский программист Гвидо ван Россум. Работа над Питоном началась еще в далеком 1989 году, в стенах исследовательского института CWI в Амстердаме. Побудительным мотивом к созданию Питона было желание иметь высокоуровневый язык программирования, занимающий промежуточное положение между языком Си и высокоуровневым языком оболочки операционной системы (shell).\n",
    "\n",
    "![](images/guido.jpg)\n",
    "\n",
    "*Автор языка Питон – Гвидо ван Россум*\n",
    "\n",
    "Название «Питон» появилось случайно. Оно происходит от названия английской комедийной передачи «Летающий цирк Монти Пайтона», популярной в том числе и среди программистов того времени. Кстати, сегодня программистов, использующих Питон, называют питонистами.\n",
    "\n",
    "Питон унаследовал многие черты языка ABC, еще одного языка, разработанного в недрах института CWI. Сразу же обращает на себя внимание ключевая особенность синтаксиса, имеющаяся и в ABC, и в Питоне.\n",
    "\n",
    "**ABC**\n",
    "\n",
    "```\n",
    "HOW TO RETURN words document:\n",
    "    PUT {} IN collection\n",
    "    FOR line IN document:\n",
    "        FOR word IN split line:\n",
    "           IF word not.in collection:\n",
    "               INSERT word IN collection\n",
    "    RETURN collection\n",
    "```\n",
    "\n",
    "**Python**\n",
    "\n",
    "```Python\n",
    "def words(document):\n",
    "    collection = set()\n",
    "    for line in document:\n",
    "        for word in line.split():\n",
    "            if word not in collection:\n",
    "                collection.add(word)\n",
    "    return collection\n",
    "```\n",
    "\n",
    "Речь, разумеется, об использовании отступов для выделения блоков в этих языках. Для программиста, который привык выделять блоки ключевыми словами `begin ... end` или фигурными скобками `{ ... }` такое решение может показаться непривычным, но в результате хорошо написанные программы на Питоне выглядят как псевдокод из учебников."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Исходные тексты первой публичной версии реализации Питона Гвидо ван Россум отправил в новостную конференцию сети Usenet. Это было в 1991 году, ниже показан перевод текста файла README. Можно заметить любопытные исторические детали, связанные с языком."
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "```\n",
    "Это Питон, расширяемый интерпретируемый язык программирования, который\n",
    "сочетает в себе заметную мощь с очень ясным синтаксисом.\n",
    "\n",
    "Это версия 0.9 (первая бета-версия), уровень исправления 1.\n",
    "\n",
    "Питон можно использовать вместо сценариев оболочки, скриптов Awk или Perl,\n",
    "для написания прототипов реальных приложений или как язык расширения больших\n",
    "систем и так далее. Имеются встроенные модули, которые взаимодействуют с\n",
    "операционной системой и интерфейсы к различным оконным системам: оконные системы X11, Mac\n",
    "(для этих двух вам нужен STDWIN) и библиотека GL от Silicon Graphics.\n",
    "Питон работает на большинстве современных версий UNIX, на Mac и я не удивлюсь,\n",
    "если он будет работать в MS-DOS без изменений. я разработал язык\n",
    "в основном на рабочей станции SGI IRIS (с использованием IRIX 3.1 и 3.2) и на\n",
    "Mac, но тестировал его также на SunOS (4.1) и BSD 4.3 (tahoe).\n",
    "\n",
    "Собрать и установить Питон несложно (но прочтите Makefile). Страница руководства\n",
    "написана в стиле UNIX и имеется обширная документация (в формате LaTeX).\n",
    "(В бета-версии документация все еще находится в стадии разработки.)\n",
    "\n",
    "Пожалуйста, попробуйте поработать с ним и пришлите мне свои комментарии (на что угодно --\n",
    "языковой дизайн, реализацию, переносимость, установку,\n",
    "документацию), а также модули, которые вы написали для Питона, чтобы сделать первый\n",
    "реальный релиз лучше. Если вам нужно изменить исходники, чтобы скомпилировать Питон\n",
    "и запустить на конкретной машине, то пришлите мне исправления -- я попробую включить\n",
    "их в следующий патч. Если вы не можете вообще заставить реализацию работать,\n",
    "то пришлите мне *подробное* описание проблемы и я попробую разобраться.\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ниже показана простая программа на языке Питон, использующая только стандартную библиотеку языка."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8\n"
     ]
    }
   ],
   "source": [
    "import json\n",
    "from urllib.request import urlopen\n",
    "\n",
    "\n",
    "def get_stars(user, repo):\n",
    "    '''Получить количество звезд github-репозитория'''\n",
    "    resp = urlopen(f'http://api.github.com/repos/{user}/{repo}')\n",
    "    return json.loads(resp.read())['stargazers_count']\n",
    "\n",
    "\n",
    "print(get_stars('true-grue', 'DandyBot'))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "На примере этой компактной программы уже видно, насколько богатой является стандартная библиотека Питона (как принято говорить — batteries included). В данном случае используется работа по протоколу HTTP и разбор формата JSON.\n",
    "\n",
    "При этом в программе отсутствуют объявления переменных и не указываются типы данных. Питон является динамически типизированным языком. Это означает, что проверка типов, в отличие от, к примеру, Java или C++, происходит в процессе выполнения программы, а не на стадии ее компиляции. В процессе выполнения программ на Питоне в большинстве случаев не допускается неопределенного состояния и при возникновении ошибки выполнение программы прекращается с выдачей информативного сообщения.\n",
    "\n",
    "Питон также иногда называют динамическим языком. То есть таким языком, в котором программы во время выполнения могут изменять элементы среды выполнения языка, включая ее внутренние структуры и компилятор.\n",
    "\n",
    "В Питоне имеется командная строка для диалога с программистом, так называемый REPL — интерактивный цикл «чтение, выполнение, вывод» (read-eval-print loop). REPL не только упрощает отладку программ, но и обеспечивает очень популярный в Питоне стиль исследовательского программирования. Этот стиль программирования удобен, когда программы развиваются эволюционно и на первых порах еще не ясны в деталях предметная область, необходимые алгоритмы и структуры данных.\n",
    "\n",
    "В Питоне, аналогично языкам C# и Java, используется автоматическое управление памятью, то есть реализована сборка мусора.\n",
    "\n",
    "Питон относится к мультипарадигменным языкам. В нем поддерживаются элементы процедурного, объектно-ориентированного и функционального программирования. Кроме того, имеются возможности метапрограммирования.\n",
    "\n",
    "Иногда возникает путаница в вопросе, является ли Питон языком компилируемым или интерпретируемым. Строго говоря, язык программирования сам по себе не может быть компилируемым или интерпретируемым, это свойство реализации языка. Основная реализация Питона, CPython, написанная на Си, включает в себя и компилятор, и интерпретатор. Первым делом программа на Питоне компилируется в байткод, то есть в представление на низкоуровневом языке виртуальной машины, а затем полученное представление выполняется с помощью интерпретатора байткода."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "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=\"524pt\" height=\"220pt\"\n viewBox=\"0.00 0.00 524.00 220.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 216)\">\n<polygon fill=\"white\" stroke=\"transparent\" points=\"-4,4 -4,-216 520,-216 520,4 -4,4\"/>\n<!-- p -->\n<g id=\"node1\" class=\"node\">\n<title>p</title>\n<polygon fill=\"none\" stroke=\"black\" points=\"300.5,-212 215.5,-212 215.5,-176 300.5,-176 300.5,-212\"/>\n<text text-anchor=\"middle\" x=\"258\" y=\"-190.3\" font-family=\"Times New Roman,serif\" font-size=\"14.00\">Программа</text>\n</g>\n<!-- c -->\n<g id=\"node2\" class=\"node\">\n<title>c</title>\n<polygon fill=\"none\" stroke=\"black\" points=\"331,-125 185,-125 185,-89 331,-89 331,-125\"/>\n<text text-anchor=\"middle\" x=\"258\" y=\"-103.3\" font-family=\"Times New Roman,serif\" font-size=\"14.00\">Компилятор CPython</text>\n</g>\n<!-- p&#45;&gt;c -->\n<g id=\"edge1\" class=\"edge\">\n<title>p&#45;&gt;c</title>\n<path fill=\"none\" stroke=\"black\" d=\"M258,-175.8C258,-164.16 258,-148.55 258,-135.24\"/>\n<polygon fill=\"black\" stroke=\"black\" points=\"261.5,-135.18 258,-125.18 254.5,-135.18 261.5,-135.18\"/>\n<text text-anchor=\"middle\" x=\"292.5\" y=\"-146.8\" font-family=\"Times New Roman,serif\" font-size=\"14.00\">Файл (*.py)</text>\n</g>\n<!-- i1 -->\n<g id=\"node3\" class=\"node\">\n<title>i1</title>\n<polygon fill=\"none\" stroke=\"black\" points=\"160,-38 0,-38 0,0 160,0 160,-38\"/>\n<text text-anchor=\"middle\" x=\"80\" y=\"-22.8\" font-family=\"Times New Roman,serif\" font-size=\"14.00\">Интерпретатор Cpython</text>\n<text text-anchor=\"middle\" x=\"80\" y=\"-7.8\" font-family=\"Times New Roman,serif\" font-size=\"14.00\">(MacOS, ARM)</text>\n</g>\n<!-- c&#45;&gt;i1 -->\n<g id=\"edge2\" class=\"edge\">\n<title>c&#45;&gt;i1</title>\n<path fill=\"none\" stroke=\"black\" d=\"M203.44,-88.96C189.05,-83.81 173.71,-77.71 160,-71 144.07,-63.2 127.4,-52.94 113.41,-43.67\"/>\n<polygon fill=\"black\" stroke=\"black\" points=\"115.33,-40.75 105.09,-38.06 111.42,-46.55 115.33,-40.75\"/>\n<text text-anchor=\"middle\" x=\"207\" y=\"-59.8\" font-family=\"Times New Roman,serif\" font-size=\"14.00\">Байткод (*.pyс)</text>\n</g>\n<!-- i2 -->\n<g id=\"node4\" class=\"node\">\n<title>i2</title>\n<polygon fill=\"none\" stroke=\"black\" points=\"338,-38 178,-38 178,0 338,0 338,-38\"/>\n<text text-anchor=\"middle\" x=\"258\" y=\"-22.8\" font-family=\"Times New Roman,serif\" font-size=\"14.00\">Интерпретатор Cpython</text>\n<text text-anchor=\"middle\" x=\"258\" y=\"-7.8\" font-family=\"Times New Roman,serif\" font-size=\"14.00\">(Windows, x64)</text>\n</g>\n<!-- c&#45;&gt;i2 -->\n<g id=\"edge3\" class=\"edge\">\n<title>c&#45;&gt;i2</title>\n<path fill=\"none\" stroke=\"black\" d=\"M258,-88.6C258,-77.06 258,-61.65 258,-48.36\"/>\n<polygon fill=\"black\" stroke=\"black\" points=\"261.5,-48.27 258,-38.27 254.5,-48.27 261.5,-48.27\"/>\n<text text-anchor=\"middle\" x=\"305\" y=\"-59.8\" font-family=\"Times New Roman,serif\" font-size=\"14.00\">Байткод (*.pyс)</text>\n</g>\n<!-- i3 -->\n<g id=\"node5\" class=\"node\">\n<title>i3</title>\n<polygon fill=\"none\" stroke=\"black\" points=\"516,-38 356,-38 356,0 516,0 516,-38\"/>\n<text text-anchor=\"middle\" x=\"436\" y=\"-22.8\" font-family=\"Times New Roman,serif\" font-size=\"14.00\">Интерпретатор Cpython</text>\n<text text-anchor=\"middle\" x=\"436\" y=\"-7.8\" font-family=\"Times New Roman,serif\" font-size=\"14.00\">(Linux, x64)</text>\n</g>\n<!-- c&#45;&gt;i3 -->\n<g id=\"edge4\" class=\"edge\">\n<title>c&#45;&gt;i3</title>\n<path fill=\"none\" stroke=\"black\" d=\"M312.56,-88.96C326.95,-83.81 342.29,-77.71 356,-71 371.93,-63.2 388.6,-52.94 402.59,-43.67\"/>\n<polygon fill=\"black\" stroke=\"black\" points=\"404.58,-46.55 410.91,-38.06 400.67,-40.75 404.58,-46.55\"/>\n<text text-anchor=\"middle\" x=\"428\" y=\"-59.8\" font-family=\"Times New Roman,serif\" font-size=\"14.00\">Байткод (*.pyс)</text>\n</g>\n</g>\n</svg>\n",
      "text/plain": [
       "<graphviz.graphs.Digraph at 0x13f87a21910>"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "d = Digraph()\n",
    "d.attr('node', shape='box')\n",
    "d.node('p', 'Программа')\n",
    "d.node('c', 'Компилятор CPython')\n",
    "d.node('i1', 'Интерпретатор Cpython\\\\n(MacOS, ARM)')\n",
    "d.node('i2', 'Интерпретатор Cpython\\\\n(Windows, x64)')\n",
    "d.node('i3', 'Интерпретатор Cpython\\\\n(Linux, x64)')\n",
    "d.edge('p', 'c', label='Файл (*.py)')\n",
    "d.edge('c', 'i1', label='Байткод (*.pyс)')\n",
    "d.edge('c', 'i2', label='Байткод (*.pyс)')\n",
    "d.edge('c', 'i3', label='Байткод (*.pyс)')\n",
    "d"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Основные принципы, согласно которым развивается Питон, сформулированы в так называемом «Дзене Питона». Его текст на английском языке можно получить с помощью следующей команды интерпретатора CPython."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "import this"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Русский перевод:\n",
    "\n",
    "Дзен Питона, Тим Питерс\n",
    "\n",
    "* Красивое лучше, чем уродливое.\n",
    "* Явное лучше, чем неявное.\n",
    "* Простое лучше, чем сложное.\n",
    "* Сложное лучше, чем запутанное.\n",
    "* Плоское лучше, чем вложенное.\n",
    "* Разреженное, лучше чем плотное.\n",
    "* Читаемость имеет значение.\n",
    "* Особые случаи не настолько особые, чтобы нарушать правила.\n",
    "* Но практичность важнее безупречности.\n",
    "* Ошибки никогда не должны замалчиваться.\n",
    "* Если только они не замалчиваются явно.\n",
    "* Перед лицом двусмысленности откажитесь от соблазна угадывать.\n",
    "* Должен существовать один и, желательно, только один очевидный способ сделать это.\n",
    "* Хотя он поначалу может быть и не очевиден, если вы не голландец. `Намек на автора языка`\n",
    "* Лучше сейчас, чем никогда.\n",
    "* Хотя никогда зачастую лучше, чем прямо сейчас.\n",
    "* Если реализацию трудно объяснить, то идея плоха.\n",
    "* Если реализацию легко объяснить, идея, возможно, хороша.\n",
    "* Пространства имен — отличная идея! Давайте делать их больше!\n",
    "\n",
    "Эти пункты действительно напоминают положения какого-то религиозно-философского учения и могут допускать различные толкования.\n",
    "\n",
    "В более строгой форме развитие языка происходит в соответствии с документами [PEP](https://www.python.org/dev/peps/) (Python Enhancement Proposal — предложения по развитию Питона)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Недостатки языка\n",
    "\n",
    "Питон, как и все прочие языки программирования, имеет свои границы применимости и свои слабые стороны.\n",
    "\n",
    "Ключевым недостатком Питона можно считать практически полное отсутствие проверок корректности программы до этапа ее выполнения. Компилятор Питона своевременно оповестит программиста о синтаксических ошибках, но если вы передали в функцию, к примеру, список вместо числа, то в этом случае узнать об ошибке можно будет только во время выполнения соответствующей функции.\n",
    "\n",
    "В Питоне, как и в других языках с динамической типизацией, указанный недостаток до некоторой степени преодолевается с помощью написания автоматических тестов и использования сторонних инструментов статического анализа. Кроме того, в современных версиях Питона введены аннотации типов, наличие которых позволяет производить необязательную статическую проверку типов (gradual typing) с использованием инструмента mypy.\n",
    "\n",
    "Традиционно многие разработчики на Питоне жалуются на недостаточную производительность своих программ. Действительно, согласно [этим](https://benchmarksgame-team.pages.debian.net/benchmarksgame/fastest/python3-gcc.html) данным, на многих задачах Питон отстает от Си более чем в 100 раз. Такой результат является платой за динамическую природу Питона. Тем не менее, существуют альтернативные реализации Питона, такие, например, как PyPy и Numba, значительно улучшающие производительность программ. Нужно, однако, добавить, что эти альтернативные реализации лишь до некоторой степени совместимы с CPython — эталонной реализацией Питона.\n",
    "\n",
    "Еще одним серьезным недостатком Питона является недостаточная совместимость между различными версиями языка. В какой-то момент существовало две основных версии Питона — вторая и третья. Сегодня большинство разработчиков, все-таки, перешли на версию 3 (но даже в рамках этой мажорной версии существовали минорные версии языка, несовместимые друг с другом). Проблемы несовместимости все еще могут давать о себе знать в тех случаях, когда вы сталкиваетесь со старым кодом на Питоне из учебников или из сети.\n",
    "\n",
    "Следует также добавить, что многих питонистов беспокоит регулярное добавление в язык новых конструкций, что приводит к все большему усложнению изначально простого языка."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В таблице ниже представлены основные этапы развития Питона в его третьей версии:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "| Версия Python 3 | Главные нововведения                                                                                      |\n",
    "| --------------- | --------------------------------------------------------------------------------------------------------- |\n",
    "| 3.10            | Сопоставление с образцом (`match/case`)                                                                   |\n",
    "| 3.8             | Оператор присваивания `:=` («морж»)                                                                       |\n",
    "| 3.7             | модуль `dataclasses`, упорядоченный `dict`                                                                |\n",
    "| 3.6             | f-строки, аннотации типов для переменных, символ подчеркивания в числах, асинхронные генераторы/включения |\n",
    "| 3.5             | Сопрограммы с `async/await`, оператор матричного умножения `@`, аннотации типов для функций               |\n",
    "| 3.3             | Конструкция `yield from`, виртуальные окружения                                                           |"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Установка Python\n",
    "\n",
    "Зайдите на сайт [python.org](https://www.python.org/) и скачайте последнюю версию Python для своей ОС. Это должна быть версия 3.10 или старше.\n",
    "\n",
    "Если вы работаете в Linux, где уже установлен Питон, то удостоверьтесь, что обновили его до самой последней версии и сделали полную установку (по умолчанию у вас может отсутствовать стандартная GUI-библиотека Tkinter).\n",
    "\n",
    "Войдите в командную строку ОС и удостоверьтесь, что команда `python` выдает в ответ информацию такого вида:\n",
    "\n",
    "```\n",
    "Python 3.11.1 (tags/v3.11.1:a7a450f, Dec  6 2022, 19:58:39) [MSC v.1934 64 bit (AMD64)] on win32\n",
    "Type \"help\", \"copyright\", \"credits\" or \"license\" for more information.\n",
    ">>>\n",
    "```\n",
    "\n",
    "Также проверьте, что команда `pip` запускается из командной строки ОС:\n",
    "\n",
    "```\n",
    "Usage:\n",
    "  pip <command> [options]\n",
    "...\n",
    "```\n",
    "\n",
    "Для написания простых программ в курсе используется среда IDLE, которая входит в комплект стандартного дистрибутива Питона. Некоторые задания потребуют использования среды Jupyter Notebook.\n",
    "\n",
    "Для работы с Jupyter-блокнотами и дополнительными библиотеками проще всего использовать редактор [Visual Studio Code](https://code.visualstudio.com/) или же можно установить отдельный дистрибутив Питона — [Anaconda](https://www.anaconda.com/products/individual).\n",
    "\n",
    "При необходимости, можно воспользоваться [веб-реализацией](https://repl.it/languages/python3) Питона, а также [веб-реализацией](https://colab.research.google.com/) Jupyer Notebook.\n",
    "\n",
    "Если вы считаете себя уже достаточно опытным программистом, то работайте в привычных вам редакторах или IDE, однако проблемы по настройке придется решать самостоятельно. В частности, этими редакторами могут быть [Visual Studio Code](https://code.visualstudio.com/) или [PyCharm](https://www.jetbrains.com/ru-ru/pycharm/)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Режим калькулятора\n",
    "\n",
    "Изучать Питон мы будем постепенно, начиная с самого простого его подмножества. Это своеобразный режим калькулятора, для работы с которым воспользуемся REPL Питона.\n",
    "\n",
    "Традиционная программа Hello World в Питоне содержит минимум кода и не требует определения класса или функции, как в некоторых иных языках:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Привет, Python 3\n"
     ]
    }
   ],
   "source": [
    "print('Привет, Python', 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Рассмотрим задачу вычисления суммы первых $n$ натуральных чисел по формуле:\n",
    "\n",
    "$$ \\sum_{i=1}^{n}i = 1 + 2 + 3 + \\ldots + n = \\frac{n(n + 1)}{2} $$\n",
    "\n",
    "```Python\n",
    ">>> n = 5\n",
    ">>> 1 + 2 + 3 + 4 + 5 # Ручной подсчет\n",
    "15\n",
    ">>> n * (n + 1) / 2\n",
    "15.0\n",
    "```\n",
    "\n",
    "Комментарии в Питоне начинаются с символа `#`, как в примере выше, и завершаются переводом строки.\n",
    "\n",
    "Обратите внимание, что регистр букв важен, поэтому, к примеру, переменные n и N различны. Говоря более строго, имена (или, иначе, идентификаторы) могут содержать буквы в верхнем или нижнем регистре, символ `_`, а также цифры (за исключением первого символа имени).\n",
    "\n",
    "В Питоне имеется три основных числовых типа:\n",
    "\n",
    "1. целые значения,\n",
    "2. значения с плавающей точкой,\n",
    "3. булевы значения.\n",
    "\n",
    "Литералы (нотация, синтаксическое представление значений) целых могут быть представлены в одной из четырех систем счисления:\n",
    "\n",
    "```Python\n",
    ">>> 12345 # Основание 10\n",
    "12345\n",
    ">>> 0xDeadBeef # Основание 16\n",
    "3735928559\n",
    ">>> 0o757 # Основание 8\n",
    "495\n",
    ">>> 0b1100 # Основание 2\n",
    "12\n",
    "```\n",
    "\n",
    "Числа с плавающей точкой записываются в привычной нотации с точкой, а также в экспоненциальной («научной») нотации, то есть в формате $m \\times 10^n$.\n",
    "\n",
    "```Python\n",
    ">>> 1234.5\n",
    "1234.5\n",
    ">>> 12345e-1\n",
    "1234.5\n",
    "```\n",
    "\n",
    "Для улучшения читаемости в числовых литералах можно использовать символ `_`:\n",
    "\n",
    "```Python\n",
    ">>> 1_000_000\n",
    "1000000\n",
    ">>> 3.14_159\n",
    "3.14159\n",
    "```\n",
    "\n",
    "Целые значения могут иметь произвольный размер (точнее говоря, насколько хватит ОЗУ). Булевы значения из множества `{True, False}` являются подмножеством целых. Значения с плавающей точкой подчиняются стандарту IEEE-754 для 64-битных значений (double в терминологии C++).\n",
    "\n",
    "Для преобразования чисел есть встроенные функции `int` и `float`:\n",
    "\n",
    "```Python\n",
    ">>> float(4)\n",
    "4.0\n",
    ">>> int(2.7)\n",
    "2\n",
    ">>> int(True)\n",
    "1\n",
    ">>> int(False)\n",
    "0\n",
    "```\n",
    "\n",
    "Операцию присваивания можно представить себе как запись по ключу в структуру данных словарь (ассоциативный массив, хеш-таблицу). Первое присваивание создает новую запись в этом словаре, называемом глобальным пространством имен (globals). Последующие записи по тому же ключу-имени обновляют соответствующее значение, которое может быть объектом произвольного типа.\n",
    "\n",
    "Важно отметить, что каждое значение в Питоне является объектом-«ящиком», в котором хранится дополнительная информация, включая тип этого объекта. Узнать тип объекта можно с помощью встроенной функции `type`.\n",
    "\n",
    "```Python\n",
    ">>> x = 42\n",
    ">>> type(x)\n",
    "<class 'int'>\n",
    ">>> x = 1.14\n",
    ">>> type(x)\n",
    "<class 'float'>\n",
    "```\n",
    "\n",
    "На рисунке ниже показано, как меняется состояние глобального пространства имен в процессе присваивания переменной x новых значений.\n",
    "\n",
    "![](images/globals.png)\n",
    "\n",
    "*Состояние глобального пространства имен после присваиваний*\n",
    "\n",
    "С помощью встроенной функции `globals` можно узнать текущее состояние глобального пространства имен:\n",
    "\n",
    "```Python\n",
    ">>> globals()\n",
    "{'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': <class '_frozen_importlib.BuiltinImporter'>, '__spec__': None, '__annotations__': {}, '__builtins__': <module 'builtins' (built-in)>, 'x': 1.14}\n",
    "```"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В Питоне, как в и большинстве других языков программирования, имеются ключевые слова. Их нельзя использовать в качестве имен пользовательских объектов. Вот список ключевых слов:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'False None True and as assert async await break class continue def del elif else except finally for from global if import in is lambda nonlocal not or pass raise return try while with yield'"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import keyword\n",
    "' '.join(keyword.kwlist)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Далее показана таблица приоритетов операторов Питона, использующихся в выражениях. Строки таблицы отсортированы высшего приоритета к низшему.\n",
    "\n",
    "| Оператор                                                         | Описание                                                                |\n",
    "| ---------------------------------------------------------------- | ----------------------------------------------------------------------- |\n",
    "| `(выражение)`, `[выражение]`, `{ключ: значение}`, `{выражение}`  | Выражение в скобках, список, словарь, множество                         |\n",
    "| `x[индекс]`, `x[индекс:индекс]`, `x(аргументы)`, `x.атрибут`     | Индексирование, срез, вызов, обращение к атрибуту                       |\n",
    "| `await выражение`                                                | Await-выражение                                                         |\n",
    "| `**`                                                             | Возведение в степень                                                    |\n",
    "| `+x`, `-x`, `~x`                                                 | Плюс, минус, побитовое отрицание                                        |\n",
    "| `*`, `@`, `/`, `//`, `%`                                         | Умножение, матричное умножение, деление, целочисленное деление, остаток |\n",
    "| `+`, `-`                                                         | Сложение, вычитание                                                     |\n",
    "| `<<`, `>>`                                                       | Побитовые сдвиги                                                        |\n",
    "| `&`                                                              | Побитовое И                                                             |\n",
    "| `^`                                                              | Побитовое исключающее ИЛИ                                               |\n",
    "| &#124;                                                           | Побитовое ИЛИ                                                           |\n",
    "| `in`, `not in`, `is`, `is not`, `<`, `<=`, `>`, `>=`, `!=`, `==` | Варианты сравнений                                                      |\n",
    "| `not x`                                                          | Булево НЕ                                                               |\n",
    "| `and`                                                            | Булево И                                                                |\n",
    "| `or`                                                             | Булево ИЛИ                                                              |\n",
    "| `if ... else`                                                    | Тернарный оператор условия                                              |\n",
    "| `lambda`                                                         | Лямбда-выражение                                                        |\n",
    "| `:=`                                                             | Выражение-присваивание                                                  |\n",
    "\n",
    "Многие операции одинаково обозначаются в Питоне и C++. Операции булевой логики Питона `not`, `and` и `or` имеют эквиваленты в C++ в виде `!`, `&&` и `||`. Операция `**` обозначает в Питоне возведение в степень. Операция ``//`` обозначает целочисленный вариант деления.\n",
    "\n",
    "Операции сравнения выдают булевы значения.\n",
    "\n",
    "В Питоне, как и в языках системного программирования, применяются побитовые операции. Зачем программисту на Питоне владеть этими операциями? Приведу несколько причин:\n",
    "\n",
    "* Понимание исходного кода CPython.\n",
    "* Реализация на Питоне виртуальных машин, симуляторов процессоров.\n",
    "* Реализация специальных структур данных, использующих битовые массивы. Это может быть, например, фильтр Блума.\n",
    "* Разбор двоичных форматов данных.\n",
    "* Использование MicroPython для программирования микроконтроллеров в задачах из области Интернета вещей.\n",
    "\n",
    "Дополнительные математические операции содержатся в модуле [math](https://docs.python.org/3/library/math.html), который импортируется в текущее пространство имен, как показано ниже (о модулях мы еще будем говорить). Функции из модуля вызываются с префиксом в виде названия модуля и через точку:\n",
    "\n",
    "```Python\n",
    ">>> import math\n",
    ">>> math.cos(0)\n",
    "1.0\n",
    "```\n",
    "\n",
    "Даже в некоторых калькуляторах есть возможность создания пользовательских функций и вот простой шаблон создания пользовательских функций в Питоне:\n",
    "\n",
    "```Python\n",
    "def имя_функции(аргумент, ..., аргумент):\n",
    "    предложение\n",
    "    ...\n",
    "    предложение\n",
    "    return выражение\n",
    "```\n",
    "\n",
    "Не забывайте, отступы важны! В данном случае они показывают компилятору Питона, какие строки относятся к телу функции. Начинающие также часто забывают ставить `return` перед возвращаемым результатом. \n",
    "\n",
    "Оформим пример вычисления суммы первых натуральных чисел в виде функции:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15.0"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def sum_first(n):\n",
    "    return n * (n + 1) / 2\n",
    "\n",
    "sum_first(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Отступы и конструкции управления\n",
    "\n",
    "Прежде чем переходить к рассмотрению ветвлений и циклов, остановимся более подробно на роли отступов в языке.\n",
    "\n",
    "\n",
    "Программа на Питоне состоит из некоторого количества строк. Есть случаи, когда в Питоне объединяется несколько «физических» строк (тех, что мы наблюдаем в текстовом редакторе) в одну строку. Вот эти случаи:\n",
    "\n",
    "* Использование символа `\\` в конце строки означает ее соединение с последующей строкой.\n",
    "* Выражение в круглых, квадратных или фигурных скобках занимает с точки зрения Питона одну строку, даже если элементы выражения располагаются на разных физических строках.\n",
    "\n",
    "В Питоне, как и во многих других языках программирования, используется блочная структура. При этом блоки отмечаются исключительно позицией отступа в строке. Питонисты придерживаются следующего соглашения: отступ занимает 4 пробела.\n",
    "\n",
    "Если вы увеличиваете отступ очередной строки, то тем самым переносите эту строку в более внутренний блок. Разумеется, строки, относящиеся к одному блоку должны обладать одинаковым отступом. Чтобы выйти из некоторого количества блоков нужно просто вернуть обратно позицию отступа до позиции желаемого блока.\n",
    "\n",
    "Вы, вероятно уже заметили при создании собственных функций, что работать с отступами в REPL не слишком удобно. С этого момента мы переходим к записи программ в отдельных файлах.\n",
    "\n",
    "Рассмотрим использование условного оператора `if`. Вот его шаблон:\n",
    "\n",
    "```Python\n",
    "if выражение:\n",
    "    блок\n",
    "elif выражение:\n",
    "    ...\n",
    "else:\n",
    "    блок\n",
    "```\n",
    "\n",
    "Результат вычисления условия в `if` и `elif` трактуется, как булево значение.\n",
    "Ниже показан пример использования ветвлений:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Результат отрицателен\n"
     ]
    }
   ],
   "source": [
    "x = -1\n",
    "if x > 0:\n",
    "    print('Результат положителен')\n",
    "elif x < 0:\n",
    "    print('Результат отрицателен')\n",
    "else:\n",
    "    print('Результат равен нулю')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Булевы операторы `and` и `or` в условиях выполняются слева направо до тех пор, пока не станет ясен общий результат выражения (аналогично тому, как это сделано, например, в C++). По этой причине в следующем примере ошибки не возникнет:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Деления на нуль не произошло\n"
     ]
    }
   ],
   "source": [
    "if 2 + 2 == 4 or 1 / 0:\n",
    "    print(\"Деления на нуль не произошло\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Для описания синтаксиса некоторых конструкций Питона будем использовать так называемые «железнодорожные диаграммы», читать которые нужно слева направо, мысленно двигаясь по путям и развилкам.\n",
    "\n",
    "В более строгой форме грамматика `if` имеет следующий вид:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "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=\"101\" viewBox=\"0 0 500.0 101\" width=\"500.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 60v20m10 -20v20m-10 -10h20\"/></g><g>\n<path d=\"M40 70h0.0\"/><path d=\"M460.0 70h0.0\"/><path d=\"M40.0 70a10 10 0 0 0 10 -10v-19a10 10 0 0 1 10 -10\"/><g>\n<path d=\"M60.0 31h15.0\"/><path d=\"M425.0 31h15.0\"/><g class=\"terminal \">\n<path d=\"M75.0 31h0.0\"/><path d=\"M112.0 31h0.0\"/><rect height=\"22\" rx=\"10\" ry=\"10\" width=\"37\" x=\"75\" y=\"20\"/><text x=\"93.5\" y=\"35\">if</text></g><path d=\"M112.0 31h10\"/><path d=\"M122.0 31h10\"/><g class=\"terminal \">\n<path d=\"M132.0 31h0.0\"/><path d=\"M228.5 31h0.0\"/><rect height=\"22\" rx=\"10\" ry=\"10\" width=\"96.5\" x=\"132\" y=\"20\"/><text x=\"180.25\" y=\"35\">выражение</text></g><path d=\"M228.5 31h10\"/><path d=\"M238.5 31h10\"/><g class=\"terminal \">\n<path d=\"M248.5 31h0.0\"/><path d=\"M277.0 31h0.0\"/><rect height=\"22\" rx=\"10\" ry=\"10\" width=\"28.5\" x=\"248.5\" y=\"20\"/><text x=\"262.75\" y=\"35\">:</text></g><path d=\"M277.0 31h10\"/><path d=\"M287.0 31h10\"/><g class=\"terminal \">\n<path d=\"M297.0 31h0.0\"/><path d=\"M351.0 31h0.0\"/><rect height=\"22\" rx=\"10\" ry=\"10\" width=\"54\" x=\"297\" y=\"20\"/><text x=\"324\" y=\"35\">блок</text></g><path d=\"M351.0 31h10\"/><path d=\"M361.0 31h10\"/><g class=\"terminal \">\n<path d=\"M371.0 31h0.0\"/><path d=\"M425.0 31h0.0\"/><rect height=\"22\" rx=\"10\" ry=\"10\" width=\"54\" x=\"371\" y=\"20\"/><text x=\"398\" y=\"35\">elif</text></g></g><path d=\"M440.0 31a10 10 0 0 1 10 10v19a10 10 0 0 0 10 10\"/><path d=\"M40.0 70h20\"/><g>\n<path d=\"M60.0 70h0.0\"/><path d=\"M440.0 70h0.0\"/><g class=\"terminal \">\n<path d=\"M60.0 70h0.0\"/><path d=\"M97.0 70h0.0\"/><rect height=\"22\" rx=\"10\" ry=\"10\" width=\"37\" x=\"60\" y=\"59\"/><text x=\"78.5\" y=\"74\">if</text></g><path d=\"M97.0 70h10\"/><path d=\"M107.0 70h10\"/><g class=\"terminal \">\n<path d=\"M117.0 70h0.0\"/><path d=\"M213.5 70h0.0\"/><rect height=\"22\" rx=\"10\" ry=\"10\" width=\"96.5\" x=\"117\" y=\"59\"/><text x=\"165.25\" y=\"74\">выражение</text></g><path d=\"M213.5 70h10\"/><path d=\"M223.5 70h10\"/><g class=\"terminal \">\n<path d=\"M233.5 70h0.0\"/><path d=\"M262.0 70h0.0\"/><rect height=\"22\" rx=\"10\" ry=\"10\" width=\"28.5\" x=\"233.5\" y=\"59\"/><text x=\"247.75\" y=\"74\">:</text></g><path d=\"M262.0 70h10\"/><path d=\"M272.0 70h10\"/><g class=\"terminal \">\n<path d=\"M282.0 70h0.0\"/><path d=\"M336.0 70h0.0\"/><rect height=\"22\" rx=\"10\" ry=\"10\" width=\"54\" x=\"282\" y=\"59\"/><text x=\"309\" y=\"74\">блок</text></g><path d=\"M336.0 70h10\"/><g>\n<path d=\"M346.0 70h0.0\"/><path d=\"M440.0 70h0.0\"/><path d=\"M346.0 70a10 10 0 0 0 10 -10v0a10 10 0 0 1 10 -10\"/><g>\n<path d=\"M366.0 50h54.0\"/></g><path d=\"M420.0 50a10 10 0 0 1 10 10v0a10 10 0 0 0 10 10\"/><path d=\"M346.0 70h20\"/><g class=\"terminal \">\n<path d=\"M366.0 70h0.0\"/><path d=\"M420.0 70h0.0\"/><rect height=\"22\" rx=\"10\" ry=\"10\" width=\"54\" x=\"366\" y=\"59\"/><text x=\"393\" y=\"74\">else</text></g><path d=\"M420.0 70h20\"/></g></g><path d=\"M440.0 70h20\"/></g><path d=\"M 460.0 70 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": [
    "if1 = Sequence('if', 'выражение', ':', 'блок', 'elif')\n",
    "if2 = Sequence('if', 'выражение', ':', 'блок', Optional('else'))\n",
    "show_diagram(Choice(1, if1, if2))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "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=\"101\" viewBox=\"0 0 517.0 101\" width=\"517.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 60v20m10 -20v20m-10 -10h20\"/></g><g>\n<path d=\"M40 70h0.0\"/><path d=\"M477.0 70h0.0\"/><path d=\"M40.0 70a10 10 0 0 0 10 -10v-19a10 10 0 0 1 10 -10\"/><g>\n<path d=\"M60.0 31h15.0\"/><path d=\"M442.0 31h15.0\"/><g class=\"terminal \">\n<path d=\"M75.0 31h0.0\"/><path d=\"M129.0 31h0.0\"/><rect height=\"22\" rx=\"10\" ry=\"10\" width=\"54\" x=\"75\" y=\"20\"/><text x=\"102\" y=\"35\">elif</text></g><path d=\"M129.0 31h10\"/><path d=\"M139.0 31h10\"/><g class=\"terminal \">\n<path d=\"M149.0 31h0.0\"/><path d=\"M245.5 31h0.0\"/><rect height=\"22\" rx=\"10\" ry=\"10\" width=\"96.5\" x=\"149\" y=\"20\"/><text x=\"197.25\" y=\"35\">выражение</text></g><path d=\"M245.5 31h10\"/><path d=\"M255.5 31h10\"/><g class=\"terminal \">\n<path d=\"M265.5 31h0.0\"/><path d=\"M294.0 31h0.0\"/><rect height=\"22\" rx=\"10\" ry=\"10\" width=\"28.5\" x=\"265.5\" y=\"20\"/><text x=\"279.75\" y=\"35\">:</text></g><path d=\"M294.0 31h10\"/><path d=\"M304.0 31h10\"/><g class=\"terminal \">\n<path d=\"M314.0 31h0.0\"/><path d=\"M368.0 31h0.0\"/><rect height=\"22\" rx=\"10\" ry=\"10\" width=\"54\" x=\"314\" y=\"20\"/><text x=\"341\" y=\"35\">блок</text></g><path d=\"M368.0 31h10\"/><path d=\"M378.0 31h10\"/><g class=\"terminal \">\n<path d=\"M388.0 31h0.0\"/><path d=\"M442.0 31h0.0\"/><rect height=\"22\" rx=\"10\" ry=\"10\" width=\"54\" x=\"388\" y=\"20\"/><text x=\"415\" y=\"35\">elif</text></g></g><path d=\"M457.0 31a10 10 0 0 1 10 10v19a10 10 0 0 0 10 10\"/><path d=\"M40.0 70h20\"/><g>\n<path d=\"M60.0 70h0.0\"/><path d=\"M457.0 70h0.0\"/><g class=\"terminal \">\n<path d=\"M60.0 70h0.0\"/><path d=\"M114.0 70h0.0\"/><rect height=\"22\" rx=\"10\" ry=\"10\" width=\"54\" x=\"60\" y=\"59\"/><text x=\"87\" y=\"74\">elif</text></g><path d=\"M114.0 70h10\"/><path d=\"M124.0 70h10\"/><g class=\"terminal \">\n<path d=\"M134.0 70h0.0\"/><path d=\"M230.5 70h0.0\"/><rect height=\"22\" rx=\"10\" ry=\"10\" width=\"96.5\" x=\"134\" y=\"59\"/><text x=\"182.25\" y=\"74\">выражение</text></g><path d=\"M230.5 70h10\"/><path d=\"M240.5 70h10\"/><g class=\"terminal \">\n<path d=\"M250.5 70h0.0\"/><path d=\"M279.0 70h0.0\"/><rect height=\"22\" rx=\"10\" ry=\"10\" width=\"28.5\" x=\"250.5\" y=\"59\"/><text x=\"264.75\" y=\"74\">:</text></g><path d=\"M279.0 70h10\"/><path d=\"M289.0 70h10\"/><g class=\"terminal \">\n<path d=\"M299.0 70h0.0\"/><path d=\"M353.0 70h0.0\"/><rect height=\"22\" rx=\"10\" ry=\"10\" width=\"54\" x=\"299\" y=\"59\"/><text x=\"326\" y=\"74\">блок</text></g><path d=\"M353.0 70h10\"/><g>\n<path d=\"M363.0 70h0.0\"/><path d=\"M457.0 70h0.0\"/><path d=\"M363.0 70a10 10 0 0 0 10 -10v0a10 10 0 0 1 10 -10\"/><g>\n<path d=\"M383.0 50h54.0\"/></g><path d=\"M437.0 50a10 10 0 0 1 10 10v0a10 10 0 0 0 10 10\"/><path d=\"M363.0 70h20\"/><g class=\"terminal \">\n<path d=\"M383.0 70h0.0\"/><path d=\"M437.0 70h0.0\"/><rect height=\"22\" rx=\"10\" ry=\"10\" width=\"54\" x=\"383\" y=\"59\"/><text x=\"410\" y=\"74\">else</text></g><path d=\"M437.0 70h20\"/></g></g><path d=\"M457.0 70h20\"/></g><path d=\"M 477.0 70 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": [
    "elif1 = Sequence('elif', 'выражение', ':', 'блок', 'elif')\n",
    "elif2 = Sequence('elif', 'выражение', ':', 'блок', Optional('else'))\n",
    "show_diagram(Choice(1, elif1, elif2))"
   ]
  },
  {
   "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=\"62\" viewBox=\"0 0 276.5 62\" width=\"276.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 21v20m10 -20v20m-10 -10h20\"/></g><path d=\"M40 31h10\"/><g>\n<path d=\"M50 31h0.0\"/><path d=\"M226.5 31h0.0\"/><g class=\"terminal \">\n<path d=\"M50.0 31h0.0\"/><path d=\"M104.0 31h0.0\"/><rect height=\"22\" rx=\"10\" ry=\"10\" width=\"54\" x=\"50\" y=\"20\"/><text x=\"77\" y=\"35\">else</text></g><path d=\"M104.0 31h10\"/><path d=\"M114.0 31h10\"/><g class=\"terminal \">\n<path d=\"M124.0 31h0.0\"/><path d=\"M152.5 31h0.0\"/><rect height=\"22\" rx=\"10\" ry=\"10\" width=\"28.5\" x=\"124\" y=\"20\"/><text x=\"138.25\" y=\"35\">:</text></g><path d=\"M152.5 31h10\"/><path d=\"M162.5 31h10\"/><g class=\"terminal \">\n<path d=\"M172.5 31h0.0\"/><path d=\"M226.5 31h0.0\"/><rect height=\"22\" rx=\"10\" ry=\"10\" width=\"54\" x=\"172.5\" y=\"20\"/><text x=\"199.5\" y=\"35\">блок</text></g></g><path d=\"M226.5 31h10\"/><path d=\"M 236.5 31 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('else', ':', 'блок'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Цикл `for` имеет следующий упрощенный шаблон:\n",
    "\n",
    "```Python\n",
    "for переменная in выражение:\n",
    "    блок\n",
    "```\n",
    "\n",
    "В качестве выражения будем использовать вызов встроенной функции `range`, которая позволяет задать диапазон повторений блока-тела цикла:\n",
    "\n",
    "* range(n). Диапазон $[0, n)$.\n",
    "* range(n, m). Диапазон $[n, m)$.\n",
    "* range(n, m, s). Диапазон $[n, m)$ с шагом $s$.\n",
    "\n",
    "Пример использования:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python 3.0\n",
      "Python 3.1\n",
      "Python 3.2\n",
      "Python 3.3\n",
      "Python 3.4\n",
      "Python 3.5\n",
      "Python 3.6\n",
      "Python 3.7\n",
      "Python 3.8\n",
      "Python 3.9\n"
     ]
    }
   ],
   "source": [
    "for i in range(10):\n",
    "    print('Python', 3 + i / 10)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Упрощенная грамматика `for`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "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=\"62\" viewBox=\"0 0 558.0 62\" width=\"558.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 21v20m10 -20v20m-10 -10h20\"/></g><path d=\"M40 31h10\"/><g>\n<path d=\"M50 31h0.0\"/><path d=\"M508.0 31h0.0\"/><g class=\"terminal \">\n<path d=\"M50.0 31h0.0\"/><path d=\"M95.5 31h0.0\"/><rect height=\"22\" rx=\"10\" ry=\"10\" width=\"45.5\" x=\"50\" y=\"20\"/><text x=\"72.75\" y=\"35\">for</text></g><path d=\"M95.5 31h10\"/><path d=\"M105.5 31h10\"/><g class=\"terminal \">\n<path d=\"M115.5 31h0.0\"/><path d=\"M212.0 31h0.0\"/><rect height=\"22\" rx=\"10\" ry=\"10\" width=\"96.5\" x=\"115.5\" y=\"20\"/><text x=\"163.75\" y=\"35\">выражение</text></g><path d=\"M212.0 31h10\"/><path d=\"M222.0 31h10\"/><g class=\"terminal \">\n<path d=\"M232.0 31h0.0\"/><path d=\"M269.0 31h0.0\"/><rect height=\"22\" rx=\"10\" ry=\"10\" width=\"37\" x=\"232\" y=\"20\"/><text x=\"250.5\" y=\"35\">in</text></g><path d=\"M269.0 31h10\"/><path d=\"M279.0 31h10\"/><g class=\"terminal \">\n<path d=\"M289.0 31h0.0\"/><path d=\"M385.5 31h0.0\"/><rect height=\"22\" rx=\"10\" ry=\"10\" width=\"96.5\" x=\"289\" y=\"20\"/><text x=\"337.25\" y=\"35\">выражение</text></g><path d=\"M385.5 31h10\"/><path d=\"M395.5 31h10\"/><g class=\"terminal \">\n<path d=\"M405.5 31h0.0\"/><path d=\"M434.0 31h0.0\"/><rect height=\"22\" rx=\"10\" ry=\"10\" width=\"28.5\" x=\"405.5\" y=\"20\"/><text x=\"419.75\" y=\"35\">:</text></g><path d=\"M434.0 31h10\"/><path d=\"M444.0 31h10\"/><g class=\"terminal \">\n<path d=\"M454.0 31h0.0\"/><path d=\"M508.0 31h0.0\"/><rect height=\"22\" rx=\"10\" ry=\"10\" width=\"54\" x=\"454\" y=\"20\"/><text x=\"481\" y=\"35\">блок</text></g></g><path d=\"M508.0 31h10\"/><path d=\"M 518.0 31 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', 'выражение', ':', 'блок'))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "\n",
    "В заключение, рассмотрим шаблон для еще одного способа организации циклов — с помощью оператора `while`:\n",
    "\n",
    "```Python\n",
    "while выражение:\n",
    "    блок\n",
    "```\n",
    "\n",
    "Упрощенная грамматика `while`:\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "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=\"62\" viewBox=\"0 0 401.5 62\" width=\"401.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 21v20m10 -20v20m-10 -10h20\"/></g><path d=\"M40 31h10\"/><g>\n<path d=\"M50 31h0.0\"/><path d=\"M351.5 31h0.0\"/><g class=\"terminal \">\n<path d=\"M50.0 31h0.0\"/><path d=\"M112.5 31h0.0\"/><rect height=\"22\" rx=\"10\" ry=\"10\" width=\"62.5\" x=\"50\" y=\"20\"/><text x=\"81.25\" y=\"35\">while</text></g><path d=\"M112.5 31h10\"/><path d=\"M122.5 31h10\"/><g class=\"terminal \">\n<path d=\"M132.5 31h0.0\"/><path d=\"M229.0 31h0.0\"/><rect height=\"22\" rx=\"10\" ry=\"10\" width=\"96.5\" x=\"132.5\" y=\"20\"/><text x=\"180.75\" y=\"35\">выражение</text></g><path d=\"M229.0 31h10\"/><path d=\"M239.0 31h10\"/><g class=\"terminal \">\n<path d=\"M249.0 31h0.0\"/><path d=\"M277.5 31h0.0\"/><rect height=\"22\" rx=\"10\" ry=\"10\" width=\"28.5\" x=\"249\" y=\"20\"/><text x=\"263.25\" y=\"35\">:</text></g><path d=\"M277.5 31h10\"/><path d=\"M287.5 31h10\"/><g class=\"terminal \">\n<path d=\"M297.5 31h0.0\"/><path d=\"M351.5 31h0.0\"/><rect height=\"22\" rx=\"10\" ry=\"10\" width=\"54\" x=\"297.5\" y=\"20\"/><text x=\"324.5\" y=\"35\">блок</text></g></g><path d=\"M351.5 31h10\"/><path d=\"M 361.5 31 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('while', 'выражение', ':', 'блок'))"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "В `for` и `while` допускается использование традиционных операторов `break` и `continue` для преждевременного выхода из цикла.\n",
    "\n",
    "Обратите внимание, конструкции Питона, которые заканчиваются двоеточием, сигнализируют о том, что далее ожидается блок — последовательность строк, выделенных отступом. Не забывайте про двоеточие!"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Литература\n",
    "\n",
    "**На русском языке**\n",
    "\n",
    "* Бизли Дэвид М. Python. Исчерпывающее руководство. — Питер, 2023. — 368 c. Современный учебник по основам языка.\n",
    "* Кэвэна-Джонс Брайан, Бизли Дэвид М. Python. Книга Рецептов. — ДМК Пресс, 2019. — 646 с. Сборник разнообразных техник программирования для уже знакомых с Питоном.\n",
    "* Рамальо Л. Python. К вершинам мастерства. — Litres, 2019. — 770 с. Полезные дополнительные сведения для уже знакомых с Питоном.\n",
    "\n",
    "**На английском языке**\n",
    "\n",
    "* Курс для начинающих David Beazley [Practical Python Programming](https://dabeaz-course.github.io/practical-python/Notes/Contents.html).\n",
    "* [Официальная документация](https://docs.python.org/3/)."
   ]
  }
 ],
 "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
}