python_lectures/python_lesson_part_2.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "bc1c968d",
   "metadata": {},
   "source": [
    "## Содержание:\n",
    "- Операторы и операнды\n",
    "- Условные конструкции\n",
    "- Встроенные функции\n",
    "- Аргументы по умолчанию\n",
    "- Детерминированность\n",
    "- Библиотеки и модули\n",
    "- Встроенные модули\n",
    "- Ключевое слово as\n",
    "- Особенности импорта модулей\n",
    "- Пример использования модуля Стандартной библиотеки Python. Сигнатура функции\n",
    "- Импорт отдельных компонентов модуля\n",
    "- Импорт под псевдонимом"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2fda1f05",
   "metadata": {},
   "source": [
    "# Операторы и операнды\n",
    "\n",
    "Ранее мы изучили булевы переменные. Их особенность в том, что они могут принимать всего два значения:\n",
    "\n",
    "- True, которое можно сравнить с 1;\n",
    "- False, которое сравнимо с 0.\n",
    "\n",
    "`Операторы` – это некий функционал, производящий какие-либо действия, который может быть представлен в виде символов, например «+», или специальных зарезервированных слов.\n",
    "\n",
    "Операторы могут производить некоторые действия над данными, и эти данные называются `операндами`.\n",
    "\n",
    "![Ошибка загрузки](https://github.com/akazachkov/python_notebook/blob/master/python_lectures/_add_material_lesson_python/03.png?raw=true)\n",
    "![Ошибка загрузки](https://github.com/akazachkov/python_notebook/blob/master/python_lectures/_add_material_lesson_python/04.jpg?raw=true)\n",
    "\n",
    "Пусть у нас есть данные о росте трех студентов в метрах (тип float). Для хранения этих данных используются три переменные:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3fb38a60",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Создаём 3 переменные, в которых содержится рост трех студентов\n",
    "\n",
    "student_01 = 1.64\n",
    "student_02 = 1.79\n",
    "student_03 = 1.79"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c31c1cd",
   "metadata": {},
   "source": [
    "Давайте сравним рост студентов. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d87f59f8",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Проверяем равенство роста 1 и 2 студента\n",
    "print(student_01 == student_02)\n",
    "# False\n",
    "\n",
    "# Проверяем равенство роста 2 и 3 студента\n",
    "print(student_02 == student_03)\n",
    "# True"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ef9b3f6a",
   "metadata": {},
   "source": [
    "# Условные конструкции\n",
    "\n",
    "Условные конструкции – конструкции с операторами условия. Условная конструкция обычно предполагает «развилку»: если условие выполняется, то должен выполняться один набор действий, если нет – другой набор действий.\n",
    "\n",
    "![Ошибка загрузки](https://github.com/akazachkov/python_notebook/blob/master/python_lectures/_add_material_lesson_python/05.png?raw=true)\n",
    "\n",
    "Напишем программу, которая будет просить пользователя ввести целое число, и если это число менее 10, на экран будет выводиться сообщение \"Меньше 10\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "71342c94",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = int(input(\"Введите число: \"))\n",
    "\n",
    "if x < 10:\n",
    "    print('Меньше 10')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8304ec90",
   "metadata": {},
   "source": [
    "Теперь дополним программу, она будет просить пользователя ввести целое число, и если это число менее 10, на экран будет выводиться сообщение \"Меньше 10\", иначе – \"Больше 10\". Это конструкция `if-else`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d1731bbf",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = int(input(\"Введите число: \"))\n",
    "\n",
    "if x < 10:\n",
    "    print(\"Меньше 10\")\n",
    "else:\n",
    "    print(\"Больше 10\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6c179797",
   "metadata": {},
   "source": [
    "В части с if мы прописываем условие, в зависимости от которого Python будет делать выбор, что выводить на экран, а после двоеточия перечисляем действия, которые будут выполняться в случае, если x удовлетворяет условию. В части с else мы уже не пишем никакого условия – оператор else сам по себе означает «в случае, если условие в выражении с if не выполнено».\n",
    "\n",
    "Часть с else является необязательной: программа может существовать только с условием if. Тогда в случае невыполнения условия ничего происходить не будет, Python просто перейдет к следующим строкам кода.\n",
    "\n",
    "Как быть, если условий несколько? Например, мы просим пользователя ввести число, и если число больше 10, на экране должно быть сообщение \"Больше 10\", если ровно 10 – \"Равно 10\", если меньше – \"Меньше 10\". Условные конструкции можно вкладывать друг друга, главное не забывать при этом про отступы.\n",
    "\n",
    "Сдвигать части кода можно при помощи горячих клавиш:\n",
    "\n",
    "    Ctrl + ] -- вправо\n",
    "    Ctrl + [ -- влево"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "32dbee29",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = int(input(\"Введите число: \"))\n",
    "\n",
    "if x < 10:\n",
    "    print(\"Меньше 10\")\n",
    "else:\n",
    "    if x == 10:\n",
    "        print(\"Равно 10\")\n",
    "    else: \n",
    "        print(\"Больше 10\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "90c003d8",
   "metadata": {},
   "source": [
    "Можно воспользоваться оператором `elif`, который по смыслу является сочетанием `else + if`: если предыдущее условие невыполнено, то, нужно проверить следующее условие, и если оно тоже не выполнено, то уже перейти к ветке с else.\n",
    "\n",
    "![Ошибка загрузки](https://github.com/akazachkov/python_notebook/blob/master/python_lectures/_add_material_lesson_python/06.png?raw=true)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a8871cce",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = int(input(\"Введите число: \"))\n",
    "\n",
    "if x < 10:\n",
    "    print(\"Меньше 10\")\n",
    "elif x == 10:\n",
    "    print(\"Равно 10\")\n",
    "else: \n",
    "    print(\"Больше 10\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9e0ece2a",
   "metadata": {},
   "source": [
    "Ответвлений с elif может быть несколько: сколько условий, столько и выражений с elif.\n",
    "\n",
    "Законный вопрос: а можно ли обойтись совсем без elif, просто записав несколько выражений с if? Тут все зависит от ситуации. Иногда решения использовать elif и if, не меняя остальной код, будут равнозначными. Если мы перепишем код в примере выше, заменив elif на if, ничего не изменится, так как условия будут проверяться последовательно в любом случае: если число меньше 10, будет выведено слово «Мало», если нет – программа перейдет к следующему условию, и так далее.\n",
    "\n",
    "В случае, когда условия как-то связаны между собой, нужно быть более внимательными к порядку заданных условий. Рассмотрим такой пример.\n",
    "\n",
    "**Случай 1.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bada8193",
   "metadata": {},
   "outputs": [],
   "source": [
    "mark = int(input(\"Введите оценку: \"))\n",
    "\n",
    "if mark < 6:\n",
    "    print(\"Плохо\")\n",
    "elif mark == 10:\n",
    "    print(\"Отлично\")\n",
    "elif mark < 10:\n",
    "    print(\"Это нормально\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5187a3fe",
   "metadata": {},
   "source": [
    "Если оценка меньше 10, мы выводим на экран сообщение \"Это нормально\", если нет, то проверяем, равна ли она 10: если да, то выводим \"Отлично\", если нет – ничего не делаем. При этом, *после* всех этих действий делаем дополнительную проверку: если оценка меньше 6, выводим \"Плохо\".\n",
    "\n",
    "**Случай 2.**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8120f9f9",
   "metadata": {},
   "outputs": [],
   "source": [
    "if mark == 10:\n",
    "    print(\"Отлично\")\n",
    "elif mark < 10:\n",
    "    print(\"Это нормально\")\n",
    "elif mark < 6:\n",
    "    print(\"Плохо\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "93282371",
   "metadata": {},
   "source": [
    "Если оценка меньше 10, мы выводим на экран сообщение \"Это нормально\", если нет, то проверяем, равна ли она 10: если да, то выводим \"Отлично\", если нет – сравниваем ее с 6. Если оценка меньше 6, выводим \"Плохо\".\n",
    "\n",
    "Во втором случае не вывелось сообщение \"Плохо\" потому что из-за второго elif мы попросту до него не дошли.\n",
    "\n",
    "Напишем программу по переводу из 10-балльной шкалы в 5-балльную: оценка 8-10 баллов – «отлично», 6 - 7 – «хорошо», 4 - 5 – «удовлетворительно», ниже 4 – «плохо».\n",
    "\n",
    "**Решение 1:** несколько вложенных условий с оператором `elif`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "648d818d",
   "metadata": {},
   "outputs": [],
   "source": [
    "grade = 10\n",
    "\n",
    "if grade > 7:\n",
    "    print(\"Отлично\")\n",
    "elif grade > 5:\n",
    "    print(\"Хорошо\")\n",
    "elif grade > 3:\n",
    "    print(\"Удовлетворительно\")\n",
    "else:\n",
    "    print(\"Плохо\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f98558e4",
   "metadata": {},
   "source": [
    "**Решение 2:** несколько сложных условий с `if`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dd18913d",
   "metadata": {},
   "outputs": [],
   "source": [
    "grade = 7\n",
    "\n",
    "if grade > 7:\n",
    "    print(\"Отлично\")\n",
    "if (grade > 5) and (grade <= 7):\n",
    "    print(\"Хорошо\")\n",
    "if (grade > 3) and (grade <= 5):\n",
    "    print(\"Удовлетворительно\")\n",
    "if grade <= 3:\n",
    "    print(\"Плохо\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bd926ebf",
   "metadata": {},
   "source": [
    "Могли бы мы использовать `else` вместо последнего условия с `if`? Проверим:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7c325a0b",
   "metadata": {},
   "outputs": [],
   "source": [
    "grade = 7\n",
    "\n",
    "if grade > 7:\n",
    "    print(\"Отлично\")\n",
    "if (grade > 5) and (grade <= 7):\n",
    "    print(\"Хорошо\")\n",
    "if (grade > 3) and (grade <= 5):\n",
    "    print(\"Удовлетворительно\")\n",
    "else:\n",
    "    print(\"Плохо\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f847f5ea",
   "metadata": {},
   "source": [
    "### Задача\n",
    "\n",
    "Реализуeм следующую программу:\n",
    "\n",
    "* В переменную time считывается целое число (время суток от 0 до 24).\n",
    "* Если время от 8 до 22 включительно, то программа печатает \"Бодрствуем!\", иначе – \"Время спать!\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7ad0a613",
   "metadata": {},
   "outputs": [],
   "source": [
    "time = int(input())\n",
    "\n",
    "if 8 <= time <= 22:\n",
    "    print(\"Бодрствуем!\")\n",
    "else:\n",
    "    print(\"Время спать!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "12b4b63b",
   "metadata": {},
   "source": [
    "### Задача\n",
    "\n",
    "Распродажа\n",
    "\n",
    "В магазине проходит акция:\n",
    "\n",
    "- На все товары за 1000 рублей и дешевле скидка 15%\n",
    "- На все товары дороже 1000, но не дороже 5000 рублей скидка 20%\n",
    "- На все товары дороже 5000 рублей скидка 25%\n",
    "\n",
    "**Ввод**\n",
    "\n",
    "    Целое неотрицательное число – цена товара в рублях\n",
    "\n",
    "**Вывод**\n",
    "\n",
    "    Целое неотрицательное число – скидка на товар в рублях"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "473f0a16",
   "metadata": {},
   "outputs": [],
   "source": [
    "price = int(input())\n",
    "\n",
    "if price <= 1000:\n",
    "    print(int(price * 0.15))\n",
    "elif price <= 5000:\n",
    "    print(int(price * 0.2))\n",
    "else:\n",
    "    print(int(price * 0.25))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "638b4973",
   "metadata": {},
   "source": [
    "### Задача\n",
    "\n",
    "Разовая поездка на метро стоит 70 рублей, проездной на 30 дней – 2500 рублей. Валя подсчитала, сколько она совершает поездок за 30 дней, помогите ей понять, чем выгоднее пользоваться – проездным или разовыми поездками. \n",
    "\n",
    "**Ввод** \n",
    "\n",
    "    Целое положительное число – количество поездок Вали на метро за 30 дней\n",
    "\n",
    "**Вывод** \n",
    "\n",
    "    Строка \"Выгоднее разовые поездки\" или \"Выгоднее проездной\" в зависимости от того, что выгоднее."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a296fc51",
   "metadata": {},
   "outputs": [],
   "source": [
    "n = int(input())\n",
    "\n",
    "if n * 70 < 2500:\n",
    "    print(\"Выгоднее разовые поездки\")\n",
    "else:\n",
    "    print(\"Выгоднее проездной\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e17baf56",
   "metadata": {},
   "source": [
    "### Задача\n",
    "\n",
    "Вводятся 4 числа – координаты клеток на шахматной доске. Если они одного цвета, то выводит YES, если разного – то NO. Если нарисовать доску, то закономерность будет видна – если вычислить остаток от деления на 2 суммы или разницы координат клетки, будет ясно, что у белых клеток остаток будет 1, а у чёрных – 0."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "72de173d",
   "metadata": {},
   "outputs": [],
   "source": [
    "v1 = int(input())\n",
    "g1 = int(input())\n",
    "v2 = int(input())\n",
    "g2 = int(input())\n",
    "\n",
    "x = (v1 - g1) % 2\n",
    "y = (v2 - g2) % 2\n",
    "\n",
    "if x == y:\n",
    "    print('YES')\n",
    "else:\n",
    "    print('NO')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "25cb95dc",
   "metadata": {},
   "source": [
    "### Задача\n",
    "\n",
    "Шахматный король ходит по горизонтали, вертикали и диагонали, но только на 1 клетку. Даны две различные клетки шахматной доски, определите, может ли король попасть с первой клетки на вторую одним ходом. На входе четыре числа от 1 до 8 каждое – номер столбца и номер строки сначала для первой, потом для второй клетки. Необходимо вывести YES, если из первой клетки ходом короля можно попасть во вторую или NO, в противном случае."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "822d47d6",
   "metadata": {},
   "outputs": [],
   "source": [
    "v1 = int(input())\n",
    "g1 = int(input())\n",
    "v2 = int(input())\n",
    "g2 = int(input())\n",
    "\n",
    "if (v1 - 1) == v2 or (v1 == v2) or (v1 + 1) == v2:\n",
    "    if (g1 - 1) == g2 or (g1 == g2) or (g1 + 1) == g2:\n",
    "        print('YES')\n",
    "    else:\n",
    "        print('NO')\n",
    "else:\n",
    "    print('NO')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "22d0a415",
   "metadata": {},
   "source": [
    "### Задача\n",
    "\n",
    "Дано три числа. Упорядочите их в порядке неубывания. Программа должна считывать три числа a,b,c, затем необходимо менять их значения так, чтобы стали выполнены условия a≤b≤c и вывести тройку a,b,c. Дополнительное ограничение: нельзя использовать дополнительные переменные."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "337ddeb2",
   "metadata": {},
   "outputs": [],
   "source": [
    "a, b, c = int(input()), int(input()), int(input())\n",
    "\n",
    "if a <= b <= c:\n",
    "    print(a, b, c)\n",
    "elif b <= a <= c:\n",
    "    print(b, a, c)\n",
    "elif c <= a <= b:\n",
    "    print(c, a, b)\n",
    "elif b <= c <= a:\n",
    "    print(b, c, a)\n",
    "elif c <= b <= a:\n",
    "    print(c, b, a)\n",
    "elif a <= c <= b:\n",
    "    print(a, c, b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b56edc9d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Результат применения функции (a,b)=(b,a):\n",
    "\n",
    "a = 2\n",
    "b = 1\n",
    "a, b = b, a\n",
    "print(a, b)  # Выведет 1 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4bed5077",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Вышенаписанная задача решена с применением функции (a,b)=(b,a):\n",
    "\n",
    "a, b, c = int(input()), int(input()), int(input())\n",
    "\n",
    "if a <= b <= c:\n",
    "    print(a, b, c)\n",
    "elif a <= c <= b:\n",
    "    (c, b) = (b, c)\n",
    "    print(a, b, c)\n",
    "elif b <= a <= c:\n",
    "    (b, a) = (a, b)\n",
    "    print(a, b, c)\n",
    "elif b <= c <= a:\n",
    "    (b, a) = (a, b)\n",
    "    (c, b) = (b, c)\n",
    "    print(a, b, c)\n",
    "elif c <= b <= a:\n",
    "    (c, a) = (a, c)\n",
    "    print(a, b, c)\n",
    "elif c <= a <= b:\n",
    "    (c, a) = (a, c)\n",
    "    (b, c) = (c, b)\n",
    "    print(a, b, c)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "986c917c",
   "metadata": {},
   "source": [
    "### Задача\n",
    "\n",
    "За многие годы заточения узник замка Иф проделал в стене прямоугольное отверстие размером D×E. Замок Иф сложен из кирпичей, размером A×B×C. Определите, сможет ли узник выбрасывать кирпичи в море через это отверстие (очевидно, стороны кирпича должны быть параллельны сторонам отверстия).\n",
    "\n",
    "Для решения необходимо сначало упорядочить размеры кирпича в порядке возрастания, затем сравнить с дырой в стене."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4934a3f7",
   "metadata": {},
   "outputs": [],
   "source": [
    "a, b, c = int(input()), int(input()), int(input())\n",
    "d, e = int(input()), int(input())\n",
    "\n",
    "if a <= c <= b:\n",
    "    (c, b) = (b, c)\n",
    "elif b <= a <= c:\n",
    "    (b, a) = (a, b)\n",
    "elif b <= c <= a:\n",
    "    (b, a) = (a, b)\n",
    "    (c, b) = (b, c)\n",
    "elif c <= b <= a:\n",
    "    (c, a) = (a, c)\n",
    "elif c <= a <= b:\n",
    "    (c, a) = (a, c)\n",
    "    (b, c) = (c, b)\n",
    "if (a <= d and b <= e) or (a <= d and c <= e) or (b <= d and c <= e):\n",
    "    print('YES')\n",
    "else:\n",
    "    print('NO')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "221a0fe8",
   "metadata": {},
   "source": [
    "### Задача\n",
    "\n",
    "Есть две коробки, первая размером A₁×B₁×C₁, вторая размером A₂×B₂×C₂. Определите, можно ли разместить одну из этих коробок внутри другой, при условии, что поворачивать коробки можно только на 90 градусов вокруг ребер. На входе числа A₁,B₁,C₁,A₂,B₂,C₂. Программа должна вывести одну из следующих строчек: Boxes are equal, если коробки одинаковые.\n",
    "\n",
    "The first box is smaller than the second one, если первая коробка может быть положена во вторую.\n",
    "\n",
    "The first box is larger than the second one, если вторая коробка может быть положена в первую.\n",
    "\n",
    "Boxes are incomparable, во всех остальных случаях.\n",
    "\n",
    "Важно иметь ввиду, что в математической вселенной, если некоторые стороны коробок равны - они могут быть помещены друг в друга.\n",
    "\n",
    "тест 1 – 1, 2, 3, 3, 2, 1 – вывод 'Boxes are equal'\n",
    "\n",
    "тест 2 – 2, 2, 3, 3, 2, 1 – вывод 'The first box is larger than the second one'\n",
    "\n",
    "Для начала упорядочиваем размеры сторон коробок в порядке возрастания, затем перебором сравниваем их."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "193542c6",
   "metadata": {},
   "outputs": [],
   "source": [
    "a1, b1, c1 = int(input()), int(input()), int(input())\n",
    "a2, b2, c2 = int(input()), int(input()), int(input())\n",
    "\n",
    "if a1 <= c1 <= b1:\n",
    "    (c1, b1) = (b1, c1)\n",
    "elif b1 <= a1 <= c1:\n",
    "    (b1, a1) = (a1, b1)\n",
    "elif b1 <= c1 <= a1:\n",
    "    (b1, a1) = (a1, b1)\n",
    "    (c1, b1) = (b1, c1)\n",
    "elif c1 <= b1 <= a1:\n",
    "    (c1, a1) = (a1, c1)\n",
    "elif c1 <= a1 <= b1:\n",
    "    (c1, a1) = (a1, c1)\n",
    "    (b1, c1) = (c1, b1)\n",
    "if a2 <= c2 <= b2:\n",
    "    (c2, b2) = (b2, c2)\n",
    "elif b2 <= a2 <= c2:\n",
    "    (b2, a2) = (a2, b2)\n",
    "elif b2 <= c2 <= a2:\n",
    "    (b2, a2) = (a2, b2)\n",
    "    (c2, b2) = (b2, c2)\n",
    "elif c2 <= b2 <= a2:\n",
    "    (c2, a2) = (a2, c2)\n",
    "elif c2 <= a2 <= b2:\n",
    "    (c2, a2) = (a2, c2)\n",
    "    (b2, c2) = (c2, b2)\n",
    "    \n",
    "# print(a1, b1, c1)  # Проверяем корректность работы функции (a,b)=(b,a)\n",
    "# print(a2, b2, c2)  # Проверяем корректность работы функции (a,b)=(b,a)\n",
    "\n",
    "if (a1 <= a2) and (b1 <= b2) and (c1 < c2):\n",
    "    print('The first box is smaller than the second one')\n",
    "elif (a1 <= a2) and (b1 < b2) and (c1 <= c2):\n",
    "    print('The first box is smaller than the second one')\n",
    "elif (a1 < a2) and (b1 < b2) and (c1 <= c2):\n",
    "    print('The first box is smaller than the second one')\n",
    "elif (a1 == a2) and (b1 == b2) and (c1 == c2):\n",
    "    print('Boxes are equal')\n",
    "elif (a1 >= a2) and (b1 >= b2) and (c1 > c2):\n",
    "    print('The first box is larger than the second one')\n",
    "elif (a1 >= a2) and (b1 > b2) and (c1 >= c2):\n",
    "    print('The first box is larger than the second one')\n",
    "elif (a1 > a2) and (b1 >= b2) and (c1 >= c2):\n",
    "    print('The first box is larger than the second one')\n",
    "else:\n",
    "    print('Boxes are incomparable')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5ec8214c",
   "metadata": {},
   "source": [
    "### Задача\n",
    "\n",
    "Даны три целых числа. Определите, сколько среди них совпадающих. Программа должна вывести одно из чисел: 3 (если все совпадают), 2 (если два совпадает) или 0 (если все числа различны)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "db930bd5",
   "metadata": {},
   "outputs": [],
   "source": [
    "a, b, c = int(input()), int(input()), int(input())\n",
    "\n",
    "if a == b and a == c and b == c:\n",
    "    print(3)\n",
    "elif a == b or a == c or b == c:\n",
    "    print(2)\n",
    "else:\n",
    "    print(0)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "549f7a44",
   "metadata": {},
   "source": [
    "### Задача\n",
    "\n",
    "Шоколадка имеет вид прямоугольника, разделенного на n×m долек. Шоколадку можно один раз разломить по прямой на две части. Определите, можно ли таким образом отломить от шоколадки часть, состоящую ровно из k долек. На входе три числа: n, m, k. На выходе должно быть одно из двух слов: YES или NO."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "36b23ec8",
   "metadata": {},
   "outputs": [],
   "source": [
    "n = int(input())\n",
    "m = int(input())\n",
    "k = int(input())\n",
    "\n",
    "if k < n * m:\n",
    "    if k % n == 0 or k % m == 0:\n",
    "        print('YES')\n",
    "    else:\n",
    "        print('NO')\n",
    "else:\n",
    "    print('NO')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "77a74690",
   "metadata": {},
   "source": [
    "### Задача\n",
    "\n",
    "Дано натуральное число. Требуется определить, является ли год с данным номером високосным. Если год является високосным, то выведите YES, иначе выведите NO. Напомним, что в соответствии с григорианским календарем, год является високосным, если его номер кратен 4, но не кратен 100, или же если он кратен 400."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "12914222",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = int(input())\n",
    "\n",
    "if a % 400 == 0:\n",
    "    print('YES')\n",
    "else:\n",
    "    if a % 100 == 0:\n",
    "        print('NO')\n",
    "    else:\n",
    "        if a % 4 == 0:\n",
    "            print('YES')\n",
    "        else:\n",
    "                print('NO')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4dc19a32",
   "metadata": {},
   "source": [
    "### Задача\n",
    "\n",
    "Для данного числа 0<=n<=100 закончите фразу \"У меня на этой неделе...\" одним из возможных продолжений: \"n дедлайн\", \"n дедлайна\", \"n дедлайнов\", правильно склоняя слово \"дедлайн\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "63369357",
   "metadata": {},
   "outputs": [],
   "source": [
    "n = int(input())\n",
    "\n",
    "if (11 <= n <= 14) or (5 <= n % 10 <= 9) or (n % 10 == 0):\n",
    "    print(n, \"дедлайнов\")\n",
    "elif n % 10 == 1:\n",
    "    print(n, \"дедлайн\")\n",
    "else:\n",
    "    print(n, \"дедлайна\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3cf9fe11",
   "metadata": {},
   "source": [
    "Похожая задача – для данного числа n<100 закончите фразу “На лугу пасется...” одним из возможных продолжений: “n коров”, “n корова”, “n коровы”, правильно склоняя слово “корова”. Программа должна вывести введенное число n и одно из слов: korov, korova или korovy. Между числом и словом должен стоять ровно один пробел."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a79b7e1c",
   "metadata": {},
   "outputs": [],
   "source": [
    "n = int(input())\n",
    "\n",
    "if n > 20 and 2 <= (n % 10) <= 4:\n",
    "    print(n, 'korovy')\n",
    "elif n % 10 == 1 and n != 11:\n",
    "    print(n, 'korova')\n",
    "elif n < 10 and 2 <= (n % 10) <= 4:\n",
    "    print(n, 'korovy')\n",
    "else:\n",
    "    print(n, 'korov')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a8456a8d",
   "metadata": {},
   "source": [
    "# Встроенные функции\n",
    "\n",
    "Сложение, конкатенация, нахождение остатка от деления и остальные рассмотренные операции – это базовые возможности языков программирования. Математика не ограничена арифметикой, кроме нее есть и другие разделы со своими операциями – например, геометрия. То же самое касается и строк: их можно переворачивать, менять регистр букв, удалять лишние символы – и это только самое простое.\n",
    "\n",
    "Еще на более высоком уровне есть прикладная логика конкретного приложения. Программы списывают деньги, считают налоги, формируют отчеты. Количество подобных операций бесконечно и индивидуально для каждой программы. И их нужно уметь выражать в коде.\n",
    "\n",
    "Чтобы выразить любую произвольную операцию, в программировании существует понятие функция. \n",
    "\n",
    "**Функция** – одна из ключевых конструкций в программировании. Без них невозможно сделать практически ничего. Знакомство с ними нужно начинать как можно раньше, так как весь дальнейший материал оперирует функциями по максимуму. Сначала мы научимся пользоваться уже созданными функциями, а потом научимся создавать собственные.\n",
    "\n",
    "Функции бывают встроенные и добавленные программистом. Выше мы познакомились с несколькими:\n",
    "\n",
    "`print` –  выводит свои аргументы на экран. Функция может принимать не один аргумент, а сколько угодно. Несколько аргументов одной функции следует разделять запятыми.\n",
    "\n",
    "`input` – тоже функция, может работать, не принимая никаких аргументов, а может в качестве аргумента принимать сообщение, которое надо вывести перед ожиданием пользовательского ввода. Но всегда считывает строку с клавиатуры и возвращает ее.\n",
    "\n",
    "`str` – переводит объект в строку\n",
    "\n",
    "`int` – преобразовывает к типу integer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8b3b9d2a",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(int(20.5 + 34.1))  # Дробная часть отбрасывается"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e72f5998",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(int(input()) + 1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f0131477",
   "metadata": {},
   "source": [
    "`float` поможет, если строка, которую надо конвертировать в число, не является целым числом"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a7200210",
   "metadata": {},
   "outputs": [],
   "source": [
    "pi_digits = '3.141592653589793238462643383279502884197169399375'\n",
    "print(float(pi_digits))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7c88a020",
   "metadata": {},
   "source": [
    "`len()` – определяет длину строки (количества символов в стоке)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0a159e30",
   "metadata": {},
   "outputs": [],
   "source": [
    "word = input()\n",
    "length = len(word)\n",
    "print('Вы ввели слово длиной', length, 'букв.')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f85dbf7b",
   "metadata": {},
   "source": [
    "`type()` – возвращает тип объекта, который вы ей передаете"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "90c5268f",
   "metadata": {},
   "outputs": [],
   "source": [
    "type(True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e6b1c9aa",
   "metadata": {},
   "source": [
    "`help()` – хотите знать, как работает определённый объект, метод или атрибут, функция help поможет вам"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6d24b437",
   "metadata": {},
   "outputs": [],
   "source": [
    "?print"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "75d3b607",
   "metadata": {},
   "outputs": [],
   "source": [
    "help(print)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "48b57d9d",
   "metadata": {},
   "source": [
    "Использование в программе функции называется вызов функции, а данные, записанные в круглых скобках – аргументами. После выполнения работы на место вызова функции (то есть имени функции и ее аргументов в скобках) подставляется результат ее работы, это называется возвращаемое значение функции."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9d36a550",
   "metadata": {},
   "source": [
    "# Аргументы по умолчанию\n",
    "Посмотрим на примере функции `round()`, которая используется для так называемого \\\"банковского округления\\\", то есть округление к ближайшему чётному:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e3f6cdf1",
   "metadata": {},
   "outputs": [],
   "source": [
    "round(3.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3996aff8",
   "metadata": {},
   "outputs": [],
   "source": [
    "round(2.5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7d330b76",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(round(2.6))\n",
    "print(round(3.1))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b3b6f7d5",
   "metadata": {},
   "source": [
    "Если нужна другая точность, до определённого знака после запятой, то можно передать второй параметр:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1e47d04e",
   "metadata": {},
   "outputs": [],
   "source": [
    "round(10.25, 0)  # 0 означает, что округление будет до целого значения"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2dabd0c9",
   "metadata": {},
   "outputs": [],
   "source": [
    "round(10.25, 1)  # Округление до одного знака после запятой"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ed38d1fc",
   "metadata": {},
   "source": [
    "Чаще всего нужно округлять именно до целого числа, а не до десятых. Поэтому создатели функции round сделали второй параметр **необязательным** и задали ему внутри функции **значение по умолчанию** 0.\n",
    "\n",
    "Если функция в Python принимает необязательные аргументы, то они всегда стоят после обязательных. Их количество может быть любым. Это зависит от самой функции, но они всегда идут рядом и в конце списка аргументов."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f8fac0b6",
   "metadata": {},
   "source": [
    "# Детерминированность\n",
    "\n",
    "У функций внутри каждого языка программирования есть фундаментальные свойства. Эти свойства помогают прогнозировать поведение функций, способы их тестирования и место использования. К таким свойствам относится детерминированность.\n",
    "\n",
    "`Детерминированная функция` возвращает один и тот же результат для одинаковых входных параметров. Например, детерминированной можно назвать функцию, которая считает количество символов:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "01797bdb",
   "metadata": {},
   "outputs": [],
   "source": [
    "len('wow')  # Результат – 3"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "434dab2b",
   "metadata": {},
   "source": [
    "Можно бесконечно вызывать эту функцию и передавать туда значение 'wow' – она всегда вернет 3.\n",
    "\n",
    "Посмотрим и обратный случай – `недетерминированные функции`. Например, к этой категории относится функция, которая возвращает случайное число: у одного и того же входа мы получим всегда разный результат. Если хотя бы один из миллиона вызовов функция вернет другой результат, она считается недетерминированной. Это работает и в том случае, если параметры не принимаются:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "edcc8bbf",
   "metadata": {},
   "outputs": [],
   "source": [
    "from random import random\n",
    "\n",
    "# Функция, которая возвращает случайное число\n",
    "random()  # Результат, например – 0.09856613113197676\n",
    "random()  # Результат, например – 0.8839904367241888"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "318e0a94",
   "metadata": {},
   "source": [
    "Детерминированность – это важное свойство функции, так как она влияет на многие аспекты. Например, детерминированные функции удобны в работе – их легко оптимизировать и тестировать. Если возможно, то лучше сделать функцию детерминированной."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "637efb4b",
   "metadata": {
    "id": "aeCztTKUEUMg"
   },
   "source": [
    "# Библиотеки и модули\n",
    "\n",
    "Если несколько функций позволяют решать схожие задачи, то их объединяют в **модули**.  Например, модуль `math` объединяет в себе математические функции , модуль `string` предназначен для работы со строками, модуль `random` предлагает функции для генерации псевдослучайных чисел.\n",
    "\n",
    "Эти модули и многие другие объединены в **Стандартную библиотеку Python**. Эта библиотека поставляется в составе Python, ее не нужно отдельно скачивать и устанавливать. Библиотека и входящие в нее модули описана в документации: https://docs.python.org/3/library/.\n",
    "\n",
    "Рассмотрим модули Стандартной библиотеки Python.\n",
    "\n",
    "# Встроенные модули\n",
    "\n",
    "Стандартных библиотек, входящей в комплект Python, уже достаточно для многих реализации множества действий. Стандартным библиотекам посвящен целый раздел документации: https://docs.python.org/3/library/\n",
    "\n",
    "Чтобы воспользоваться функциями, в составе каких-либо модулей, их необходимо подключить – импортировать. За импорт в Python отвечает директива `import`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "914c60a1",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy\n",
    "print(numpy.pi)  # Вызов конкретной функции из импортированной библиотеки"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "99dd9ef1",
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import pi  # Возьмем число пи из библиотеки math\n",
    "print(pi)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "af7d98a5",
   "metadata": {},
   "outputs": [],
   "source": [
    "!pip install opencv-python  # Команда установки новой библиотеки opencv-python"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bea2ee52",
   "metadata": {},
   "source": [
    "Если ошибка pip.\n",
    "\n",
    "Откройте Anaconda, далее нужно открыть терминал и вести команду:\n",
    "\n",
    "python -m pip install --upgrade pip\n",
    "\n",
    "![Ошибка загрузки](https://github.com/akazachkov/python_notebook/blob/master/python_lectures/_add_material_lesson_python/07.png?raw=true)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2aa8d6c0",
   "metadata": {},
   "source": [
    "# Ключевое слово as"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d4415fb5",
   "metadata": {},
   "outputs": [],
   "source": [
    "import math as m  # После данной команды, вместо math.log, можно писать более кратко:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cc8b7a14",
   "metadata": {},
   "outputs": [],
   "source": [
    "m.log(80)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d11a9402",
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import log  # Импортировав функцию log, указывать через точку имя библиотеки math, больше не нужно:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "10538735",
   "metadata": {},
   "outputs": [],
   "source": [
    "log(80)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c8e9aef5",
   "metadata": {},
   "source": [
    "Модуль, переменную, класс или функцию можно при импорте назвать своим именем – для этого служит ключевое слово `as`, например:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "78b8cec4",
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import pi as число_пи\n",
    "число_пи"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "094f6eaa",
   "metadata": {},
   "source": [
    "Более того, поскольку в программе на языке Python в именах допустимы буквенные символы любых алфавитов, можно использовать даже греческие буквы (впрочем, это неудобно, если у вас кириллическо-латинская клавиатура)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e6a0a453",
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import pi as π\n",
    "print(π)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3d145cc6",
   "metadata": {},
   "source": [
    "Мы можем импортировать всю библиотеку, но тогда для доступа к ее содержимому нужно снова использовать точку:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e79a0b46",
   "metadata": {},
   "outputs": [],
   "source": [
    "import math\n",
    "print(math.pi)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cfdfa9a1",
   "metadata": {},
   "source": [
    "# Особенности импорта модулей\n",
    "\n",
    "Значения после директивы `import` можно писать через запятую:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "295214ed",
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import sin, cos, tan"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a1e090cd",
   "metadata": {},
   "outputs": [],
   "source": [
    "sin(0.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b7afda5a",
   "metadata": {},
   "source": [
    "Значок `*` означает, что из библиотеки нужно импортировать всё, что доступно."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "476983be",
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ea36746d",
   "metadata": {},
   "outputs": [],
   "source": [
    "cos(50)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a595348f",
   "metadata": {},
   "source": [
    "Но так делать не рекомендуется, поскольку при таком подходе засоряется пространство имен."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "628bdb4c",
   "metadata": {},
   "outputs": [],
   "source": [
    "help(sin)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "92488fd9",
   "metadata": {},
   "outputs": [],
   "source": [
    "help(radians)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6ec2bfb7",
   "metadata": {},
   "outputs": [],
   "source": [
    "sin(radians(90))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1037563a",
   "metadata": {},
   "outputs": [],
   "source": [
    "help(math)  # Просмотр справки по библиотеке и всех входящих в неё функций"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dabc0a9b",
   "metadata": {},
   "outputs": [],
   "source": [
    "conda list  # Команда для просмотра всех установленных библиотек и их версий"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1c922908",
   "metadata": {
    "id": "fKNEhWQKEUMk"
   },
   "source": [
    "## Пример использования модуля Стандартной библиотеки Python. Сигнатура функции\n",
    "Воспользуемся функцией `sqrt()` из модуля  `math`. Эта функция как раз вычисляет квадратный корень, попробуем ее вызвать."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4d7fc265",
   "metadata": {
    "id": "Y2qpyo4kEUMl",
    "outputId": "bceae8e7-ae5f-4a47-a501-ae88c1e91c00"
   },
   "outputs": [],
   "source": [
    "sqrt(16)  # Вызвов функцию sqrt() из модуля math"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b49cd41d",
   "metadata": {
    "id": "a3ap8pGHEUMn"
   },
   "source": [
    "Не получилось. Необходимо импортировать модуль:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "def6603d",
   "metadata": {
    "id": "XieNCrq9EUMn"
   },
   "outputs": [],
   "source": [
    "import math  # Импортируем модуль math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "31cb3cd3",
   "metadata": {
    "id": "cwYsJhZJEUMo",
    "outputId": "6406f594-59e6-488a-a8d5-e52214ac65b6"
   },
   "outputs": [],
   "source": [
    "sqrt(16)  # Снова пытаемся вызвать функцию sqrt() из модуля math, предварительно его импортировав"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ecbe7107",
   "metadata": {
    "id": "igtDQnoFEUMo"
   },
   "source": [
    " Необходимо выполнить следующее: `<модуль>.<функция()>`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6efe8802",
   "metadata": {
    "id": "85Yb61feEUMp",
    "outputId": "9c373c1c-94cc-4891-8ad1-aa734b2eccc6"
   },
   "outputs": [],
   "source": [
    "math.sqrt(16)  # снова пытаемся вызвать функцию sqrt(), указав, что это функция из модуля math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1e47bc91",
   "metadata": {},
   "outputs": [],
   "source": [
    "math.__dict__"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0969fb08",
   "metadata": {},
   "source": [
    "Функция `pow()` возводит число в степень. Она принимает два параметра: какое число возводить и в какую степень возводить. Если вызывать pow() без параметров, то Python выдаст следующее: \"TypeError: pow expected at least 2 arguments, got 0\". Интерпретатор сообщает, что функция ожидает два параметра, а вы вызвали ее без них.\n",
    "\n",
    "Функция pow() всегда имеет два обязательных параметра, поэтому ее невозможно вызвать с другим количеством параметров.\n",
    "\n",
    "Более того, параметрами pow() могут быть только числа. Например, если передать в нее пару строк, это приведет к следующей ошибке: \"TypeError: unsupported operand type(s) for ** or pow(): 'str' and 'str'\". Результат вызова функции – тоже всегда число."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b484880b",
   "metadata": {},
   "outputs": [],
   "source": [
    "math.pow(2, 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "db0ca1ef",
   "metadata": {},
   "source": [
    "Чтобы узнать подробности о конкретной функции, нужно изучать ее сигнатуру.\n",
    "\n",
    "**Сигнатура функции** – формальное описание типов аргументов и типа возвращаемого значения функции.\n",
    "\n",
    "Про функцию pow() можно почитать в [официальной документации Python](https://docs.python.org/3/library/functions.html?highlight=pow#pow) или в [неофициальной документации на русском языке](https://docs-python.ru/tutorial/vstroennye-funktsii-interpretatora-python/funktsija-pow/).\n",
    "\n",
    "Обычно документация для функции выглядит так:"
   ]
  },
  {
   "cell_type": "raw",
   "id": "338fe0c6",
   "metadata": {},
   "source": [
    "pow(x, y[, z])\n",
    "\n",
    "Возвращает x в степени y; если z присутствует, возвращает x в степени y, по модулю z "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f0d0700e",
   "metadata": {},
   "source": [
    "Первая строка здесь – это сигнатура функции. У функции два обязательных параметра – x и y. Необязательный параметр z указан в квадратных скобках. Следом поясняется, для чего функция нужна. Документация дает понять, сколько аргументов у функции и какого они типа. Также она описывает, что возвращает функция и какого типа будет возвращаемое значение."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b32c1673",
   "metadata": {
    "id": "O_RfnljHEUMq"
   },
   "source": [
    "# Импорт отдельных компонентов модуля\n",
    "\n",
    "Писать каждый раз название модуля, точку, название функции не всегда удобно. Можно явно указать, что именно необходимо импортировать из модуля."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dcb0b031",
   "metadata": {
    "id": "jb8XgX_0EUMq"
   },
   "outputs": [],
   "source": [
    "from random import randint, uniform  # Импортируем две функции из модуля random"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f059758c",
   "metadata": {
    "id": "ACVfRQPyEUMr"
   },
   "source": [
    "Чтобы узнать, что делают эти функции и какие аргументы им нужно подавать, можно посмотреть документацию или воспользоваться функцией `help()`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b543d23f",
   "metadata": {
    "id": "47l6FMnLEUMr",
    "outputId": "4bb92cc1-2559-4b59-aaaa-268acdf66256"
   },
   "outputs": [],
   "source": [
    "help(randint)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "15bc5b30",
   "metadata": {},
   "outputs": [],
   "source": [
    "?randint"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e8365136",
   "metadata": {},
   "outputs": [],
   "source": [
    "help(uniform)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "35fb93f8",
   "metadata": {
    "id": "kjuUZ5w8EUMr",
    "outputId": "fa04c1f2-c2e8-4599-d825-902fc7b97779"
   },
   "outputs": [],
   "source": [
    "# Вызываем функции по 5 раз\n",
    "for i in range(5):\n",
    "    print(randint(100, 200))\n",
    "    print(uniform(100, 200))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "62f24801",
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "help(random)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "13ce5a42",
   "metadata": {
    "id": "ScXYOliPEUMs"
   },
   "source": [
    "Получили по 5 разных псевдослучайных чисел для каждой функции в указанном диапазоне – все получилось без указания модуля через точку.\n",
    "\n",
    "Если необходимо импортировать много функций и переменных из одного модуля, то можно импортировать всё сразу, используя звездочку. Тогда указывать модуль через точку тоже не нужно."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "77979d1d",
   "metadata": {
    "id": "zWCFJYVzEUMs"
   },
   "outputs": [],
   "source": [
    "from math import *  # Импортируем всё из модуля math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7f38b220",
   "metadata": {},
   "outputs": [],
   "source": [
    "sqrt(16)"
   ]
  },
  {
   "cell_type": "markdown",
   "execution_count": null,
   "id": "2b220ca1-3688-4fff-a380-5981ed68017c",
   "metadata": {
    "id": "Wzd9QvdnEUMt"
   },
   "outputs": [],
   "source": [
    "Получили число с высокой точностью, так как в модуле `math` содержится переменная `pi` с большим количеством знаков после запятой (точки):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "afa1db9c",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(pi)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4693f89d",
   "metadata": {
    "id": "SKuYIiB6EUMu"
   },
   "source": [
    "Допустим, потом мы проводим еще какие-то вычисления, где не нужна такая точность. Мы создаем свою переменную `pi`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dbd2a3f9",
   "metadata": {
    "id": "BoCfskzKEUMu"
   },
   "outputs": [],
   "source": [
    "pi = 3.14"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "16036c6d",
   "metadata": {
    "id": "vaPe03kGEUMu"
   },
   "source": [
    "Переприсвоили значение переменной pi:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4d0b2e30",
   "metadata": {
    "id": "r6KuGL0QEUMu",
    "outputId": "c431994c-7bbb-4f75-9000-c83b37c0422d"
   },
   "outputs": [],
   "source": [
    "print(pi)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bbb03d00",
   "metadata": {
    "id": "ZnReGLS6EUMv"
   },
   "source": [
    "Если бы мы импортировали `math` и записывали бы через точку, значение `math.pi` не изменилось бы:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5789cf0a",
   "metadata": {
    "id": "w1nXqmiiEUMv",
    "outputId": "a6d9e925-6241-4eb9-d556-3aca586876da"
   },
   "outputs": [],
   "source": [
    "import math\n",
    "\n",
    "pi = 3.14\n",
    "print(pi, math.pi)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0294b419",
   "metadata": {
    "id": "nF7F8X2IEUMv"
   },
   "source": [
    "# Импорт под псевдонимом\n",
    "\n",
    "Чтобы избежать таких сложностей, лучше писать название модуля. Но можно воспользоваться следующим упрощением: дать модулю псевдоним. Посмотрим на примере модуля `string`, предназначенного для работы со строками. Допустим, мы решили, что целиком слово `string` писать слишком долго, и хотим писать просто `s`. Посмотрим, как это можно сделать."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f9255d47",
   "metadata": {
    "id": "OBUja_geEUMv",
    "outputId": "05933234-9378-4a6b-c8c1-b40873556ac9"
   },
   "outputs": [],
   "source": [
    "import string as s    # Даем псевдоним модулю string\n",
    "print(s.punctuation)  # Печатаем строку со знаками препинания, хранящуюся в модуле"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a7300abb",
   "metadata": {
    "id": "IzB9YC1dEUMw"
   },
   "source": [
    "Теперь мы вместо `string.punctuation` будем писать `s.punctuation`, а `string.punctuation` не сработает."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "97f8dbc0",
   "metadata": {
    "id": "ZypEiwekEUMw",
    "outputId": "35482cb6-d4e4-4ac9-e57a-ace034713d1e"
   },
   "outputs": [],
   "source": [
    "print(string.punctuation)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1f896846",
   "metadata": {},
   "outputs": [],
   "source": [
    "s = 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1ab1c9bd",
   "metadata": {},
   "outputs": [],
   "source": [
    "s.punctuation"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c25d0159",
   "metadata": {
    "id": "mJ4UcF26EUMw"
   },
   "source": [
    "Наконец, если вы совсем не готовы писать название модуля и даже слово `punctuation` кажется вам тоже слишком длинным, можно и ему дать псевдоним:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "270f5f07",
   "metadata": {
    "id": "pS-HCRnmEUMw"
   },
   "outputs": [],
   "source": [
    "from string import punctuation as punc\n",
    "print(punc)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b60a0671",
   "metadata": {},
   "source": [
    "## math"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "14ba5238",
   "metadata": {},
   "outputs": [],
   "source": [
    "# В качестве примера, импортированы некоторые функции:\n",
    "\n",
    "from math import floor, ceil, sqrt, factorial, gcd\n",
    "\n",
    "print(int(2.9), int(3.5), int(-2.5))  # int округляет в сторону нуля, отбрасывая дробную часть\n",
    "print(floor(2.5), floor(3.5), floor(-2.5))  # floor округляет в меньшую сторону\n",
    "print(ceil(2.5), ceil(3.5), ceil(-2.5))  # ceil округляет в большую сторону\n",
    "print(round(2.4), round(3.6), round(-2.1))  # Округление функцией round происходит до ближайшего целого значения (для 2.5 и 3.5 - округление будет до ближайшего чётного - 2 и 4)\n",
    "\n",
    "print(sqrt(2))  # sqrt позволяет извлечь квадратный корень\n",
    "print(gcd(34, 17))  # gcd позволяет найти общий делитель\n",
    "print(factorial(5))  # Вычисление факториала"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f3a25ce4",
   "metadata": {},
   "source": [
    "Интересный факт – округление \"ломается\", при работе с некоторыми числами, у которых много значений после запятой. Нагляднее на примерах:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "861f59be",
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import ceil, floor\n",
    "\n",
    "print(ceil(10.0000000000000009))\n",
    "print(ceil(10.0000000000000008))\n",
    "\n",
    "print(floor(10.9999999999999992))\n",
    "print(floor(10.9999999999999991))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f8630e60",
   "metadata": {},
   "source": [
    "## random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d21d8f12",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Случайное число от 0 до 1\n",
    "random.random()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bb1136f0",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Случайное число из заданного диапазона\n",
    "random.randint(1, 100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "05778fbd",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Случайное число с плавающей точкой\n",
    "random.uniform(1, 100)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6b8004f4",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Случайный элемент из непустой последовательности, например, из списка\n",
    "lst = [1, 26, 3, 24, 16, 17, 30, 17, 27, 28]\n",
    "random.choice(lst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6d63794b",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Перемешать последовательность\n",
    "random.shuffle(lst)\n",
    "lst"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b9c610b6",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Список заданной длины из последовательности\n",
    "random.sample(lst, 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eee120a0",
   "metadata": {},
   "source": [
    "## datetime"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "77e99fc5",
   "metadata": {},
   "outputs": [],
   "source": [
    "import datetime"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d47e7c38",
   "metadata": {},
   "outputs": [],
   "source": [
    "today = datetime.date.today()  # Текущая дата\n",
    "print(today)\n",
    "today = datetime.datetime.now()\n",
    "print(today)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c5fb0a8f",
   "metadata": {},
   "outputs": [],
   "source": [
    "day = datetime.date(2024, 1, 16)\n",
    "print(day)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "569747b4",
   "metadata": {},
   "outputs": [],
   "source": [
    "import time\n",
    "\n",
    "sec = time.time()\n",
    "print(sec)\n",
    "print(datetime.datetime.fromtimestamp(sec))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3c92ece4",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Задать время\n",
    "time = datetime.time()\n",
    "print(time)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "65662ff5",
   "metadata": {},
   "outputs": [],
   "source": [
    "time = datetime.time(13)\n",
    "print(time)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "b0f86c82",
   "metadata": {},
   "outputs": [],
   "source": [
    "time = datetime.time(13, 24)\n",
    "print(time)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d21d1001",
   "metadata": {},
   "outputs": [],
   "source": [
    "time = datetime.time(13, 24, 57)\n",
    "print(time)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "42e983ce",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Получение текущего времени\n",
    "date_time = datetime.datetime.today()\n",
    "print(date_time)\n",
    "\n",
    "date_time = datetime.datetime.now()\n",
    "print(date_time)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "78722c9d",
   "metadata": {},
   "outputs": [],
   "source": [
    "date_str = \"16 February 2024\"\n",
    "date_format = \"%d %B %Y\"\n",
    "\n",
    "print(datetime.datetime.strptime(date_str, date_format))\n",
    "\n",
    "date_str = \"16 Feb 2024\"\n",
    "date_format = \"%d %b %Y\"\n",
    "\n",
    "print(datetime.datetime.strptime(date_str, date_format))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5f6bd1a9",
   "metadata": {},
   "outputs": [],
   "source": [
    "d1 = datetime.datetime.strptime(\"01.01.2024 13:16\", \"%d.%m.%Y %H:%M\")\n",
    "print(d1)\n",
    "d2 = datetime.datetime.strptime(\"2024/03/03 17:18\", \"%Y/%m/%d %H:%M\")\n",
    "print(d2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "51b8fb77",
   "metadata": {},
   "outputs": [],
   "source": [
    "d2 - d1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e3993e79",
   "metadata": {},
   "outputs": [],
   "source": [
    "(d2 - d1).days"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5e1cfe4f",
   "metadata": {},
   "outputs": [],
   "source": [
    "(d2 - d1).seconds"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cbaf3653",
   "metadata": {},
   "outputs": [],
   "source": [
    "now = datetime.datetime.now()\n",
    "date_str = now.strftime(\"%m/%d/%y %H:%M:%S\")\n",
    "print(date_str)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "64bc5cd2",
   "metadata": {},
   "outputs": [],
   "source": [
    "datetime.datetime.now() - datetime.timedelta(days = 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "08dc2aa6",
   "metadata": {},
   "outputs": [],
   "source": [
    "datetime.datetime.now() + datetime.timedelta(weeks = 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "49bffd5d",
   "metadata": {},
   "outputs": [],
   "source": [
    "# День недели\n",
    "date_time = datetime.datetime.today()\n",
    "date_time.weekday()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1b6d2bda",
   "metadata": {},
   "source": [
    "## pprint"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "241f6e1e",
   "metadata": {},
   "outputs": [],
   "source": [
    "import pprint\n",
    "data = {\n",
    "    \"name\": \"John\",\n",
    "    \"age\": 30,\n",
    "    \"city\": \"New York\",\n",
    "    \"hobbies\": [\"reading\", \"playing guitar\", \"travelling\"],\n",
    "}\n",
    "\n",
    "pprint.pprint(data)\n",
    "print(data)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f1b73128",
   "metadata": {},
   "source": [
    "Функция pprint предоставляет несколько параметров для настройки вывода данных. Например, можно установить ширину строки вывода и количество отступов для вложенных структур данных."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e55a97fb",
   "metadata": {},
   "outputs": [],
   "source": [
    "pprint.pprint(data, width = 50, indent = 4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5a0b2ed6",
   "metadata": {},
   "outputs": [],
   "source": [
    "pprint.pprint(data, depth = 1)  # Указать глубину"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "acdab7a8",
   "metadata": {},
   "outputs": [],
   "source": [
    "file = [\"file_00.csv\", \"file_01.csv\", \"file_02.csv\",\n",
    "        \"file_03.csv\", \"file_04.csv\", \"file_05.csv\",\n",
    "        \"file_06.csv\", \"file_07.csv\", \"file_08.csv\",\n",
    "        \"file_09.csv\", \"file_10.csv\", \"file_11.csv\",\n",
    "        \"file_12.csv\", \"file_13.csv\", \"file_14.csv\",\n",
    "        \"file_15.csv\", \"file_16.csv\", \"file_17.csv\",]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "edcb8827",
   "metadata": {},
   "outputs": [],
   "source": [
    "file"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "981944d0",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(file)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "813d9201",
   "metadata": {},
   "outputs": [],
   "source": [
    "pprint.pprint(file)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "28b6457c",
   "metadata": {},
   "source": [
    "## timeit\n",
    "\n",
    "Этот модуль предназначен для оценки производительности небольших фрагментов кода.\n",
    "\n",
    "Для этого необходимо импортировать саму библиотеку `timeit` и вызвать из нее метод `.timeit()`, передав ему название нашей функции и количество необходимых повторений.\n",
    "\n",
    "Рассмотрим следующую задачу конкатенации строк: Составить строку из чисел от 1 до 100, отделив числа друг от друга запятой."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a0bb2469",
   "metadata": {},
   "outputs": [],
   "source": [
    "import timeit\n",
    "\n",
    "# Алгоритм 1\n",
    "def concat():\n",
    "    s = \"\"\n",
    "    for i in range(100):\n",
    "        s += str(i) + \",\"\n",
    "    s += \"100\"\n",
    "\n",
    "# Алгоритм 2\n",
    "def join():\n",
    "    s = \",\".join(map(str, range(101)))\n",
    "\n",
    "print(timeit.timeit(concat, number = 1000))\n",
    "print(timeit.timeit(join, number = 1000))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "89abff44",
   "metadata": {},
   "source": [
    "Про функции, объявленные с помощью слова **def**, подробнее будет рассказано в четвёртом файле."
   ]
  }
 ],
 "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.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}