Lecture 4.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "# Программирование на языке Python для сбора и анализа данных\n",
    "\n",
    "*Текст лекции: Щуров И.В., НИУ ВШЭ*\n",
    "\n",
    "Данный notebook является конспектом лекции по курсу «Программирование на языке Python для сбора и анализа данных» (НИУ ВШЭ, 2015-16). Он распространяется на условиях лицензии [Creative Commons Attribution-Share Alike 4.0](http://creativecommons.org/licenses/by-sa/4.0/). При использовании обязательно упоминание автора курса и аффилиации. При наличии технической возможности необходимо также указать активную гиперссылку на [страницу курса](http://math-info.hse.ru/s15/m). Фрагменты кода, включенные в этот notebook, публикуются как [общественное достояние](http://creativecommons.org/publicdomain/zero/1.0/).\n",
    "\n",
    "Другие материалы курса, включая конспекты и видеозаписи лекций, а также наборы задач, можно найти на [странице курса](http://math-info.hse.ru/s15/m)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Лекция №4: Функции"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Пример определения функции\n",
    "Нам постоянно приходится выполнять похожие действия. Каждый день, просыпаясь, мы чистим зубы, идём завтракать, едем в университет. Если бы мы захотели написать программу для своей жизни, то нам пришлось бы каждый раз перечислять все шаги, которые необходимо выполнить, например, чтобы приготовить себе завтрак. Это было бы очень утомительно и такая программа была бы очень большой. Вместо этого программисты выделяют фрагменты кода, которые решают определенную задачу, в виде так называемых *функций*. У функции есть имя и список аргументов, которые она принимает. Например:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8.0"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from math import sqrt\n",
    "sqrt(25)+sqrt(9)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Что означает этот код? В первой строчке мы импортировали функцию `sqrt` из пакета `math`, то есть загрузили в память (или «выписали на бумажку») инструкцию о том, как считать квадратные корни (её написали раньше умные люди, разработчики Python). Эта инструкция — такая маленькая программка (когда-то давно функций в современном понимании не было, но были *подпрограммы*). \n",
    "\n",
    "Во второй строчке необходимо вычислить сумму двух выражений, каждое из которых, в свою очередь, содержит *вызов функции* `sqrt`.\n",
    "В тот момент, когда мы написали `sqrt(25)`, Python посмотрел на бумажку и пользуясь этой маленькой программкой посчитал корень из того числа, которое мы этой функции передали (то есть из 25). После этого функция «вернула» значение `5.0`. Это означает, что в строчке `sqrt(25)+sqrt(9)` фрагмент `sqrt(25)` превратился в результат выполнения функции, то есть в `5.0`. Затем то же самое произошло с `sqrt(9)`, этот фрагмент превратился в число `3.0`. Затем мы сложили два числа и получили число `8.0`.\n",
    "\n",
    "Функции в программировании похожи на функции в математике, хотя имеют и свою специфику. Давайте напишем какую-нибудь функцию. Для примера рассмотрим *факториал*. Напомним, что факториал от натурального числа $n$ это произведение всех натуральных чисел (начиная с 1) до $n$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "$$\\mathop{\\mathrm{factorial}}(n)=1\\times 2\\times \\ldots \\times n$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "> Обычно в математике факториал обозначается восклицательным знаком (например, $3!=1\\times 2\\times 3=6$).\n",
    "\n",
    "Давайте для начала напишем программу для вычисления факториала какого-нибудь числа. Она будет выглядеть так:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "120\n"
     ]
    }
   ],
   "source": [
    "n = 5\n",
    "\n",
    "f = 1\n",
    "for i in range(2, n+1):\n",
    "    f = f * i\n",
    "    # эквивалентный синтаксис: f *= i\n",
    "print(f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Здесь инициализируется переменная `f`, в ней помещается значение 1, затем переменная `f` последовательно умножается на все числа от 2 до n включительно (нам пришлось прибавить единицу при вызове `range()`, потому что правый конец никогда не включается в интервал, см. [конспект лекции №2](http://nbviewer.ipython.org/github/ischurov/pythonhse/blob/master/Lecture%202.ipynb) про циклы и `range()`), каждый раз записывая результат умножения снова в `f`. Таким образом в `f` оказалось искомое произведение.\n",
    "\n",
    "Если бы нам пришлось вычислять факториалы в разных частях программы, то можно было бы просто скопировать в них этот короткий фрагмент кода. Однако, так почти никогда делать не следует: если вам приходится копировать какие-то строчки кода в своей программе, почти наверняка это значит, что вы делаете что-то не то. (В программировании это называется «принципом DRY» — Don't Repeat Yourself.) Например, представьте себе, что вы скопируете этот код в десять мест программы, а потом придумаете, как сделать вычисление факториала более эффективным. Вам придётся тогда вносить изменение в десять разных мест!\n",
    "\n",
    "В данном случае нам нужно написать функцию, вычисляющую факториал. Она выглядит так:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def factorial(n):\n",
    "    f = 1\n",
    "    for i in range(2, n+1):\n",
    "        f = f * i\n",
    "    return f"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "При выполнении этой ячейки вроде бы ничего не произошло — по крайней мере, Python не выдал никакого вывода. Так и должно быть. На самом деле, в этот момент Python достал большую чёрную записную книжку на странице на букву f (это метафора, на самом деле нет никаких страниц) и записал в неё: «если меня попросят выполнить функцию factorial, нужно сделать вот такие действия». Теперь мы можем *вызывать* функцию `factorial`, передавая ей параметр."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "720"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "factorial(6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": true
   },
   "source": [
    "И даже использовать её в более сложных выражениях:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "840"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "factorial(5)+factorial(6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Посмотрим более внимательно на то, что происходит, когда Python вычисляет значение выражения `factorial(6)`. В первую очередь он открывает свою записную книжку и ищет там функцию `factorial`. Находит (поскольку раньше мы её туда записали). Дальше он смотрит на первую строчку определения функции (это так называемая *сигнатура*):\n",
    "\n",
    "```python\n",
    "def factorial(n):\n",
    "```\n",
    "\n",
    "Здесь он видит, что функция `factorial()` имеет аргумент, который называется `n`. Python помнит, что мы вызвали `factorial(6)`, то есть значение аргумента должно быть равно 6. Таким образом, дальше он выполняет строчку (которую мы не писали)\n",
    "```python\n",
    "n = 6\n",
    "```\n",
    "\n",
    "После чего выполняет остальные строчки из *тела функции*:\n",
    "```python\n",
    "f = 1\n",
    "for i in range(2, n+1):\n",
    "    f = f * i\n",
    "```\n",
    "\n",
    "Наконец он доходит до строчки\n",
    "```python\n",
    "return f\n",
    "```\n",
    "В этот момент переменная `f` имеет значение 24. Слово `return` означает, что Python должен вернуться к строчке, в которой был вызов `factorial(6)`, и заменить там `factorial(6)` на 24 (то, что написано после `return`). На этом вызов функции завершён."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Возвращаемые значения и побочные эффекты"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Давайте а нарисую такую схему:\n",
    "\n",
    "![Схема работы функции](http://math-info.hse.ru/f/2015-16/all-py/func.svg)\n",
    "\n",
    "Функция — это такая машинка, которая что-то получает на вход (аргументы), что-то выдаёт на выход (возвращаемое значение), а ещё может попутно что-то сделать с окружающей реальностью (побочные эффекты). Например, функция может что-то напечатать на экране, записать в файл или отправить e-mail. Это всё будут побочные эффекты.\n",
    "> Представьте себе кофейный автомат, который на вход принимает деньги, возвращает кофе, но ещё при каждом запуске отправляет компании-производителю письмо с информацией о том, какой кофе был заказан последним. Вот эта отправка письма и будет побочным эффектом.\n",
    "\n",
    "Давайте посмотрим на примере, в чём разница между возвращаемым значением и побочным эффектом. Напишем функцию, которую приветствует пользователя."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def hello(name):\n",
    "    return \"Hello, \"+name+\"!\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "s = hello(\"World\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Hello, World!'"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В переменной `s` сейчас — результат выполнения функции `hello()`, которой на вход передали аргумент `name`, равный `\"World\"`.\n",
    "\n",
    "А теперь давайте напишем другую функцию, которая не *возвращает* строчку, а печатает её."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def say_hello(name):\n",
    "    print(\"Hello, \"+name+\"!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В этой функции вообще нет команды `return`, но Python поймёт, что из функции надо возвращаться в основную программу в тот момент, когда строчки в функции закончились. В данном случае в функции только одна строка."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, Harry!\n"
     ]
    }
   ],
   "source": [
    "s = say_hello(\"Harry\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Обратите внимание: теперь при выполнении `s = say_hello(\"Harry\")` строчка выводится на печать. Это и есть *побочный эффект* выполнения функции `say_hello`. Что лежит в переменной `s`?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n"
     ]
    }
   ],
   "source": [
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "collapsed": false
   },
   "source": [
    "В ней лежит *ничего*. Это специальный объект `None`, который испоьзуется, когда какое-то значение нужно присвоить переменной, но никакого значения нет. В данном случае его нет, потому что функция ничего не вернула. Возвращаемого значения у `say_hello()` нет. Так бывает."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Более сложные ситуации с функциями"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Функции могут вызывать другие функции. Например, вместо того, чтобы копировать строчку `\"Hello, \"+name+\"!\"` из функции `hello()` в функцию `say_hello()`, просто вызовем `hello()` из `say_hello()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def new_say_hello(name):\n",
    "    print(hello(name))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, Harry!\n"
     ]
    }
   ],
   "source": [
    "new_say_hello(\"Harry\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Современные программы обычно так и выглядят — это набор из множества функций, каждая из которых вызывает другие функции. В обычной жизни происходит примерно то же самое: мы разбиваем задачу, которую нужно решить, на более простых задач, которые нужно решить последовательно, потом каждую из этих задач разбиваем на ещё более простые и так далее. Например, чтобы решить задачу «доехать до университета», нужно решить задачи «выйти из дома», «дойти до остановки общественного транспорта», «сесть на общественный транспорт», «доехать до нужной остановки» и т.д. Чтобы решить задачу «выйти из дома», нужно решить задачу «встать с кровати», «позавтракать», «одеться», «открыть дверь» и т.д. В программистских терминах мы бы написали функцию `go_to_university()`, которая бы в какой-то момент вызывала функции `exit_from_home()`, `go_to_stop()`, `get_transport()` и т.д., а функция `exit_from_home()` вызывала бы `wake_up()`, `breakfast()` и т.д.\n",
    "\n",
    "Например, давайте напишем функцию, которая вычисляет *биномиальные коэффициенты*. Напомним, что биномиальным коэффициентом $C_n^k$ (читается «це из эн по ка») называется число, показывающее, сколькими способами можно выбрать $k$ объектов из $n$. Великая наука комбинаторика учит нас, что это число может быть вычислено следующим образом:\n",
    "\n",
    "$$\n",
    "C_n^k=\\frac{n!}{k!(n-k)!}\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Здесь восклительными знаками обозначаются факториалы. Напишем функцию, которая вычисляет биномиальный коэффициент. Используем для этого написанную ранее функцию `factorial`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def binom(k, n):\n",
    "    \"\"\"\n",
    "    calculates binomial coeffs: k from n\n",
    "    k, n are integers\n",
    "    retuns C_n^k\n",
    "    \"\"\"\n",
    "    return factorial(n)//(factorial(k)*factorial(n-k))\n",
    "    # можно использовать целочисленное деление, поскольку результат гарантированно целый"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Сколькими способами можно выбрать двух дежурных из трёх участников похода? Тремя — потому что выбрать двух дежурных это то же самое, что и выбрать одного человека, который не дежурит."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "binom(2,3) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В тройных кавычках сразу после сигнатуры функции обычно приводится её описание (так называемая `docstring`). Это комментарий для людей, которые будут использовать вашу функцию в будущем. Даже если это будете вы сами, скорее всего, через месяц вы уже забудете, что именно делает эта функция, какие аргументы принимает и какие значения возвращает. Написать всё это сразу бывает очень полезно. Чтобы посмотреть на эту справку, можно набрать название вашей функции, открывающую скобку и нажать *Shift+Tab+Tab*."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "После выполнения строчки `return` выполнение функции прекращается. Давайте рассмотрим ещё один пример: вычислим модуль некоторого числа. Код для этой функции может иметь такой вид (я назвал её `my_abs()`, потому что в Python есть встроенная функция `abs`, которая решает ту же задачу):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def my_abs(x):\n",
    "    if x > 0:\n",
    "        return x\n",
    "    else:\n",
    "        return -x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_abs(-5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Это самое простое решение: если число положительное, то возвращается оно само, а если отрицательное, то возвращается оно с обратным знаком (`-x`). Подробнее об условном операторе `if` написано в [конспекте лекции №3](http://nbviewer.ipython.org/github/ischurov/pythonhse/blob/master/Lecture%203.ipynb).\n",
    "\n",
    "Можно было бы написать эту функцию и таким образом:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def my_abs(x):\n",
    "    print(\"New my_abs\")\n",
    "    # если функция с таким названием уже была, то Python про неё забудет и запишет вместо этого новую функция\n",
    "    # чтобы убедиться в этом я поставил здесь этот print\n",
    "    if x > 0:\n",
    "        return x\n",
    "    return -x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "New my_abs\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_abs(-6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Здесь происходит следующее: если число положительное, то срабатывает `return x` и после этого выполнение функции прекращается, до строчки `return -x` дело не доходит. А если число отрицательное, то наборот, срабатывает только строчка `return -x` (из-за оператора `if`)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The tutormagic extension is already loaded. To reload it, use:\n",
      "  %reload_ext tutormagic\n",
      "The tutormagic extension is already loaded. To reload it, use:\n",
      "  %reload_ext tutormagic\n"
     ]
    }
   ],
   "source": [
    "%load_ext tutormagic"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Локальные и глобальные переменные"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Внутри функции могут создаваться и использоваться различные переменные. Чтобы это не создавало проблем, переменные, определенные внутри функции, не видны извне. Давайте рассмотрим пример:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n",
      "In the function, f = 40320\n",
      "40320\n",
      "Out of function\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "f = 10\n",
    "\n",
    "def factorial(n):\n",
    "    f = 1\n",
    "    for i in range(2, n+1):\n",
    "        f = f * i\n",
    "    print(\"In the function, f =\", f)\n",
    "    return f\n",
    "\n",
    "f = 10\n",
    "print(f)\n",
    "print(factorial(8))\n",
    "print(\"Out of function\")\n",
    "print(f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Тот же код, запущенный в визуализаторе:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "        <iframe\n",
       "            width=\"90%\"\n",
       "            height=\"350\"\n",
       "            src=\"http://pythontutor.com/iframe-embed.html#code=f%20%3D%2010%0A%0Adef%20factorial%28n%29%3A%0A%20%20%20%20f%20%3D%201%0A%20%20%20%20for%20i%20in%20range%282%2C%20n%2B1%29%3A%0A%20%20%20%20%20%20%20%20f%20%3D%20f%20%2A%20i%0A%20%20%20%20print%28%22In%20the%20function%2C%20f%20%3D%22%2C%20f%29%0A%20%20%20%20return%20f%0A%0Af%20%3D%2010%0Aprint%28f%29%0Aprint%28factorial%288%29%29%0Aprint%28%22Out%20of%20function%22%29%0Aprint%28f%29&origin=opt-frontend.js&cumulative=false&heapPrimitives=false&textReferences=false&py=3&rawInputLstJSON=%5B%5D&curInstr=0&codeDivWidth=50%25&codeDivHeight=100%25\"\n",
       "            frameborder=\"0\"\n",
       "            allowfullscreen\n",
       "        ></iframe>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.lib.display.IFrame at 0x1076fce80>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%%tutor lang='python3'\n",
    "f = 10\n",
    "\n",
    "def factorial(n):\n",
    "    f = 1\n",
    "    for i in range(2, n+1):\n",
    "        f = f * i\n",
    "    print(\"In the function, f =\", f)\n",
    "    return f\n",
    "\n",
    "f = 10\n",
    "print(f)\n",
    "print(factorial(8))\n",
    "print(\"Out of function\")\n",
    "print(f)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Как видно из результата выполнения этого кода, переменная `f` в основной программе и переменная `f` внутри функции — это совсем разные переменные (визуализатор pythontutor рисует их в разных *фреймах*). От того, что мы как-то меняем `f` внутри функции, значение переменной `f` вне её не поменялось, и наоборот. Это очень удобно: если бы функция меняла значение «внешней» переменной, то она могла бы сделать это случайно и это привело бы к непредсказуемым последствиям.\n",
    "\n",
    "Тем не менее, иногда нам всё-таки хочется, чтобы функция имела доступ к какой-то внешней переменной. Допустим, мы хотим написать функцию, которая будет приветствовать пользователя, используя язык, указанный им в настройках. Она могла бы выглядеть таким образом:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def hello_i18n(name, lang):\n",
    "    if lang == 'ru':\n",
    "        print(\"Привет,\",name)\n",
    "    else:\n",
    "        print(\"Hello,\",name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Привет, Ivan\n"
     ]
    }
   ],
   "source": [
    "hello_i18n(\"Ivan\", 'ru')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, Ivan\n"
     ]
    }
   ],
   "source": [
    "hello_i18n(\"Ivan\", 'en')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Проблема в том, что функций, которым нужно знать, какой язык выбран, может быть очень много, и каждый раз передавать им вручную значение переменной `lang` отдельным параметром довольно мучительно. Оказывается, можно этого избежать:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello world\n",
      "Привет, Ivan\n",
      "Hello, John\n"
     ]
    }
   ],
   "source": [
    "def hello_i18n(name):\n",
    "    if lang == 'ru':\n",
    "        print(\"Привет,\",name)\n",
    "    else:\n",
    "        print(\"Hello,\",name)\n",
    "        \n",
    "lang = 'ru'\n",
    "print(\"Hello world\")\n",
    "hello_i18n('Ivan')\n",
    "\n",
    "lang = 'en'\n",
    "hello_i18n('John')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Как видите, сейчс поведение функции зависит от того, чему равняется переменная `lang`, определенная вне функции. Может быть и в функции `factorial()` можно было обратиться к переменной `f` до того момента, как мы положили в неё число 1? Давайте попробуем:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def factorial(n):\n",
    "    print(\"In the function, before assignment, f =\", f)\n",
    "    f = 1\n",
    "    for i in range(2, n+1):\n",
    "        f = f * i\n",
    "    print(\"In the function, f =\", f)\n",
    "    return f"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "UnboundLocalError",
     "evalue": "local variable 'f' referenced before assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mUnboundLocalError\u001b[0m                         Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-44-21ad3053ce9b>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mfactorial\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-43-d4a84f87351c>\u001b[0m in \u001b[0;36mfactorial\u001b[0;34m(n)\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[0;32mdef\u001b[0m \u001b[0mfactorial\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mn\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m     \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"In the function, before assignment, f =\"\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mf\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      3\u001b[0m     \u001b[0mf\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m     \u001b[0;32mfor\u001b[0m \u001b[0mi\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mn\u001b[0m\u001b[0;34m+\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      5\u001b[0m         \u001b[0mf\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mf\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mi\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mUnboundLocalError\u001b[0m: local variable 'f' referenced before assignment"
     ]
    }
   ],
   "source": [
    "factorial(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В этом случае Python выдаёт ошибку: локальная переменная `f` использовалась до присвоения значения. В чём разница между этим кодом и предыдущим?\n",
    "\n",
    "Оказывается, Python очень умный: прежде, чем выполнить функцию, он анализирует её код и определяет, какая из переменных является локальной, а какая глобальной. В качестве глобальных переменных по умолчанию используются те, которые не меняются в теле функции (то есть такие, к которым не применяются операторы типа приравнивания или `+=`). Иными словами, по умолчанию глобальные переменные доступны только для чтения, но не для модификации изнутри функции.\n",
    "\n",
    "Ситуация, при которой функция модифицирует глобальную переменную, обычно не очень желательна: функции должны быть изолированы от кода, который из запускает, иначе вы быстро перестанете понимать, что делает ваша программа. Тем не менее, иногда модификация глобальных переменных необходима. Например, мы хотим написать функцию, которая будет устанавливать значение языка пользовавателя. Она может выглядеть примерно так:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "def set_lang():\n",
    "    useRussian = input(\"Would you like to speak Russian (Y/N): \")\n",
    "    if useRussian == 'Y':\n",
    "        lang = 'ru'\n",
    "    else:\n",
    "        lang = 'en'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "en\n",
      "Would you like to speak Russian (Y/N): Y\n",
      "en\n"
     ]
    }
   ],
   "source": [
    "lang = 'en'\n",
    "print(lang)\n",
    "set_lang()\n",
    "print(lang)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Как видим, эта функция не работает — собственно, и не должна. Чтобы функция set_lang смогла менять значение переменной `lang`, её необходимо явно объявить как глобальную с помощью ключевого слова `global`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def set_lang():\n",
    "    global lang\n",
    "    useRussian = input(\"Would you like to speak Russian (Y/N): \")\n",
    "    if useRussian == 'Y':\n",
    "        lang = 'ru'\n",
    "    else:\n",
    "        lang = 'en'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "en\n",
      "Would you like to speak Russian (Y/N): Y\n",
      "ru\n"
     ]
    }
   ],
   "source": [
    "lang = 'en'\n",
    "print(lang)\n",
    "set_lang()\n",
    "print(lang)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Теперь всё работает!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Передача аргументов\n",
    "Есть разные способы передавать аргументы функции. С одним из них мы уже знакомы:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def hello(name, title):\n",
    "    print(\"Hello\", title, name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello Mr. Potter\n"
     ]
    }
   ],
   "source": [
    "hello(\"Potter\", \"Mr.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В некоторым случаях мы хотим, чтобы какие-то аргументы можно было не указывать. Скажем, мы хотим иметь возможность вызвать функцию `hello()`, определённую выше, не указывая `title`. В этом случае сейчас нам выдадут ошибку:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "hello() missing 1 required positional argument: 'title'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-83-dd83cc2cf4d3>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mhello\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Harry\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: hello() missing 1 required positional argument: 'title'"
     ]
    }
   ],
   "source": [
    "hello(\"Harry\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Это неудивительно: мы сказали, что функция `hello()` должна использовать аргумент `title`, но не передали его — какое же значение тогда использовать? Для преодоления этой трудности используютя значения по умолчанию (default values)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello  Harry\n"
     ]
    }
   ],
   "source": [
    "def hello(name, title=\"\"):\n",
    "    print(\"Hello\", title, name)\n",
    "hello(\"Harry\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello Mrs. Smith\n"
     ]
    }
   ],
   "source": [
    "hello(\"Smith\", \"Mrs.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Аргументы можно передавать, указывая их имена."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello Mr. Smith\n"
     ]
    }
   ],
   "source": [
    "hello(\"Smith\", title = \"Mr.\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello Mr. Smith\n"
     ]
    }
   ],
   "source": [
    "hello(name = \"Smith\", title= \"Mr.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В этом случае порядок будет неважен."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello Mr. Smith\n"
     ]
    }
   ],
   "source": [
    "hello(title= \"Mr.\", name = \"Smith\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ещё бывают функции, которые принимают неограниченное число аргументов. Например, так ведёт себя функция `print()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "8 7 5 hello 8\n"
     ]
    }
   ],
   "source": [
    "print(8, 7, 5, 'hello', 8)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Как она устроена? Примерно вот так:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def my_print(*args):\n",
    "    for x in args:\n",
    "        print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n",
      "8\n",
      "9\n",
      "hello\n",
      "88\n",
      "55\n"
     ]
    }
   ],
   "source": [
    "my_print(6, 8, 9, 'hello', 88, 55)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Обратите внимание на звёздочку перед `args` в сигнатуре функции. Давайте посмотрим повнимательнее, как работает этот код:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3, 'hello')\n"
     ]
    }
   ],
   "source": [
    "def test(*args):\n",
    "    print(args)\n",
    "test(1,2,3, 'hello')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Оказывается, что в `args` теперь лежит так называемые *кортеж*, состоящий из элементов, которые мы передали функции. \n",
    "\n",
    "### Отступление: кортежи\n",
    "Кортеж (`tuple`) — это почти то же самое, что и список, только его элементы неизменяемы. Обозначается он круглыми скобками."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n",
      "(2, 3)\n"
     ]
    }
   ],
   "source": [
    "t = (2,3, 5, 1)\n",
    "print(t[1])\n",
    "print(t[0:2])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "3\n",
      "5\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "for x in t:\n",
    "    print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'tuple' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-93-eaf187d38884>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mt\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m10\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "t[0] = 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "'tuple' object has no attribute 'append'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-94-2337caf868e4>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mappend\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m: 'tuple' object has no attribute 'append'"
     ]
    }
   ],
   "source": [
    "t.append(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Тот факт, что нельзя изменять кортеж, не означает, что нельзя переопределить переменную `t`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "t = (8, 1, 2, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(8, 1, 2, 3)"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "t"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Можно думать о списке как о меловой доске, расчерченной на отдельные ячейки, в которые можно записывать разные значения. Тогда кортеж — это глинянная (или каменная) дощечка, на которой выбиты какие-то значения. Вы не можете изменить значения, которые на ней выбиты, но вы можете разбить старую дощечку и изготовить новую.\n",
    "\n",
    "Можно также конвертировать списки в кортежи и наоборот."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3]\n",
      "(1, 2, 3)\n"
     ]
    }
   ],
   "source": [
    "print( list( (1, 2, 3) ) )\n",
    "print( tuple( [1, 2, 3] ) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Возвращаясь к функциям\n",
    "\n",
    "Таким образом, звёздочка в сигнатуре как бы ставит дополнительные скобки вокруг аргументов. Например, следующие два вызова приводят к одинаковым результатам."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3)\n",
      "(1, 2, 3)\n"
     ]
    }
   ],
   "source": [
    "def test1(*args):\n",
    "    print(args)\n",
    "test1(1, 2, 3)\n",
    "\n",
    "def test2(args):\n",
    "    print(args)\n",
    "test2( (1,2,3) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Можно комбинировать списочные переменные и обычные (при условии, что переменная со звёздочкой только одна):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def my_print(sep, *args):\n",
    "    for x in args:\n",
    "        print(x, end = sep)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7----8----9----hello----"
     ]
    }
   ],
   "source": [
    "my_print('----', 7, 8, 9, 'hello')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "На сегодня всё :)"
   ]
  }
 ],
 "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.5.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}