jupyter_tutorial/04_calculation.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Вычисления в Jupyter Notebook: переменные, функции, модули и пакеты"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[К оглавлению](00_contents.ipynb)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Выполнение кода\n",
    "\n",
    "### Общие принципы\n",
    "* Содержание блокнота - это компьютерная программа, то есть инструкция для компьютера, которая позволяет ему прийти к нужному вам результату\n",
    "* Вы можете создавать и выполнять эту программу последовательно, по частям. В любой момент можно остановиться и изучить полученные результаты.\n",
    "* Блокнот позволяет только редактировать код и отображать выполнения. Все вычисления производятся ядром (kernel) - интерпретатором Python, запущенным на вашем компьютере\n",
    "* При первом открытии блокнота, или после перезапуска ядра все нужно вычислять заново\n",
    "* Блокнот сохраняет содержимое ячеек вывода, поэтому если нужно только посмотреть на результаты, то повторные вычисления не требуются\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Выражения\n",
    "\n",
    "Выражения - это формулы, составленные из констант, имен переменных и функций. Выражение может быть вычислено. Результатом вычисления является некоторое значение, которое может быть использовано. \n",
    "\n",
    "Несколько простых выражений"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Математические вычисления\n",
    "2 + 2 * 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "515"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Использование встроенной функции\n",
    "15 + max(100, 500)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'учиться, учиться, и еще раз учиться'"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Операции со строками\n",
    "'учиться, ' * 2 + 'и еще раз учиться'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Несколько выражений в одной ячейке\n",
    "2 * 2\n",
    "3 * 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Автовывод результатов\n",
    "\n",
    "- Если результат вычисления выражения не присваивается никакой переменной, то он выводится на экран (автовывод - autoprint).\n",
    "- Выводится только последний результат в ячейке\n",
    "- При необходимости, можно отключить автовывод, добавив в конце выражения символ ;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Отключить автовывод\n",
    "2**10;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Переменные\n",
    "\n",
    "Переменные позволяют сохранять результаты вычислений и использовать их в дальнейшем. Чтобы обратиться к результату, можно использовать *имя переменной*, которой этот результат был *присвоен*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x = 2**10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1024"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2048"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 * x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В Python не нужно объявлять тип переменной. Тип определяется тем результатом (объектом), на который переменная ссылается (динамическая типизация)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "x = 'Хорошо! '"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Хорошо! Хорошо! '"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 * x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Порядок вычислений в блокноте\n",
    "\n",
    "Код в блокноте записан последовательно. Однако вы можете изменить порядок выполнения, запуская отдельные ячейки в произвольном порядке.\n",
    "При этом значения переменных и другие результаты вычислений будут определяться порядком **выполнения** ячеек с кодом, а не порядком их **записи** в блокноте!\n",
    "\n",
    "При перезапуске ядра все результаты в памяти стираются. Их нужно будет получать заново, запуская соответствующие ячейки."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Функции\n",
    "\n",
    "Функции позволяют разделить код на отдельные блоки, которые можно затем многократно использовать, не заботясь о деталях реализации.\n",
    "\n",
    "- В отличие от имен переменных, после имени функции обязательно должны следовать скобки ()\n",
    "\n",
    "- Функция может иметь набор *аргументов*, которые нужно задавать при вызове функции.\n",
    "\n",
    "- Функция может возвращать *значение*. В этом случае функцию можно использовать как часть выражения, т.е. использовать возвращаемый результат в формуле."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Пример использования функции\n",
    "min(3, 1, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Встроенные функции"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В Python доступно множество встроенных функций. Увидеть список встроенных функций можно с помощью функции `dir()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException', 'BlockingIOError', 'BrokenPipeError', 'BufferError', 'BytesWarning', 'ChildProcessError', 'ConnectionAbortedError', 'ConnectionError', 'ConnectionRefusedError', 'ConnectionResetError', 'DeprecationWarning', 'EOFError', 'Ellipsis', 'EnvironmentError', 'Exception', 'False', 'FileExistsError', 'FileNotFoundError', 'FloatingPointError', 'FutureWarning', 'GeneratorExit', 'IOError', 'ImportError', 'ImportWarning', 'IndentationError', 'IndexError', 'InterruptedError', 'IsADirectoryError', 'KeyError', 'KeyboardInterrupt', 'LookupError', 'MemoryError', 'NameError', 'None', 'NotADirectoryError', 'NotImplemented', 'NotImplementedError', 'OSError', 'OverflowError', 'PendingDeprecationWarning', 'PermissionError', 'ProcessLookupError', 'ReferenceError', 'ResourceWarning', 'RuntimeError', 'RuntimeWarning', 'StopIteration', 'SyntaxError', 'SyntaxWarning', 'SystemError', 'SystemExit', 'TabError', 'TimeoutError', 'True', 'TypeError', 'UnboundLocalError', 'UnicodeDecodeError', 'UnicodeEncodeError', 'UnicodeError', 'UnicodeTranslateError', 'UnicodeWarning', 'UserWarning', 'ValueError', 'Warning', 'WindowsError', 'ZeroDivisionError', '__IPYTHON__', '__IPYTHON__active', '__build_class__', '__debug__', '__doc__', '__import__', '__loader__', '__name__', '__package__', '__spec__', 'abs', 'all', 'any', 'ascii', 'bin', 'bool', 'bytearray', 'bytes', 'callable', 'chr', 'classmethod', 'compile', 'complex', 'copyright', 'credits', 'delattr', 'dict', 'dir', 'divmod', 'dreload', 'enumerate', 'eval', 'exec', 'filter', 'float', 'format', 'frozenset', 'get_ipython', 'getattr', 'globals', 'hasattr', 'hash', 'help', 'hex', 'id', 'input', 'int', 'isinstance', 'issubclass', 'iter', 'len', 'license', 'list', 'locals', 'map', 'max', 'memoryview', 'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'print', 'property', 'range', 'repr', 'reversed', 'round', 'set', 'setattr', 'slice', 'sorted', 'staticmethod', 'str', 'sum', 'super', 'tuple', 'type', 'vars', 'zip']\n"
     ]
    }
   ],
   "source": [
    "# Список встроенных функций (и не только функций)\n",
    "print(dir(__builtin__))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Еще больше функций содержится в библиотеках, которые вы можете подключить и использовать для решения своих задач.\n",
    "\n",
    "### Справка по функциям\n",
    "Справку по фукнкции можно получить так:\n",
    "- `help(функция)` - краткая справка (docstring), вывод в ячейку результата\n",
    "- `функция?` - краткая справка (в docstring), вывод в отдельную панель\n",
    "- `функция??` - расширенная справка, выводится код функции (если он доступен), вывод в отдельную панель\n",
    "\n",
    "Закрыть панель со справкой можно по клавише `q` или щелчком на разделителе."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function min in module builtins:\n",
      "\n",
      "min(...)\n",
      "    min(iterable, *[, default=obj, key=func]) -> value\n",
      "    min(arg1, arg2, *args, *[, key=func]) -> value\n",
      "    \n",
      "    With a single iterable argument, return its smallest item. The\n",
      "    default keyword-only argument specifies an object to return if\n",
      "    the provided iterable is empty.\n",
      "    With two or more arguments, return the smallest argument.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Справка по функции min\n",
    "help(min)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Справка по функции min в отдельной панели\n",
    "min?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Автодополнение\n",
    "При вводе имен переменных и функций в блокноте работает автодополнение (`Tab`).\n",
    "\n",
    "Подсказку по аргументам функции можно получить по клавише `Shift-Tab` (сначала набрать имя функции и открывающую скобку)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#Какие аргументы есть у встроенной функции print?\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Пользовательские функции\n",
    "\n",
    "Свою функцию можно определить, используя оператор `def`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Функция, которая возвращает квадрат значения\n",
    "def square(x):\n",
    "    return x * x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "NB: По отступам Python определяет вложенность блоков кода (клавиша `Tab`)\n",
    "\n",
    "Чтобы изменить уровень вложенности, надо выделить нужные строки и воспользоваться клавишами `Tab` или `Shift-Tab`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "25"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Вызов пользовательской функции\n",
    "square(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Подсказка по аргументам пользовательской фуникци\n",
    "#square("
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Документирование функций - docstring\n",
    "Для того, чтобы подсказка выводилась и по собственным функциям, необходимо поместить после заголовка функции специальный комментарий - docstring"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def distance(x0, y0, x1, y1):\n",
    "    '''\n",
    "    Вычисление расстояния между двумя точками на плоскости\n",
    "    Аргументы:\n",
    "    x0, y0 - координаты первой точки\n",
    "    x1, y1 - координаты второй точки\n",
    "    '''\n",
    "    return ((x0 - x1)**2 + (y0 - y1)**2)**.5    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "#проверка:\n",
    "#distance(\n",
    "\n",
    "#вычислите координаты между точками (5, 5) и (5, 6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Определение простых функций\n",
    "\n",
    "Простые однострочные функции - например, математические - удобно определять так:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f = lambda x,y : x**2 + y**2\n",
    "\n",
    "f(1, 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Такой способ определения функций называется **лямбда-выражение**. Интерсно, что лямбда-выражения можно использовать даже не присваивая полученной функции никакого имени. Можно написать лямбда-выражение прямо в том месте, где ожидается имя функции.\n",
    "\n",
    "Ограничением лямбда-выражений является то, что в них нельзя использовать никаких операторов."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Область видимости\n",
    "\n",
    "Определяемые пользователем переменные и функции имеют свою _область видимости_ (_scope_). Видимость имени определяется тем, в каком месте кода оно определено.\n",
    "\n",
    "Просмотреть список имен пользовательских переменных и функций в текущей области видимости можно с помощью волшебных команд: `%who` и `%whos`. Также можно использовать функцию `dir()`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "distance\t f\t square\t x\t \n"
     ]
    }
   ],
   "source": [
    "%who"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Variable   Type        Data/Info\n",
      "--------------------------------\n",
      "distance   function    <function distance at 0x04BDE4B0>\n",
      "f          function    <function <lambda> at 0x04BDE540>\n",
      "square     function    <function square at 0x04BDE2B8>\n",
      "x          str         Хорошо! \n"
     ]
    }
   ],
   "source": [
    "%whos"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Локальные и глобальные переменные\n",
    "\n",
    "_Глобальные переменные_ определяются в модуле (верхний уровень программы). Они доступны из любого места модуля.\n",
    "\n",
    "_Локальные переменные_ определяются в теле функции. Они доступны только внутри функции.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "функция proba 20 10 30\n",
      "функция proba ['x', 'z']\n",
      "модуль 5 10\n",
      "distance\t f\t proba\t square\t x\t y\t \n"
     ]
    }
   ],
   "source": [
    "x = 5 #глобальная переменная\n",
    "y = 10 #глобальная переменная\n",
    "\n",
    "def proba(x):     \n",
    "    z = 30 #локальная переменная\n",
    "    print('функция proba', x, y, z) # внутри функции имя x будет связано со значением первого аргумента функции    \n",
    "    print('функция proba', dir())\n",
    "    \n",
    "proba(20)\n",
    "\n",
    "print('модуль', x, y)\n",
    "\n",
    "#print(x, y, z) #ошибка! Переменная z доступна только внутри функции\n",
    "\n",
    "%who\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Область для функции proba](pics/scope.svg 'Область для функции proba')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "функция proba2 50 100 30\n",
      "функция proba2 ['x', 'y', 'z']\n",
      "модуль 5 10\n",
      "distance\t f\t proba\t proba2\t square\t x\t y\t \n"
     ]
    }
   ],
   "source": [
    "x = 5 #глобальная переменная\n",
    "y = 10 #глобальная переменная\n",
    "\n",
    "def proba2(x):\n",
    "    x = 50 #внутри функции имя x будет связано со значением первого аргумента функции    \n",
    "    z = 30 #локальная переменная\n",
    "    y = 100 #локальная переменная, перекрывающая глобальную\n",
    "    print('функция proba2', x, y, z)\n",
    "    print('функция proba2', dir())    \n",
    "    \n",
    "proba2(20)\n",
    "\n",
    "print('модуль', x, y) # значения не изменились\n",
    "\n",
    "%who"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Область для функции proba2](pics/scope2.svg 'Область для функции proba2')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Модули\n",
    "\n",
    "- Большие программы обычно разбиваются на отдельные файлы - модули. \n",
    "- _Модуль_ в Python - это файл, содержащий определения переменных, функций и классов. \n",
    "- Модули разрабатывают как логически завершенные наборы объектов, позволяющие решить некоторую задачу или логически связанные задачи. Например, в модуле `sys` содержатся объекты для работы с системными ресурсами, в модуле `math` - математические функции и константы.\n",
    "- Внутри модуля доступны все объекты, определенные в нем. Также можно пользоваться объектами, определенными в других модулях. Для этого их нужно _импортировать_ с помощью операторов `import` или `from`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "import sys #импорт всех объектов из модуля sys, они будут доступны через sys.имя\n",
    "from math import pi #импорт одной переменной из модуля math, она будет доступна как pi"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Пространства имен\n",
    "\n",
    "Чтобы избежать конфликта имен, при импорте модуля оператором `import` имена объектов, определенных в модуле, добавляются в отдельное **пространство имен**. К ним нужно обращаться так:\n",
    "\n",
    "`модуль.имя объекта`.  \n",
    "\n",
    "Список всех объектов в модуле после импорта можно просмотреть функцией `dir(модуль)`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Объекты из модуля sys:\n",
      " ['__displayhook__', '__doc__', '__egginsert', '__excepthook__', '__interactivehook__', '__loader__', '__name__', '__package__', '__plen', '__spec__', '__stderr__', '__stdin__', '__stdout__', '_clear_type_cache', '_current_frames', '_debugmallocstats', '_getframe', '_home', '_mercurial', '_xoptions', 'api_version', 'argv', 'base_exec_prefix', 'base_prefix', 'builtin_module_names', 'byteorder', 'call_tracing', 'callstats', 'copyright', 'displayhook', 'dllhandle', 'dont_write_bytecode', 'exc_info', 'excepthook', 'exec_prefix', 'executable', 'exit', 'flags', 'float_info', 'float_repr_style', 'getallocatedblocks', 'getcheckinterval', 'getdefaultencoding', 'getfilesystemencoding', 'getprofile', 'getrecursionlimit', 'getrefcount', 'getsizeof', 'getswitchinterval', 'gettrace', 'getwindowsversion', 'hash_info', 'hexversion', 'implementation', 'int_info', 'intern', 'maxsize', 'maxunicode', 'meta_path', 'modules', 'path', 'path_hooks', 'path_importer_cache', 'platform', 'prefix', 'ps1', 'ps2', 'ps3', 'setcheckinterval', 'setprofile', 'setrecursionlimit', 'setswitchinterval', 'settrace', 'stderr', 'stdin', 'stdout', 'thread_info', 'version', 'version_info', 'warnoptions', 'winver'] \n",
      "\n"
     ]
    }
   ],
   "source": [
    "print('Объекты из модуля sys:\\n', dir(sys),'\\n') #список имен, определенных в модуле"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.4.3 (v3.4.3:9b73f1c3e601, Feb 24 2015, 22:43:06) [MSC v.1600 32 bit (Intel)]\n"
     ]
    }
   ],
   "source": [
    "print(sys.version) #доступ к объекту из пространства имен модуля"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Также можно исследовать содержание пространства имен модуля с помощью автодополнения:  \n",
    "`sys.<нажмите Tab>`\n",
    "\n",
    "![Автодополнение](pics/autocomplete.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Если функция или константа были импортированы из модуля оператором `from ... import ...`, то они будут доступны просто по имени:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Число Пи = 3.141592653589793\n"
     ]
    }
   ],
   "source": [
    "print(\"Число Пи =\", pi) #доступ к объекту, импортированному в пространство имен текущего модуля"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "При импорте с помощью `from` объекты добавляются в пространство имен текущего модуля и могут переопределить уже существующие в нем имена."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Переименование модулей\n",
    "\n",
    "При частом доступе к объектам в пространстве имен модуля удобно, когда префикс, состоящий из имени модуля, имеет небольшую длину. Поэтому часто используемые модули при импорте переименовывают с помощью оператора `as`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4])"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "np.arange(5) #функция arange из модуля numpy (переименован в np)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Пакеты\n",
    "\n",
    "- _Пакеты_ (packages) - это способ организации модулей в библиотеки.\n",
    "- Пакеты соответствуют каталогам в файловой системе, в которых размещены файлы родственных модулей.\n",
    "- Пакеты могут включать подпакеты (subpackages), которые позволяют организовать иерархию в пространстве имен пакета.\n",
    "\n",
    "Например, разработчик пакета для работы со звуковыми файлами, может создать такую структуру:\n",
    "\n",
    "![Пакеты](pics/packages.png 'Структура каталогов пакета')\n",
    "\n",
    "Пользователи пакета смогут импортировать модуль для создания эффекта эхо, указав составное имя: `пакет.подпакет.модуль`\n",
    "```python\n",
    "import sound.effects.echo```\n",
    "\n",
    "Для Python разработано множество пакетов, решающих различные задачи. Глобальный каталог пакетов  - [Python Package Index](https://pypi.python.org/pypi)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Наиболее часто используемые в научных вычислениях пакеты перечислены в таблице\n",
    "\n",
    "Модуль | Назначение\n",
    ":-|:-\n",
    "`numpy` | Работа с массивами данных\n",
    "`sympy` | Символьная математика (аналитическое вычисление/преобразование выражений)\n",
    "`pandas`| Обработка данных в табличной форме\n",
    "`matplotlib` | Библиотека для построения графиков\n",
    "`matplotlib.pyplot`| Набор функций для построения графиков в стиле Matlab\n",
    "`seaborn`| Надстройка над matplotlib, облегчающая визуализацию данных\n",
    "`scipy.optimize` | Методы оптимизации\n",
    "`scipy.integrate` | Численное интегрирование\n",
    "`scipy.stats` | Статистические функции\n",
    "\n",
    "Документация по двум ключевым пакетам научных вычислений - numpy и scipy доступна на сайте: http://scipy.org"
   ]
  }
 ],
 "metadata": {
  "hide_input": false,
  "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.4.3"
  },
  "latex_envs": {
   "bibliofile": "biblio.bib",
   "cite_by": "apalike",
   "current_citInitial": 1,
   "eqLabelWithNumbers": true,
   "eqNumInitial": 0
  },
  "toc": {
   "toc_cell": false,
   "toc_number_sections": false,
   "toc_threshold": 4,
   "toc_window_display": false
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}