lect2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Лекция №2. Простые скрипты\n",
    "\n",
    "П.Н. Советов, РТУ МИРЭА"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Типы данных\n",
    "\n",
    "В Питоне значения различных типов являются объектами. Важно учитывать, что объекты передаются (при присваиваниях и использовании в качестве аргументов) по ссылке, а не копируются. Типы данных в Питоне делятся на изменяемые (mutable) и неизменяемые (immutable). У объекта изменяемого типа содержимое может быть модифицировано. \n",
    "\n",
    "На рисунке ниже показаны основные встроенные типы данных языка Питон.\n",
    "\n",
    "![](images/types.svg)\n",
    "\n",
    "*Основные встроенные типы данных в Python*\n",
    "\n",
    "К изменяемым типам данных относятся:\n",
    "* список `list`,\n",
    "* словарь `dict`,\n",
    "* множество `set`,\n",
    "* байтовый массив `bytearray`.\n",
    "\n",
    "В Питоне некоторые типы данных имеют общее название — последовательности. Существует ряд общих операций, применимых для всех последовательностей: обращение по индексу, получение длины и другие.\n",
    "\n",
    "К типам-последовательностям относятся:\n",
    "* строка `str`,\n",
    "* список `list`,\n",
    "* кортеж `tuple`,\n",
    "* байтовая последовательность `bytes`,\n",
    "* байтовый массив `bytearray`.\n",
    "\n",
    "Для создания и преобразования объектов различных типов могут быть использованы встроенные функции. Ниже приведены некоторые примеры работы этих функций.\n",
    "\n",
    "```Python\n",
    "str(42) = '42'\n",
    "int('0123') = 123\n",
    "list('0123') = ['0', '1', '2', '3']\n",
    "tuple('0123') = ('0', '1', '2', '3')\n",
    "str([-1, 1]) = '[-1, 1]'\n",
    "tuple([-1, 1]) = (-1, 1)\n",
    "str((2, 4)) = '(2, 4)'\n",
    "list((2, 4)) = [2, 4]\n",
    "str({'a': 1, 'b': 2}) = \"{'a': 1, 'b': 2}\"\n",
    "list({'a': 1, 'b': 2}) = ['a', 'b']\n",
    "tuple({'a': 1, 'b': 2}) = ('a', 'b')\n",
    "```\n",
    "\n",
    "В практике прикладного программирования на Питоне среди упомянутых выше новых типов данных наиболее популярны строки, списки, кортежи и словари. Работу с этими типами данных нужно изучить в первую очередь.\n",
    "\n",
    "В Питоне есть средства для создания пользовательских типов данных. Кроме рассматриваемых здесь встроенных типов данных существуют прикладные типы данных, реализованные на уровне стандартной библиотеки."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### None\n",
    "\n",
    "Тип `NoneType` имеет единственный элемент `None`, который обозначает отсутствие или необязательность значения. При вычислении условий `None` трактуется, как `False`.\n",
    "\n",
    "Функция, в которой явно не задано возвращаемое значение, возвращает `None`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'NoneType'>\n"
     ]
    }
   ],
   "source": [
    "def f():\n",
    "    pass\n",
    "\n",
    "print(type(f()))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Обратите внимание, что в Питоне не разрешено использовать пустые блоки. Нужного эффекта, как показано выше, можно добиться с помощью ключевого слова `pass`.\n",
    "\n",
    "Для определения констант нет специального синтаксиса, но, по соглашению, имена переменных, используемых в качестве констант, записываются в верхнем регистре:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "MAX_SIZE = 100"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Строки\n",
    "\n",
    "Строки могут быть записаны различными способами:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "s1 = 'строка в одинарных кавычках'\n",
    "s2 = \"строка в двойных кавычках\"\n",
    "s3 = '''\n",
    "многострочный\n",
    "текст\n",
    "'''\n",
    "s4 = \"\"\"\n",
    "другой\n",
    "многострочный\n",
    "текст\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Строковой литерал с тройными кавычками можно также использовать для определения многострочного комментария.\n",
    "\n",
    "Строковой литерал в начале тела функции играет роль документации (docstring):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def some_function():\n",
    "    '''\n",
    "    Эта функция еще не реализована.\n",
    "    '''\n",
    "    return 0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Документацию по выбранной функции можно получить с помощью `help()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on function some_function in module __main__:\n",
      "\n",
      "some_function()\n",
      "    Эта функция еще не реализована.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(some_function)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function max in module builtins:\n",
      "\n",
      "max(...)\n",
      "    max(iterable, *[, default=obj, key=func]) -> value\n",
      "    max(arg1, arg2, *args, *[, key=func]) -> value\n",
      "    \n",
      "    With a single iterable argument, return its biggest item. The\n",
      "    default keyword-only argument specifies an object to return if\n",
      "    the provided iterable is empty.\n",
      "    With two or more arguments, return the largest argument.\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(max)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Строки представляют собой последовательности значений Юникода. В Питоне отсутствует отдельный тип символа (char), вместо него используются строки единичной длины.\n",
    "\n",
    "Для получения символа по его коду и кода по символу имеются соответствующие функции:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0 48\n"
     ]
    }
   ],
   "source": [
    "print(chr(48), ord('0'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "С использованием ключевого слова in можно проверить наличие заданной подстроки в строке:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'two' in 'one,two,tree'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'four' not in 'one,two,tree'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Важно помнить, что строку нельзя модифицировать:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "s = 'python'\n",
    "# s[0] = 'P' приведет к ошибке"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Вместо модификации текущей строки необходимо создать новую строку из уже имеющихся:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Python'"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'P' + s[1:]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Срезы"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В примере выше использовалась очень популярная операция над последовательностями в Питоне — взятие среза.\n",
    "\n",
    "В срезе s[i:j] полученная подпоследовательность включает в себя элементы с индексами из $[i, j)$.\n",
    "\n",
    "Проиллюстрируем работу срезов на примерах:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ython'"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[1:] # от s[1] до s[len(s) - 1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'pyt'"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[:3] # от s[0] до s[2]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Индекс -1 обозначает индекс последнего элемента последовательности. В общем случае обращение по отрицательному индексу `s[-i]` трактуется, как `s[len(s) - i]`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('n', 'ytho', 'ytho')"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[-1], s[-5:-1], s[len(s) - 5:len(s) - 1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ytho'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[1:-1] # от s[1] до s[len(s) - 2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'pto'"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s[::2] # от s[0] до s[len(s) - 1] с шагом 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Для неизменяемой последовательности, примером которой является строка, определен ряд общих операций:\n",
    "\n",
    "| Операция         | Описание                                |\n",
    "|------------------|-----------------------------------------|\n",
    "|      x in s      | Проверка на наличие x в s             |\n",
    "|    x not in s    | Проверка на отсутствие x в s            |\n",
    "|      s1 + s2     | Соединение последовательностей          |\n",
    "| s * n            | Последовательность из n повторений s    |\n",
    "| s[i]             | Получение элемента по индексу           |\n",
    "| s[i:j], s[i:j:k] | Получение подпоследовательности (среза) |\n",
    "| len(s)           | Длина s                                 |\n",
    "| max(s), min(s)   | Максимальный/минимальный элемент в s    |\n",
    "| s.index(x)       | Индекс первого вхождения x в s          |\n",
    "| s.count(x)       | Количество вхождений x в s              |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Для экранирования специальных символов в Питоне используются знакомые программистам на C++ средства:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "first\n",
      "second\n"
     ]
    }
   ],
   "source": [
    "print('first\\nsecond')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "При необходимости, интерпретацию специальных символов можно отключить при использовании строкового литерала с префиксом r:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "first\\nsecond\n"
     ]
    }
   ],
   "source": [
    "print(r'first\\nsecond')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В функции `print` могут использоваться дополнительные именованные аргументы:\n",
    "* `sep` для разделения обычных аргументов заданной строкой,\n",
    "* `end` для указания окончания строки при выводе на экран. Позволяет выводить текст без перевода на новую строку."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "логин:пароль:почта\n",
      "начало...завершение\n"
     ]
    }
   ],
   "source": [
    "print('логин', 'пароль', 'почта', sep=':')\n",
    "print('начало', end='...')\n",
    "print('завершение')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В цикле `for`, помимо итератора `range()` может использоваться и значение типа последовательность, как показано в примере ниже."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "P Y T H O N "
     ]
    }
   ],
   "source": [
    "for c in s:\n",
    "    print(c.upper(), end=' ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Следует избегать построения длинных строк с помощью тяжеловесной операции `+` (конкатенации). Большей производительности можно достичь с помощью метода `join()`, как показано ниже:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'АБВГДЕЖЗИЙКЛМНОПРСТУФХЦЧШЩЪЫЬЭЮЯ'"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "alpha = range(ord('А'), ord('Я') + 1)\n",
    "''.join([chr(c) for c in alpha])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Описание других методов для работы со строками в Питоне можно найти в [официальной документации](https://docs.python.org/3/library/stdtypes.html#string-methods)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Форматирование строк"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В Питоне имеется несколько способов форматирования строк. В частности, поддерживается форматирование в стиле printf, с использованием операции `%`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "x: 42\n",
      "значения: python, 1.23\n"
     ]
    }
   ],
   "source": [
    "x = 42\n",
    "pi = 3.14159265359\n",
    "print('x: %d' % x)\n",
    "print('значения: %s, %.2f' % (s, 1.2345))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Также может использоваться строковой метод `format()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "значения: python, 42, 3.14\n",
      "значения: python, 42, 3.14\n"
     ]
    }
   ],
   "source": [
    "print('значения: {:s}, {:d}, {:.2f}'.format(s, x, pi))\n",
    "print('значения: {s:s}, {x:d}, {pi:.2f}'.format(s=s, x=x, pi=pi))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Все большую популярность приобретает еще один метод форматирования — с помощью f-строк:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "значения: python, 42, 3.14\n"
     ]
    }
   ],
   "source": [
    "print(f'значения: {s:s}, {x:d}, {pi:.2f}')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В случае f-строк лучше не перегружать шаблон форматирования кодом на Питоне, поскольку это ухудшает читаемость программы.\n",
    "\n",
    "Подробности о языке форматирования строк приведены в [официальной документации](https://docs.python.org/3/library/string.html#formatstrings)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Списки\n",
    "\n",
    "Список в Питоне имеет обманчивое название. Это не связный список, а динамический массив, элементами которого могут выступать объекты произвольных типов.\n",
    "\n",
    "Важно учитывать, что списки являются изменяемыми и передаются по ссылке, а не по значению, как показано в примере ниже."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['список', [1, 2], [1, 2]]\n",
      "['список', [None, 2], [None, 2]]\n"
     ]
    }
   ],
   "source": [
    "s1 = [1, 2]\n",
    "s2 = ['список', s1, s1]\n",
    "print(s2)\n",
    "s1[0] = None\n",
    "print(s2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Рассмотренная в примере ситуация изображена на картинке ниже.\n",
    "\n",
    "![](images/list_objects.png)\n",
    "\n",
    "Попробуйте поэкспериментировать со списками с помощью сайта [pythontutor.com](http://pythontutor.com/).\n",
    "\n",
    "По возможности, следует использовать неизменяемые типы данных, поскольку, как видно в примере выше, модификация списка может привести к неожиданным результатам и ошибкам, которые, зачастую, трудно обнаружить. В частности, не следует модифицировать список в цикле прохода по элементам этого списка."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Для списков и других изменяемых последовательностей используются те же общие операции, что и для строк, а также иных неизменяемых последовательностей. Кроме того, существует ряд операций, специально предназначенных для изменяемых последовательностей:\n",
    "\n",
    "| Операция                           | Описание                                        |\n",
    "|------------------------------------|-------------------------------------------------|\n",
    "|              s[i] = x              | Заменить элемент по индексу                     |\n",
    "|    s1[i:j] = s2, s1[i:j:k] = s2    | Переписать срез              |\n",
    "| del s[i], del s[i:j], del s[i:j:k] | Удалить элемент или срез       |\n",
    "| s.append(x)                        | Добавить в конец s элемент x                    |\n",
    "| s.clear()                          | Удалить все элементы из s                       |\n",
    "| s[:], s.copy()                     | Получить копию s (копируются ссылки на объекты) |\n",
    "| s1 += s2, s1.extend(s2)            | Добавить к s1 последовательность s2             |\n",
    "| s.insert(i, x)                     | Вставить x в s по индексу                       |\n",
    "| s.pop(), s.pop(i)                           | Вытолкнуть последний элемент из s или по индексу              |\n",
    "| s.remove(x)                        | Удалить первое вхождение x из s                 |\n",
    "| s.reverse()                        | Обратить последовательность                     |\n",
    "\n",
    "Следующие операции над списком имеют вычислительную сложность O(1):\n",
    "* `s.append(x)`,\n",
    "* `s.pop()`,\n",
    "* `s[i]`,\n",
    "* `s[i] = x`,\n",
    "* `len(s)`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Списковые включения\n",
    "\n",
    "Списковые включения в Питоне представляют собой способ компактного описания порождения списка. Нотация вдохновлена математической записью для построения множества, а также языком программирования SETL.\n",
    "\n",
    "В математике множество квадратов чисел от 1 до 9 можно определить, как\n",
    "\n",
    "$$\n",
    "\\{n^2: \\forall n \\in N, 1 \\le n \\lt 10 \\}\n",
    "$$\n",
    "\n",
    "В Питоне список, который содержит приведенное выше множество чисел, можно описать следующим образом:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 4, 9, 16, 25, 36, 49, 64, 81]"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[n ** 2 for n in range(1, 10)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "При генерации списка можно указать дополнительное условие, как показано в примере ниже:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 4, 6, 8]"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Список четных чисел в заданном диапазоне\n",
    "[n for n in range(1, 10) if n % 2 == 0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Упрощенный шаблон спискового включения выглядит так:\n",
    "\n",
    "```Python\n",
    "[выражение for переменная in последовательность if условие]\n",
    "```\n",
    "\n",
    "Это соответствует следующему псевдокоду:\n",
    "\n",
    "```Python\n",
    "результат = []\n",
    "for переменная in последовательность:\n",
    "    if условие:\n",
    "        результат.append(выражение)\n",
    "```\n",
    "\n",
    "Реальный синтаксис спискового включения сложнее, поскольку допускает вложенность, которой иногда программисты злоупотребляют.\n",
    "\n",
    "Далее представлена железнодорожная диаграмма синтаксиса включения (`включение-for`). Этот синтаксис является общим для порождения списков, словарей и множеств.\n",
    "\n",
    "![](images/comp_for.svg)\n",
    "\n",
    "Часть `включение-if`:\n",
    "\n",
    "![](images/comp_if.svg)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В Питоне отсутствует встроенный тип многомерного массива. Тем не менее, имитировать многомерный массив можно с помощью обычных списков, как показано в примере ниже."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "arr[0,0]=0 arr[0,1]=0 arr[0,2]=0 arr[0,3]=0 arr[0,4]=0 \n",
      "arr[1,0]=0 arr[1,1]=1 arr[1,2]=2 arr[1,3]=3 arr[1,4]=4 \n",
      "arr[2,0]=0 arr[2,1]=2 arr[2,2]=4 arr[2,3]=6 arr[2,4]=8 \n"
     ]
    }
   ],
   "source": [
    "arr = [[x * y for x in range(5)] for y in range(3)]\n",
    "for y in range(3):\n",
    "    for x in range(5):\n",
    "        print(f'arr[{y},{x}]={arr[y][x]}', end=' ')\n",
    "    print()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Кортежи\n",
    "\n",
    "Кортеж является неизменяемым вариантом списка. Запись кортежа имеет особенности, как показано далее."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 2)"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Пустой кортеж\n",
    "() \n",
    "# Кортеж из одного элемента,\n",
    "# запятая нужна, чтобы отличать от выражения в скобках\n",
    "('single',) \n",
    "# Еще один кортеж\n",
    "(1, 2, [\"three\", 4])\n",
    "# Скобки можно опустить, важны запятые\n",
    "1, 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Последний из вышеприведенных примеров показывает, как в Питоне реализовано возвращение нескольких результатов из функции. Это делается с помощью кортежа:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3, -1) <class 'tuple'>\n"
     ]
    }
   ],
   "source": [
    "def addsub(x, y):\n",
    "    return x + y, x - y\n",
    "\n",
    "print(addsub(1, 2), type(addsub(1, 2)))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "С помощью кортежей можно организовать множественное присваивание значений переменных:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Python 30\n",
      "dynamic strong\n"
     ]
    }
   ],
   "source": [
    "data = ['Python', ('strong', 'dynamic'), 30]\n",
    "language, (ty1, ty2), value = data\n",
    "print(language, value)\n",
    "ty1, ty2 = ty2, ty1\n",
    "print(ty1, ty2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Множественное присваивание удобно использовать в цикле `for` с итератором `enumerate()`, позволяющим получить как индекс, так и значение для элементов последовательности:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0:a 1:b 2:c 3:d 4:e 5:f "
     ]
    }
   ],
   "source": [
    "for i, x in enumerate('abcdef'):\n",
    "    print(i, x, sep=':', end=' ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Словари\n",
    "\n",
    "Словарь в Питоне представляет собой изменяемую хеш-таблицу. Ключом в словаре может быть любое хешируемое значение (для которого можно использовать встроенную функцию `hash()`). На практике это означает, что ключом должен быть неизменяемый объект (элементы которого тоже неизменяемы), такой, например, как строка. \n",
    "\n",
    "Ниже показаны различные способы определения словаря: с помощью перечисление пар ключ-значения, с помощью аналога спискового включения для словарей и с помощью конструктора `dict`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'language': 'Python', 'score': 1.0}\n",
      "{'language': 'Python', 'score': 1.0}\n",
      "{'language': 'Python', 'score': 1.0}\n"
     ]
    }
   ],
   "source": [
    "{} # Пустой словарь\n",
    "print({'language':'Python', 'score': 1.0})\n",
    "print({k: v for k, v in [('language', 'Python'), ('score', 1.0)]})\n",
    "print(dict(language='Python', score=1.0))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Следующие операции над словарем в Питоне имеют вычислительную сложность O(1):\n",
    "* `k in d`,\n",
    "* `d[k]`,\n",
    "* `d[k] = x`,\n",
    "* `del d[k]`.\n",
    "\n",
    "Порядок вставленных элементов по ключу в словаре в новых версиях языка (старше 3.6) сохраняется:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tree 3\n",
      "two 2\n",
      "one 1\n"
     ]
    }
   ],
   "source": [
    "d = {}\n",
    "d['tree'] = 3\n",
    "d['two'] = 2\n",
    "d['one'] = 1\n",
    "for k, v in d.items(): # аналог enumerate() для словаря\n",
    "    print(k, v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Обращение по несуществующему ключу в словаре вызывает ошибку (исключение). Метод `get()` удобно использовать в тех случаях, когда при обращении по новому ключу достаточно подставить значение по умолчанию, не изменяя словарь:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a 1 b 2 c 3 "
     ]
    }
   ],
   "source": [
    "d = dict(a=1, b=2)\n",
    "for k in 'abc':\n",
    "    print(k, d.get(k, 3), end=' ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Множества\n",
    "\n",
    "Тип множество понимается в математическом смысле — как коллекция неупорядоченных объектов. Задается множество, аналогично словарю, с помощью фигурных скобок, но без указания ключей. При это многие операции имеют названия, отличные от общих для типов-последовательностей:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'Kaspersky', 'Yandex', 'MCST'} True {'Kaspersky', 'Yandex'}\n"
     ]
    }
   ],
   "source": [
    "firms = {'Yandex', 'Yandex', 'JetBrains', 'MCST'}\n",
    "set(['Yandex', 'JetBrains', 'MCST']) # еще один вариант определения множества\n",
    "firms.add('Kaspersky')\n",
    "firms.remove('JetBrains')\n",
    "print(firms, 'Kaspersky' in firms, {x for x in firms if 'a' in x})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Над типом множество поддерживаются также операции объединения, пересечения и другие операции, описание которых приведено в [официальной документации](https://docs.python.org/3/library/stdtypes.html#set-types-set-frozenset)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Идентичность объектов\n",
    "\n",
    "Как мы уже знаем, Питон оперирует объектами различных типов. Помимо типа и значения, каждый объект характеризуется уникальным числом — в реализации CPython это адрес объекта в памяти. Для получения адреса используется встроенная функция `id()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1, 2], [1, 2], [1, 2]] ['0x1da0018e400', '0x1da0018e400', '0x1da001e1400']\n"
     ]
    }
   ],
   "source": [
    "s1, s2 = [1, 2], [1, 2]\n",
    "s3 = [s1, s1, s2]\n",
    "print(s3, [hex(id(x)) for x in s3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "С помощью проверки адресов можно установить идентичность двух объектов. Для этого используется операция `x is y`, которая эквивалентна следующему выражению: `id(x) == id(y)`. При этом надо различать проверку на равенство (`==`) и на идентичность (`is`):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(True, False)"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s1 == s2, s1 is s2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В прикладных программах `is` наиболее часто используется для сравнения с `None`. Поскольку `None` является уникальным объектом, то принято писать `x is None` или `x is not None`, вместо `x == None` или `x != None`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Еще раз о функциях\n",
    "\n",
    "В Питоне аргументы функции передаются по ссылке, а не копируются при вызове функции. Аргументы и определенные внутри функции переменные попадают в локальную область видимости функции (`locals()`). \n",
    "\n",
    "Иногда возникает необходимость изменить глобальные данные из функции. Это можно сделать с помощью ключевого слова `global`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3 3\n"
     ]
    }
   ],
   "source": [
    "Counter = 0\n",
    "\n",
    "def f():\n",
    "    # без этого объявления речь шла об увеличении локальной переменной\n",
    "    global Counter \n",
    "    Counter += 1\n",
    "    return Counter\n",
    "    \n",
    "print(f(), f(), f(), Counter)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "При этом использование `global`, как и в других языках, не является признаком хорошего тона. С помощью функций, классов и модулей в большинстве случаев удается обойтись без модификации глобальных объектов."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Вызывать функцию можно как с позиционными (тот вариант, который мы использовали ранее), так и с именованными аргументами:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Иван: 20, Михаил: 19\n"
     ]
    }
   ],
   "source": [
    "def f(name, age):\n",
    "    return f'{name}: {age}'\n",
    "    \n",
    "print(f('Иван', 20), f(name='Михаил', age=19), sep=', ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В функциях могут использоваться аргументы по умолчанию. Они располагаются после всех обязательных аргументов:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Иван: 20, Михаил: 19\n"
     ]
    }
   ],
   "source": [
    "def f(name, age=20):\n",
    "    return f'{name}: {age}'\n",
    "    \n",
    "print(f('Иван'), f(name='Михаил', age=19), sep=', ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Аргументы по умолчанию получают свои значения во время определения функции. В результате может сложиться проблемная ситуация, как в примере ниже:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[0, 1, 2, 3], [0, 1, 2, 3], [0, 1, 2, 3], [0, 1, 2, 3]]"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "def f(lst=[]):\n",
    "    lst.append(len(lst))\n",
    "    return lst\n",
    "\n",
    "[f() for i in range(4)]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Чтобы избежать неочевидного поведения аргументов, следует в качестве значений по умолчанию использовать неизменяемые объекты."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Переменные, заданные в списковых (и прочих) включениях, имеют время жизни, ограниченное включением:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "([0, 0, 0, 0], False)\n"
     ]
    }
   ],
   "source": [
    "def f():    \n",
    "    return [0 for i in range(4)], 'i' in locals()\n",
    "\n",
    "print(f())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Для установления времени жизни переменных, определенных в цикле `for`, используются более запутанные правила:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(3, True, False)\n"
     ]
    }
   ],
   "source": [
    "def f():\n",
    "    for i in range(4):\n",
    "        pass\n",
    "    for j in range(0): # цикл не выполняется\n",
    "        pass\n",
    "    return i, 'i' in locals(), 'j' in locals()\n",
    "\n",
    "print(f())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Пример использования рассмотренных средств языка"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В программе ниже организован разбор формальной грамматики, представленной в БНФ, а также порождение случайных фраз по заданной грамматике.\n",
    "\n",
    "В нотации используются:\n",
    "* альтернативный выбор (`a | b`),\n",
    "* последовательность (`a b`), \n",
    "* рекурсия (`a = a | b`).\n",
    "\n",
    "Видите ли вы аналогию с ранее рассмотренными железнодорожными диаграммами?\n",
    "\n",
    "Постарайтесь самостоятельно разобраться, как работает эта программа. Описание неизвестных для вас методов и функций смотрите в официальной документации."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(7-5/z*(z/3-58555808+z-y)*19)\n",
      "((z))\n",
      "z\n",
      "((810-(392))-x+((4156+841)+49750))/((x))\n",
      "((y-z-(597)-3-8/x-(1)))\n",
      "6\n",
      "x\n",
      "z\n",
      "20\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "import random\n",
    "\n",
    "\n",
    "def parse_bnf(text):\n",
    "    '''\n",
    "    Преобразовать текстовую запись БНФ в словарь.\n",
    "    '''\n",
    "    grammar = {}\n",
    "    rules = [line.split('=') for line in text.strip().split('\\n')]\n",
    "    for name, body in rules:\n",
    "        grammar[name.strip()] = [alt.split() for alt in body.split('|')]\n",
    "    return grammar\n",
    "\n",
    "\n",
    "def generate_phrase(grammar, start):\n",
    "    '''\n",
    "    Сгенерировать случайную фразу.\n",
    "    '''\n",
    "    if start in grammar:\n",
    "        seq = random.choice(grammar[start])\n",
    "        return ''.join([generate_phrase(grammar, name) for name in seq])\n",
    "    return str(start)\n",
    "\n",
    "\n",
    "BNF = '''\n",
    "V = x | y | z\n",
    "D = 0 | 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9\n",
    "N = D | D N\n",
    "O = + | - | * | /\n",
    "E = V | N | ( E ) | E O E\n",
    "'''\n",
    "\n",
    "for i in range(10):\n",
    "    print(generate_phrase(parse_bnf(BNF), 'E'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Работа с файлами\n",
    "\n",
    "В Питоне имеется встроенная функция `open()` для открытия файлов.\n",
    "\n",
    "Прочесть данные из файла:\n",
    "\n",
    "```Python\n",
    "f = open('data.txt', 'r')\n",
    "data = f.read()\n",
    "f.close()\n",
    "```\n",
    "\n",
    "Записать данные в файл:\n",
    "\n",
    "```Python\n",
    "f = open('data.txt', 'w')\n",
    "f.write(data)\n",
    "f.close()\n",
    "```\n",
    "\n",
    "Как и в C++, добавление 'b' к строкам 'r' или 'w' означает открытие файла в двоичном режиме.\n",
    "\n",
    "Чтобы не беспокоиться о закрытии файла удобно использовать менеджер контекста с помощью ключевого слова `with`:\n",
    "\n",
    "```Python\n",
    "with open('data.txt', 'r') as f:\n",
    "    data = f.read()\n",
    "```\n",
    "\n",
    "или\n",
    "\n",
    "```Python\n",
    "with open('data.txt', 'w') as f:\n",
    "    f.write(data)\n",
    "```\n",
    "\n",
    "Файл будет автоматически закрыт по выходу из блока `with`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Интерфейс командной строки\n",
    "\n",
    "Простые скрипты в Питоне обычно представляют собой собой программы, имеющие интерфейс командной строки.\n",
    "Аргументы, передаваемые на вход программы из командной строки, хранятся в списке `sys.argv`. Рассмотрим следующую программу:\n",
    "\n",
    "```Python\n",
    "import sys\n",
    "\n",
    "print(sys.argv)\n",
    "```\n",
    "\n",
    "Если вызвать ее из командной строки с помощью `python cli.py -o file.dat 123`, то будет получен следующий результат:\n",
    "\n",
    "```\n",
    "['cli.py', '-o', 'file.dat', '123']\n",
    "```\n",
    "\n",
    "Для удобного разбора опций командной строки имеется модуль `argparse`, описание которого приведено в [официальной документации](https://docs.python.org/3/library/argparse.html).\n",
    "\n",
    "Краткое руководство по хорошему стилю определения опций командной строки находится [здесь](https://nullprogram.com/blog/2020/08/01/) (англ.)."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}