lect1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Лекция №1. Введение\n",
    "\n",
    "П.Н. Советов, РТУ МИРЭА"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Зачем изучать Python?\n",
    "\n",
    "Современному программисту и так приходится иметь дело с большим количеством языков программирования. Поэтому для изучения очередного языка нужны какие-то веские причины.\n",
    "\n",
    "Питон является одним из самых популярных и востребованных языков программирования. Об этом говорит целый ряд рейтингов за 2020 год.\n",
    "\n",
    "1. Индекс [TIOBE](https://www.tiobe.com/tiobe-index/) присвоил Питону звание языка программирования года.\n",
    "1. На [Stack Оverflow](https://insights.stackoverflow.com/survey/2020#technology-most-loved-dreaded-and-wanted-languages-wanted) Питон возглавляет список языков, к изучению которых разработчики проявляют интерес.\n",
    "1. В рейтинге популярных языков программирования журнала [IEEE Spectrum](https://spectrum.ieee.org/at-work/tech-careers/top-programming-language-2020) Питон находится на первом месте.\n",
    "1. В исследовании, проведенном компанией [JetBrains](https://www.jetbrains.com/ru-ru/lp/devecosystem-2020/), отмечается, что Питон \"обошел Java в списке используемых языков. Кроме того, это самый изучаемый язык\".\n",
    "1. Среди используемых языков программирования в проектах [Github](https://madnight.github.io/githut/#/pull_requests/2020/4) Питон занимает второе место после JavaScript.\n",
    "\n",
    "Можно выделить следующие причины популярности Питона:\n",
    "\n",
    "* Огромное количество библиотек для самых разных областей применения.\n",
    "* Возможность быстрого прототипирования приложений, благодаря наличию в языке динамической типизации, автоматического управления памятью (\"сборка мусора\"), а также благодаря свободной поддержке различных стилей программирования.\n",
    "* Легкость обучения основам языка, высокая читаемость кода. Синтаксис Питона называют \"исполняемым псевдокодом\".\n",
    "\n",
    "Питон широко применяется в проектах, связанных с машинным обучением и обработкой естественного языка. На [сайте](https://www.tensorflow.org/about/case-studies) популярной библиотеки для глубокого обучения TensorFlow приведены примеры использования Питона крупнейшими мировыми компаниями. Этот язык применяется для задач машинного обучения в компаниях [Яндекс](https://yandex.ru/jobs/vacancies/dev/?tags=python) и Google.\n",
    "\n",
    "Питон популярен в области анализа и визуализации данных, где используются такие известные библиотеки, как Pandas и Matplotlib.\n",
    "\n",
    "<img src=\"https://numpy.org/images/content_images/cs/blackhole.jpg\" width=\"50%\">\n",
    "<div style=\"text-align:center\">Изображение черной дыры в центре галактики M87 получено с помощью Питона</div>\n",
    "\n",
    "Первое изображение черной дыры астрофизики получили с помощью инструментов, реализованных на Питоне. При этом [использовались](https://numpy.org/case-studies/blackhole-image/) популярные библиотеки NumPy и SciPy.\n",
    "\n",
    "Еще одной естественной областью применения рассматриваемого языка является разработка веб-приложений, а также извлечение данных из веб-страниц (web scrapers, web crawlers). Фреймворк Django пользуется известностью среди веб-разработчиков. С его помощью [разработаны](https://www.djangoproject.com/start/overview/) такие сайты, как, например, Instagram и Pinterest.\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",
    "Наконец, язык Питон сегодня является одним из самых популярных языков для обучения программированию. В этой роли он используется как в школах, так и в университетах."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Что собой представляет Python\n",
    "\n",
    "Среди русскоязычных разработчиков, равно как и в этом тексте, одинаково употребляется и \"Питон\", и \"Python\". При этом название языка никак не связано со змеями. Здесь лучше обратиться к истории создания Питона.\n",
    "\n",
    "Автором языка является голландский программист Гвидо ван Россум. Работа над Питоном началась еще в далеком 1989 году, в стенах исследовательского института CWI в Амстердаме. Побудительным мотивом к созданию Питона было желание иметь высокоуровневый язык программирования, занимающий промежуточное положение между языком Си и языком оболочки операционной системы (shell).\n",
    "\n",
    "<img src=\"https://gvanrossum.github.io/images/guido-headshot-2019.jpg\" width=\"25%\">\n",
    "<div style=\"text-align:center\">Автор языка Питон</div>\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` или фигурными скобками `{ ... }` такое решение может показаться непривычным, но в результате хорошо написанные программы на Питоне выглядят, как псевдокод из учебников.\n",
    "\n",
    "Ниже показана простая программа на языке Питон, использующая только стандартную библиотеку языка."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\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'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "На примере этой компактной программы уже видно, насколько богатой является стандартная библиотека Питона. В данном случае используется работа по протоколу 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, написанная на Си, включает в себя и компилятор, и интерпретатор. Первым делом программа на Питоне компилируется в байткод, то есть в представление для виртуальной машины, а затем полученное представление выполняется с помощью интерпретатора байткода.\n",
    "\n",
    "<img src=\"data/pythoncomp.svg\" width=\"50%\">\n",
    "<div style=\"text-align:center\">Процесс компиляции и интерпретации программы на Питоне</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Основные принципы, согласно которым развивается Питон, сформулированы в так называемом \"Дзене Питона\". Его текст на английском языке можно получить с помощью следующей команды интерпретатора CPython."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Zen of Python, by Tim Peters\n",
      "\n",
      "Beautiful is better than ugly.\n",
      "Explicit is better than implicit.\n",
      "Simple is better than complex.\n",
      "Complex is better than complicated.\n",
      "Flat is better than nested.\n",
      "Sparse is better than dense.\n",
      "Readability counts.\n",
      "Special cases aren't special enough to break the rules.\n",
      "Although practicality beats purity.\n",
      "Errors should never pass silently.\n",
      "Unless explicitly silenced.\n",
      "In the face of ambiguity, refuse the temptation to guess.\n",
      "There should be one-- and preferably only one --obvious way to do it.\n",
      "Although that way may not be obvious at first unless you're Dutch.\n",
      "Now is better than never.\n",
      "Although never is often better than *right* now.\n",
      "If the implementation is hard to explain, it's a bad idea.\n",
      "If the implementation is easy to explain, it may be a good idea.\n",
      "Namespaces are one honking great idea -- let's do more of those!\n"
     ]
    }
   ],
   "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": [
    "## Установка Python\n",
    "\n",
    "Зайдите на сайт [python.org](https://www.python.org/) и скачайте последнюю версию Python для своей ОС. Это должна быть версия 3.9 или старше.\n",
    "\n",
    "Если вы работаете в Linux, где уже установлен Питон, то удостоверьтесь, что обновили его до самой последней версии и сделали полную установку (по умолчанию у вас может отсутствовать стандартная GUI-библиотека Tkinter).\n",
    "\n",
    "Войдите в командную строку ОС и удостоверьтесь, что команда `python` выдает в ответ информацию такого вида:\n",
    "\n",
    "```\n",
    "Python 3.9.0 (tags/v3.9.0:9cf6752, Oct  5 2020, 15:34:40) [MSC v.1927 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-блокнотами и дополнительными библиотеками проще всего установить отдельный дистрибутив Питона — [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": 4,
   "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",
    "```\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",
    "```\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",
    "```\n",
    ">>> 1234.5\n",
    "1234.5\n",
    ">>> 12345e-1\n",
    "1234.5\n",
    "```\n",
    "\n",
    "Для улучшения читаемости в числовых литералах можно использовать символ `_`:\n",
    "\n",
    "```\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",
    "```\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",
    "```\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",
    "<img src=\"data/globals.svg\" width=\"50%\">\n",
    "<div style=\"text-align:center\">Состояние глобального пространства имен после присваиваний</div>\n",
    "\n",
    "С помощью встроенной функции `globals` можно узнать текущее состояние глобального пространства имен:\n",
    "\n",
    "```\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",
    "```\n",
    "\n",
    "В выражениях фигурируют различные операции. Далее показана сравнительная таблица приоритетов некоторых операций Питона и C++. Строки таблицы отсортированы по старшинству приоритетов.\n",
    "\n",
    "| Python          | C++         |\n",
    "|-----------------|-------------|\n",
    "|        **       |             |\n",
    "|     +x -x ~x    | +x -x ~x !x |\n",
    "|      * / // %      | * /  %       |\n",
    "| + -             | + -         |\n",
    "| << >>           | << >>       |\n",
    "| &               | < <= > >=   |\n",
    "| ^               | == !=       |\n",
    "| \\|              | &           |\n",
    "| < <= > >= != == | ^           |\n",
    "| not             | \\|          |\n",
    "| and             | &&          |\n",
    "| or              | &#124;&#124;        |\n",
    "\n",
    "Многие операции одинаково обозначаются в Питоне и C++. Операции булевой логики Питона `not`, `and` и `or` имеют эквиваленты в C++ в виде `!`, `&&` и `||`. Операция `**` обозначает в Питоне возведение в степень. Операция ``//`` обозначает целочисленный вариант деления.\n",
    "\n",
    "Операции сравнения выдают булевы значения. \n",
    "\n",
    "Дополнительные математические операции содержатся в модуле [math](https://docs.python.org/3/library/math.html), который импортируется в текущее пространство имен, как показано ниже (о модулях мы еще будем говорить). Функции из модуля вызываются с префиксом в виде названия модуля и через точку:\n",
    "\n",
    "```\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": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15.0"
      ]
     },
     "execution_count": 2,
     "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": 11,
   "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": 10,
   "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": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"data/if1.svg\">\n",
    "\n",
    "Часть `elif`:\n",
    "\n",
    "<img src=\"data/if2.svg\">\n",
    "\n",
    "Часть `else`:\n",
    "\n",
    "<img src=\"data/if3.svg\">"
   ]
  },
  {
   "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": 13,
   "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)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Упрощенная грамматика `for`:\n",
    "\n",
    "<img src=\"data/for.svg\">\n",
    "\n",
    "В заключение, рассмотрим шаблон для еще одного способа организации циклов — с помощью оператора `while`:\n",
    "\n",
    "```Python\n",
    "while выражение:\n",
    "    блок\n",
    "```\n",
    "\n",
    "Упрощенная грамматика `while`:\n",
    "\n",
    "<img src=\"data/while.svg\">\n",
    "\n",
    "В `for` и `while` допускается использование традиционных операторов `break` и `continue` для преждевременного выхода из цикла.\n",
    "\n",
    "Обратите внимание, конструкции Питона, которые заканчиваются двоеточием, сигнализируют о том, что далее ожидается блок — последовательность строк, выделенных отступом. Не забывайте про двоеточие!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## О курсе\n",
    "\n",
    "Курс программирования на языке Python предназначен для студентов, уже имеющих опыт использования таких языков, как C++, Java или C#, а также знакомых с базовыми алгоритмами и структурами данных.\n",
    "\n",
    "Питон позиционируется, как простой язык для изучения, однако изучение его на серьезном уровне требует немалых усилий. В этой связи курс разделен на 2 части: базовые сведения и материалы для углубленного изучения.\n",
    "\n",
    "Акцент делается на общих подходах и алгоритмах, а не на изучении популярных сегодня фреймворков. Последние за несколько лет могут устареть, поэтому полезнее иметь фундаментальную подготовку, которая позволит быстро сориентироваться и изучить актуальные библиотеки и технологии.\n",
    "\n",
    "**Часть 1**\n",
    "\n",
    "| Название                                  | Описание                                                                                                          | Объем (лекций) |\n",
    "|-------------------------------------------|-------------------------------------------------------------------------------------------------------------------|----------------|\n",
    "|                  Введение                 | Мотивация. О языке. Режим калькулятора. Отступы и конструкции ветвления. О курсе.                                                               | 1              |\n",
    "|              Простые скрипты              | Типы данных. Стандартная библиотека. Командная строка. Jupyter-блокноты.    | 1              |\n",
    "|     Модульность и организация программ    | Хороший стиль оформления кода и PEP8. Модули, пакеты. Pip, venv. Исключения. Тестирование и отладка.          | 1              |\n",
    "| Объектно-ориентированное программирование | Пользовательские типы данных, обобщенное программирование и утиная типизация. Современный взгляд на ООП. | 1              |\n",
    "\n",
    "**Часть 2**\n",
    "\n",
    "| Название                                     | Описание                                                                                      | Объем (лекций) |\n",
    "|----------------------------------------------|-----------------------------------------------------------------------------------------------|----------------|\n",
    "|        Функциональное программирование       | Замыкания (nonlocal), lambda. Итераторы, генераторы. Библиотеки functools, itertools. NumPy.  | 2              |\n",
    "| Параллельное и конкурентное программирование | Сопрограммы. asyncio, multiprocessing. GIL. Программирование для Web. | 1              |\n",
    "|             Метапрограммирование             | eDSL. Модуль ast. Необязательная типизация. Внутреннее устройство CPython.              | 1              |\n",
    "\n",
    "Задачи по курсу делятся на два основных типа:\n",
    "\n",
    "1. \"Скучные\" задачи, которые генерируются (на Питоне!) процедурно для каждого студента в отдельности. Они являются обязательными к выполнению.\n",
    "2. \"Творческие\" задачи, для тех, кто справился с задачами \"скучными\". \n",
    "\n",
    "Различные поощрения можно получить следующим образом:\n",
    "\n",
    "* Создание новых уровней и доработка игры [DandyBot](https://github.com/true-grue/DandyBot) (pull request).\n",
    "* Создание генератора для своей \"скучной\" задачи.\n",
    "* Обнаружение ошибок в Jupyter-блокнотах и предложения по дополнению материала (pull request)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Источники\n",
    "\n",
    "**На русском языке**\n",
    "\n",
    "* Jupyter-блокноты Александра Дьяконова [Приёмы при написании python-программ](https://github.com/Dyakonov/python_hacks). Полезны начинающим.\n",
    "* Книга *Лутц Марк. Изучаем Python, 4-е издание*. Объемный, многословный учебник.\n",
    "* Книга *Кэвэна-Джонс Брайан, Бизли Дэвид М. Python. Книга Рецептов*. Отличный сборник разнообразных техник программирования для уже знакомых с Питоном.\n",
    "\n",
    "**На английском языке**\n",
    "\n",
    "* Хороший курс Дэвида Бизли [Practical Python Programming](https://dabeaz-course.github.io/practical-python/Notes/Contents.html) для начинающих.\n",
    "* [Официальная документация](https://docs.python.org/3/).\n",
    "* Справочник David Beazley. Python Essential Reference, 4th Edition."
   ]
  }
 ],
 "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}