lectures/01-intro.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "# Практикум по программированию на языке Python\n",
    "\n",
    "## <font color='lilac'>Занятие 1: введение в Python, встроенные типы данных, модель памяти</font>\n",
    "\n",
    "#### Мурат Апишев (mel-lain@yandex.ru)\n",
    "#### Москва, 2025"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### <font color='lilac'>Правила курса</font>\n",
    "\n",
    "- Курс будет состоять из примерно 10 тем, разбитых на 3 логических блока\n",
    "- Будет 4 базовых и одно дополнительное домашние задания на 2 недели каждое\n",
    "- Для получения зачета обязательно выполнение всех базовых заданий не менее чем на половину возможных баллов\n",
    "- Дополнительное задание может быть выдано индивидуально при нехватке баллов (оно сложнее базовых)\n",
    "- Списывать (в т.ч. из LLM) и пропускать дедлайны нельзя\n",
    "- Зачёт выставляется по результатам выполнения заданий (точные баллы будут позже) и очного собеседования"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Зачем изучать Python?</font>\n",
    "\n",
    "Несколько смежных вопросов:\n",
    "\n",
    "- зачем DS уметь программировать?\n",
    "- зачем DS уметь программировать хорошо?\n",
    "- зачем учиться программировать хорошо на Python?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Python - хороший язык, потому что он</font>\n",
    "\n",
    "- _читабельный и согласованный_ - его легко понимать и сопровождать\n",
    "- _высокоуровневый_ - код лаконичнее, чем у большинства других языков\n",
    "- _универсальный_ - вести успешную разработку на Python можно почти в любой IT-области\n",
    "- _мультипарадигмальный_ - процедурный, объектно-ориентированный, функциональный\n",
    "- _кроссплатформенный_ - легко разрабатывать и запускать код под любой популярной ОС\n",
    "- _легко интегрируемый_ - активно используется в связке с другими языками\n",
    "- _прост в изучении_ - сложно найти язык с более низким порогом входа\n",
    "- _богатый и активно развивающийся_ - open-source + большое сообщество способны на многое"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Где писать код на Python</font>\n",
    "\n",
    "- в любом удобном текстовом редакторе\n",
    "- в Jupyter Notebook\n",
    "- в специализированной IDE (например, PyCharm)\n",
    "\n",
    "Обычно файлы с кодом на Python имеют расширение `.py`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Где исполнять код на Python</font>\n",
    "\n",
    "- Python - скриптовый язык, исполняемый интерпретатором\n",
    "- Стандартная версия интепретатора - CPython, будем пользоваться ей\n",
    "- Можно установить интерпретатор + стандартные библиотеки языка (https://www.python.org)\n",
    "- Удобнее поставить распространённый дистрибутив Anaconda (https://www.anaconda.com/download)\n",
    "- В комплекте идут дополнительно популярные библиотеки и Jupyter Notebook\n",
    "\n",
    "\n",
    "__При установке обратите внимание, что в курсе мы ориентируемся на Python версии 3.7__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Как можно запускать код на Python</font>\n",
    "\n",
    "- Запускаем интерпретатор в терминале и напрямую пишем команды\n",
    "- Пишем код в файле и запускаем командой `python <имя файла>`\n",
    "- Создаём файл Jupyter Notebook и запускаем код в его ячейках"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Классическая первая программа</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello world!\n"
     ]
    }
   ],
   "source": [
    "print('Hello world!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "-"
    }
   },
   "source": [
    "- не требуется специфических объявлений точки входа программы (main в C++) - код запускается с первой строки файла/ячейки\n",
    "- `print` - стандартная функция языка, печатающая аргументы в стандартный поток вывода"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Операторы присваивания</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "a = 5\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5 6 7\n"
     ]
    }
   ],
   "source": [
    "a, b, c = 5, 6, 7\n",
    "print(a, b, c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Ввод с клавиатуры</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdin",
     "output_type": "stream",
     "text": [
      "Enter your first name: M\n",
      "Enter your last name: A\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "M A\n"
     ]
    }
   ],
   "source": [
    "f_name = input('Enter your first name:')\n",
    "l_name = input('Enter your last name:')\n",
    "print(f_name, l_name)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Выполнение кода на Python в виде строки</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "168"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eval('123 + 45')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1728\n",
      "12 3\n"
     ]
    }
   ],
   "source": [
    "exec(\n",
    "'''\n",
    "a = 12\n",
    "b = 3\n",
    "print(a ** b)\n",
    "''')\n",
    "print(a, b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- `eval` позволяет вычислить выражение и возвращает его результат (чистая функция)\n",
    "- `exec` позволяет запустить любой фрагмент кода на python (пример: ячейки Jupyter Notebook)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Объекты и переменные</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- создан объект типа `int`, который содержит значение 4\n",
    "- поскольку на этот объект нет ссылок, он уничтожается после создания и печати"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 5"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- создан объект типа `int`, в котором содержится значение 5\n",
    "- затем создана переменная с именем `a`, которая ссылается на этот объект"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "del a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- переменная `a` принудительно удалена\n",
    "- объект, на который она ссылалась, тоже был удалён, поскольку больше на него нет ссылок"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Объекты и переменные</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 5\n",
    "b = a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- создан объект типа `int`, в котором содержится значение 5\n",
    "- затем создана переменная с именем `a`, которая ссылается на этот объект\n",
    "- создана переменная `b`, которая указывает на тот же объект типа `int`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "a = a + 1  # equals to a += 1\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- выражение `a = a + 1` создаёт новый объект типа `int`, равный 6\n",
    "- переменная `a` начинает ссылаться на него и больше не связана с объектом, равным 5\n",
    "- `b` продолжает ссылаться на него"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Объекты и переменные в Python</font>\n",
    "\n",
    "- Переменные $\\ne$ объекты\n",
    "- Объект - это сущность, созданная и используемая в коде\n",
    "- Объектами являются числа, строки, контейнеры, классы, функции и т.п.\n",
    "- Переменная - это именованная ссылка на объект\n",
    "- У одного объекта может быть много ссылок-переменных\n",
    "- Объекты являются строго типизированными, ссылки - нет"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Основные встроенные типы данных</font>\n",
    "\n",
    "- _логический, числовые, None_\n",
    "- _строковые_\n",
    "- _контейнерные: списки, словари, кортежи, множества_\n",
    "- _файловый_\n",
    "- _прочие: функции, классы, модули, сами типы_\n",
    "\n",
    "Python -\n",
    "- динамически типизируемый (сам следит за выводом типов)\n",
    "- язык со строгой типизацией (объект заданного типа допускает только связанные с ним операции)\n",
    "\n",
    "__Тип объекта можно получить с помощью функции type__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Логический тип</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True or False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True or destroy_the_world()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "True and (False or True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bool()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "bool"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Целые числа</font>\n",
    "\n",
    "В Python тип `int` поддерживает бесконечно большие числа"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "7"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 + 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "4 // 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "4 % 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1267650600228229401496703205376"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 ** 100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Литералы типа int</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(100, -20, 0)"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "100, -20, 0  # decimal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 2)"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0b11, 0B10  # binary"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(9, 9)"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0o11, 0O11  # octal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2314, 159)"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0x90A, 0X9F # hexadecimal"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('0b1111101000', '0o1750', '0x3e8')"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "bin(1000), oct(1000), hex(1000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Побитовые операции</font>\n",
    "\n",
    "Работаем с целыми числами как с битовыми массивами"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 << 2  # 001b -> 100b == 4d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "7 >> 1  # 111b -> 011b == 3d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 & 2  # 01b || 10b == 00b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1 | 2  # 01b || 10b == 11b == 3d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Числа с плавающей точкой</font>\n",
    "\n",
    "Вещественные числа в Python - это тип `double` из C"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.0"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1.0 + 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.3333333333333333"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "4 / 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15.588457268119896"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3 ** 2.5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(1.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(float())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Литералы числовых типов языка</font>\n",
    "\n",
    "- Вещественные:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1.3, 4.0, 100000.0, 1e+54)"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "1.3, 4., 1e+5, 1.0E+54"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Комплексные:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((3+4j), (2+1j), 5j)"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3+4j, 2.0+1j, 5J"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Расширение для дробных чисел"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "Exceeds the limit (4300 digits) for integer string conversion; use sys.set_int_max_str_digits() to increase the limit",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[76], line 3\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m \u001b[38;5;21;01mfractions\u001b[39;00m\n\u001b[1;32m      2\u001b[0m a \u001b[38;5;241m=\u001b[39m fractions\u001b[38;5;241m.\u001b[39mFraction(\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m3\u001b[39m \u001b[38;5;241m*\u001b[39m\u001b[38;5;241m*\u001b[39m \u001b[38;5;241m1000000\u001b[39m)\n\u001b[0;32m----> 3\u001b[0m \u001b[38;5;28mlen\u001b[39m(\u001b[38;5;28;43mstr\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43ma\u001b[49m\u001b[38;5;241;43m.\u001b[39;49m\u001b[43mdenominator\u001b[49m\u001b[43m)\u001b[49m)\n",
      "\u001b[0;31mValueError\u001b[0m: Exceeds the limit (4300 digits) for integer string conversion; use sys.set_int_max_str_digits() to increase the limit"
     ]
    }
   ],
   "source": [
    "import fractions\n",
    "a = fractions.Fraction(1, 3 ** 1000000)\n",
    "len(str(a.denominator))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Сравнение чисел</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [],
   "source": [
    "x, y, z = 1, 2, 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x < y < z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 79,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x < y >= z"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 80,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x < y != z"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Округление вещественных чисел</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3.0"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "11.0 // 3.0  # remove remainder"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "-4\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "print(math.trunc(4.7))  # move to zero\n",
    "print(math.trunc(-4.7))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "-5\n"
     ]
    }
   ],
   "source": [
    "print(math.floor(4.7))  # move to lowest integer\n",
    "print(math.floor(-4.7))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "-5\n"
     ]
    }
   ],
   "source": [
    "print(round(4.3))  # standart round\n",
    "print(round(-4.7))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Полезные встроенные функции для чисел</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "pow(2, 4) == 2 ** 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "abs(-2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 87,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum((1, 2, 3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-7"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "min(1, 2, -7, 44)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.0\n",
      "0.9893582466233818\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "print(math.sqrt(4))\n",
    "print(math.sin(8))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Тип None</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "None == None"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 91,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "None or True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "NoneType"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for *: 'int' and 'NoneType'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[93], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[38;5;241;43m5\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m*\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;28;43;01mNone\u001b[39;49;00m  \u001b[38;5;66;03m# strong typing\u001b[39;00m\n",
      "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for *: 'int' and 'NoneType'"
     ]
    }
   ],
   "source": [
    "5 * None  # strong typing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Строки</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = 'qwerty'\n",
    "type(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(s)  # built-in function to get sequence length"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s[0]  # make a copy of element"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s[-1]  # make a copy of element"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s[0: 3]  # make a copy of elements from 0 to 3 excluding"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s + '-add-on'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Подробнее об индексировани и срезах</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = 'qwerty'\n",
    "s[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s[0: 10]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s[slice(1, 3)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s[:10:2]  # QwErTy____"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s[::-1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Операции над строками</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s + 5  # strong typing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s * 5  # strong typing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s[0] = 'a'  # str type is immutable"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Операции над строками</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = 'Qwe{}'.format('rty')\n",
    "s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(s.find('w'), s.find('9'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s.split('r')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'-'.join(['New', 'York'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s.replace('ty', 'TY')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s[0].isupper()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Операции над строками</font>\n",
    "\n",
    "Две новые простые операции были добавлены в Python 3.9:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'prefix_string'.removeprefix('prefix_')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'string_suffix'.removesuffix('_suffix')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Как ещё можно задавать строки</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'qwe\\'rty'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"qwe'rty\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'''qwe'rty'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'qwe\\0rty'  # print hex code in '\\xNN' format for non-printable characters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'qwe\\nrty'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print('qwe\\nrty')  # we'll discuss difference between __repr__ and __str__ further"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Форматирование строк</font>\n",
    "\n",
    "В Python есть похожих способа форматирования - выражение и метод"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'x = %d, y = %f' % (10.5, 11)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'x = %o, y = %E' % (8, 1.0 / 3)  # octal format, exponential + upper case"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'x = %10.2f' % (1.0 / 3)  # min width and precision"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# add leading zeros if len < min width\n",
    "s = '''\n",
    "x = %(value_1)010.2f\n",
    "x = %(value_2)010.2f\n",
    "''' % ({'value_1': 10000, 'value_2': 0.12345})\n",
    "\n",
    "print(s)  # __str__\n",
    "s         # __repr__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Форматирование строк</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'x = {}, y = {}'.format(10, 20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'x = {1}, y = {0}'.format(10, 20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "f'x = {10}, y = {20}'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "'x = {val_1:f}, y = {val_2:010.2f}'.format(val_1=10, val_2=10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "'platform: {sys_var.platform}'.format(sys_var=sys)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Оператор присваивания в форматных строках</font>\n",
    "\n",
    "Синтаксический сахар, добавленый в версии Python 3.8:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from datetime import date\n",
    "from math import cos, radians\n",
    "\n",
    "user = 'eric_idle'\n",
    "member_since = date(1975, 7, 31)\n",
    "\n",
    "f'{user=} {member_since=}'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Можно форматировать вывод:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "delta = date.today() - member_since\n",
    "f'{user=!s}  {delta.days=:d}'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Можно вставлять вычисления и выводить как результат, так и вычисляющий код:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "theta = 4\n",
    "f'{theta=}  {cos(radians(theta))=:.3f}'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Строка как набор байтов</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = bytearray(b'qwerty')\n",
    "type(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b[1] = ord('a')\n",
    "b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- `bytearray` - массив байтов, в который можно записывать номера 8-битных символов\n",
    "- в отличие от `str`, объекты этого типа являются изменяемыми\n",
    "- функция `ord` возвращает по символу его номер в таблице ASCII"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Контейнерные типы: списки"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lst = [1, None, 'qwerty']\n",
    "list([1, None, 'qwerty']) == lst  # list() gets any iterable object as input"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lst[0] = [10, 20]\n",
    "lst"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- список - более общий аналог массива (не путать со структурой данных \"список\")\n",
    "- элементы могут быть произвольного типа (в т.ч. и ссылками)\n",
    "- сам список является изменяемым типом"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Списки</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(lst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(lst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lst[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lst[: 100]  # slice bounds can be exceed real ones"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lst[5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Операции над списками</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lst = [1, 2, 3]\n",
    "lst.append(4)\n",
    "lst"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(lst.pop(), lst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lst.sort(reverse=True)  # equals to lst.reverse()\n",
    "lst"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lst * 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lst + list('abc')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Списковые включения и генераторы списков</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[x ** 2 for x in [1, 2, 3]]  # list comprehension"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lst = [x ** 2 for x in [1, 2, 3] if x > 1]\n",
    "print(type(lst))\n",
    "\n",
    "for _ in [1, 2]:  # _ means value we really don't need\n",
    "    for e in lst:\n",
    "        print(e)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "lst = (x ** 2 for x in [1, 2, 3] if x > 1)  # list generator\n",
    "print(type(lst))\n",
    "\n",
    "for _ in [1, 2]:\n",
    "    for e in lst:\n",
    "        print(e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Снова про объекты и переменные</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [2]\n",
    "b = a\n",
    "a += [1]\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- список - изменяемый объект, создание новой ссылки не приводит к появлению нового объекта\n",
    "- есть две переменные, указывающие на один и тот же список"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "del a\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- удаление `a` не приводит у удалению списка, поскольку на него ещё ссылается `b`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Копирование изменяемых объектов</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [1, 2, 3]\n",
    "b = a[:]\n",
    "b.append(4)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [1, 2, 3]\n",
    "b = a.copy()\n",
    "b.append(4)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Копирование вложенных изменяемых объектов</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [['a', 'b', 'c'], 2, 3]\n",
    "b = a.copy()\n",
    "b[0].append('d')\n",
    "print(a)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import copy\n",
    "\n",
    "a = [['a', 'b', 'c'], 2, 3]\n",
    "b = copy.deepcopy(a)\n",
    "b[0].append('d')\n",
    "print(a)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Контейнерные типы: словари</font>\n",
    "\n",
    "- словарь (`dict`) - это ассоциативный массив (отображение), т.е. набор пар \"ключ-значение\"\n",
    "- словарь поддерживает возможность быстро искать значение по ключу\n",
    "- в Python словари реализованы на основе хэш-таблиц (сложность поиска O(1))\n",
    "- словари также являются изменяемым типом данных\n",
    "- значения могут иметь произвольный тип\n",
    "- ключи - произвольный неизменяемый тип"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Словари</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(dict()), type({})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# simple creation of nested structures!\n",
    "d = {'1': 1, 's': 2, None: [1, {None: True}]}\n",
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d['s'] = 'two'\n",
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "del d['1']  # remove object\n",
    "print(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d2 = {('s', 3), ('a', 'b')}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Операции над словарями</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d = dict.fromkeys(list('abcccc'))\n",
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for k in d.keys():  # view object\n",
    "    d[k] = ord(k)\n",
    "d"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for k, v in d.items():  # view object\n",
    "    print(k, v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "D = dict(a=ord('a'), b=ord('b'), c=ord('c'))\n",
    "d == D"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d.update(d2)\n",
    "d"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Операции над словарями</font>\n",
    "\n",
    "Новый оператор слияния словарей был введен начиная с Python 3.9:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d_1, d_2 = {1: 'a', 2: 'b'}, {3: 'c', 4: 'd'}\n",
    "d_1 | d_2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d_2 = {1: 'c'}\n",
    "d_1 | d_2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#d_1 | [(3, 'c'), (4, 'd')] -> TypeError: unsupported operand type(s) for |: 'dict' and 'list'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d_1, d_2 = {1: 'a', 2: 'b'}, {3: 'c', 4: 'd'}\n",
    "d_1 |= d_2\n",
    "d_1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d_1 = {1: 'a', 2: 'b'}\n",
    "d_1 |= [(3, 'c'), (4, 'd')]\n",
    "d_1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Контейнерные типы: кортежи</font>\n",
    "\n",
    "- очень похожи на списки, но являются неизменяемыми"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "type(()), type(tuple())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 2, 'str', 4.0, None)"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(1, 2, 'str', 4.0, None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 2, 3.0, 6, None)"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(1, 2) + (3.0, 6, None)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tpl = tuple([1, 2, 3])\n",
    "tpl[2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Контейнерные типы: множества</font>\n",
    "\n",
    "- Как и словари, основаны на хэш-таблицах\n",
    "- Элементы должны быть неизменяемыми"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(set, set, dict)"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(set()), type({1}), type({})  # Empty '{}' is a dict, not a set!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 'a', 'set'}"
      ]
     },
     "execution_count": 98,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{1, 2, 3, 3, 2, 1, 'set', 'a'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 2, 3, 4}"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s = {1, 2, 3}\n",
    "s.add(4)\n",
    "s"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{1, 2}\t{1, 2, 3, 4, 5}\t{3}\tFalse\n"
     ]
    }
   ],
   "source": [
    "s1, s2 = {1, 2, 3}, set([3, 4, 5])\n",
    "\n",
    "print('{}\\t{}\\t{}\\t{}'.format(s1 - s2, s1 | s2, s1 & s2, s1 < s2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Операции над множествами</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [],
   "source": [
    "A, B = set('abc'), {'a', 'c', 'd'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'b'}"
      ]
     },
     "execution_count": 102,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A - B  # minus: in A and not in B (== A.difference(B))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a', 'b', 'c', 'd'}"
      ]
     },
     "execution_count": 103,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A | B  # union: in A or in B (== A.union(B))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a', 'c'}"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A & B  # intersection: in A and in B (== A.intersection(B))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'b', 'd'}"
      ]
     },
     "execution_count": 105,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A ^ B  # sym diff: (in A and not in B) and via versa (== A.symmetric_difference(B))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Операции над множествами</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a', 'b', 'c', 'e'}"
      ]
     },
     "execution_count": 106,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.add('e')\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'a', 'b', 'c', 'd', 'e'}"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.update(B)\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'b', 'c', 'd', 'e'}"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.remove('a')\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'a' in A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "{'a', 'b'} < A  # is subset (== {'a', 'b'}.issubset(A))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Файловый тип</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "some\n",
      "content\n",
      "\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fin = open('some_file.txt', 'r')  # 'r' can be avoided\n",
    "print(fin.read())\n",
    "fin.close()\n",
    "fin.closed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "some content\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fin = open('some_file.txt', 'r')  # 'r' can be avoided\n",
    "\n",
    "# strip removes blank and special characters from edges\n",
    "lines = [line.strip() for line in fin.readlines()]\n",
    "\n",
    "print(' '.join(lines))\n",
    "fin.close()\n",
    "fin.closed"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Файловый менеджер контекста</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "ename": "ZeroDivisionError",
     "evalue": "division by zero",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mZeroDivisionError\u001b[0m                         Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[114], line 2\u001b[0m\n\u001b[1;32m      1\u001b[0m fin \u001b[38;5;241m=\u001b[39m \u001b[38;5;28mopen\u001b[39m(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124msome_file.txt\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mr\u001b[39m\u001b[38;5;124m'\u001b[39m)  \u001b[38;5;66;03m# 'r' can be avoided\u001b[39;00m\n\u001b[0;32m----> 2\u001b[0m \u001b[38;5;28mprint\u001b[39m(fin\u001b[38;5;241m.\u001b[39mread(), \u001b[38;5;241;43m0\u001b[39;49m\u001b[38;5;241;43m/\u001b[39;49m\u001b[38;5;241;43m0\u001b[39;49m)\n\u001b[1;32m      3\u001b[0m fin\u001b[38;5;241m.\u001b[39mclose()\n",
      "\u001b[0;31mZeroDivisionError\u001b[0m: division by zero"
     ]
    }
   ],
   "source": [
    "fin = open('some_file.txt', 'r')  # 'r' can be avoided\n",
    "print(fin.read(), 0/0)\n",
    "fin.close()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 115,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fin.closed"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Файловый менеджер контекста</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "ename": "ZeroDivisionError",
     "evalue": "division by zero",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mZeroDivisionError\u001b[0m                         Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[116], line 2\u001b[0m\n\u001b[1;32m      1\u001b[0m \u001b[38;5;28;01mwith\u001b[39;00m \u001b[38;5;28mopen\u001b[39m(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124msome_file.txt\u001b[39m\u001b[38;5;124m'\u001b[39m, \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mr\u001b[39m\u001b[38;5;124m'\u001b[39m) \u001b[38;5;28;01mas\u001b[39;00m fin:\n\u001b[0;32m----> 2\u001b[0m     \u001b[38;5;28mprint\u001b[39m(fin\u001b[38;5;241m.\u001b[39mread(), \u001b[38;5;241;43m0\u001b[39;49m\u001b[38;5;241;43m/\u001b[39;49m\u001b[38;5;241;43m0\u001b[39;49m)\n",
      "\u001b[0;31mZeroDivisionError\u001b[0m: division by zero"
     ]
    }
   ],
   "source": [
    "with open('some_file.txt', 'r') as fin:\n",
    "    print(fin.read(), 0/0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "fin.closed"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Запись в файл</font>\n",
    "\n",
    "- отступы используются для обозначения операторных блоков (вместо фигурных скобок в C++)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('some_file.txt', 'a') as fout:\n",
    "    fout.write('additional string')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "some\n",
      "content\n",
      "additional string\n"
     ]
    }
   ],
   "source": [
    "with open('some_file.txt', 'r') as fin:\n",
    "    print(fin.read())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('some_file.txt', 'w') as fout:\n",
    "    fout.write('new\\ncontent')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "new\n",
      "content\n"
     ]
    }
   ],
   "source": [
    "with open('some_file.txt', 'r') as fin:\n",
    "    print(fin.read())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Содержимое файлов как массив байтов</font>\n",
    "\n",
    "Полезно при работе с сериализаторами"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = bytearray('строка', 'utf-8')\n",
    "with open('tmp.bin', 'wb') as fout:\n",
    "    fout.write(s)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['с', 'т', 'р', 'о', 'к', 'а']\n"
     ]
    }
   ],
   "source": [
    "with open('tmp.bin', 'r') as fin:\n",
    "    print(list(fin.read()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[209, 129, 209, 130, 209, 128, 208, 190, 208, 186, 208, 176]\n"
     ]
    }
   ],
   "source": [
    "with open('tmp.bin', 'rb') as fin:\n",
    "    print(list(fin.read()))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 125,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len('з'.encode('utf-8'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Условный оператор if</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "success\n"
     ]
    }
   ],
   "source": [
    "if 3 % 3 == 0:\n",
    "    print('success')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "a = 5\n",
    "if a == 2:\n",
    "    print(2)\n",
    "elif a == 4:\n",
    "    print(4)\n",
    "else:\n",
    "    print(a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.5\n"
     ]
    }
   ],
   "source": [
    "print(a if a > 5 else 2.5)  # ternary operator"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Оператор цикла while</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Current a: 5\n"
     ]
    }
   ],
   "source": [
    "a = 5\n",
    "while a > 4:\n",
    "    print('Current a: {}'.format(a))\n",
    "    a -= 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [
    {
     "ename": "KeyboardInterrupt",
     "evalue": "",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m                         Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[130], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[38;5;28;01mwhile\u001b[39;00m \u001b[38;5;28;01mTrue\u001b[39;00m:  \u001b[38;5;66;03m# infinity loop\u001b[39;00m\n\u001b[1;32m      2\u001b[0m     \u001b[38;5;28;01mpass\u001b[39;00m  \u001b[38;5;66;03m# in Python 3 the equal statement is '...'\u001b[39;00m\n",
      "\u001b[0;31mKeyboardInterrupt\u001b[0m: "
     ]
    }
   ],
   "source": [
    "while True:  # infinity loop\n",
    "    pass  # in Python 3 the equal statement is '...'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n"
     ]
    }
   ],
   "source": [
    "a = 6\n",
    "while a > 2:\n",
    "    a -= 1\n",
    "    if a == 5: continue\n",
    "    if a == 3: break\n",
    "    print(a)\n",
    "else:\n",
    "    print('else')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- `pass` - оператор пустого действия\n",
    "- `continue` - досрочный переход на следующую итерацию цикла\n",
    "- `break` - досрочный выход из цикла\n",
    "- `else` - обозначает секцию, которая выполняется, если цикл был завершён не по `break`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Оператор цикла for</font>\n",
    "\n",
    "- в отличие от C/C++, в Python чаще всего используются range-based for-циклы\n",
    "- классические циклы по индексам так же доступны, но при прочих равных менее предпочтительны"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\n",
      "b\n",
      "c\n"
     ]
    }
   ],
   "source": [
    "lst = ['a', 'b', 'c']\n",
    "for element in lst:  # range-based for\n",
    "    print(element)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a\n",
      "b\n",
      "c\n"
     ]
    }
   ],
   "source": [
    "for index in range(len(lst)):  # index-based for\n",
    "    print(lst[index])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- функция `range` создаёт генератор, позволяющий итерироваться по последовательности чисел с заданными границами и шагом"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Оператор цикла for</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 a\n",
      "2 b\n",
      "For-loop ended without break!\n"
     ]
    }
   ],
   "source": [
    "for x, y in [(1, 'a'), [2, 'b']]:\n",
    "    print(x, y)\n",
    "else:\n",
    "    print('For-loop ended without break!')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a b c\n"
     ]
    }
   ],
   "source": [
    "for x, y, z in [[1, 2, 3], ['a', 'b', 'c'], [True, False, None]]:\n",
    "    if isinstance(x, int):\n",
    "        continue\n",
    "    print(x, y, z)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- `isinstance` - функция языка, позволяющая проверить принадлженость объекта типу (учитывает иерархию наследования типов)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Оператор walrus</font>\n",
    "\n",
    "- \"Моржовый\" оператор был добавлен в Python начиная с версии 3.8\n",
    "- Он является присваивающим _выражением_, т.е., в отличие от _оператора_ присваивания, он возвращает присвоенное значение"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "String is too long (4)\n"
     ]
    }
   ],
   "source": [
    "if (n := len('test')) > 3:\n",
    "    print(f'String is too long ({n})')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Иногда он может уменьшить объем вычислений:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 4, 16, 36, 64]"
      ]
     },
     "execution_count": 137,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[x ** 2 for x in range(10) if x ** 2 % 2 == 0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[0, 4, 16, 36, 64]"
      ]
     },
     "execution_count": 138,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[y for x in range(10) if (y := x ** 2) % 2 == 0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Атрибуты объекта</font>\n",
    "\n",
    "- любой объект в Python имеет атрибуты: набор полей и методов, определяющих свойства объекта и способы работы с ним\n",
    "- атрибуты можно читать, устанавливать и менять\n",
    "- список всех атрибутов получается с помощью встроенной функции `dir`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "74\n",
      "['__abs__', '__add__', '__and__', '__bool__']\n"
     ]
    }
   ],
   "source": [
    "print(len(dir(5)))\n",
    "print(dir(5)[: 4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0"
      ]
     },
     "execution_count": 140,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 5\n",
    "a.__and__(0)  # exactly the same as 'a and 0'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Как правильно называть переменные</font>\n",
    "\n",
    "- `regular_variable`\n",
    "- `ClassName`\n",
    "- `SOME_CONSTANT_10`\n",
    "- `_private_class_field_or_method`\n",
    "- `__avoid_overriding_of_this_field_or_method_in_childrens`\n",
    "- `__magic_method__` or `__special_field__`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "__Не используйте переменные с unicode-символами__:\n",
    "- `плохое_имя_для_переменной`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Модули</font>\n",
    "\n",
    "- любой файл на Python представляет собой модуль\n",
    "- импорт модуля вызовет выполнение содержащегося в нём кода"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('test_module.py', 'w') as fout:\n",
    "    fout.write('print(10)\\n')\n",
    "    fout.write('def new_print(a):\\n\\tprint(a)\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- создали текстовый файл и записали в него оператор печати и определение функции\n",
    "- ключевое слово `def` используется для определения функций и классов (не единственный способ)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "import test_module"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- импортируем модуль, операторы выполнятся\n",
    "\n",
    "__В стандартной библиотеке языка есть много полезных модулей - надо пользоваться__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Пространства имён модулей</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'new_print' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[143], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43mnew_print\u001b[49m(\u001b[38;5;241m5\u001b[39m)\n",
      "\u001b[0;31mNameError\u001b[0m: name 'new_print' is not defined"
     ]
    }
   ],
   "source": [
    "new_print(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "test_module.new_print(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "5\n"
     ]
    }
   ],
   "source": [
    "from test_module import new_print\n",
    "new_print(5)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Повторная загрузка модуля</font>\n",
    "\n",
    "- если модуль был один раз загружен (исполнен), второй импорт ничего не произведёт\n",
    "- это верно даже в том случае, если модуль был изменён после импорта"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {},
   "outputs": [],
   "source": [
    "import test_module  # no any output!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- но модуль можно перезагрузить принудительно"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "<module 'test_module' from '/Users/msk-hq-nb-2930/Work/mipt-python/lectures/test_module.py'>"
      ]
     },
     "execution_count": 147,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from importlib import reload\n",
    "reload(test_module)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Компиляция кода на Python</font>\n",
    "\n",
    "- Код на языке Python перед выполнением транслируется в байт-код\n",
    "- Это байт-код выполняется виртуальной машиной языка, в ходе чего он переводится в машинные команды\n",
    "- Генерация байт-кода при выполнении кода скрипта выполняется на лету\n",
    "- Однако в случае импортирования кода из модуля байт-код этого модуля сохраняется в файлы с расширением `.pyc`\n",
    "- В дальнейшем это позволяет ускорить загрузку модуля (но не скорость выполнения!)\n",
    "- Необходимость перегенерации файла `.pyc` определяется по времени последнего изменения этого файла и его исходника\n",
    "- Хорошей практикой является игнорирование этих файлов и автоматическая перегенерация при каждом запуске в новом окружении\n",
    "- Помимо файлов `.pyc` генерироваться могут файлы `.pyo` (запуск с оптимизацией) и `.pyd` (файл типа dll в ОС Windows)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Модуль collections</font>\n",
    "\n",
    "Стандартная задача: подсчёт числа элементов"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = 'GDJKFHGKJXBZFVJHBJZBXXXXXXXXXXXXXXXXXXXHFG'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(G: 3) (D: 1) (J: 4) (K: 2) (F: 3) (H: 3) (X: 20) (B: 3) (Z: 2) (V: 1)\n"
     ]
    }
   ],
   "source": [
    "d = {}\n",
    "for element in s:\n",
    "    if not element in d:\n",
    "        d[element] = 0\n",
    "    d[element] += 1\n",
    "\n",
    "result = ''\n",
    "for k, v in d.items():\n",
    "    result += f'({k}: {v}) '\n",
    "print(result.strip())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(G: 3) (D: 1) (J: 4) (K: 2) (F: 3) (H: 3) (X: 20) (B: 3) (Z: 2) (V: 1) \n"
     ]
    }
   ],
   "source": [
    "from collections import Counter\n",
    "\n",
    "for k, v in Counter(s).items():\n",
    "    print(f'({k}: {v}) ', end='')  # print can end not only with '\\n'\n",
    "print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Модуль os</font>\n",
    "\n",
    "`os` содержит разнообразные функции и библиотеки для широкого круга задач:\n",
    "- работа с переменными окружения\n",
    "- работа с процессами\n",
    "- работа с файловой системой\n",
    "- работы с путями в файловой системе (библиотека `os.path`)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 151,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import os\n",
    "\n",
    "len(os.listdir('.'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "os.mkdir('temp')\n",
    "os.rmdir('temp')\n",
    "\n",
    "os.mkdir('temp')\n",
    "os.mkdir('temp/temp')\n",
    "#os.rmdir('temp') -> OSError: [Errno 39] Directory not empty: 'temp'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {},
   "outputs": [],
   "source": [
    "import shutil\n",
    "\n",
    "shutil.rmtree('temp')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Библиотека os.path</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print(os.path.exists('01-intro.ipynb'))\n",
    "print(os.path.isfile('01-intro.ipynb'))\n",
    "print(os.path.isdir('01-intro.ipynb'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/Users/msk-hq-nb-2930/Work/mipt-python/lectures\n"
     ]
    }
   ],
   "source": [
    "addr = os.path.dirname(os.path.abspath('01-intro.ipynb'))\n",
    "print(addr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Users/msk-hq-nb-2930/Work/mipt-python/lectures'"
      ]
     },
     "execution_count": 156,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "os.path.join(*addr.split('/'))  # f(*[a, b, c]) -> f(a, b, c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>pathlib - более удобный модуль для работы с файловой системой</font>\n",
    "\n",
    "- До Python 3.4 работа с ФС производилась с помощью `os` и `glob`\n",
    "- Теперь удобнее и нагляднее пользоваться модулем `pathlib`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {},
   "outputs": [],
   "source": [
    "os.makedirs(os.path.join('temp', 'temp'), exist_ok=True)\n",
    "os.rename('temp', 'new_temp')\n",
    "shutil.rmtree('new_temp')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {},
   "outputs": [],
   "source": [
    "from pathlib import Path\n",
    "\n",
    "Path('temp/temp').mkdir(parents=True, exist_ok=True)\n",
    "Path('temp').rename('new_temp')\n",
    "shutil.rmtree('new_temp')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Вложенные вызовы тяжелее читать, чем последовательные\n",
    "- Модуль `shutil` все ещё необходим для удаления непустых директорий, перемещения и копирования"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>pathlib: пример</font>\n",
    "\n",
    "Считывание текста из всех .ipynb-файлов в текущей директории с помощью `glob`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "metadata": {},
   "outputs": [],
   "source": [
    "from glob import glob\n",
    "\n",
    "contents_1 = []\n",
    "for filename in glob('*.ipynb', recursive=False):\n",
    "    with open(filename) as fin:\n",
    "        contents_1.append(fin.read())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "И с помощью `pathlib`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 160,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from pathlib import Path\n",
    "\n",
    "contents_2 = [path.read_text() for path in Path.cwd().glob('*.ipynb')]\n",
    "\n",
    "contents_1 == contents_2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>pathlib: итоговые замечания</font>\n",
    "\n",
    "- Использование `pathlib` улучшает качество кода и является рекомендованным стандартом для работы с ФС\n",
    "- `pathlib.Path` самостоятельно производит нормализацию путей в зависимости от ОС\n",
    "- Встроенные функции в Python 3.6 и выше, принимающие на вход строки-пути, умеют обрабатывать и объекты `Path`\n",
    "- `pathlib` уступает в скорости `os` в 2-4 раза, поэтому не подходит для фрагментов кода с очень интенсивной работой с ФС\n",
    "\n",
    "\n",
    "В новых версиях Python обеспечивается легкая взаимозаменяемость путей-строк и объектов `Path`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {},
   "outputs": [],
   "source": [
    "path_str = os.path.join('temp', 'temp')\n",
    "path_path = Path('temp/temp')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "temp/temp temp/temp <class 'str'> <class 'str'>\n"
     ]
    }
   ],
   "source": [
    "from os import fspath\n",
    "\n",
    "a, b = fspath(path_str), fspath(path_path)\n",
    "print(a, b, type(a), type(b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(PosixPath('temp/temp'), PosixPath('temp/temp'))"
      ]
     },
     "execution_count": 163,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Path(path_str), Path(path_path)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Модуль re для регулярных выражений</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {},
   "outputs": [],
   "source": [
    "import re"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- `[]` - множество допустимых символов\n",
    "- `-` - обозначает диапазон\n",
    "- `*` - любое число повторений (в т.ч. 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<re.Match object; span=(0, 0), match=''>\n",
      "<re.Match object; span=(0, 6), match='qwerty'>\n",
      "<re.Match object; span=(0, 0), match=''>\n",
      "<re.Match object; span=(0, 6), match='QWERTY'>\n",
      "<re.Match object; span=(0, 3), match='qwe'>\n"
     ]
    }
   ],
   "source": [
    "eng_letters = re.compile('[a-zA-Z]*')\n",
    "\n",
    "print(eng_letters.match(''))\n",
    "print(eng_letters.match('qwerty'))\n",
    "print(eng_letters.match('йцукен'))\n",
    "print(eng_letters.match('QWERTY'))\n",
    "print(eng_letters.match('qweкен'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Регулярные выражения</font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Букву Ё прописываем отдельно, она вне диапазона\n",
    "- Как в обычных строках, спецсимволы вносим как обычные с помощью `\\`\n",
    "- `+` - любое число повторений, но не менее одного"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n",
      "<re.Match object; span=(0, 6), match='йцукен'>\n",
      "<re.Match object; span=(0, 4), match='Ёжик'>\n",
      "<re.Match object; span=(0, 10), match='Фрекен-Бок'>\n",
      "<re.Match object; span=(0, 10), match='mail@ya.ru'>\n"
     ]
    }
   ],
   "source": [
    "eng_letters = re.compile('[a-zA-Zа-яА-ЯёЁ\\\\-.@]+')\n",
    "\n",
    "print(eng_letters.match(''))\n",
    "print(eng_letters.match('йцукен'))\n",
    "print(eng_letters.match('Ёжик'))\n",
    "print(eng_letters.match('Фрекен-Бок'))\n",
    "print(eng_letters.match('mail@ya.ru'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Регулярные выражения</font>\n",
    "\n",
    "- `^` - обозначает необходимость начала строки при совпадении\n",
    "- `$` - обозначает необходимость конца строки при совпадении\n",
    "- `{}` - после квадратных скобок позволяет ограничить количество вхождений символов"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None\n",
      "<re.Match object; span=(0, 16), match='+7 (916) 7698275'>\n",
      "<re.Match object; span=(0, 14), match='+7(916)7698275'>\n"
     ]
    }
   ],
   "source": [
    "phone_pattern = re.compile('^(\\\\+[0-9]{1} ?\\\\(?[0-9]{3}\\\\)? ?[0-9]{7})+$')\n",
    "\n",
    "print(phone_pattern.match('89167698275'))\n",
    "print(phone_pattern.match('+7 (916) 7698275'))\n",
    "print(phone_pattern.match('+7(916)7698275'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<re.Match object; span=(0, 18), match='mel-lain@yandex.ru'>\n",
      "None\n",
      "None\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<>:1: SyntaxWarning: invalid escape sequence '\\.'\n",
      "<>:1: SyntaxWarning: invalid escape sequence '\\.'\n",
      "/var/folders/r2/563zpwbs3215hdfprj61qz880000gn/T/ipykernel_70517/2520189013.py:1: SyntaxWarning: invalid escape sequence '\\.'\n",
      "  email_pattern = re.compile('^[A-Za-z0-9\\.\\+_-]+@[A-Za-z0-9\\._-]+\\.[a-zA-Z]*$')\n"
     ]
    }
   ],
   "source": [
    "email_pattern = re.compile('^[A-Za-z0-9\\.\\+_-]+@[A-Za-z0-9\\._-]+\\.[a-zA-Z]*$')\n",
    "\n",
    "print(email_pattern.match('mel-lain@yandex.ru'))\n",
    "print(email_pattern.match('mel&lain@yandex.ru'))\n",
    "print(email_pattern.match('mel-lain@yandex'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Регулярные выражения</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<re.Match object; span=(0, 18), match='mel-lain@yandex.ru'>\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<>:1: SyntaxWarning: invalid escape sequence '\\.'\n",
      "<>:1: SyntaxWarning: invalid escape sequence '\\.'\n",
      "/var/folders/r2/563zpwbs3215hdfprj61qz880000gn/T/ipykernel_70517/2430247187.py:1: SyntaxWarning: invalid escape sequence '\\.'\n",
      "  email_pattern = re.compile('[A-Za-z0-9\\.\\+_-]+@[A-Za-z0-9\\._-]+\\.[a-zA-Z]*')\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "['mel-lain@yandex.ru', 'mel-lain@yandex.ru']"
      ]
     },
     "execution_count": 169,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "email_pattern = re.compile('[A-Za-z0-9\\.\\+_-]+@[A-Za-z0-9\\._-]+\\.[a-zA-Z]*')\n",
    "\n",
    "print(email_pattern.match('mel-lain@yandex.ru mel-lain@yandex.ru'))\n",
    "email_pattern.findall('mel-lain@yandex.ru mel-lain@yandex.ru')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Вместо конкретных символов можно использовать общие обозначения:\n",
    "\n",
    "- `\\s` - один пробел\n",
    "- `\\S` - один не пробел\n",
    "- `\\w` - один alpha-numeric символ"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "<>:1: SyntaxWarning: invalid escape sequence '\\w'\n",
      "<>:1: SyntaxWarning: invalid escape sequence '\\w'\n",
      "/var/folders/r2/563zpwbs3215hdfprj61qz880000gn/T/ipykernel_70517/3240456138.py:1: SyntaxWarning: invalid escape sequence '\\w'\n",
      "  re.split('\\w', '&а%б!7#в*')\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "['&', '%', '!', '#', '*']"
      ]
     },
     "execution_count": 170,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "re.split('\\w', '&а%б!7#в*')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Идентификатор объекта</font>\n",
    "\n",
    "- у каждого объекта в Python есть целочисленный идентификатор\n",
    "- на время жизни объекта он является уникальным\n",
    "- получить идентификатор объекта можно с помощью функции `id`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4385623912 4385623976\n"
     ]
    }
   ],
   "source": [
    "a = 10\n",
    "b = 12\n",
    "print(id(a), id(b))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- идентификатор зависит от реализации, это может быть адрес в памяти\n",
    "- у одинаковых константных объектов этот идентификатор всегда одинаковый"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4385623912 4385623912 \n",
      "\n",
      "4385623976 4385623976\n"
     ]
    }
   ],
   "source": [
    "a, b = 10, 10\n",
    "c, d = 12, 12\n",
    "print(id(a), id(b), '\\n')\n",
    "print(id(c), id(d))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Идентификатор константного объекта</font>\n",
    "\n",
    "- таким образом, одинаковые константы хранятся в единственном экземпляре\n",
    "- Python делает так для экономии памяти\n",
    "- типы в Python тоже являются объектами"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4384741384 4384741384 4384741384 \n",
      "\n",
      "4384759024 4384757840\n"
     ]
    }
   ],
   "source": [
    "print(id(type(12)), id(type(5)), id(int), '\\n')\n",
    "print(id(None), id(type(None)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- проверка равенства идентификаторов делается с помощью оператора `is`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "a = None\n",
    "print(a is None)\n",
    "print(a == None)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Идентификатор изменяемого объекта</font>\n",
    "\n",
    "- два одинаковых списка не идентичны:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 175,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = [1, 2, 3]\n",
    "b = [1, 2, 3]\n",
    "a is b"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- две ссылки на один список идентичны:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 176,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "c = a\n",
    "a is c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- и все между собой, очевидно, равны:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 177,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 177,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a == b == c"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Почему на None надо проверять с помощью is</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "# https://stackoverflow.com/questions/3257919/what-is-the-difference-between-is-none-and-none\n",
    "\n",
    "class Foo:\n",
    "    def __eq__(self,other):  # magic method: == operator\n",
    "        return True\n",
    "\n",
    "foo=Foo()\n",
    "\n",
    "print(foo == None)\n",
    "\n",
    "print(foo is None)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- кроме того, проверка на идентичность в общем случае быстрее, чем на эквивалентность"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Стадии жизни объекта</font>\n",
    "\n",
    "- Создание объекта приводит к выделению фрагмента памяти\n",
    "- У каждого объекта есть счётчик ссылок\n",
    "- Каждое новая ссылающаяся переменная увеличивает этот счётчик на единицу\n",
    "- Ссылку можно удалить с помощью оператора `del`\n",
    "- Когда счётчик ссылок на объект становится равным 0, объект удаляется\n",
    "- Удаление и создание объектов может не приводит к изменениям памяти в некоторых случаях из-за кэширования (например 0 или None)\n",
    "- Но в общем случае память выделяется и освобождается"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Сборщик мусора</font>\n",
    "\n",
    "- Освобождение памяти производит сборщик мусора (Garbage Collector)\n",
    "- Памяти освобождается не моментально, а в некоторый недетерминированный момент\n",
    "- Одной из сложностей поиска объектов для удаления являются т.н. циклические ссылки"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 179,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = [None]\n",
    "a[0] = a\n",
    "del a"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Сборщик мусора умеет работать с такими случаями"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Полезные функции</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "469"
      ]
     },
     "execution_count": 180,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import gc\n",
    "gc.collect()  # call collection immediately"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4294967295\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "import sys\n",
    "a = 1\n",
    "print(sys.getrefcount(a))  # cached popular value\n",
    "print(sys.getrefcount('some str'))  # 1 after creation, 1 temporary, 1 - ???"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Слабые ссылки</font>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- Иногда возникает необходимость вести учёт объектов только когда они используются где-нибудь ещё\n",
    "- Но само слежение уже создаёт ссылку, из-за которой объект будет оставаться в памяти\n",
    "- Слабые ссылки дают возможность вести учёт объекта без создания ссылок на них\n",
    "- Для этого используется модуль weakref\n",
    "- Классическое приложение - кэширование объектов, пересоздание которых является затратным\n",
    "- Слабые ссылки нельзя создавать на объекты базовых типов"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Слабые ссылки</font>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 182,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 182,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# http://old.pynsk.ru/posts/2015/Sep/19/tainstvo-standartnoi-biblioteki-slabye-ssylki-weakref/#.XkhkS9kueV4\n",
    "\n",
    "import weakref, gc\n",
    "\n",
    "class A:\n",
    "    def __init__(self, value):\n",
    "        self.value = value\n",
    "    def __repr__(self):  # magic method: information for print\n",
    "        return str(self.value)\n",
    "\n",
    "a = A(10)  # create object and strong reference\n",
    "d = weakref.WeakValueDictionary()  # dict with weak references\n",
    "\n",
    "d['k'] = a\n",
    "d['k']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 183,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 183,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "del a\n",
    "gc.collect()\n",
    "d['k']"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "- при запуске из терминала получается вывод \"KeyError: 'k'\"\n",
    "- видимо, в ноутбуке создаются дополнительные неявные ссылки"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "slideshow": {
     "slide_type": "slide"
    }
   },
   "source": [
    "### <font color='lilac'>Проверка стиля кода</font>\n",
    "\n",
    "- Стандартным набором правил codestyle для Python является PEP8\n",
    "- Есть несколько инструментов для проверки кода на соответствию стиля: `pep8`, `pyflakes`, `flake8`, `Pylint`\n",
    "- В рамках курса в качестве линтера используется `flake8`\n",
    "- Установка модуля стандартная через `pip`, используется он как утилита с управляющими флагами:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 187,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os, shutil\n",
    "os.mkdir('tmp')\n",
    "with open('temp.py', 'w') as fout:\n",
    "    fout.write('\\n'.join([\n",
    "        'print(1111111111111111111111111111111111111111111111111111111111111111111)',\n",
    "        'print(1111111111111111111111111111111111111111111111111111111111111111111)  # noqa: E501\\n',\n",
    "    ]))\n",
    "\n",
    "with open(os.path.join('tmp', 'temp.py'), 'w') as fout:\n",
    "    fout.write('''print(1111111111111111111111111111111111111111111111111111111111111111111)''')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 188,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1m./temp.py\u001b[m\u001b[36m:\u001b[m1\u001b[36m:\u001b[m21\u001b[36m:\u001b[m \u001b[1m\u001b[31mE501\u001b[m line too long (74 > 20 characters)\n",
      "print(1111111111111111111111111111111111111111111111111111111111111111111)\n",
      "                    ^\n",
      "\u001b[1m./test_module.py\u001b[m\u001b[36m:\u001b[m2\u001b[36m:\u001b[m1\u001b[36m:\u001b[m \u001b[1m\u001b[31mE302\u001b[m expected 2 blank lines, found 0\n",
      "def new_print(a):\n",
      "^\n",
      "\u001b[1m./test_module.py\u001b[m\u001b[36m:\u001b[m3\u001b[36m:\u001b[m1\u001b[36m:\u001b[m \u001b[1m\u001b[31mW191\u001b[m indentation contains tabs\n",
      "\tprint(a)\n",
      "^\n",
      "1     E302 expected 2 blank lines, found 0\n",
      "1     E501 line too long (74 > 20 characters)\n",
      "1     W191 indentation contains tabs\n",
      "3\n"
     ]
    }
   ],
   "source": [
    "!flake8 . --extend-exclude=tmp --show-source --statistics --count --max-line-length=20\n",
    "shutil.rmtree('tmp')"
   ]
  }
 ],
 "metadata": {
  "celltoolbar": "Slideshow",
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.12.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}