PyProgPerm/lectures/calc-variables.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Программирование на Python\n",
    "\n",
    "*Алла Тамбовцева, НИУ ВШЭ*\n",
    "\n",
    "*Данный ноутбук частично основан на [лекции](http://python.math-hse.info:8080/github/ischurov/pythonhse/blob/master/Lecture%201.ipynb) Щурова И.В., [курс](http://math-info.hse.ru/s15/m) «Программирование на языке Python для сбора и анализа данных» (НИУ ВШЭ).*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Вычисления и переменные в Python"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Python как калькулятор"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Привычные арифметические действия (сложение, вычитание, умножение, деление) в Python выглядят так же, как во многих других языках или калькуляторах:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 + 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5 * 4 - 9"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.5"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "7 / 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "При делении Python всегда будет выдавать результат в виде числа с плавающей точкой (тип *float*), даже тогда, когда ожидается целочисленный ответ."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.0"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "8 / 2  # не 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Получился дробный результат, где дробная часть равна 0. Если нужен ответ в виде целого числа, можно воспользоваться целочисленным делением."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "8 // 2  # теперь 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Тут важно помнить, что при использовании оператора `//` дробная часть всегда будет просто отбрасываться – никакого округления происходить не будет. Для округления существуют специальные функции, и мы их обсудим позже."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "7 // 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В Python 2 обычное деление с помощью `/` было целочисленным. Для того чтобы получить привычные результаты деления, нужно было либо импортировать обычное деление из модуля `__future__`, который позволяет использовать функционал более новых версий Python  (см. [здесь](http://rextester.com/VMMS70343)), либо использовать другие хитрости, например, делить число с плавающей точкой на целое (см. [здесь](http://rextester.com/YJZV11974)).\n",
    "\n",
    ">**Примечание:** для того, чтобы сравнивать исполнение одного и того же кода в Python 3 и Python 2 совсем необязательно устанавливать обе версии на компьютер. Можно воспользоваться онлайн-компиляторами (например,  http://rextester.com: выбирать Python или Python 3). Полноценно работать в них, не устанавливая Python, будет неудобно. Но для нескольких строк для сравнения как раз. Кроме того, создавать исполняемые файлы в разных версиях Python можно в среде PyCharm. Сейчас встретить код на Python 2 можно довольно редко, но вдруг! "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Если нам нужен остаток от деления, понадобится оператор `%`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "8 % 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Что ещё можно делать с числами? Возводить в степень и извлекать из них корень. При расчётах на калькуляторе и в некоторых языках для возведения числа в степень иногда используется оператор `^`. Попробуем! "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5 ^ 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Получилось что-то неожиданное. В Python оператор `^` используется для операции «исключающее или», которая при применении к двум целым числам соответствует побитному сложению по модулю два. Другими словами, Python переводит оба числа в двоичный формат, применяет к полученным последовательностям из 0 и 1 логическую операцию «исключающее или» (XOR) и полученный результат преобразует в число в десятичной системе счисления.\n",
    "\n",
    "Для возведения числа в степень потребуется оператор `**`:  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "25"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5 ** 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.8171205928321397"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "6 ** (1/3)  # дробная степень - корень 3 степени"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Теперь попробуем извлечь квадратный корень из числа с помощью довольно привычной функции `sqrt()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'sqrt' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-11-9ea6aceded53>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0msqrt\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m9\u001b[0m\u001b[0;34m)\u001b[0m  \u001b[0;31m# не получается!\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m: name 'sqrt' is not defined"
     ]
    }
   ],
   "source": [
    "sqrt(9)  # не получается!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python пишет, что не знает, что такое `sqrt`. В каких случаях Python может такое писать? Например, если мы опечатались в названии функции (Python не понимает, что мы от него хотим) или если мы пытаемся обратиться к функции, которая не входит в стандартную библиотеку (Python не знает, откуда её брать). В данном случае мы столкнулись со второй проблемой. Функция для вычисления квадратного корня из числа хранится в специальном модуле `math`. Этот модуль стандартный, дополнительно устанавливать его не нужно. Но для того чтобы воспользоваться этой функцией, нужно сначала импортировать модуль, а потом вызвать из него функцию `sqrt`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.0"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.sqrt(9)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Если из `math` нам нужна только одна функция `sqrt` , можно извлечь только её, и тогда прописывать название модуля перед функцией не понадобится: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.0"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from math import sqrt\n",
    "sqrt(16)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "С помощью конструкции `from ... import` можно импортировать сразу несколько функций:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import sqrt, exp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "20.085536923187668"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "exp(3)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Иногда, если неизвестно, сколько функций потребуется, но каждый раз прописывать полностью название модуля не хочется, можно импортировать его сразу с сокращённым названием. Сделать это можно с помощью конструкции `import ... as ...`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.0"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import math as ma\n",
    "ma.sqrt(9)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ">**Примечание:** то же будет верно и для библиотек. Пока мы столкнулись с модулем `math`, в темах по обработке данных мы будем активно работать с разными библиотеками. Если совсем упростить, модуль – это набор функций, а библиотека – это набор модулей, то есть что-то более сложное по структуре и более насыщенное по функционалу."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Если мы знаем, что будем использовать практически все функции из модуля `math`, их можно извлечь все сразу, с помощью конструкции `from ... import *`, и тогда прописывать название библиотеки нам не понадобится нигде. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import *"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Однако в общем случае так делать нежелательно, потому что это нерационально и увеличивает время исполнения кода (Python загружает все функции, а мы пользуемся только некоторыми)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В `math` есть много полезных функций для вычислений. Чтобы посмотреть, какие функции там есть, после импортирования всего модуля через `import math` можно набрать `math.` и нажать на *Tab* (актуально при работе в интерактивных средах). Посмотрим на некоторые из них:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.6931471805599453"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.log(2)  # натуральный логарифм"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.0"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.log10(100)  # логарифм по основанию 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.sin(0)  # синус"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.ceil(8.7)  # ceil - потолок, округление в большую сторону"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "8"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.floor(8.7)  # floor - пол, округление в меньшую сторону"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "А ещё из `math` можно импортировать константы $\\pi$ и $e$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import pi, e"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.141592653589793"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pi"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.718281828459045"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "e"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "С чем ещё можно столкнуться, выполняя вычисления в Python? С такими вещами:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.1513310942010236e-32"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 / 18 ** 25"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Результат выше – компьютерная форма экспоненциальной записи числа. Здесь `e-32` – это $10^{-32}$, а вся запись означает $4.1513310942010236 \\cdot 10^{-32}$, то есть примерно $4.15 \\cdot 10^{-32}$. Теоретически, если число было очень большим, `e` стояло бы в положительной степени. Но в Python такое не случается, обычно он выводит огромные числа, просто переходя на новую строку, если места на одной не хватает:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12899047957225248523006646539464335721979411301041340884781899303831010765027442196396594170642790934375007246578677182803636590164161819235523359334210795997877313526230138186880373768216363562984711930606834390635683889567066017501638286295454450223592921380025243612655929972891854670089005958782301313748919257409270999076443855743717129316401343809648755190213387432370099603517989905917859013302341878321325941570315088698234189444110362237214217846884135935952399097352427521852877620725021626938113437232848226058128334528859922677792198697568021708059256675191088006467069748109014817451375952598349790911535607651796493584493889427435570940502359773301622881259890983839926411232560174739455589741388073805529446667461505169110660161765843273557623843219490805708791092602475974648916336329253754550331716502327365416889998212147857020330942368277430427804385066546271943413689950822020931400593245046303758610973943882235592749794293155060009636680119916358947879472882782808870076229635495297702820410851089251120079429452529354919596272075046635023793735251154878700529432000342403111069160632592433095161936605646694694109530441088995393229754160740330575038216906404744009495445586324655891258721903641299986081018110880120922925030222636715904777957341225983442938451506259053249716900875692689602609775497863867095485915444153828849"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "23 ** 990"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Компьютерная форма записи числа отчасти помогает понять, почему дробные числа называются числами с плавающей точкой (тип *float*). Возьмем число попроще, например, $12.34$. Его можно записать как $12.34$, как $1.234 \\cdot 10$, как $123.4 \\cdot 10^{-1}$, $1234 \\cdot 10^{-2}$ и так далее. Точка, отделяющая дробную часть от целой, будет «плавать», однако само число при этом меняться не будет, будут меняться только множители – разные степени десятки."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "С числами с плавающей точкой связана ещё одна сложность — округление. На первый взгляд, всё хорошо:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "13"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "round(12.6)  # округлим до целого - по умолчанию"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "12.5"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "round(12.53, 1)  # округлим до первого знака после запятой"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "С другой стороны, могут возникнуть странности: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "round(2.50)  # не 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.52"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "round(3.525, 2)  # не 3.53"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Эти странности связаны с тем, что число, которое мы видим, не совпадает с тем, которое хранится в компьютере (так называемая «проблема представления», возникающая из-за конфликта Python и архитектуры системы при преобразовании чисел из десятичной системы в двоичную и обратно). Чтобы понять, как Python видит число 3.525 при обработке, обратимся к модулю `decimal`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Decimal('3.524999999999999911182158029987476766109466552734375')"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from decimal import Decimal\n",
    "Decimal(3.525)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Такое число будет законно округляться до 3.52 по правилам арифметического округления. \n",
    "\n",
    "С одной стороны, полезно помнить, что числа с плавающей точкой (тип *float*) не рекомендуется использовать в финансовых вычислениях и вообще в вычислениях, требующих высокой точности, поскольку они «накапливают ошибку», то есть могут давать неточные результаты. С другой стороны, важно понимать, что эта проблема решаема. Вместо того чтобы использовать дробные числа в виде чисел с плаващей точкой «как есть», можно вопользоваться тем же модулем `decimal` или модулем `fractions`, если речь идёт об обычных дробях."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Переменные"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python, в отличие от многих низкоуровневых языков программирования (C, C++, Java) – язык с динамической типизацией, он сам распознаёт, что мы сохраняем в переменную: число, целое число, текст, список чисел... Поэтому при создании переменной нам не нужно указывать её тип."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Python поймет, что это целые числа\n",
    "\n",
    "x = 2\n",
    "y = 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "print(x)\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Значения переменных мы можем обновлять – изменить значение и сохранить в переменную с тем же названием. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3\n"
     ]
    }
   ],
   "source": [
    "x = x + 1\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "6\n"
     ]
    }
   ],
   "source": [
    "y = y * 2\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    ">**Примечание:** в Python также можно использовать операторы для инкремента и декремента: `x += 1` вместо обычного `x = x + 1`, `x -= 1` вместо `x = x - 1`, или `y *= 2` вместо `y = y * 2`. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В Python реализуется принцип сбора мусора – объекты, которые не используются, удаляются, тем самым, освобождается место в памяти. Разберём такой пример: сначала в переменную `x` мы сохраним число 5, а потом – текст \"abc\":"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 5\n",
    "x = \"abc\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Для Python эти операции выглядят так. Есть объект 5, это целое число, для которого резервируется некоторая ячейка памяти. Мы создаём переменную `x`, создавая при этом ссылку, которая соединяет название `x` и объект 5. Когда мы присваиваем `x` значение `\"abc\"`, мы помещаем в некоторую ячейку памяти строковый объект \"abc\" и перенаправляем ссылку с названием `x` на эту ячейку. При этом значение 5, если оно больше нигде не используется, удаляется с целью экономии памяти."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Названия переменных в Python могут быть почти любыми. Три общих правила: название переменной не должно начинаться с цифры, в названии не должно быть пробелов, название не должно совпадать со служебными (зарезервированными) словами в Python. Список зарезервированных слов можно узнать так:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['False', 'None', 'True', 'and', 'as', 'assert', 'async', 'await', 'break', 'class', 'continue', 'def', 'del', 'elif', 'else', 'except', 'finally', 'for', 'from', 'global', 'if', 'import', 'in', 'is', 'lambda', 'nonlocal', 'not', 'or', 'pass', 'raise', 'return', 'try', 'while', 'with', 'yield']\n"
     ]
    }
   ],
   "source": [
    "import keyword\n",
    "print(keyword.kwlist)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Обычно рекомендуется давать переменным осмысленные названия: если речь идёт о доходе, называть переменную не `x`, а `income`, если речь идёт о данных по преступности, сохранять таблицу в переменную `crimes`, и так далее. Технически, Python 3 допускает названия на кириллице, но это будет выглядеть странно и неуместно."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "У Python есть интересная особенность – возможность присваивать значения нескольким переменным одновременно, множественное присваивание (*multiple assignment*). Например, мы можем следующим образом записать сразу значения двух переменных `a` и `b`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "a, b = 0, 1\n",
    "print(a)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Это возможно, за счёт того, что если Python сталкивается с перечнем элементов через запятую, он объединяет их в структуру данных – кортеж:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(0, 1)"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0, 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Поэтому при присваивании он понимает, что первый элемент кортежа нужно записать в `a`, в второй – в `b`. Что интересно, множественное присваивание позволяет менять значения переменных местами:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5 2\n"
     ]
    }
   ],
   "source": [
    "a = 2\n",
    "b = 5\n",
    "a, b = b, a\n",
    "print(a, b)"
   ]
  }
 ],
 "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.7.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}