python_pd/02_syntax/02_variables.ipynb

{
 "metadata": {
  "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.9.0-final"
  },
  "orig_nbformat": 2,
  "kernelspec": {
   "name": "python3",
   "display_name": "Python 3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2,
 "cells": [
  {
   "source": [
    "# Переменные и выражения\n",
    "\n",
    "## Переменные и операция связывания, цепочки присваивания\n",
    "\n",
    "В дальнейших примерах используется функция ```print``` -- одна из встроенных функций Python, которая позволяет выводить что-либо на экран. Она может принимать любое количество аргументов, печатая их через пробел.\n",
    "\n",
    "Для использования переменной достаточно указать ее имя и через знак ```=``` задать определенное значение. Указывать тип переменной и объявлять переменную отдельно в Python не нужно."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "foo = 42\n"
     ]
    }
   ],
   "source": [
    "foo = 42\n",
    "print('foo =', foo)"
   ]
  },
  {
   "source": [
    "В Python такая операция называется операцией связывания, которая ставит в соответствие некоторому имени переменной определенное значение, т. е. связывает.\n",
    "\n",
    "После создания переменной её можно использовать в других выражениях, где будет использоваться ее значение.\n",
    "\n",
    "Для того, чтобы связать один объект с несколькими именами использую так называемые цепочки присваивания. Сначала записываются имена, чередующиеся знаками ```=```, а после нужное значение."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "a = 42\nb = 42\nc = 42\n"
     ]
    }
   ],
   "source": [
    "a = b = c = 42\n",
    "print('a =', a)\n",
    "print('b =', b)\n",
    "print('c =', c)"
   ]
  },
  {
   "source": [
    "Теперь каждое имя связано с одним объектом, значение которого 42.\n",
    "\n",
    "Похожим способом можно связать несколько имен с несколькими объектами."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "a = 1\nb = 2\nc = 3\n"
     ]
    }
   ],
   "source": [
    "a, b, c = 1, 2, 3\n",
    "print('a =', a)\n",
    "print('b =', b)\n",
    "print('c =', c)"
   ]
  },
  {
   "source": [
    "## Представление переменной в памяти\n",
    "\n",
    "В Python всё является объектом, в том числе простые типы данных. Например, при вводе в интерпретатор целого числа ```42``` будет создан объект целого числа со значением 42. Эти объекты имеют ряд \"служебной\" информации, такой как адрес в памяти, тип значения, само значение и т.д.. Представить такой объект в упрощенном виде можно следующим образом:\n",
    "\n",
    "<img src=\"https://raw.githubusercontent.com/redb0/python-bp/master/python_pd/02_syntax/image/pyobject_int.png\" align=\"center\"/>\n",
    "\n",
    "Здесь ```PyObject``` общее названия для всех объектов Python.\n",
    "\n",
    "В процессе выполнения выражения \n",
    "```python\n",
    "foo = 42\n",
    "```\n",
    "Python создаст объект целого числа со значением ```42```, поместит его в память с определенным адресом или id. Затем свяжет его с именем ```foo```. Это можно представить в виде ссылки на объект.\n",
    "\n",
    "<img src=\"https://raw.githubusercontent.com/redb0/python-bp/master/python_pd/02_syntax/image/name_object.png\" align=\"center\"/>\n",
    "\n",
    "Таким образом, в Python нет \"классических\" переменных, которые присутствуют в других языках программирования. Вместо этого переменные это лишь имена, указывающие на объект в памяти. Это приводит к тому, что само имя не имеет типа, тип есть непосредственно у объекта.\n",
    "\n",
    "В случае выражения множественного связывания:\n",
    "\n",
    "```python\n",
    "foo = bar = baz = 42\n",
    "```\n",
    "\n",
    "Python свяжет все три имени с одним объектом. На схеме это выглядит так.\n",
    "\n",
    "<img src=\"https://raw.githubusercontent.com/redb0/python-bp/master/python_pd/02_syntax/image/multiple_names.png\" align=\"center\"/>\n",
    "\n",
    "Аналогичное поведение будет, если связывать имена с объектами в разных местах программы:\n"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "foo = 42\n",
    "bar = foo\n",
    "baz = bar"
   ]
  },
  {
   "source": [
    "## Операторы, приоритеты и операции над простыми типами\n",
    "\n",
    "Все доступные операторы можно разделить на группы:\n",
    "\n",
    "- Арифметические (```+```, ```-```, ```*```, ```/```, ```//```, ```%```, ```**```)\n",
    "- Битовые (```&```, ```|```, ```^```, ```~```, ```<<```, ```>>```)\n",
    "- [Сравнения](https://docs.python.org/3/library/stdtypes.html#comparisons) (```>```, ```<```, ```>=```, ```<=```, ```==```, ```!=```)\n",
    "- In-place операторы (```+=```, ```-=```, ```|=``` и другие)\n",
    "- Операторы членства (```in```, ```not in```)\n",
    "- Операторы тождественности (```is```, ```is not```)\n",
    "- [Логические](https://docs.python.org/3/library/stdtypes.html#boolean-operations-and-or-not) (```and```, ```or```, ```not```)\n",
    "\n",
    "### Арифметические операции над числами"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Сумма: 42 + 5 = 47\nОстаток: 42 % 5 = 2\nЦелая часть от деления: 42 // 5 = 8\nВозведение в степень: 100 ** 42 = 1000000000000000000000000000000000000000000000000000000000000000000000000000000000000\nДеление: (1+3j) / (1+3j) = (1+0j)\n"
     ]
    }
   ],
   "source": [
    "# Операции с числами\n",
    "a = 42\n",
    "b = 5\n",
    "c = 2.5\n",
    "d = 1 + 3j\n",
    "print('Сумма:', a, '+', b, '=', a + b)\n",
    "print('Остаток:', a, '%', b, '=', a % b)\n",
    "print('Целая часть от деления:', a, '//', b, '=', a // b)\n",
    "print('Возведение в степень:', 100, '**', a, '=', 100 ** a)\n",
    "print('Деление:', d, '/', d, '=', d / d)"
   ]
  },
  {
   "source": [
    "У целых чисел есть одна особенность -- они не ограничены по памяти, ограничением выступает только оперативная память компьютера. Поэтому в Python \"из коробки\" доступна длинная арифметика.\n",
    "\n",
    "Результат операций с числами разных типов будет иметь тип операнда, у которого обширнее тип. Это можно представить как ```int < float < complex```, если один операнд будет целого типа, а другой с плавающей точкой, то и результат будет с плавающей точкой, т. е. ```float```. Из этого правила есть только одно исключение. Оператор деления ```/``` всегда приводит тип к ```float```, даже когда два операнда будут целого типа. Для целочисленного деления (целая часть) есть оператор ```//```.\n"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Сумма: 42 + 2.5 = 44.5\nОстаток: 7 % 2.5 = 2.0\nВозведение в степень: 42 ** (1+3j) = (9.06046295499066-41.01107181044214j)\nДеление: 42 / 7 = 6.0\n"
     ]
    }
   ],
   "source": [
    "# Операции с числами разных типов\n",
    "a = 42\n",
    "b = 7\n",
    "c = 2.5\n",
    "d = 1 + 3j\n",
    "print('Сумма:', a, '+', c, '=', a + c)  # результат float\n",
    "print('Остаток:', b, '%', c, '=', b % c)  # результат float\n",
    "print('Возведение в степень:', a, '**', d, '=', a ** d)  # результат complex\n",
    "print('Деление:', a, '/', b, '=', a / b)  # результат float"
   ]
  },
  {
   "source": [
    "В памяти компьютера информация представлена в виде последовательности нулей и единиц. Это накладывает ограничения на представление чисел с плавающей запятой. Они также хранятся в виде ограниченного двоичного представления. Поэтому при операциях с ними могут появляться неточности."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "0.1 + 0.2 = 0.30000000000000004\n"
     ]
    }
   ],
   "source": [
    "a = 0.1\n",
    "b = 0.2\n",
    "print(a, '+', b, '=', a + b)"
   ]
  },
  {
   "source": [
    "### In-place операторы\n",
    "\n",
    "Для всех арифметических и битовых операторов существуют их in-place аналоги. Это операторы с добавлением знака ```=```. Предназначены эти операторы для изменения переменной \"на месте\"."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "a = 42\n"
     ]
    }
   ],
   "source": [
    "a = 196\n",
    "a += 1  # 197\n",
    "a //= 5  # 39\n",
    "a -= 18  # 21\n",
    "a *= 2  # 42\n",
    "print('a =', a) "
   ]
  },
  {
   "source": [
    "### Операции над строками\n",
    "\n",
    "Некоторые арифметические операторы, такие как ```+``` и ```*``` можно применять и со строками для конкатенации (объединения) и размножения строк."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Результат конкатенации: foo_bar\nУмножение на константу: foo * 5 = foofoofoofoofoo\n"
     ]
    }
   ],
   "source": [
    "a = 'foo'\n",
    "b = 'bar'\n",
    "c = a + '_' + b\n",
    "print('Результат конкатенации:', c)\n",
    "print('Умножение на константу:', a, '*', 5, '=', a * 5)"
   ]
  },
  {
   "source": [
    "Умножение строки на константу удобно использовать для разделения вывода с помощью линий из разных разделителей, например, ```-``` или ```*```."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "--------------------------------------------------\n"
     ]
    }
   ],
   "source": [
    "print('-' * 50)"
   ]
  },
  {
   "source": [
    "### Операции с логическим типом\n",
    "\n",
    "Логический тип данных (```bool```) в Python образован от типа целого числа (```int```). В связи с эти его константы ```True``` и ```False``` могут быть представлены целыми числами. ```True``` эквивалентна 1, а ```False``` -- 0. Эта особенность делает возможным использование этих констант в арифметических выражениях."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "0\n6\n"
     ]
    }
   ],
   "source": [
    "print(True * False)\n",
    "print(5 + True - 4 * False)"
   ]
  },
  {
   "source": [
    "### Логические операторы\n",
    "\n",
    "Лигических операторов всего три: ```or``` (или), ```and``` (и), ```not``` (не). Их работа продемонстрирована в следующем примере.\n"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "0 and 0: False\n0 and 1: False\n1 and 0: False\n1 and 1: True\n--------------------\n0 or 0: False\n0 or 1: True\n1 or 0: True\n1 or 1: True\n--------------------\nnot 0: False\nnot 1: True\n"
     ]
    }
   ],
   "source": [
    "print('0 and 0:', False and False)\n",
    "print('0 and 1:', False and True)\n",
    "print('1 and 0:', True and False)\n",
    "print('1 and 1:', True and True)\n",
    "print('-' * 20)\n",
    "print('0 or 0:', False or False)\n",
    "print('0 or 1:', False or True)\n",
    "print('1 or 0:', True or False)\n",
    "print('1 or 1:', True or True)\n",
    "print('-' * 20)\n",
    "print('not 0:', False)\n",
    "print('not 1:', True)"
   ]
  },
  {
   "source": [
    "Однако, логические операторы способны работать не только с операндами типи ```bool```, но и с другими типапми данных."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "or -> 2\nand -> 3\nand -> False\n"
     ]
    }
   ],
   "source": [
    "print('or ->', 2 or 3)\n",
    "print('and ->', 2 and 3)\n",
    "print('and ->', not 3)"
   ]
  },
  {
   "source": [
    "В этом примере оператор ```or``` вернул первый операнд в качестве результата. Это происходит в связи с тем, что Python считает объект целого числа со значением 2 истинным, т. е. эквивалентным ```True```. Это сочетается с другим свойством логических операторов, а именно с ленивостью. Под ленивостью здесь понимается тот факт, что если первый операнд ```a``` в выражении ```a and b``` является истинным, то второй ```b``` проверяться не будет, т. к. результат выражения будет ```True```. Это верно для ```or```. В случае ```and``` поведение будет обратное, если первый операнд ```a``` эквивалентен ```False```, то второй операнд не проверяется, а значение всего выражения будет ```False```. В следующей таблице представлены варианты работы операторов в зависимости от их операндов.\n",
    "\n",
    "| Выражение | a <=> True | b <=> True     | Результат |\n",
    "|-----------|------------|----------------|-----------|\n",
    "| a or b    | Да         | Не вычисляется | a         |\n",
    "| a or b    | Нет        | Не важно       | b         |\n",
    "| a and b   | Да         | Не важно       | b         |\n",
    "| a and b   | Нет        | Не вычисляется | a         |\n",
    "\n",
    "(Значок ```<=>``` означает эквивалентность)\n",
    "\n",
    "Обратите внимание, что в некоторых случаях, когда результат выражения известен из первого операнда, второй операнд не вычисляется. С другой стороны, когда по первому операнду не удается понять результат выражения, то будет сразу возвращен второй операнд, т. к. результат выражения теперь зависит только от него. \n",
    "\n",
    "Ленивость операторов позволяет проводить разные проверки, когда успешность одной проверки влияет на последующую. Например, в следующем примере используется деление на ноль, в Python оно запрещено и вызывает ошибку и прекращение работы программы. Но этот пример выполниться корректно, т. к. первый операнд эквивалентен ```False```, а значит второй не вычисляется.\n"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "metadata": {},
     "execution_count": 31
    }
   ],
   "source": [
    "False and 1 / 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "output_type": "execute_result",
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "metadata": {},
     "execution_count": 37
    }
   ],
   "source": [
    "# Еще один пример плохо читаемого выражения\n",
    "2 and 0 or 4 or 5 and False  # 4"
   ]
  },
  {
   "source": [
    "### Сравнения\n",
    "\n",
    "Операторы сранения в Python возвращают результат логического типа. "
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "False\n"
     ]
    }
   ],
   "source": [
    "print(2 > 4)"
   ]
  },
  {
   "source": [
    "Кроме этого они позволяют строить [цепочки сравнения](https://docs.python.org/3/reference/expressions.html#comparisons), выражения аналогичные двойным неравенствам в математике. Такие цепочки раскрываются с помощью оператора ```and```."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Цепочка сравнения: True\nЭквивалент: True\n"
     ]
    }
   ],
   "source": [
    "print('Цепочка сравнения:', 1 <= 3 < 5)\n",
    "print('Эквивалент:', 1 <= 3 and 3 < 5)"
   ]
  },
  {
   "source": [
    "Такими выражениями легко злоупотребить, например:"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "False\nTrue\nTrue\n"
     ]
    }
   ],
   "source": [
    "print((6 > 7) == 0)  # True\n",
    "print(6 > (7 == 0))  # True\n",
    "print(6 > 7 == 0)  # чистое зло, False"
   ]
  },
  {
   "source": [
    "### Операторы членства\n",
    "\n",
    "Эти операторы предназначены для проверки вхождения каких-либо элементов в строки или какие-либо другие коллекции (о них речь пойдет чуть позднее). "
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Оператор in: True\nОператор not in: True\n"
     ]
    }
   ],
   "source": [
    "print('Оператор in:', 'monty' in 'monty_python')\n",
    "print('Оператор not in:', 'foo' not in 'monty_python')"
   ]
  },
  {
   "source": [
    "Стоит отметить, что оператор ```not in``` это единая конструкция и записывать ее следующим образом будет неправильно, хоть и корректно:"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Неправильно: True\n"
     ]
    }
   ],
   "source": [
    "print('Неправильно:', not 'foo' in 'monty_python')"
   ]
  },
  {
   "source": [
    "Каждый оператор в Python имеет определенный приоритет, определяющий порядок выполнения внутри выражения. Высокий приоритет, означает, что оператор будет выполнен перед более низкоприоритетными операциями. Например, оператор возведения в степень имеет один из самых высоких приоритетов, соответственно будет выполняться в первую очередь. Обратите внимание, что оператор сравнения имеют одинаковый приоритет.\n",
    "\n",
    "С полной таблицей приоритетов операций можно ознакомиться в [документации](https://docs.python.org/3/reference/expressions.html#operator-summary)"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "source": [
    "## Различие операторов == и is\n",
    "\n",
    "Оператор ```==```, один из операторов сравнения, сравнивает два объекта на равенство их значений. \n"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Оператор \"==\": True\n"
     ]
    }
   ],
   "source": [
    "foo = 376\n",
    "bar = 376\n",
    "print('Оператор \"==\":', foo == bar)"
   ]
  },
  {
   "source": [
    "В Python существуют операторы тождественности ```is``` и ```is not```. Эти операторы проверяют объекты на тождественность, т. е. являются ли два объекта идентичными или одним и тем же объектом. Объекты в Python могут иметь одни и те же значения, но при этом не быть одним и тем же объектом. Два объекта в Python считаются одним и тем же, если они лежат в одном месте в памяти. Пример ниже можно представить на схеме в следующем виде.\n",
    "\n",
    "<img src=\"https://raw.githubusercontent.com/redb0/python-bp/master/python_pd/02_syntax/image/multiple_object.png\" align=\"center\"/>\n",
    "\n",
    "Здесь числа ```id``` это просто адреса в памяти, где размещены эти объекты.\n",
    "\n",
    "Еще одна из встроенных в Python функций, помимо ```print```, называется ```id```. Она принимает только один аргумент -- произвольный объект. В качестве результата она возвращает число, которое является адресом объекта в памяти. Пример ниже демонстрирует, что два объекта целого числа имеют одинаковое значение и, соответственно, оператор ```==``` возвращает ```True```. Однако, эти объекты лежат в разных ячейках памяти, что демонстрирует функция ```id```. Таким образом результат сравнения этих объектов на тождественность отрицательный."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "Оператор \"==\": True\nАдрес \"foo\": 104256176\nАдрес \"bar\": 104258720\nСравнение адресов с помощью ==: False\nОператор \"is\": False\n"
     ]
    }
   ],
   "source": [
    "foo = 376\n",
    "bar = 376\n",
    "print('Оператор \"==\":', foo == bar)\n",
    "print('Адрес \"foo\":', id(foo))\n",
    "print('Адрес \"bar\":', id(bar))\n",
    "print('Сравнение адресов с помощью ==:', id(foo) == id(bar))\n",
    "print('Оператор \"is\":', foo is bar)"
   ]
  },
  {
   "source": [
    "Здесь стоит помнить, что не всегда Python создает новые объекты для тех же значений. В качестве оптимизации Python не создает несколько объектов для малых чисел в диапазоне $[-5, 256]$. Поэтому возможно следующее"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "42 is 42: True\n"
     ]
    }
   ],
   "source": [
    "a = 42\n",
    "b = 42\n",
    "print('42 is 42:', a is b)"
   ]
  },
  {
   "source": [
    "Вот некоторые интересные источники по этому вопросу:\n",
    "- [документация](https://docs.python.org/3/c-api/long.html) с описанием реализации целых чисел\n",
    "- [обсуждение](https://stackoverflow.com/questions/306313/is-operator-behaves-unexpectedly-with-integers) различий операторов ```is``` и ```==```\n",
    "\n",
    "Стоит также отметить, что если выполнять такой код в файле, а не в REPL, то там может работать другая оптимизация и даже большие числа будут иметь одинаковый адрес в памяти.\n",
    "\n",
    "Помимо чисел в Python существует ряд объектов, которые всегда существуют в памяти в одном экземпляре. Такими объектам являются логические константы ```True``` и ```False```, а также ```None```. Поэтому проверку на эти значения стоит осуществлять с помощью операторов ```is``` или ```is not```. Оператор ```is not``` аналогичен оператору ```not in```, его не стоит разделять, иначе можно получить не тот результат, который предполагался. \n"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "is: True\nis not: False\nnot ... is: False\n==: True\n"
     ]
    }
   ],
   "source": [
    "foo = None\n",
    "print('is:', foo is None)\n",
    "print('is not:', foo is not None)\n",
    "print('not ... is:', not foo is None)  # Не правильно\n",
    "print('==:', foo == None)  # Не по стандарту"
   ]
  },
  {
   "source": [
    "## Моржовый оператор\n",
    "\n",
    "В версии интерпретатора 3.8 в Python добавили новый оператор присваивания ```:=``` - оператор моржа ([PEP 572](https://www.python.org/dev/peps/pep-0572/)). Этот оператор предназначен для использования только внутри выражений. Использование моржового оператора вместо стандартного ```=```, т. е. выражения вида ```a := 5``` вместо ```a = 5```, работать не будет. \n",
    "\n",
    "Рассмотрим довольно бесполезный пример. Пример ниже эквивалентен записи ```a = b = 6```. Скобки здесь обязательны. "
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "a = 6\nb = 6\n"
     ]
    }
   ],
   "source": [
    "a = (b := 6)\n",
    "print('a =', a)\n",
    "print('b =', b)"
   ]
  },
  {
   "source": [
    "Моржовый оператор не просто присваивает переменной определенное значение, но и возвращает в качестве результата то, что было присвоено. Таким образом, здесь сначала вычисляется выражение в скобках и его результат будет ```6```. Затем этот результат связывается с именем ```a```.\n",
    "\n",
    "Вот несколько ситуаций, когда оператор моржа может быть особенно полезен:\n",
    "- вычисление части формулы и ее переиспользование\n",
    "- использования внутри условий и циклов.\n",
    "\n",
    "Рассмотрим первый случай. Для примера возьмем вычисление чисел Фибоначчи по [формуле Бине](https://en.wikipedia.org/wiki/Fibonacci_number). Эта формула выглядит следующим образом:\n",
    "\n",
    "$$\n",
    "F_n = \\frac {\\phi^n - (-\\phi)^{-n}}{2\\phi - 1}, \\phi = \\frac {1+\\sqrt 5}{2}\n",
    "$$\n",
    "\n",
    "В этой формуле значение $\\phi$ используется в трех местах, вполне логично вычислить эту часть заранее."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "F_5 = 5.000000000000001\n"
     ]
    }
   ],
   "source": [
    "# заранее вычислим золотое сечение\n",
    "phi = (1 + 5**0.5) / 2\n",
    "\n",
    "# 5-е число Фибоначчи\n",
    "f_5 = (phi**5 - (-phi)**(-5)) / (2 * phi - 1)\n",
    "print('F_5 =', f_5)"
   ]
  },
  {
   "source": [
    "Здесь мы можем применить моржовый оператор для вычисления $\\phi$ непосредственно внутри $F_n$. Не стоит злоупотреблять этим оператором, т. к. он может усложнить читаемость, иногда лучше вынести часть вычислений на новую строку (как в примере выше)."
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "output_type": "stream",
     "name": "stdout",
     "text": [
      "F_5 = 5.000000000000001\n"
     ]
    }
   ],
   "source": [
    "# Вычисляем phi внутри основной формулы\n",
    "f_5 = ((phi := (1 + 5**0.5) / 2)**5 - (-phi)**(-5)) / (2 * phi - 1)\n",
    "print('F_5 =', f_5)"
   ]
  },
  {
   "source": [
    "## Сообщения об ошибках\n",
    "\n",
    "При выполнении примером неизбежно могут возникнуть ситуации, когда ключевое слово будет введено некорретно или будет произведена попытка выполнения неверной операции. В этом случае интерпретатор покажет ошибку. Например, выполним попытку деления на ноль:"
   ],
   "cell_type": "markdown",
   "metadata": {}
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "output_type": "error",
     "ename": "ZeroDivisionError",
     "evalue": "division by zero",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mZeroDivisionError\u001b[0m                         Traceback (most recent call last)",
      "\u001b[1;32m<ipython-input-54-bc757c3fda29>\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[1;36m1\u001b[0m \u001b[1;33m/\u001b[0m \u001b[1;36m0\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mZeroDivisionError\u001b[0m: division by zero"
     ]
    }
   ],
   "source": [
    "1 / 0"
   ]
  },
  {
   "source": [
    "В первой строке сообщения указывается тип ошибки. В нашем случае это ```ZeroDivisionError```. Он уже указывает на причину ее появления. В следующей строке указывается в каком файле произошла ошибка. Ключевая информация заключена в третьей строке вида ```----> 1 1 / 0```. В ней указан номер строки, в которой произошла ошибка, а сама строка продублирована. В самом конце сообщения об ошибке указывается ее описание. \n",
    "\n",
    "Когда возникает ошибка стоит всегда внимательно читать возникающее сообщение. Оно поможет понять в каком месте программы появилась ошибка и по какой причине."
   ],
   "cell_type": "markdown",
   "metadata": {}
  }
 ]
}