{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!-- dom:TITLE: Введение -->\n",
    "# Введение\n",
    "<!-- dom:AUTHOR: С.В. Лемешевский Email:sergey.lemeshevsky@gmail.com at Институт математики НАН Беларуси -->\n",
    "<!-- Author: -->  \n",
    "**С.В. Лемешевский** (email: `sergey.lemeshevsky@gmail.com`), Институт математики НАН Беларуси\n",
    "\n",
    "Date: **Feb 26, 2020**\n",
    "\n",
    "<!-- Common Mako variable and functions -->\n",
    "<!-- -*- coding: utf-8 -*- -->\n",
    "\n",
    "\n",
    "\n",
    "# Установка\n",
    "<div id=\"intro:install\"></div>\n",
    "\n",
    "## Версии Python\n",
    "<div id=\"intro:install:vers\"></div>\n",
    "\n",
    "На сегодняшний день существуют две версии Python — это Python 2\n",
    "и Python 3, у них отсутствует полная совместимость друг с другом. На\n",
    "данный момент вторая версия Python ещё широко используется,\n",
    "но, судя по изменениям, которые происходят, со временем, она останется\n",
    "только для запуска старого кода. Мы будем Python 3, и, в дальнейшем,\n",
    "если где-то будет встречаться слово Python, то под ним следует\n",
    "понимать Python 3. Случаи применения Python 2 будут специально\n",
    "оговариваться.\n",
    "\n",
    "## Установка Python\n",
    "<div id=\"intro:install:python\"></div>\n",
    "\n",
    "Для установки интерпретатора Python на ваш компьютер, первое, что\n",
    "нужно сделать — это скачать дистрибутив. Загрузить его можно с\n",
    "официального сайта, перейдя по ссылке <https://www.python.org/downloads/>\n",
    "\n",
    "<!-- dom:FIGURE: [fig-intro/python_downloads.png, width=600 frac=1.0] -->\n",
    "<!-- begin figure -->\n",
    "![](fig-intro/python_downloads.png)<!-- end figure -->\n",
    "\n",
    "\n",
    "\n",
    "### Установка Python в Windows\n",
    "\n",
    "<div id=\"intro:install:python:windows\"></div>\n",
    "\n",
    "Для операционной системы Windows дистрибутив распространяется либо в виде\n",
    "исполняемого файл, либо в виде архивного файла.\n",
    "\n",
    "<!-- dom:FIGURE: [fig-intro/python_dwl_list_files.png, width=600 frac=1.0] -->\n",
    "<!-- begin figure -->\n",
    "![](fig-intro/python_dwl_list_files.png)<!-- end figure -->\n",
    "\n",
    "\n",
    "**Порядок установки.**\n",
    "\n",
    "1. Запустите скачанный установочный файл.\n",
    "\n",
    "2. Выберете способ установки.\n",
    "\n",
    "<!-- dom:FIGURE: [fig-intro/python_inst_1.png, width=600 frac=1.0] -->\n",
    "<!-- begin figure -->\n",
    "![](fig-intro/python_inst_1.png)<!-- end figure -->\n",
    "\n",
    "\n",
    "В данном окне предлагается два варианта *Install Now* и *Customize installation*. При\n",
    "выборе *Install Now*, Python установится в папку по указанному пути. Помимо самого\n",
    "интерпретатора будет установлен `IDLE` (интегрированная среда разработки), `pip`\n",
    "(пакетный менеджер) и документация, а также будут созданы соответствующие ярлыки\n",
    "и установлены связи файлов, имеющие расширение `.py` с интерпретатором Python.\n",
    "*Customize installation* – это вариант настраиваемой установки. Опция *Add python 3.* to\n",
    "`PATH` нужна для того, чтобы появилась возможность запускать интерпретатор без\n",
    "указания полного пути до исполняемого файла при работе в командной строке.\n",
    "\n",
    "1. Отметьте необходимые опций установки (доступно при выборе *Customize installation*)\n",
    "\n",
    "<!-- dom:FIGURE: [fig-intro/python_inst_2.png, width=600 frac=1.0] -->\n",
    "<!-- begin figure -->\n",
    "![](fig-intro/python_inst_2.png)<!-- end figure -->\n",
    "\n",
    "\n",
    "На этом шаге нам предлагается отметить дополнения, устанавливаемые вместе с\n",
    "интерпретатором Python . Рекомендуем выбрать все опции:\n",
    "\n",
    "* `Documentation` – установка документаций.\n",
    "\n",
    "* `pip` – установка пакетного менеджера pip.\n",
    "\n",
    "* `tcl/tk` and `IDLE` – установка интегрированной среды разработки (`IDLE`) и библиотеки для построения графического интерфейса (`tkinter`).\n",
    "\n",
    "2. Выберете место установки (доступно при выборе Customize installation )\n",
    "\n",
    "<!-- dom:FIGURE: [fig-intro/python_inst_3.png, width=600 frac=1.0] -->\n",
    "<!-- begin figure -->\n",
    "![](fig-intro/python_inst_3.png)<!-- end figure -->\n",
    "\n",
    "\n",
    "Помимо указания пути, данное окно позволяет внести дополнительные\n",
    "изменения в процесс установки с помощью опций:\n",
    "\n",
    "* `Install for all users` – Установить для всех пользователей. Если не выбрать данную опцию, то будет предложен вариант инсталляции в папку пользователя, устанавливающего интерпретатор.\n",
    "\n",
    "* `Associate files with Python` – Связать файлы, имеющие расширение `.py`, с Python. При выборе данной опции будут внесены изменения в Windows , позволяющие запускать Python скрипты по двойному щелчку мыши.\n",
    "\n",
    "* `Create shortcuts for installed applications` – Создать ярлыки для запуска приложений.\n",
    "\n",
    "* `Add Python to environment variables` – Добавить пути до интерпретатора Python в переменную `PATH`.\n",
    "\n",
    "* `Precomple standard library` – Провести прекомпиляцию стандартной библиотеки.\n",
    "\n",
    "Последние два пункта (`Download debugging symbols`, `Download debug\n",
    "binaries`) связаны с загрузкой компонентов для отладки, их мы устанавливать не будем.\n",
    "\n",
    "\n",
    "1. После успешной установки вас ждет следующее сообщение.\n",
    "\n",
    "<!-- dom:FIGURE: [fig-intro/python_inst_4.png, width=600 frac=1.0] -->\n",
    "<!-- begin figure -->\n",
    "![](fig-intro/python_inst_4.png)<!-- end figure -->\n",
    "\n",
    "\n",
    "### Установка Python в Linux\n",
    "\n",
    "<div id=\"intro:install:python:linux\"></div>\n",
    "\n",
    "Чаще всего интерпретатор Python уже в входит в состав дистрибутива. Это можно\n",
    "проверить набрав в терминале"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "        Terminal> python\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "или"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "        Terminal> python3\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В первом случае, вы запустите Python 2 во втором – Python 3. В будущем, скорее\n",
    "всего, во всех дистрибутивах Linux, включающих Python, будет входить только третья\n",
    "версия. Если у вас, при попытке запустить Python, выдается сообщение о том, что он\n",
    "не установлен, или установлен, но не тот, что вы хотите, то у вас есть два пути: а)\n",
    "собрать Python из исходников; б) взять из репозитория.\n",
    "\n",
    "Например, для установки из репозитория в Ubuntu воспользуйтесь командой:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "        Terminal> sudo apt-get install python3\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Установка Anaconda\n",
    "<div id=\"intro:install:anaconda\"></div>\n",
    "\n",
    "Для удобства запуска примеров и изучения языка Python , советуем установить на\n",
    "свой ПК пакет Anaconda . Этот пакет включает в себя интерпретатор языка Python (есть\n",
    "версии 2 и 3), набор наиболее часто используемых библиотек и удобную среду\n",
    "разработки и исполнения, запускаемую в браузере.\n",
    "\n",
    "Для установки этого пакета, предварительно нужно скачать дистрибутив\n",
    "<https://www.continuum.io/downloads>.\n",
    "\n",
    "Есть варианты под Windows , Linux и Mac OS .\n",
    "\n",
    "### Установка Anaconda в Windows\n",
    "\n",
    "<div id=\"intro:install:anaconda:windows\"></div>\n",
    "\n",
    "1. Запустите скачанный инсталлятор. В первом появившемся окне необходимо\n",
    "нажать «Next».\n",
    "\n",
    "<!-- dom:FIGURE: [fig-intro/anaconda_inst_1.png, width=600 frac=1.0] -->\n",
    "<!-- begin figure -->\n",
    "![](fig-intro/anaconda_inst_1.png)<!-- end figure -->\n",
    "\n",
    "\n",
    "2. Далее следует принять лицензионное соглашение.\n",
    "\n",
    "<!-- dom:FIGURE: [fig-intro/anaconda_inst_2.png, width=600 frac=1.0] -->\n",
    "<!-- begin figure -->\n",
    "![](fig-intro/anaconda_inst_2.png)<!-- end figure -->\n",
    "\n",
    "\n",
    "\n",
    "3. Выберете одну из опций установки:\n",
    "\n",
    "<!-- dom:FIGURE: [fig-intro/anaconda_inst_3.png, width=600 frac=1.0] -->\n",
    "<!-- begin figure -->\n",
    "![](fig-intro/anaconda_inst_3.png)<!-- end figure -->\n",
    "\n",
    "\n",
    "* `Just Me` – только для пользователя, запустившего установку;\n",
    "\n",
    "* `All Users – для всех пользователей.`\n",
    "\n",
    "4. Укажите путь, по которому будет установлена Anaconda.\n",
    "\n",
    "<!-- dom:FIGURE: [fig-intro/anaconda_inst_4.png, width=600 frac=1.0] -->\n",
    "<!-- begin figure -->\n",
    "![](fig-intro/anaconda_inst_4.png)<!-- end figure -->\n",
    "\n",
    "\n",
    "5. Укажите дополнительные опции:\n",
    "\n",
    "<!-- dom:FIGURE: [fig-intro/anaconda_inst_5.png, width=600 frac=1.0] -->\n",
    "<!-- begin figure -->\n",
    "![](fig-intro/anaconda_inst_5.png)<!-- end figure -->\n",
    "\n",
    "\n",
    "* `Add Anaconda to the system PATH environment variable` – добавить Anaconda в системную переменную `PATH`;\n",
    "\n",
    "* `Register Anaconda as the system Python 3` – использовать Anaconda, как интерпретатор Python 3 по умолчанию.\n",
    "\n",
    "Для начала установки нажмите на кнопку «Install».\n",
    "\n",
    "5. После этого будет произведена установка Anaconda на ваш компьютер.\n",
    "\n",
    "<!-- dom:FIGURE: [fig-intro/anaconda_inst_6.png, width=600 frac=1.0] -->\n",
    "<!-- begin figure -->\n",
    "![](fig-intro/anaconda_inst_6.png)<!-- end figure -->\n",
    "\n",
    "\n",
    "### Установка Anaconda в Linux\n",
    "\n",
    "<div id=\"intro:install:anaconda:linux\"></div>\n",
    "\n",
    "Скачайте дистрибутив Anaconda для Linux, он будет иметь расширение\n",
    "`.sh` , и запустите установку командой:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "        Terminal> bash имя_дистрибутива.sh\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В результате вы увидите приглашение к установке. Для продолжения\n",
    "процессе нажмите «Enter».\n",
    "\n",
    "<!-- dom:FIGURE: [fig-intro/anaconda_inst_7.png, width=600 frac=1.0] -->\n",
    "<!-- begin figure -->\n",
    "![](fig-intro/anaconda_inst_7.png)<!-- end figure -->\n",
    "\n",
    "\n",
    "2. Прочитайте лицензионное соглашение, его нужно пролистать до конца.\n",
    "\n",
    "<!-- dom:FIGURE: [fig-intro/anaconda_inst_8.png, width=600 frac=1.0] -->\n",
    "<!-- begin figure -->\n",
    "![](fig-intro/anaconda_inst_8.png)<!-- end figure -->\n",
    "\n",
    "\n",
    "Согласитесь с ним, для этого требуется набрать в командной строке `yes`, в ответе\n",
    "на вопрос инсталлятора:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "        Terminal> Do you approve the license terms? [yes|no]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!-- dom:FIGURE: [fig-intro/anaconda_inst_9.png, width=600 frac=1.0] -->\n",
    "<!-- begin figure -->\n",
    "![](fig-intro/anaconda_inst_9.png)<!-- end figure -->\n",
    "\n",
    "\n",
    "3. Выберете место установки. Можно выбрать один из следующих вариантов:\n",
    "\n",
    "<!-- dom:FIGURE: [fig-intro/anaconda_inst_10.png, width=600 frac=1.0] -->\n",
    "<!-- begin figure -->\n",
    "![](fig-intro/anaconda_inst_10.png)<!-- end figure -->\n",
    "\n",
    "\n",
    "* `Press ENTER to confirm the location` – нажмите ENTER для принятия предложенного пути установки. Путь по умолчанию для моей машины: /home/tester/anaconda3 , он представлен чуть выше данного меню.\n",
    "\n",
    "* `Press CTRL-C to abort the installation` – нажмите CTRL-C для отмены установки.\n",
    "\n",
    "* `Or specify a different location below` – или укажите другой путь в строке ниже.\n",
    "\n",
    "Нажмите «ENTER».\n",
    "\n",
    "4. После этого начнется установка.\n",
    "\n",
    "<!-- dom:FIGURE: [fig-intro/anaconda_inst_11.png, width=600 frac=1.0] -->\n",
    "<!-- begin figure -->\n",
    "![](fig-intro/anaconda_inst_11.png)<!-- end figure -->\n",
    "\n",
    "\n",
    "## Проверка работоспособности\n",
    "<div id=\"intro:install:check\"></div>\n",
    "\n",
    "Теперь проверим работоспособность всего того, что мы установили.\n",
    "\n",
    "### Проверка интерпретатора Python\n",
    "\n",
    "<div id=\"intro:install:check:python\"></div>\n",
    "\n",
    "Для начала протестируем интерпретатор в командном режиме. Если вы работаете\n",
    "в Windows , то нажмите сочетание Win+R и в появившемся окне введите\n",
    "`python`. В Linux откройте окно терминала и в нем введите `python3`\n",
    "(или `python`).\n",
    "\n",
    "В результате Python запустится в командном режиме, выглядеть это будет\n",
    "примерно так (картинка приведена для Windows, в Linux результат будет\n",
    "аналогичным):\n",
    "\n",
    "<!-- dom:FIGURE: [fig-intro/check_1.png, width=600 frac=1.0] -->\n",
    "<!-- begin figure -->\n",
    "![](fig-intro/check_1.png)<!-- end figure -->\n",
    "\n",
    "\n",
    "В окне введите:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "print(\"Hello, World!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Результат должен быть следующий:\n",
    "\n",
    "<!-- dom:FIGURE: [fig-intro/check_2.png, width=600 frac=1.0] -->\n",
    "<!-- begin figure -->\n",
    "![](fig-intro/check_2.png)<!-- end figure -->\n",
    "\n",
    "\n",
    "### Проверка Anaconda\n",
    "\n",
    "<div id=\"intro:install:check:anaconda\"></div>\n",
    "\n",
    "Здесь и далее будем считать, что пакет Anaconda установлен в Windows, в папку\n",
    "`C:\\Anaconda3`, в Linux, вы его можете найти в каталоге, который\n",
    "выбрали при установке.\n",
    "\n",
    "Перейдите в папку `Scripts` и введите в командной строке:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "        Terminal> ipython notebook\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!-- dom:FIGURE: [fig-intro/check_3.png, width=600 frac=1.0] -->\n",
    "<!-- begin figure -->\n",
    "![](fig-intro/check_3.png)<!-- end figure -->\n",
    "\n",
    "\n",
    "Если вы находитесь в Windows и открыли папку `C:\\Anaconda3\\Scripts` через\n",
    "проводник, то для запуска интерпретатора командной строки для этой папки в поле\n",
    "адреса введите `cmd`.\n",
    "\n",
    "<!-- dom:FIGURE: [fig-intro/check_4.png, width=600 frac=1.0] -->\n",
    "<!-- begin figure -->\n",
    "![](fig-intro/check_4.png)<!-- end figure -->\n",
    "\n",
    "\n",
    "\n",
    "В результате запустится веб-сервер и среда разработки в браузере.\n",
    "\n",
    "<!-- dom:FIGURE: [fig-intro/check_5.png, width=600 frac=1.0] -->\n",
    "<!-- begin figure -->\n",
    "![](fig-intro/check_5.png)<!-- end figure -->\n",
    "\n",
    "\n",
    "Создайте ноутбук для разработки, для этого нажмите на кнопку «New» (в правом углу\n",
    "окна) и в появившемся списке выберете Python.\n",
    "\n",
    "В результате будет создана новая страница в браузере с ноутбуком. Введите в\n",
    "первой ячейке команду"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "print(\"Hello, World!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "и нажмите Alt+Enter на клавиатуре. Ниже ячейки должна появиться соответствующая надпись.\n",
    "\n",
    "<!-- dom:FIGURE: [fig-intro/check_6.png, width=600 frac=1.0] -->\n",
    "<!-- begin figure -->\n",
    "![](fig-intro/check_6.png)<!-- end figure -->\n",
    "\n",
    "\n",
    "<!-- Local Variables: -->\n",
    "<!-- doconce-chapter-nickname: \"intro\" -->\n",
    "<!-- doconce-section-nickname: \"install\" -->\n",
    "<!-- End: -->\n",
    "# Установка библиотек\n",
    "<div id=\"intro:libs\"></div>\n",
    "\n",
    "В зависимости от вашей системы и предыдущих инсталляций среда Python\n",
    "может оказаться неукомплектованной всем тем, что может понадобиться.\n",
    "\n",
    "Чтобы установить любую нужную библиотеку, можно применить команду\n",
    "`pip`. Инструмент установки библиотек Python `pip` непосредственно\n",
    "получает доступ к Интернету и получает их из каталога библиотек Python\n",
    "[PyPI](https://pypi.python.org/pypi). PyPI представляет собой\n",
    "репозиторий, содержащий сторонние библиотеки с открытым исходным\n",
    "кодом, которые постоянно поддерживаются в работоспособном состоянии и\n",
    "сохраняются в репозитории их автором.\n",
    "\n",
    "Устанавливать библиотеки лучше всего при помощи `pip` по следующим\n",
    "причинам:\n",
    "* он является предпочтительным диспетчером библиотек Python и начиная с Python 2.7.9 и Python 3.4 по умолчанию включен в дистрибутивы Python;\n",
    "\n",
    "* он обеспечивает функциональность по деинсталляции библиотек;\n",
    "\n",
    "* он возвращает вашу систему в исходное состояние и оставляет ее чистой, если по какой-либо причине установленная библиотека перестала работать.\n",
    "\n",
    "Команда `pip` работает в командной строке. Чтобы удостовериться в том,\n",
    "что инструмент `pip` установлен на локальной машине, выполните\n",
    "следующую команду:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "        Terminal> pip -V\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В некоторых инсталляциях в Linux и Mac OS устанавливается и Python 3 и\n",
    "Python 2, в результате чего могут присутствовать команды `pip3` и\n",
    "`pip2`. Если это так, то `pip2` подходит только для установки\n",
    "библиотек в Python 2, а команды `pip` и `pip3` — только для библиотек\n",
    "Python 3.\n",
    "\n",
    "Если проверка закончилась ошибкой, то вам действительно нужно\n",
    "установить `pip` с нуля. Для установки `pip` следуйте инструкциям на\n",
    "<https://pip.pypa.io/en/stable/installing/>. Самый безопасный\n",
    "путь состоит в том, чтобы скачать сценарий `get-pip.py` по прямой\n",
    "ссылке с [get-pip.py](https://bootstrap.pypa.io/get-pip.py) и затем\n",
    "выполнить его при помощи следующей команды:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "        Terminal> python get-pip.py\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "После того, как вы удостоверитесь, что инструмент `pip` установлен,\n",
    "можно будет устанавливать дополнительные библиотеки Python. Чтобы\n",
    "установить типовую библиотеку `<lib>`, нужно просто выполнить команду:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "        Terminal> pip install <lib>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "После этого библиотека `<lib>` и все библиотеки, от которых она\n",
    "зависит, будут скачаны и установлены.\n",
    "\n",
    "Если вы установили дистрибутив Anaconda, то в нем для управления\n",
    "установкой библиотек используется инструмент `conda`\n",
    "\n",
    "## Способы обновления библиотек\n",
    "<div id=\"intro:libs:update\"></div>\n",
    "\n",
    "Как правило, может возникнуть ситуация, когда необходимо обновить\n",
    "библиотеку, потому что некая связанная с ней другая библиотека,\n",
    "т.н. зависимость, требует наличия более новой версии, либо имеется\n",
    "дополнительный функционал, который требуется задействовать. Для этого\n",
    "сначала нужно проверить версию установленной библиотеки, обратившись к\n",
    "атрибуту `__version__`, как показано в примере с библиотекой NumPy\n",
    "ниже:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "import numpy\n",
    ">>> numpy.__version__ # 2 символа подчеркивания перед ним и после него"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Далее если нужно ее обновить до более новой версии, скажем в точности\n",
    "до версии 1.9.2, то из командной строки можно выполнить следующую ниже\n",
    "команду:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "        Terminal> pip install -U numpy==1.9.2\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Если вы просто заинтересованы в обновлении до последней доступной\n",
    "версии, то просто выполните команду"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "        Terminal> pip install -U numpy\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<!-- Local Variables: -->\n",
    "<!-- doconce-chapter-nickname: \"intro\" -->\n",
    "<!-- doconce-section-nickname: \"libs\" -->\n",
    "<!-- End: -->\n",
    "# Среды для вычислений в Python\n",
    "<div id=\"intro:environments\"></div>\n",
    "\n",
    "Программный код на языке Python можно записать с помощью любого\n",
    "простого текстового редактора, который способен загружать и сохранять\n",
    "текст либо в кодировке ASCII, либо UTF-8. По умолчанию предполагается,\n",
    "что файлы с программным кодом на языке Python сохраняются в кодировке\n",
    "UTF-8, надмножестве кодировки ASCII, с помощью которой можно\n",
    "представить практически любой символ любого национального\n",
    "алфавита. Файлы с программным кодом на языке Python обычно имеют\n",
    "расширение `.py`, хотя в некоторых UNIX-подобных системах (таких как\n",
    "Linux и Mac OS X) некоторые приложения на языке Python не имеют\n",
    "расширения, а программы на языке Python с графическим интерфейсом, в\n",
    "частности в Windows и Mac OS X, обычно имеют расширение `.pyw`. В этой\n",
    "книге все время будет использоваться расширение `.py` для обозначения\n",
    "консольных программ и модулей Python и расширение `.pyw` – для\n",
    "программ с графическим интерфейсом. Все примеры, представленные в\n",
    "книге, не требуют изменений для запуска в любой из платформ,\n",
    "поддерживаемых Python 3.\n",
    "\n",
    "\n",
    "Язык Python – это *интерпретируемый* язык. Это означает, что помимо\n",
    "непосредственно самой программы, вам необходим специальный инструмент для её\n",
    "запуска. Напомним, что существуют компилируемые и интерпретируемые языки\n",
    "программирования. В первом случае, программа с языка высокого уровня переводится\n",
    "в машинный код для конкретной платформы. В дальнейшем, среди пользователей,\n",
    "она, как правило, распространяется в виде бинарного файла. Для запуска такой\n",
    "программы не нужны дополнительные программные средства (за исключением\n",
    "необходимых библиотек, но эти тонкости выходят за рамки нашего обсуждения).\n",
    "Самыми распространенными языками такого типа являются C++ и C . Программы на\n",
    "интерпретируемых языках, выполняются интерпретатором и распространяются в виде\n",
    "исходного кода.\n",
    "\n",
    "Ниже представим несколько сред вычислений в Python.\n",
    "\n",
    "## Интерпретатор\n",
    "<div id=\"intro:environments:interpret\"></div>\n",
    "\n",
    "Стандартный способ выполнения файлов со сценариями Python — запуск программ\n",
    "напрямую через интерпретатор с помощью команды `python`. Если в\n",
    "качестве аргумента команды `python` передается исходный файл,\n",
    "то выполняется код Python, записанный в файле:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "        Terminal> python hello.py\n",
    "        Hello from Python!\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Здесь файл [hello.py](src-intro/hello.py) содержит одну строку:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "print(\"Hello from Python!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Кроме выполнения файлов со сценариями Python интерпретатор можно\n",
    "использовать в качестве интерактивной консоли (REPL:\n",
    "Read-Evaluate-Print-Loop). Выполнив команду `python` без аргументов,\n",
    "вы можете запустить интерпретатор Python в интерактивном\n",
    "режиме:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "        Terminal> python\n",
    "        Python 3.8.1 (default, Jan 22 2020, 06:38:00) \n",
    "        [GCC 9.2.0] on linux\n",
    "        Type \"help\", \"copyright\", \"credits\" or \"license\" for more information.\n",
    "        >>> \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Здесь можно вводить код Python. При этом для каждой инструкции\n",
    "интерпретатор выполняет код и выводит результат на экран.\n",
    "Интерпретатор Python предоставляет такие возможности как история\n",
    "команд и базовое автодополнение команд.\n",
    "\n",
    "## Консоль IPython\n",
    "<div id=\"intro:environments:ipython\"></div>\n",
    "\n",
    "IPython\n",
    "— расширенная среда интерпретатора REPL для Python с\n",
    "дополнительными функциями для интерактивных и исследовательских\n",
    "вычислений. Например, IPython предоставляет улучшенный просмотр\n",
    "истории команд (также между сессиями), систему кэшировния ввода и\n",
    "вывода, улучшенное автодополнение, более подробные и полезные\n",
    "отслеживания исключений и многое другое. Фактически, IPython теперь\n",
    "намного больше, чем расширенный интерфейс командной строки Python. \n",
    "\n",
    "Выполнение команды `ipython` запускает интерпретатор IPython:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "        Terminal> ipython\n",
    "        Python 3.8.1 (default, Jan 22 2020, 06:38:00) \n",
    "        Type 'copyright', 'credits' or 'license' for more information\n",
    "        IPython 7.12.0 -- An enhanced Interactive Python. Type '?' for help.\n",
    "        \n",
    "        In [1]:  \n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Кэширование ввода и вывода\n",
    "\n",
    "<div id=\"intro:environments:ipython:caching\"></div>\n",
    "\n",
    "В консоли IPython подсказка ввода обозначается как `In[1]:`, а\n",
    "соответствующий вывод обозначается как `Out[1]:`, где число в\n",
    "квадратных скобках увеличивается для каждого нового ввода и\n",
    "вывода. Эти подсказки ввода и вывода называются *ячейками* в \n",
    "IPython. Значения как входных так и выходныех предыдущих ячеек можно\n",
    "потом использовать через переменные `In` и `Out`, которые\n",
    "автоматически создаются IPtyhon. Переменные `In` и `Out` — это список\n",
    "и словарь соответственно, которые могут быть проиндексированы индексом\n",
    "ячейки. Например, рассмотрим следующую сессию IPython:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "3*3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "In[]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "Out[]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "In"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "Out"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Кэширование ввода и вывода часто полезно при интерактивных и\n",
    "исследовательских вычислениях, так как результат вычислений может быть\n",
    "доступен даже если он не был явно присвоен переменной.\n",
    "\n",
    "Отметим, что когда ячейка выполнена, значение последнего выражения в\n",
    "ячейке ввода по-умолчанию отображается в соответствующей ячейке\n",
    "вывода, если выражение не является присваиванием или если значение не\n",
    "равно `None`. Вывод можно пресечь посредством ввода точки с запятой в\n",
    "конце инструкции:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "1+2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "1+2;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "x=1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "x=2; x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Автодополнение и самоанализ объектов\n",
    "\n",
    "<div id=\"intro:environments:ipython:autocompl\"></div>\n",
    "\n",
    "В Ipython нажатие клавиши `TAB` активирует автодополнение, которое\n",
    "отображает список символов (переменных, функций, классов и т.д.) с\n",
    "именами, которые доступны для дополнения того, что уже было\n",
    "набрано. Автодополнение в IPython является контекстным, и оно будет\n",
    "искать совпадающие переменные и функции в текущем пространстве имен\n",
    "или среди атрибутов и методов класса при вызове после имени экземпляра\n",
    "класса. Например, `os.<TAB>` даст список переменных, функций и классов\n",
    "из модуля `os`, а нажатие `TAB` после того, как набрали `os.w` даст\n",
    "список символов из модуля `os`, которые начинаются с `w`. Эта функция\n",
    "называется самоанализом объекта. Она очень полезна для\n",
    "интерактивного изучения свойств объекта Python. \n",
    "\n",
    "\n",
    "### Документация\n",
    "\n",
    "<div id=\"intro:environments:\"></div>\n",
    "\n",
    "Самоанализ объекта удобен для изучения API модулей и содержащихся в\n",
    "них классов и функций, и вместе со строками документации или\n",
    "«docstrings», которые обычно представлены в коде Python, он\n",
    "предоставляет встроенное динамическое справочное руководство для почти\n",
    "всех модулей, которые установлены и могут быть импортированы. Если\n",
    "закончить объект Python знаком вопроса и выполнить команду, то будет\n",
    "выведена строка документации для объекта. Это аналогично вызову\n",
    "Python-функции `help`. Ввод объекта можно закончить двумя знаками\n",
    "вопроса. В этом случае IPython пытается отобразить более детальную\n",
    "документацию, вколючая (если возможно) исходный код. Например, для\n",
    "того чтобы получить описание функции `cos` из модуля `math` можно\n",
    "сделать следующее:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "import math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "math.cos?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Строки документации могут быть заданы для модулей, функций, классов и\n",
    "их атрибутов и методов. Хорошо документированные модули включают\n",
    "документацию своего API в исходный код.\n",
    "\n",
    "### Взаимодействие с оболочкой системы\n",
    "\n",
    "<div id=\"intro:environments:ipython:sysshell\"></div>\n",
    "\n",
    "IPython предоставляет также расширение языка Python, которое делает\n",
    "его удобным для взаимодействия с оболочкой системы, в которой он\n",
    "запущен. Все, что следует за восклицательным знаком\n",
    "выполняется с помощью системной оболочки. Например, в UNIX-подобных\n",
    "системах, таких как Linux или Mac OS X, список файлов из текущего\n",
    "каталога можно получить следующим образом:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "!ls"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В Windows эквивалентная команда — `!dir`. Этот метод взаимодействия с\n",
    "операционной системой является очень мощной функцией, которая дает\n",
    "возможность легкой навигации по файловой системе и использования\n",
    "IPython в качестве консольной системной оболочки.  Вывод команд,\n",
    "следующих за восклицательным знаком, может быть легко записан в\n",
    "переменную Python. Например, список файлов, полученный командой `!ls`\n",
    "можно сохранить в список следующим образом:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "files = !ls"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "len(files)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "files"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Аналогично, мы можем передать значения переменных Python командам\n",
    "оболочки, поставив перед именем переменной знак `$`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "file = \"test.py\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "!ls -l $file"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Такое двухстороннее взаимодействие между консолью IPython и системной\n",
    "оболочкой может оказаться очень удобным когда, например, мы\n",
    "обрабатываем файлы с данными.\n",
    "\n",
    "### Расширения IPython\n",
    "\n",
    "<div id=\"intro:environments:ipython:ext\"></div>\n",
    "\n",
    "IPython предоставляет команды расширения, так называемые *магические*\n",
    "команды. Эти команды начинаются со знака `%`. Один знак `%`\n",
    "используется для однострочных команд, а два знака `%` используются для\n",
    "команд, которые действуют на нескольких ячейках (многострочные\n",
    "команды). Чтобы получить полный список доступных команд расширения,\n",
    "наберите `%lsmagic`, а документацию для каждой команды можно получить\n",
    "заканчивая магическую команду знаком вопроса:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "%lsmagic?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Навигация по файловой системе\n",
    "\n",
    "<div id=\"intro:environments:ipython:nav\"></div>\n",
    "\n",
    "Кроме взаимодействия с системной оболочкой IPython предоставляет\n",
    "команды для навигации по файловой системе. Команды будут знакомы\n",
    "пользователям UNIX-подобных систем: `%ls` (список файлов), `%pwd`\n",
    "(вернуть текущий рабочий каталог), `%cd` (изменить рабочий каталог),\n",
    "`%cp` (копировать файл), `%less` (вывести содержимое файла) и\n",
    "`%writefile filename` (записать содержимое ячейки в файл\n",
    "`filename`). Отметим, что в IPython автодополнение работает и для имен\n",
    "файлов в текущем работчем каталоге.\n",
    "\n",
    "### Запуск сценариев из консоли IPython\n",
    "\n",
    "<div id=\"intro:environments:ipython:runscr\"></div>\n",
    "\n",
    "Команда `%run` — важное и полезное расширение. С помощью этой команды\n",
    "можно выполнять внешние файлы со сценариями Python в интерактивной\n",
    "сессии IPython. Оставляя сессию активной между несколькими запусками\n",
    "сценария, мы можем анализировать переменные и функции, определенные в\n",
    "сценарии, интерактивно после окончания выполнения сценария. Рассмотрим\n",
    "файл"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "# -*- coding: utf-8 -*-\n",
    "def fib(n):\n",
    "    \"\"\"\n",
    "    Возвращает список первых n чисел Фибоначи\n",
    "    \"\"\"\n",
    "    f0, f1 = 0, 1\n",
    "    f = [1]*n\n",
    "    for i in range(1, n):\n",
    "        f[i] = f0 + f1\n",
    "        f0, f1 = f1, f[i]\n",
    "\n",
    "    return f\n",
    "\n",
    "print(fib(10))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Сценарий определеяет функцию, которая генерирует последовательность из $n$\n",
    "чисел Фибоначчи, и выводит результат при $n=10$. Его можно запустить в\n",
    "системной консоли, используя стандартный интерпретатор Python:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "        Terminal> python fib.py\n",
    "        [1, 1, 2, 3, 5, 8, 13, 21, 34, 55]\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Также этот файл со сценарием можно выполнить в интерактивной сессии\n",
    "IPython, которая выполнит тот же вывод, а также добавит символы\n",
    "определенные в файле в локальное пространство имен, так что функция\n",
    "`fib` будет доступна для использования в интерактивной сессий после\n",
    "выполнения команды `%run`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "%run src-intro/fib.py"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "%who"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "fib(6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В предыдущем примере мы также использовали команду `%who`, которая\n",
    "перечисляет все определенные символы (переменные и функции).\n",
    "Команда `%whos` аналогична, но также предоставляет более подробную\n",
    "информацию о типе и значении каждого символа, когда это применимо. \n",
    "\n",
    "### Отладчик\n",
    "\n",
    "<div id=\"intro:environments:ipython:debugger\"></div>\n",
    "\n",
    "IPython включает режим отладки, который может быть вызван после того\n",
    "как возникло исключение Python (ошибка). После того, как в консоли\n",
    "IPythob было напечатано сообщение об ошибке (Traceback) не\n",
    "перехваченного исключения, можно непосредственно перейти в отладчик с\n",
    "помощью команды `%debug`. Такая возможность позволяет не перезапускать\n",
    "программу с самого начала с помощью отладчика или с использованием\n",
    "метода отладки с добавлением операторов печати в код. Если исключение\n",
    "было неожиданным и произошло после длительных вычислений, это может\n",
    "значительно сэкономить время.\n",
    "\n",
    "Для того, чтобы увидеть как может работать команда `%debug`,\n",
    "рассмотрим следующий некорректный вызов функции `fib`, определенной\n",
    "выше. Вызов будет некорректным, так как мы передадим значение типа\n",
    "`float` в то время, как функция реализована в предположении, что\n",
    "передаваемый аргумент имеет тип `int`.`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "fib(1.0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В строке с номером 7 код сталкивается с ошибкой типа, и интерпретатор\n",
    "Python вызывает исключение типа `TypeError`. IPython перехватывает\n",
    "исключение и выводит полезную трассировку вызовов в консоль. Если мы\n",
    "не понимаем, почему код в строке 7 содержит ошибку, полезно запустить\n",
    "отладчик с помощью команды `%debug`. Тогда мы можем получить доступ к\n",
    "локальному пространству имен в источнике исключения, который позволит\n",
    "нам изучить более детально, почему возникло исключение."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "%debug"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> **Подсказка.**\n",
    ">\n",
    "> Наберите знак вопроса в строке отладчика для того, чтобы получить\n",
    "> подсказку с  перечислением доступных команд.\n",
    "> \n",
    "> Больше информации об отладчике Python и его возможностях можно\n",
    "> получить в документации Python по адресу <http://docs.python.org/3/library/pdb.html>.\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "### Сброс пространства имен\n",
    "\n",
    "<div id=\"intro:environments:ipython:reset\"></div>\n",
    "\n",
    "Сброс пространства имен сессии IPython часто полезен для гарантии\n",
    "того, что программа запускается в нетронутой среде, не перегруженной\n",
    "существующими переменными и функциями. Команда `%reset` предоставляет\n",
    "такую возможность (используйте аргумент `-f` для принудительного\n",
    "сброса). Использование этой команды часто устраняет необходимость в\n",
    "других распространенных циклах выхода-перезапуска консоли. Несмотря на\n",
    "то, что после выполнения команды `%reset` необходимо заново\n",
    "импортировать модули, важно знать, что даже если модули изменялись с\n",
    "момента последнего импорта, новый импорт после команды `%reset` не\n",
    "будет импортировать новый модуль, а, скорее всего, включит\n",
    "кэшированную версию модуля из предыдущего импорта. Такое поведение не\n",
    "желательно при разработке новых модулей Python. В этом случае\n",
    "повторный импорт ранее импортированного (и с тех пор обновленного)\n",
    "модуля часто может быть достигнут с помощью функции `reload` из\n",
    "`IPython.lib.deepreload`. Однако, этот метод не всегда работает, так\n",
    "как некоторые библиотеки выполняют код во время импорта, который\n",
    "должен выполняться только один раз. В этом случае есть только один\n",
    "способ: остановить и заново запустить консоль IPython.\n",
    "\n",
    "### Расчет времени выполнения и профилирование кода\n",
    "\n",
    "<div id=\"intro:environments:ipython:timing\"></div>\n",
    "\n",
    "Команды `%timeit` и `%time` предоставляют простые средства сравнения,\n",
    "которые полезны при попытках оптимизировать код.  Команда `%timeit`\n",
    "запускает оператор Python несколько раз и дает оценку времени\n",
    "выполнения (используйте `%%timeit`, чтобы сделать \n",
    "то же самое для многострочной ячейки). Точное количество раз \n",
    "выполнения оператора, определяется эвристически, если явно не\n",
    "установлено с помощью флагов `-n` и `-r`. Команда `%timeit` не\n",
    "возвращает значение выражения. Если необходим результат выполнения\n",
    "вычислений, можно использовать команды `%time` или `%%time` (для\n",
    "многострочной ячейки), но эти команды запускают выражение только один\n",
    "раз и, следовательно, дают менее точную оценку времени выполнения.\n",
    "\n",
    "Следующий пример демонстрирует типичное использование команд `%timit`\n",
    "и `%time`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "%timeit fib(100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "result = %time fib(100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Хотя команды `%timeit` и `%time` полезны для измерения времени\n",
    "выполнения вычислений, они не дают никакой подробной информации о том,\n",
    "какая часть вычислений занимает больше времени. Такой анализ требует\n",
    "более сложного профилировщика кода, такого, например, как `cProfile`,\n",
    "предоставляемого стандартной библиотекой Python. Профилировщик Python\n",
    "доступен в IPython с помощью команд `%prun` (для операторов) и `%run`\n",
    "с аргументом `-p` (для запуска внешних сценариев). Вывод\n",
    "профилировщика довольно многословен и может быть настроен с помощью\n",
    "опций команд `%prun` и `%run -p` (см. `%prun?`).\n",
    "\n",
    "В качестве примера рассмотрим функцию, которая моделирует $N$\n",
    "случайных ходоков, которые делают по $M$ шагов, а затем вычисляет\n",
    "самое дальнее расстояние от начальной точки, достигнутой любым из\n",
    "случайных ходоков."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "# -*- coding: utf-8 -*-\n",
    "import numpy as np\n",
    "\n",
    "def random_walker_max_distance(M, N):\n",
    "    trajectories = [np.random.randn(M).cumsum() for _ in range(N)]\n",
    "    return np.max(np.abs(trajectories))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Вызов этой функции с использованием профилировщика дает генерирует\n",
    "следующий вывод, который включает информацию о том, как много раз\n",
    "вызывается каждая функция и разбивку общего и совокупного времени,\n",
    "потраченного на каждую функцию. По этой информации мы можем сделать\n",
    "вывод, что в нашем простом примере вызовы функции `np.random.rand`\n",
    "потребляет большую часть времени вычислений."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false,
    "jupyter": {
     "outputs_hidden": false
    }
   },
   "outputs": [],
   "source": [
    "%prun random_walker_max_distance(400, 10000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Интерпретатор и текстовый редактор как среда разработки\n",
    "<div id=\"intro:environments:de\"></div>\n",
    "\n",
    "В принципе, интерпретаторы Python и IPython и хороший текстовый\n",
    "редактор — это все, что нужно для полной среды разработки на\n",
    "Python. Эта простая связка, по сути, является предпочтительной\n",
    "средой разработки для многих опытных программистов. Однако в следующих\n",
    "разделах мы рассмотрим Jupyter Notebook и интегрированную среду\n",
    "разработки Spyder. Эти среды предоставляют более широкие возможности,\n",
    "которые повышают производительность при работе с интерактивными и\n",
    "исследовательскими приложениями. \n",
    "\n",
    "## Jupyter\n",
    "<div id=\"intro:environments:jupyter\"></div>\n",
    "\n",
    "Проект\n",
    "Jupyter\n",
    "Проект Jupyter является побочным продуктом проекта IPython, который\n",
    "включает независимые интерфейсы Python — в первую очередь блокноты\n",
    "(notebook) — и коммуникационную структуру, которая позволяет отделить\n",
    "внешний интерфейс от вычислительных серверных частей, известных как\n",
    "ядра. \n",
    "\n",
    "До создания проекта Jupyter, блокноты и базовая структура приложения\n",
    "для них были частью проекта IPython. Однако, поскольку внешний\n",
    "интерфейс для блокнотов не зависит от языка — его также можно использовать\n",
    "с большим количеством других языков, таких как R и Julia, — он был\n",
    "выделен из отдельного проекта, чтобы лучше обслуживать более широкое\n",
    "вычислительное сообщество и избегать предполагаемой предвзятости в\n",
    "сторону Python. Теперь роль IPython заключается в том, чтобы\n",
    "сосредоточиться на приложениях, специфичных для Python, таких как\n",
    "интерактивная консоль Python, и предоставить ядро Python для среды\n",
    "Jupyter.\n",
    "\n",
    "В среде Jupyter интерфейс взаимодействует с серверными частями\n",
    "(ядрами). Интерфейс может иметь несколько зарегистрированных ядер,\n",
    "например, для различных языков программирования, для различных версий\n",
    "Python, или различных сред Python. Ядро поддерживает состояние\n",
    "интерпретатора и выполняет фактические вычисления, в то время как\n",
    "интерфейс управляет тем, как код вводится и организуется, и как\n",
    "результаты вычислений визуализируются пользователю.\n",
    "\n",
    "Здесь мы рассмотрим Jupyter QtConsole и интерфейсы для блокнотов.\n",
    "\n",
    "\n",
    "\n",
    "### Jupyter QtConsole\n",
    "\n",
    "<div id=\"intro:environments:jupyter:qtconsole\"></div>\n",
    "\n",
    "Jupyter QtConsole — это расширенное консольное приложение, которое\n",
    "может служить заменой стандартной консоли IPython. QtConsole\n",
    "запускается передачей аргумента `qtconsole` команде `jupyter`:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "        Terminal> jupyter qtconsole\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Откроется новое приложение в системной консоли, способное\n",
    "отображать мультимедийные объекты, такие как рисунки и\n",
    "математические уравнения. Jupyter QtConsole также предоставляет\n",
    "механизм на основе меню для отображения результатов автозаполнения, и\n",
    "он запрашивает строки документации для функций во всплывающем окне при\n",
    "вводе открывающей скобки функции или вызова метода. Скриншот Jupyter\n",
    "QtСonsole показан на следующем рисунке:\n",
    "\n",
    "<!-- dom:FIGURE: [fig-intro/jupyter_1.png, width=400 frac=1.0] -->\n",
    "<!-- begin figure -->\n",
    "![](fig-intro/jupyter_1.png)<!-- end figure -->\n",
    "\n",
    "\n",
    "## Jupyter Notebook\n",
    "<div id=\"intro:environments:jupyter:notebook\"></div>\n",
    "\n",
    "Кроме интерактивной консоли Jupyter также предоставляет веб-приложение\n",
    "для блокнотов. Блокнот предоставляет много преимуществ по\n",
    "сравнению с традиционной средой разработки при работе с анализом\n",
    "данных и решением вычислительных задач. В частности, среда блокнота\n",
    "позволяет писать и запускать код, отображать выходные данные, \n",
    "произведенные кодом, а также документировать и интерпретировать код и\n",
    "результаты: все в одном документе. Это означает, что весь рабочий\n",
    "процесс анализа записывается в один файл, который впоследствии можно\n",
    "сохранить, восстановить и использовать повторно. Напротив, при работе\n",
    "с текстовым редактором или IDE код, соответствующие файлы данных и\n",
    "рисунки, а также документация распределяются по нескольким файлам в\n",
    "файловой системе, и для поддержания такого рабочего процесса требуются\n",
    "значительные усилия.\n",
    "\n",
    "Jupyter Notebook оснащен богатой системой отображения, которая может\n",
    "отображать мультимедиа, такие как уравнения, рисунки и видео, как\n",
    "встроенные объекты в блокноте. Также возможно создавать элементы\n",
    "пользовательского интерфейса с HTML и JavaScript, используя\n",
    "систему виджетов Jupyter. Эти виджеты можно использовать в\n",
    "интерактивных приложениях, которые связывают веб-приложение с кодом\n",
    "Python, который выполняется в ядре IPython (на стороне сервера). Эти и\n",
    "многие другие функции Jupyter Notebook делают его отличной средой для\n",
    "интерактивных и грамотных вычислений. Для запуска среды Jupyter\n",
    "Notebook аргумент `notebook` передается команде `jupyter`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "        Terminal> jupyter notebook\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Это запускает ядро ноутбука и веб-приложение, которое по умолчанию\n",
    "обслуживает веб-сервер через порт 8888 на локальном хосте, доступ к\n",
    "которому осуществляется через локальный адрес <http://localhost:8888/>\n",
    "в \n",
    "веб-браузере.\n",
    "По умолчанию при запуске `jupyter notebook` в браузере открывается\n",
    "страница с панелью инструментов. На панели инструментов перечислены\n",
    "все блокноты, доступные в каталоге, из которого был запущен\n",
    "Jupyter Notebook, а также простой обозреватель каталогов, который\n",
    "можно использовать для навигации по подкаталогам относительно места,\n",
    "где был запущен сервер, и для открытия блокнотров в нем. На рисунке\n",
    "показан снимок экрана веб-браузера и страницы с панелью инструментов\n",
    "Jupyter Notebook:\n",
    "\n",
    "<!-- dom:FIGURE: [fig-intro/jupyter_2.png, width=400 frac=1.0] -->\n",
    "<!-- begin figure -->\n",
    "![](fig-intro/jupyter_2.png)<!-- end figure -->\n",
    "\n",
    "\n",
    "Нажатием кнопки «New» создадим новый блокнот и откроем его на новой\n",
    "странице в браузере. Вновь созданный блокнот имеет имя `Untitled` или\n",
    "`Untitled1` и т.д. Блокнот можно переименовать нажав на поле с\n",
    "заголовком в верхней части страницы. Файлы Jupyter Notebook\n",
    "сохраняются в формате JSON со специальным разрешением `ipynb`. Файл\n",
    "Jupyter Notebook не является чистым кодом на Python, но при\n",
    "необходимости код на Python можно легко выделить из блокнота используя\n",
    "либо меню **File | Download as | Python** или с помощью утилиты\n",
    "`nbconvert`.\n",
    "\n",
    "<!-- dom:FIGURE: [fig-intro/jupyter_3.png, width=400 frac=1.0] -->\n",
    "<!-- begin figure -->\n",
    "![](fig-intro/jupyter_3.png)<!-- end figure -->\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "### Jupyter Lab\n",
    "\n",
    "<div id=\"intro:environments:jupyter:lab\"></div>\n",
    "\n",
    "Jupyter Lab — это новая альтернативная среда разработки из проекта\n",
    "Jupyter. Она объединяет интерфейс Jupyter Notebook с файловым\n",
    "браузером, текстовым редактором, командной оболочкой и консолью\n",
    "IPython:\n",
    "\n",
    "<!-- dom:FIGURE: [fig-intro/jupyter_4.png, width=400 frac=1.0] -->\n",
    "<!-- begin figure -->\n",
    "![](fig-intro/jupyter_4.png)<!-- end figure -->\n",
    "\n",
    "\n",
    "Среда Jupyter Lab объединяет в себе множество преимуществ среды\n",
    "для блокнотов и сильные стороны традиционных IDE. Доступ к консолям\n",
    "оболочки и текстовым редакторам в одном веб-интерфейсе также удобен\n",
    "при работе на сервере Jupyter, работающем в удаленной системе,\n",
    "например в вычислительном кластере или в облаке. \n",
    "\n",
    "### Типы ячеек\n",
    "\n",
    "<div id=\"intro:environments:jupyter:cell-types\"></div>\n",
    "\n",
    "Основное содержимое блокнота, расположенное под строкой меню и\n",
    "панелью инструментов, организовано как ячейки ввода и вывода. Ячейки\n",
    "могут быть нескольких типов, тип выбранной ячейки можно изменять\n",
    "используя меню в панели инструментов. Наиболее важные типы:\n",
    "\n",
    "* **Code**: ячейка с кодом может содержать произвольное количество многострочного кода на Python. Нажатие «Shift-Enter» посылает код из ячейки ядру для выполнения в интерпретаторе Python. Результат выполнения возвращается браузеру и отображается в соответствующей ячейке вывода.\n",
    "\n",
    "* **Markdown**: ячейка такого типа может содержать размеченный текст, который интерпретируется с использованием языка Markdown и HTML.\n",
    "\n",
    "* **Headings**: ячейка такого типа может использоваться для разбивки блокнота на разделы.\n",
    "\n",
    "* **Raw**: ячейка такого типа отображает необработанный текст.\n",
    "\n",
    "### Редактирование ячеек\n",
    "\n",
    "<div id=\"intro:environments:jupyter:edit\"></div>\n",
    "\n",
    "Используя меню и панель инструментов, ячейки можно добавлять,\n",
    "удалять, перемещать вверх и вниз, вырезать и вставлять и т.д. Эти\n",
    "функции также связаны с сочетаниями клавиш, которые удобны и\n",
    "экономят время при работе с ноутбуками Jupyter. В ноутбуке\n",
    "используется двухрежимный интерфейс ввода: режим редактирования и\n",
    "командный режим. В режим редактирования можно войти, щелкнув ячейку\n",
    "или нажав клавишу ввода на клавиатуре, когда ячейка находится в\n",
    "фокусе. Находясь в режиме редактирования, содержимое ячейки ввода\n",
    "можно редактировать. Выход из режима редактирования осуществляется\n",
    "нажатием клавиши ESC или нажатием Shift-Enter для выполнения ячейки. В\n",
    "командном режиме стрелки вверх и вниз можно использовать для\n",
    "перемещения фокуса между ячейками, а ряд сочетаний клавиш\n",
    "сопоставляется с основными действиями по манипулированию ячейками,\n",
    "доступными через панель инструментов и меню. \n",
    "\n",
    "\n",
    "\n",
    "## Таблица 1 : Клавиши <div id=\"table:1\"></div>\n",
    "\n",
    "\n",
    "<table border=\"1\">\n",
    "<thead>\n",
    "<tr><th align=\"left\">Сочетание клавиш</th> <th align=\"left\">                       Описание                      </th> </tr>\n",
    "</thead>\n",
    "<tbody>\n",
    "<tr><td align=\"left\">   <code>b</code>                 </td> <td align=\"left\">   Создать ячейку ниже текущей                              </td> </tr>\n",
    "<tr><td align=\"left\">   <code>a</code>                 </td> <td align=\"left\">   Создать ячейку выше текущей                              </td> </tr>\n",
    "<tr><td align=\"left\">   <code>d-d</code>               </td> <td align=\"left\">   Удалить текущую ячейку                                   </td> </tr>\n",
    "<tr><td align=\"left\">   от <code>1</code> до <code>6</code>       </td> <td align=\"left\">   Ячейка с заглавием раздела (heading) уровня от 1 до 6    </td> </tr>\n",
    "<tr><td align=\"left\">   <code>x</code>                 </td> <td align=\"left\">   Вырезать текущую ячейку в буфер обмена                   </td> </tr>\n",
    "<tr><td align=\"left\">   <code>c</code>                 </td> <td align=\"left\">   Скопировать текущую ячейку в буфер обмена                </td> </tr>\n",
    "<tr><td align=\"left\">   <code>v</code>                 </td> <td align=\"left\">   Вставить ячейку из буфера обмена                         </td> </tr>\n",
    "<tr><td align=\"left\">   <code>m</code>                 </td> <td align=\"left\">   Преобразовать тип ячейки в Markdown                      </td> </tr>\n",
    "<tr><td align=\"left\">   <code>y</code>                 </td> <td align=\"left\">   Преобразовать тип ячейки в Code                          </td> </tr>\n",
    "<tr><td align=\"left\">   <code>Up</code>                </td> <td align=\"left\">   Выбрать предыдущую ячейку                                </td> </tr>\n",
    "<tr><td align=\"left\">   <code>Down</code>              </td> <td align=\"left\">   Выбрать следующую ячейку                                 </td> </tr>\n",
    "<tr><td align=\"left\">   <code>Enter</code>             </td> <td align=\"left\">   Войти в режим редактирования ячейки                      </td> </tr>\n",
    "<tr><td align=\"left\">   <code>Escape</code>            </td> <td align=\"left\">   Выйти из режима редактирования ячейки                    </td> </tr>\n",
    "<tr><td align=\"left\">   <code>Shift-Enter</code>       </td> <td align=\"left\">   Выполнить ячейку                                         </td> </tr>\n",
    "<tr><td align=\"left\">   <code>h</code>                 </td> <td align=\"left\">   Показать окно помощи со списком сочетаний клавиш         </td> </tr>\n",
    "<tr><td align=\"left\">   <code>0-0</code>               </td> <td align=\"left\">   Перезапустить ядро                                       </td> </tr>\n",
    "<tr><td align=\"left\">   <code>i-i</code>               </td> <td align=\"left\">   Прервать выполнение ячейки                               </td> </tr>\n",
    "<tr><td align=\"left\">   <code>s</code>                 </td> <td align=\"left\">   Сохранить блокнот                                        </td> </tr>\n",
    "</tbody>\n",
    "</table>\n",
    "\n",
    "\n",
    "Во время выполнения ячейки блокнота номер ячейки обозначается\n",
    "звездочкой (`In [*]`), а индикатор в правом верхнем углу страницы\n",
    "сигнализирует о том, что ядро IPython занято. Прервать выполнение\n",
    "ячейки можно через меню **Kernel | Interrupt** или сочетанием клавиш\n",
    "`i-i` в командном режиме (т.е., дважды нажать клавишу `i`). В таблице [table:1](#table:1)\n",
    "представлены наиболее популярные сочетания клавиш командного режима\n",
    "Jupyter Notebook.\n",
    "\n",
    "### Ячейки Markdown\n",
    "\n",
    "<div id=\"intro:environments:jupyter:markdown\"></div>\n",
    "\n",
    "Одна из ключевых возможностей Jupyter Notebook заключается в том, что\n",
    "ячейки с кодом и ячейки с результатом могут быть дополнены\n",
    "документацией, содержащейся в текстовых ячейках. Текстовые ячейки\n",
    "имеют тип Markdown. Входной текст преобразуется с использованием языка\n",
    "разметки Markdown. Markdown разработан  как легкая система набора\n",
    "текста, которая позволяет преобразовывать текст с простыми правилами\n",
    "разметки в HTML и другие форматы для более удобного\n",
    "отображения. Правила разметки разработаны так, чтобы быть удобными для\n",
    "пользователя и читаемыми, как в текстовом формате. Например, фрагмент\n",
    "текста можно выделить курсивом, окружив его звездочками (`*text*`),\n",
    "можно сделать полужирным, окружив двойными звездочками\n",
    "(`**text**`). Markdown также позволяет создавать нумерованные и\n",
    "маркированные списки, таблицы и гиперссылки. Расширение Markdown,\n",
    "поддерживаемое Jupyter, заключается в том, что математические\n",
    "выражения можно набирать в LaTeX с помощью библиотеки JavaScript LaTeX\n",
    "MathJax.\n",
    "\n",
    "Ниже приведем краткое описание синтаксиса Markdown.\n",
    "\n",
    "**Выделение.**\n",
    "\n",
    "Одинарные звездочки используются для выделения курсивом"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "        это *выделенный* текст\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Двойные звездочки используются для выделения полужирным"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "        это **очень выделенный** текст\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Код в строке.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "        Используйте функцию `printf()` для вывода.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Ссылки.**\n",
    "\n",
    "Инлайн ссылки"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "        Это простая [ссылка](http://rukeba.com/) в тексте.\n",
    "        Это [ссылка](http://rukeba.com/ \"Титул\") с аттрибутом title.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Сноски"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "        Это [ссылка][1] в справочном стиле.\n",
    "        ...\n",
    "        ...\n",
    "        [1]: http://rukeba.com/ \"Необязательный титул\"\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Чтобы веб-адрес в тексте стал ссылкой его нужно обрамить `<` и `>`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "        По ссылке <http://python.org> находится сайт.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Изображения.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "        ![alt-текст](http://example.com/image.jpg \"Необязательный титул\")\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "или в справочном стиле:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "        ![alt-текст][2]\n",
    "        ...\n",
    "        ...\n",
    "        [2]: http://example.com/image.jpg \"Необязательный титул\"\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Абзац.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "        <пустая строка>\n",
    "        Текст параграфа. Может быть\n",
    "        разбит на несколько строк.\n",
    "        <пустая строка>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Разрыв строки.**\n",
    "\n",
    "Что бы вставить перевод строки без начала нового параграфа, в конец\n",
    "нужно добавить два или больше пробелов."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "        Текст параграфа.<пробел><пробел>\n",
    "        Этот текст будет с новой строки.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Код.**\n",
    "\n",
    "Отступ в четыре пробела или один таб генерирует блок кода:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "        <пробел><пробел><пробел><пробел>print 'Hello, World!'\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Горизонтальная линия.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "        * * *\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "или так:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "        ***\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "или так:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "        ------\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Таблица.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "        | A | B | C |\n",
    "        |---|---|---|\n",
    "        | 1 | 2 | 3 |\n",
    "        | 4 | 5 | 6 |\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Заголовки.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "        # Заголовок первого уровня H1\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Цитаты.**"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "        > Это\n",
    "        > многострочная\n",
    "        > цитата\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Списки.**\n",
    "\n",
    "Ненумерованный:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "        * красный\n",
    "        * зеленый\n",
    "        * синий\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Нумерованный:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "        1. Первый\n",
    "        2. Второй\n",
    "        3. Третий\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**LaTeX.**\n",
    "\n",
    "Строчные формулы:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "        $\\LaTeX$\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Выключеная формула (с новой строки и по-центру):"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "        $$\n",
    "        \\LaTeX\n",
    "        $$\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "или"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "        \\begin{env}\n",
    "        ...\n",
    "        \\end{env}\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Здесь `env` LaTeX окружение для формул: `equation`, `eqnarray`,\n",
    "`align` и т.д.\n",
    "\n",
    "Ячейки типа Markdown могут также содержать код HTML, и интерфейс\n",
    "Jupyter Notebook будет отображать его как обработанный HTML.\n",
    "\n",
    "Больше информации о MathJax и Markdown доступно на страницах проектов:\n",
    "<http://www.mathjax.com> и <http://daringfireball.net/projects/markdown/>. \n",
    "\n",
    "## Spyder: Интегрированная среда разработки\n",
    "<div id=\"intro:environments:spyder\"></div>\n",
    "\n",
    "Рассмотрим свободную интегрированную среду разработки Spyder, особенно\n",
    "хорошо подходит для вычислений и анализа данных с использованием\n",
    "Python.\n",
    "\n",
    "Spyder IDE был специально создан для программирования на Python и, в\n",
    "частности, для научных вычислений с использованием Python. Как\n",
    "таковой, он обладает функциями, которые полезны для интерактивных и\n",
    "исследовательских вычислений: в частности, интеграция с консолью\n",
    "IPython непосредственно в IDE. Пользовательский интерфейс Spyder\n",
    "состоит из нескольких дополнительных панелей, которые могут быть\n",
    "по-разному организованы в приложении.\n",
    "\n",
    "Самые важные панели:\n",
    "\n",
    "* Редактор исходного кода\n",
    "\n",
    "* Консоли интерпретаторов Python и IPython и системной оболочки\n",
    "\n",
    "* Инспектор объектов для показа документации по объектам Python\n",
    "\n",
    "* Обозреватель переменных\n",
    "\n",
    "* Обозреватель файловой\n",
    "\n",
    "* История команд\n",
    "\n",
    "* Профилировщик\n",
    "\n",
    "Каждую панель можно настроить для отображения или скрытия в\n",
    "зависимости от предпочтений и потребностей пользователя, используя\n",
    "меню **View | Panes**.\n",
    "\n",
    "### Редактор исходного кода\n",
    "\n",
    "<div id=\"intro:environments:spyder:editor\"></div>\n",
    "\n",
    "Редактор исходного кода в Spyder поддерживает подсветку синтаксиса,\n",
    "умное автодополнение, работу с несколькими открытыми файлами\n",
    "одновременно, проверку соответствия скобок и др. Дополнительным\n",
    "преимуществом использования IDE является то, что код может \n",
    "быть запущен из редактора — код целиком (клавиша F5) или выделенный\n",
    "код (клавиша F9) — в подключенных консолях Python и IPython.\n",
    "\n",
    "Кроме того, редактор Spyder имеет очень полезную поддержку статической\n",
    "проверки кода с помощью `pylint`, `pyflakes` и `pep8` —  внешних\n",
    "инструментов, которые анализируют исходный код Python и сообщают об\n",
    "ошибках, таких как неопределенные символы, синтаксические ошибки,\n",
    "нарушения стиля кодирования и т. д. \n",
    "\n",
    "> **Подсказка.**\n",
    ">\n",
    "> Язык Python является универсальным, и эквивалентный исходный код\n",
    "> Python может быть написан с использованием самых разных стилей и\n",
    "> способов. Однако был предложен стандарт стиля кодирования Python,\n",
    "> PEP8, для поощрения единообразного внешнего вида кода Python. \n",
    "> Настоятельно рекомендуем изучить стандарт стиля кодирования PEP8 и \n",
    "> соответствовать этому в вашем коде. PEP8 описан по адресу\n",
    "> <http://www.python.org/dev/peps/pep-0008>.\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "### Консоли\n",
    "\n",
    "<div id=\"intro:environments:spyder:console\"></div>\n",
    "\n",
    "Интегрированные консоли Python и IPython могут использоваться для\n",
    "запуска файла, который редактируется в окне текстового редактора, или\n",
    "для запуска кода Python с интерактивным вводом. При выполнении файлов\n",
    "исходного кода Python из редактора переменные пространства имен,\n",
    "созданные в сценарии, сохраняются в сеансе IPython или Python в\n",
    "консоли. Это важная особенность, которая делает Spyder интерактивной\n",
    "вычислительной средой, в дополнение к традиционному приложению IDE,\n",
    "поскольку она позволяет исследовать значения переменных после\n",
    "завершения выполнения сценария. Spyder поддерживает одновременное\n",
    "открытие нескольких консолей Python и IPython, и, например, новую\n",
    "консоль IPython можно запустить через меню **Consoles | Open an IPython\n",
    "console**. При запуске сценария из редактора нажатием клавиши F5 или\n",
    "кнопки запуска на панели инструментов сценарий по умолчанию\n",
    "запускается в самой последней активированной консоли. Это позволяет\n",
    "поддерживать разные консоли с независимыми пространствами имен для\n",
    "разных сценариев или проектов. \n",
    "\n",
    "### Инспектор объектов\n",
    "\n",
    "<div id=\"intro:environments:spyder:inspector\"></div>\n",
    "\n",
    "Инспектор объектов (панель справки) очень помогает при написании кода\n",
    "Python. Он может отображать строки форматированного документа для\n",
    "объектов, определенных в исходном коде, созданном с помощью редактора,\n",
    "и для символов, определенных в библиотечных модулях, установленных в\n",
    "системе.  Текстовое поле объекта в верхней части панели инспектора\n",
    "объектов можно использовать для ввода имени модуля, функции или\n",
    "класса, для которого отображается строка документации. Модули и\n",
    "символы не нужно импортировать в локальное пространство имен, чтобы\n",
    "можно было отображать их строки документов с помощью инспектора\n",
    "объектов. Документацию для объекта в редакторе или консоли также можно\n",
    "открыть в инспекторе объектов, выбрав объект с помощью курсора и\n",
    "используя сочетание клавиш `Ctrl-i` (`Cmd-i` в Mac OS X). Можно даже\n",
    "автоматически отображать строки документов для вызываемых объектов,\n",
    "когда вводится его открывающая левая скобка. Это дает немедленное\n",
    "напоминание об аргументах и ​​их порядке для вызываемого объекта, что\n",
    "может значительно повысить производительность. Чтобы активировать эту\n",
    "функцию, перейдите на страницу «Help» в окне «Preferences» и\n",
    "установите флажки в разделе «Automatic connections». \n",
    "\n",
    "\n",
    "<!-- Local Variables: -->\n",
    "<!-- doconce-chapter-nickname: \"intro\" -->\n",
    "<!-- doconce-section-nickname: \"environments\" -->\n",
    "<!-- End: -->\n",
    "\n",
    "\n",
    "<!-- Local Variables: -->\n",
    "<!-- doconce-chapter-nickname: \"intro\" -->\n",
    "<!-- End: -->"
   ]
  }
 ],
 "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.1"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
