{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "7cb1603d-3cb3-4b7c-a925-c1fe404edbe7",
   "metadata": {},
   "source": [
    "# Основы Python. Часть 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cc726a7c-09ff-4c4b-a7dc-788834c46b7a",
   "metadata": {},
   "source": [
    "##  Присвоение значений и динамическая типизация"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "3a4e4ca0-cd09-447a-8f05-d5f110fc1ff9",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Комментарий\n",
    "a = 5\n",
    "b = 5.5\n",
    "c = \"привет\"\n",
    "d = b\"\\x00\\x7f\\x2e\"\n",
    "e = True\n",
    "f = None"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8f565abb-e936-43af-80ba-9be645cac145",
   "metadata": {},
   "source": [
    "При повторном присваивании типы не проверяются, а создается новая переменная с тем-же именем. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "4db17b76-be17-4a34-930a-39716a7eae50",
   "metadata": {},
   "outputs": [],
   "source": [
    "d = 42 # Успешно: d теперь имеет тип int и значение 42"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ba950d4c-0aee-4635-b96a-acf64cab648d",
   "metadata": {},
   "source": [
    "При выполнении прочих операций типы проверяются "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "5388eb2f-e375-4496-8b08-5d4718c08fe1",
   "metadata": {},
   "outputs": [],
   "source": [
    "# d = a + c # Ошибка"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f3eb7ad4-eda9-44cf-9e50-baff1444f4e5",
   "metadata": {},
   "source": [
    "Можно смешивать переменные разных числовых типов в одном выражении "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "92dee996-f0b5-4817-a31c-06f724ae3c33",
   "metadata": {},
   "outputs": [],
   "source": [
    " q = a + b # Успешно: d теперь имеет тип float и значение 27.5"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "54d454a3-10ca-4663-8888-06f4fff5f82a",
   "metadata": {},
   "source": [
    "## Строки"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "15128208-b013-4fcb-9bf0-ba84f792b95b",
   "metadata": {},
   "source": [
    "### Способы записи строк"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "a397be35-38c8-4bff-b1e5-cff1a5bf29b2",
   "metadata": {},
   "outputs": [],
   "source": [
    "s = \"строка\"\n",
    "s = \"строка с одинарными 'ковычками'\"\n",
    "s = 'строка с двойными \"ковычками\"'\n",
    "s = '''строка\n",
    "из нескольких строк\n",
    "с переносами'''\n",
    "s = 'Строка с символами \\tс экранирования\\n'\n",
    "s = r'Строка без \\n экранирования'\n",
    "s = b'Byte String - Only Ascii and \\x24'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ceaac55d-3e6c-4a43-a49b-28ae95befb05",
   "metadata": {},
   "source": [
    "### Распространенные непечатные символы"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f9a25a36-25e4-4543-afaf-68e127a6d52f",
   "metadata": {},
   "source": [
    "| Символ      | Значение |\n",
    "| ----------- | ----------- |\n",
    "| `\\n`          | Новая строка       |\n",
    "| `\\t`          | Табуляция        |\n",
    "| `\\r`          | Возврат каретки        |\n",
    "| `\\u????`      | Символ Unicode: `????` — код символа (для строк)       |\n",
    "| `\\x??`        | Байт `??` — код байта (для байтовых строк)       |\n",
    "| `\\\\`          | Символ `\\`       |"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a71d0516-da11-4ad4-9b6d-900b89510f52",
   "metadata": {},
   "source": [
    "Проблемы с экранированием возникают при работе с регулярными выражениями и именами папок в Windows: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "3496213c-d35c-4ac0-bbe1-0d67561c8d6a",
   "metadata": {},
   "outputs": [],
   "source": [
    "# pth = 'C:\\new_files\\ret_id' # Ошибка \\n и \\r недопустимы в имени папки\n",
    "pth = 'C:\\\\new_files\\\\ret_id' # Все хорошо\n",
    "pth = r'C:\\new_files\\ret_id' # Все хорошо\n",
    "# pth = 'C:\\files\\ ' # Ошибка экранированный символ \\' в конце строки \\'\n",
    "pth = 'C:\\files'  # Все хорошо"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f2a73ee6-1d1c-47d5-a51e-9603914c4dcd",
   "metadata": {},
   "source": [
    "## Вызов функций и операторы"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "825dbb16-07ee-4bcb-b40b-0a4dff00bd5a",
   "metadata": {},
   "source": [
    "### Вызов функций"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8d11452d-0049-40b7-94ab-c4464cffc45e",
   "metadata": {},
   "source": [
    "Функции вызываются стандартно: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e1cd71b0-a108-44f3-b37a-f5ed8dc5123e",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Привет!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "41d2ea99-205a-4c3a-af9f-c124127efd68",
   "metadata": {},
   "source": [
    "и могут принимать:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ae88cf0c-595f-41e0-b0ce-5e49546dfacc",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Аргументы по порядку\n",
    "print(1, 2, \"test\")\n",
    "# Аргументы по имени\n",
    "print(sep = \";\", end = \"?\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9f8aa08d-0857-4290-8248-c087bec26121",
   "metadata": {},
   "source": [
    "Способы передачи аргументов можно смешивать, но аргументы по порядку должны идти в начале"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "38e9b3ce-35da-4a94-9390-d7f5eebf3c17",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(1, 2, sep = \"-\") # Правильно\n",
    "# print(sep = \"-\", 1, 2) # Ошибка"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5f964655-10d4-49fa-8826-420cde322f81",
   "metadata": {},
   "source": [
    "### Возвращаемые значения"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "167c7990-c620-4c33-8043-cf462942dd9a",
   "metadata": {},
   "source": [
    "Функция может возвращать одно или несколько значений. Если функция не вернула ни одного значения, то считается, что она вернула None. Если возвращаемое значение не было присвоено переменной, то оно теряется. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "70cc02b3-cf67-458f-b824-ab2c6d1bc699",
   "metadata": {},
   "outputs": [],
   "source": [
    "def foo(x):\n",
    "    return x*x\n",
    "\n",
    "foo(24)\n",
    "x = foo(24)\n",
    "\n",
    "def bar(x):\n",
    "    return x*x, x+x, x**x\n",
    "\n",
    "x,y,t = bar(42)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5db048c1-661c-437b-98e7-4226e67f78e6",
   "metadata": {},
   "source": [
    "### Некоторые встроенные функции\n",
    "\n",
    "| Функция | Назначение |\n",
    "| ----------- | ----------- |\n",
    "| `len(x)` | Длина перечисляемого x, например строки или списка, возвращает int |\n",
    "| `type(x)` | Тип данных x, возвращает специальный объект — тип |\n",
    "| `print(x)` | Печать на экран x, возвращает None |"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d364cf4a-11e2-4e68-b2ef-6101b161b71a",
   "metadata": {},
   "source": [
    "### Операторы"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "626b395f-8370-4275-ba66-7ea38f57e052",
   "metadata": {},
   "source": [
    "Об операторах надо думать, как об упрощенной форме записи вызовов функций: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "658324e5-01fc-4ffd-b811-07fa2a72e24b",
   "metadata": {},
   "outputs": [],
   "source": [
    "y = 1+2*3 # тоже, что и y = __add__(1,__mult__(2,3))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0305d00e-2708-41d3-baba-24e31b29c434",
   "metadata": {},
   "source": [
    "Операторы и вызовы функций можно свободно смешивать: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "id": "88b43c2f-398c-4eac-9256-0991d1749fed",
   "metadata": {},
   "outputs": [],
   "source": [
    "y = 2*len(\"test\")+1\n",
    "y = len(\"test\" + \"code\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e8d8261e-8892-430e-9394-3c872f87fa1c",
   "metadata": {},
   "source": [
    "Многие операторы имеют сокращенную форму записи:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "05b9232f-b841-4c28-b3cd-3ad08ef1b06d",
   "metadata": {},
   "outputs": [],
   "source": [
    "y = y + 1\n",
    "y += 1"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "17996740-ab26-4f73-bc6d-27bb943c06ba",
   "metadata": {},
   "source": [
    "### Некоторые операторы\n",
    "\n",
    "| Оператор | Тип данных | Действие | Пример |\n",
    "| -------- | ---------- | -------- | ------ |\n",
    "|    `+`     | Числовые | Сложение |  `2+5` |\n",
    "|    `+`     | Перечислимые | Конкатенация |  `\"a\"+\"b\"` |\n",
    "|    `-`     | Числовые | Вычитание |  `5-2` |\n",
    "|    `*`     | Числовые | Умножение |  `2*5` |\n",
    "|    `*`    | Числовые | Повторение |  `\"a\"*5` |\n",
    "|    `**`     | Числовые | Возведение в степень |  `2**5` |\n",
    "|    `/`    | Числовые | Деление тип результата всегда действительное число |  `5/2` |\n",
    "|    `//`    | Числовые | Деление нацело |  `5//2` |\n",
    "|    `%`    | Числовые | Остаток от деления |  `5%2` |\n",
    "|    `%`    | Строки | Подстановка |  `\"hello %s\" % \"world\"` |\n",
    "\n",
    "Python позволяет смешивать переменные разных числовых типов в одном выражении, при этом тип результата определяется наиболее содержательным типом."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b1e07ca2-9e72-473e-854b-24fb16151db9",
   "metadata": {},
   "source": [
    "### Операторы сравнения\n",
    "\n",
    "Применяются для определения условий. Результат имеет тип bool.\n",
    "\n",
    "| Оператор | Действие | Пример |\n",
    "| -------- | -------- | ------ |\n",
    "| `==` | Равно | `x == 3` |\n",
    "| `!=` | Не равно | `x != 3` |\n",
    "| `>` | Больше | `x > 3` |\n",
    "| `<` | Меньше | `x < 3` |\n",
    "| `>=` | Больше или равно | `x >= 3` |\n",
    "| `<=` | Меньше или равно | `x <= 3` |\n",
    "| `is` | Тождество переменных | `x is True` |\n",
    "\n",
    "### Логические операторы\n",
    "\n",
    "Применяются для объединения логических выражений. Результат имеет тип bool.\n",
    "\n",
    "| Оператор | Действие | Пример |\n",
    "| -------- | -------- | ------ |\n",
    "| `not` | Логическое НЕ | `not x > 1` |\n",
    "| `and` | Логическое И | `x > 1 and x < 3` |\n",
    "| `or` | Логическое ИЛИ | `x > 3 or x < 1` |\n",
    "\n",
    "### Побитовые операторы\n",
    "\n",
    "Применяются для битовой арифметики над целыми числами или для операций над массивами numpy.\n",
    "a = 25\n",
    "print(\"тест:\", a , \"-\", 3.158)\n",
    "\n",
    "| Оператор | Действие | Пример |\n",
    "| -------- | -------- | ------ |\n",
    "| `~` | Побитовое НЕ | `~x` |\n",
    "| `&` | Побитовое И | `x & 3` |\n",
    "| `\\` | Побитовое ИЛИ | `x | 3` |\n",
    "| `^` | Побитовое исключающее ИЛИ | `x ^ 3` |"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "60e5b12b-492d-4e2f-831b-d0f4b7f54406",
   "metadata": {},
   "source": [
    "## Загрузка модулей"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dff1f4a8-466b-4e3b-96eb-643d78048a7c",
   "metadata": {},
   "source": [
    "Почти все функции как стандартной библиотеки, так и и сторонних организованы в модули\n",
    "\n",
    "Для подключения модулей используется ключевое слово `import`\n",
    "\n",
    "Для доступа к методам используется оператор `.`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a34a347c-5cd8-4f6b-863e-dfb2c3ce9d67",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy\n",
    "numpy.cos(3) # Успешно\n",
    "# cos(3) # Ошибка"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "399eda59-b8a2-47a9-891c-3dc9b146044b",
   "metadata": {},
   "outputs": [],
   "source": [
    "from numpy import cos\n",
    "cos(3) # Успешно"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "16d32ca0-d9dd-48c1-b712-77542d8d945a",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "np.cos(3) # Успешно"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ad89a872-d2c1-4dd9-9539-843c8b988ab3",
   "metadata": {},
   "source": [
    "### Важные модули стандартной библиотеки\n",
    "\n",
    "| Модули | Возможности |\n",
    "| -------- | -------- |\n",
    "| `sys` | Служебные функции интерпретатора, аргументы командной строки, выход | \n",
    "| `os`, `shutils` | Операции с файлами и папками, переменные окружения, запуск сторонних программ | \n",
    "| `glob`, `Path` | Операции с путями к файлам | \n",
    "| `math`, `statistics` | Базовые математические функции. Мы их использовать не будем | \n",
    "| `random` | Генерация случайных чисел и последовательностей | \n",
    "| `struct` | Работа с бинарными структурами | \n",
    "| `datetime` | Работа с датой и временем | \n",
    "| `copy` | Копирование составных объектов | \n",
    "| `pprint` | Улучшенный `print` | \n",
    "| `pickle` | Сохранение объектов Python в файлы | \n",
    "\n",
    "### Важные сторонние модули доступные в pip\n",
    "\n",
    "| Модули | Возможности |\n",
    "| -------- | -------- |\n",
    "| `numpy` | Эффективные методы для работы с числовыми данными |\n",
    "| `scipy` | Коллекция математических методов |\n",
    "| `matplotlib` | Рисование графиков |\n",
    "| `pandas` | Таблицы данных |"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1209d69c-a0c0-4a8a-aa21-12e2c13d8d74",
   "metadata": {},
   "source": [
    "## Приведение типов"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a139a909-cb2b-4d9f-bb16-ecd7f50e7082",
   "metadata": {},
   "source": [
    "Типы данных в Python автоматически не приводятся. Но типы `int`, `float` и `bool` можно смешивать в арифметических выражениях. Результат будет определяться наиболее ёмким типом (float > int > bool).\n",
    "\n",
    "| Исходный тип | Целевой тип | Способ приведения для переменной `x` | `Пример` |\n",
    "| -------- | -------- | ------ | ------ |\n",
    "| `int`, `float`, `str`, `bytes` | `bool` | `bool(x)` | `bool(42)` |\n",
    "| `bool`, `str` | `int` | `int(x)` | `int(\"42\")` |\n",
    "| `float` | `int` | `round(x)` | `round(123.456)` |\n",
    "| `bytes` | `int` | `struct.unpack(fmt, x)` | `struct.unpack('I',b'\\x2f\\x00\\x00\\x00')[0]` |\n",
    "| `bool`, `int`, `str` | `float` |  `float(x)` | `float(\"3.4\")` |\n",
    "| `bool`, `int`, `str` | `bytes` |  `struct.unpack(fmt,x)` | `struct.unpack('f',b'\\xc3\\xf5H@'')[0]` |\n",
    "| `bool`, `int`, `float` | `str` | `str(x)` |  |\n",
    "| `int` | `str` | `fmt % x` | `'%04d' % x` |\n",
    "| `float` | `str` | `fmt % x` | `'%6.2f' % x` |\n",
    "| `bytes` | `str` | `x.decode(encoding)` | `x.decode('utf8')` |"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ad781b89-826c-40f9-9e1f-124e6a7873e2",
   "metadata": {},
   "source": [
    "## Функция print"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1a1b0981-96f4-456c-9ce4-812cb95b867b",
   "metadata": {},
   "source": [
    "Функция `print` — печатает текст в консоли. Принимает произвольное число аргументов, производного типа, если аргумент не строка, то у него вызывается метод `__str__()`, а при отсутствии потом `__repr__()` (есть у всех переменных всех типов). Таким образом `print` так или иначе выведет на печать переменную любого типа."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "0c8ffab2-d50f-44c3-9421-1b2c07dd4b8a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "тест: 24 - 3.158 <built-in function print>\n"
     ]
    }
   ],
   "source": [
    "print(\"тест:\", 24 , \"-\", 3.158, print)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d4fd4a5b-1b88-4201-84fb-a85f9592b4e5",
   "metadata": {},
   "source": [
    "Важнейшие дополнительные аргументы: `sep` — разделитель между аргументами (по умолчанию — пробел) и `end` — конец строки, по умолчанию `\\n`. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "5f19b87d-d6c4-4a94-b472-80720c97faa7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "a;1;b;2<==\n"
     ]
    }
   ],
   "source": [
    "print('a', 1, 'b', '2', sep=';', end='<==\\n')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "49fc5d44-ae6d-4950-bbfd-7023a846b2b1",
   "metadata": {},
   "source": [
    "## Условия и циклы\n",
    "\n",
    "Одной из главных особенностей Python является использование пробелов для оформления блоков операторов: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "da00f178-7d1e-4d28-9a54-50120acd7724",
   "metadata": {},
   "outputs": [],
   "source": [
    "if a > 0:\n",
    "    b = 2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ca146c02-eb20-475c-b27e-7fb0f0c39554",
   "metadata": {},
   "source": [
    "### Условный оператор if"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f8e3b5fc-f431-4ed2-be64-3ff6f1b13101",
   "metadata": {},
   "source": [
    "```\n",
    "if 〖логическое выражение〗:\n",
    "    〖операторы〗\n",
    "else:\n",
    "    〖операторы〗\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "188d8eb6-dabd-44f9-9ad1-dbb8c2e6d0b5",
   "metadata": {},
   "source": [
    "Примеры:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "dac1d07d-6e07-47bf-b53e-ce6eb2e4d179",
   "metadata": {},
   "outputs": [],
   "source": [
    "a,b,c = 1,2,3\n",
    "\n",
    "if a > 0:\n",
    "    b = 2\n",
    "else:\n",
    "    b = 3\n",
    "    print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b4bfa90e-a1ce-4835-a963-ce7d0229a0ad",
   "metadata": {},
   "outputs": [],
   "source": [
    "if a > 0:\n",
    "    if c > 0:\n",
    "        print(\"a > 0 и c > 0\")\n",
    "\n",
    "if a > 0 and c > 0:\n",
    "    print(\"a > 0 и c > 0\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2ef50c4e-dde5-49e3-8607-7e9dfed54ab5",
   "metadata": {},
   "outputs": [],
   "source": [
    "if a > 0:\n",
    "    print(\"a > 0\")\n",
    "elif a >= -2:\n",
    "    print(\"a >= -2\")\n",
    "else:\n",
    "    print(\"a < -2\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8a08de62-0647-4847-92d3-3c5533cbc635",
   "metadata": {},
   "source": [
    "### Условный цикл while"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9faba322-bf06-4e7e-8893-844f3fadabcf",
   "metadata": {},
   "source": [
    "```\n",
    "while 〖логическое выражение〗:\n",
    "    〖операторы〗\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1e2b30e0-4b83-47e4-bc81-b245d4535263",
   "metadata": {},
   "source": [
    "Примеры: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "344acae6-f52f-403c-81dd-7e701b5c258f",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 5\n",
    "while x > 0:\n",
    "    print(x)\n",
    "    x = x - 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "990f66f8-a12e-4031-a629-78e8ab766598",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 5\n",
    "while True:\n",
    "    print(x)\n",
    "    if x < 0:\n",
    "        break\n",
    "    x = x - 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "af4c4858-81be-4c73-ac8b-fb88bfb6b772",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 5\n",
    "while x > -3:\n",
    "    x = x - 1\n",
    "    if x > 0:\n",
    "        continue\n",
    "    print(x)    "
   ]
  }
 ],
 "metadata": {
  "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.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}