DL_Course_SamU/1147/lab_1.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "e445b979",
   "metadata": {},
   "source": [
    "# Лабораторная работа 1: Введение в Python"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0810a8a9",
   "metadata": {},
   "source": [
    "Данная лабораторная предназначена для рассмотрения основного синтаксиса языка Python в рамках анализа данных и не является всеобъемлющей. \n",
    "\n",
    "Всегда пользуйтесь гуглом если вам что-то непонятно. Если непонятно как загуглить, значит вы не можете сформулировать вопрос, а значит не понимаете что хотите узнать. Поэтому СНАЧАЛА формулируйте емко и четко вопрос, и только потом отправляйтесь за поиском ответа.\n",
    "\n",
    "Для более подробного рассмотрения синтаксиса обращайтесь к книге М.Лутца \"Изучаем Python\" в двух томах (Qui quaerit, repent), ютуб каналам и, конечно же, к официальной документации [Python](https://docs-python.ru/)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4ad2dcab",
   "metadata": {},
   "source": [
    "В данной лабораторной будут рассмотрены:\n",
    "- Типы данных\n",
    "- Условные конструкции\n",
    "- Циклы\n",
    "- Функции\n",
    "- Классы\n",
    "- Импорт модулей"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6fdf59bc",
   "metadata": {},
   "source": [
    "Задания будут после каждого раздела на закрепление ранее пройденного материала"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ed8886ab",
   "metadata": {},
   "source": [
    "### - Для выполнения ячейки можно нажать нажать комбинацию клавиш shift+enter\n",
    "### ВНИМАНИЕ! \n",
    "Результат выполнения ячеек будет сохраняться все время пока активно ядро jupyter! Для избежания багов и прочих неприятных коллизий перезапускайте ядро!\n",
    "### - Для удобства вывода лучше использовать функцию print()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d09c5f06",
   "metadata": {},
   "source": [
    "## Типы данных\n",
    "Типы данных в Python можно разделить следующим образом:\n",
    "- Числа\n",
    " - Целочисленный int\n",
    " - Вещественный float\n",
    "- Последовательности\n",
    " - Строка str\n",
    " - Список list \n",
    " - Кортеж tuple\n",
    "- Множества set\n",
    "- Словари dict\n",
    "- Логические bool"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1bbab2d1",
   "metadata": {},
   "source": [
    "Стоит выделить что все эти типы разделяются на две группы:\n",
    "- Изменяемые (list, dict, set)\n",
    "- Неизменяемые (int, float, str, tuple, bool)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "749ea9a2",
   "metadata": {},
   "source": [
    "Комментарии в Python бывают двух видов:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "96cc4252",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'\\n-Многострочный комментарий. Филин, подтверди.\\n-Подтверждаю.\\n'"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Однострочный\n",
    "\n",
    "\"\"\"\n",
    "-Многострочный комментарий. Филин, подтверди.\n",
    "-Подтверждаю.\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "id": "db18d3d4",
   "metadata": {},
   "source": [
    "Язык Python является динамически типизированным поэтому при создании переменных и при их перезаписи не требуется явное указание типа данных"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "18383531",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Пример динамической типизации\n",
    "variable = 'some string'\n",
    "variable = 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "100832f1",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Неявная типизация\n",
    "integer_variable = 3\n",
    "\n",
    "# Для удобства написания и дальнейшей работы с кодом можно использовать аннотирование\n",
    "integer_variable: int = 4"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6a10553c",
   "metadata": {},
   "source": [
    "### 1 Целочисленный тип данных\n",
    "\n",
    "Целочисленный тип данных позволяет работать с целыми числами, поддерживая длинную арифметику и неявное приведение к вещественному типу данных при операциях деления или извлечения корня"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cdc766c9",
   "metadata": {},
   "source": [
    "#### 1 Операции над целыми числами"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "639abff2",
   "metadata": {},
   "source": [
    "1.1 Сложение и вычитание\n",
    "\n",
    "Используются операторы + и - соответственно"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "8e02c2e7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "25\n",
      "-5\n"
     ]
    }
   ],
   "source": [
    "var_1 = 10\n",
    "var_2 = 15\n",
    "\n",
    "sum_var = var_1 + var_2\n",
    "subtr_var = var_1 - var_2\n",
    "\n",
    "print(sum_var)\n",
    "print(subtr_var)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "961c51ba",
   "metadata": {},
   "source": [
    "1.2 Умножение\n",
    "\n",
    "Используется оператор *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "101e4b3e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "150\n",
      "14999999999999999999999999999999999999999985\n"
     ]
    }
   ],
   "source": [
    "# Обычное умножение\n",
    "print(var_1 * var_2)\n",
    "\n",
    "# Поддерживается длинная арифметика\n",
    "print(var_2 * 999999999999999999999999999999999999999999)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9b6b9a57",
   "metadata": {},
   "source": [
    "1.3 Возведение в степень\n",
    "\n",
    "Используется оператор **"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "d074f4e3",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3375\n"
     ]
    }
   ],
   "source": [
    "print(var_2 ** 3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e0255f85",
   "metadata": {},
   "source": [
    "1.4 Деление\n",
    "\n",
    "Используются операторы:\n",
    "- / деление\n",
    "- // деление до целой части\n",
    "- % остаток от деления"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "a6eeda85",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.6666666666666666\n",
      "3\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "# Деление, в результате получаем вещественное число (число с плавающей точкой)\n",
    "print(var_1 / var_2)\n",
    "\n",
    "# Деление до целой части\n",
    "print(var_1 // 3)\n",
    "\n",
    "# Остаток от деления\n",
    "print(var_2 % 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "63eb42b8",
   "metadata": {},
   "source": [
    "### Задание:\n",
    "Создайте переменную и присвойте ей значение 42317. Посчитайте остаток от деления на 7 и целочисленное деление на 7.\n",
    "\n",
    "Разницу между результатами возведите в квадрат."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "87b96139",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "17b226d5",
   "metadata": {},
   "source": [
    "### 2 Вещественный тип данных\n",
    "\n",
    "Вещественный тип данных так же позволяет использовать все вышеперечисленные операции"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "5626c58a",
   "metadata": {},
   "outputs": [],
   "source": [
    "float_var_1 = 10.0\n",
    "float_var_2 = 3.33\n",
    "\n",
    "# равнозначно записи 0.03\n",
    "float_var_3 = .03 "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "06e853d4",
   "metadata": {},
   "source": [
    "### Задание:\n",
    "Создайте переменные со значениями 15.17 и 21.11. Выведите кубический корень их отношения."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "162b77eb",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "e0a26e59",
   "metadata": {},
   "source": [
    "### 3 Последовательности\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "88178c88",
   "metadata": {},
   "source": [
    "### 3.1 Строки\n",
    "\n",
    "Строковый тип данных (str) в Python может представляться как последовательность отдельных символов (строк одинарной длины). Использование двойных или одинарных кавычек равнозначно. В строках могут применяться все символы из ASCII."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "6c9e047c",
   "metadata": {},
   "outputs": [],
   "source": [
    "# пустая строка\n",
    "s = '' \n",
    "\n",
    "s = 'There is some text and 100500 reasons for scroll it down'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b1a53d83",
   "metadata": {},
   "source": [
    "С последовательностями можно работать поиндексно, для этого после имени последовательности ставятся квадратные скобки и указываются следующие значения:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "70961f1f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "o\n",
      "T\n"
     ]
    }
   ],
   "source": [
    "# Выбор элемента по индексу 10 (начинается отсчет с 0)\n",
    "print(s[10])\n",
    "\n",
    "print(s[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "75eacb11",
   "metadata": {},
   "source": [
    "Так как str является неизменяемым типом данных, то мы не можем поменять его элементы - будет ошибка:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "2c849a9c",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'str' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_11148/2869417731.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0ms\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;34m't'\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: 'str' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "s[0] = 't'"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8025408b",
   "metadata": {},
   "source": [
    "Возможно использование срезов при помощи выражения left_bound:right_bound. Левая граница включается, правая не включается:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "21da35ad",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "There is\n",
      " some text and 100500 reasons for scroll it down\n",
      "ext a\n"
     ]
    }
   ],
   "source": [
    "print(s[:8])\n",
    "\n",
    "print(s[8:])\n",
    "\n",
    "print(s[15:20])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9f4745e8",
   "metadata": {},
   "source": [
    "Можно использовать итерацию с шагом при помощи выражения ::step :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "41777d28",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "There is some text and 100500 reasons for scroll it down\n",
      "Teei oetx n 050raosfrsrl tdw\n"
     ]
    }
   ],
   "source": [
    "print(s[::1])\n",
    "print(s[::2])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "554025c3",
   "metadata": {},
   "source": [
    "Строки можно складывать (конкатенация) и умножать (репликация)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "1999b11d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "First part of stringSecond part\n",
      "hehehehehehehehe\n"
     ]
    }
   ],
   "source": [
    "# Как будет видно по выводу пробел между двумя частями в \"склейке\" отсутствует\n",
    "print('First part of string' + 'Second part') \n",
    "\n",
    "print('he' * 8)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "98ffe209",
   "metadata": {},
   "source": [
    "Так как питон имеет строгую типизацию, то результат следующей операции будет ошибкой:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "c3722f45",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "can only concatenate str (not \"int\") to str",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_11148/1637851998.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m'Variable is:'\u001b[0m \u001b[1;33m+\u001b[0m \u001b[1;36m5\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: can only concatenate str (not \"int\") to str"
     ]
    }
   ],
   "source": [
    "print('Variable is:' + 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d63a833e",
   "metadata": {},
   "source": [
    "Для исправления этого нужно применить ЯВНОЕ приведение типа, которое получается следующим образом:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "80dcc4a9",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Variable is: 5\n"
     ]
    }
   ],
   "source": [
    "print('Variable is: ' + str(5))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5343ca9d",
   "metadata": {},
   "source": [
    "Справедливо и обратное преобразование:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "2f579b77",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10\n"
     ]
    }
   ],
   "source": [
    "print(int('5') + 5)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "65521673",
   "metadata": {},
   "source": [
    "Для любой последовательности применима встроенная функция len() которая вернет длину переданной последовательности:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "aa71f297",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "56\n"
     ]
    }
   ],
   "source": [
    "print(len(s))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "46402c76",
   "metadata": {},
   "source": [
    "Для строк применимы встроенные методы, которые можно вызвать у объекта строки:\n",
    "- Приведение к верхнему/нижнему регистру\n",
    "- Поиск подстроки\n",
    "- Замена символов\n",
    "- и т.д.\n",
    "\n",
    "Весь список можно посмотреть здесь: https://pythonworld.ru/tipy-dannyx-v-python/stroki-funkcii-i-metody-strok.html"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "eb1c034e",
   "metadata": {},
   "source": [
    "### Задание\n",
    "\n",
    "Создайте переменную со следующим значением:\n",
    "\n",
    "Habitasse est. Sodales ultricies. Imperdiet sit nunc odio. Non ultricies. Dapibus risus mattis dui tempus arcu elit. Imperdiet in e.\n",
    "\n",
    "Приведите ее к нижнему регистру и удалите все знаки препинания. Найдите позицию первого знака в слове ultricies."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "41aa8aab",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "c3207dd3",
   "metadata": {},
   "source": [
    "### 3.2 Списки"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b876e6dc",
   "metadata": {},
   "source": [
    "Списки list создаются при помощи квадратных скобок [] и перечисления элементов внутри них. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "a7785ba6",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4]\n",
      "['sad', 'story']\n",
      "['abc', 1, 2.0, [1]]\n"
     ]
    }
   ],
   "source": [
    "l = [1, 2, 3, 4]\n",
    "print(l)\n",
    "\n",
    "l = ['sad', 'story']\n",
    "print(l)\n",
    "\n",
    "# можно засунуть разные типы данных\n",
    "l = ['abc', 1, 2.0, [1]]\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9f101047",
   "metadata": {},
   "source": [
    "Со списками так же можно работать при помощи индексов и срезов:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "d8913676",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "d\n",
      "['b', 'c', 'd']\n"
     ]
    }
   ],
   "source": [
    "l = ['a', 'b', 'c', 'd', 'e']\n",
    "\n",
    "print(l[3])\n",
    "\n",
    "print(l[1:4])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4099e4e9",
   "metadata": {},
   "source": [
    "Так как списки являются изменяемым типом данных, то его элементы можно менять, добавлять и удалять"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "7fc4eb86",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['a', 'b', 'c', 'd', 'e']\n",
      "['a', 'b', 'c', 'new', 'e']\n"
     ]
    }
   ],
   "source": [
    "print(l)\n",
    "l[3] = 'new'\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6d10f033",
   "metadata": {},
   "source": [
    "Возможно добавление вложенных списков любой глубины:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "90fc2986",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, [1], [[1], [1]]]\n"
     ]
    }
   ],
   "source": [
    "l = [1, [1],[[1],[1]]]\n",
    "print(l)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3441b42d",
   "metadata": {},
   "source": [
    "Списки можно объединять через оператор сложения"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "73d873b5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3, 4, 5, 6]\n"
     ]
    }
   ],
   "source": [
    "l_1 = [1, 2, 3]\n",
    "l_2 = [4, 5, 6]\n",
    "\n",
    "print(l_1 + l_2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2be49e02",
   "metadata": {},
   "source": [
    "Вызывая у списка методы .append() или .extend() можно добавлять элемент или дополнять исходный список (в результате он изменяется!):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "be99d904",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3]\n",
      "[1, 2, 3, [4, 5, 6]]\n"
     ]
    }
   ],
   "source": [
    "print(l_1)\n",
    "l_1.append(l_2)\n",
    "print(l_1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "id": "ffa84b26",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 2, 3]\n",
      "[1, 2, 3, 4, 5, 6]\n"
     ]
    }
   ],
   "source": [
    "l_1 = [1, 2, 3]\n",
    "print(l_1)\n",
    "l_1.extend(l_2)\n",
    "print(l_1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "90486247",
   "metadata": {},
   "source": [
    "Другие встроенные методы можно посмотреть здесь https://pythonworld.ru/tipy-dannyx-v-python/spiski-list-funkcii-i-metody-spiskov.html"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "74e93061",
   "metadata": {},
   "source": [
    "### Задание\n",
    "\n",
    "Создайте несколько два списка с элементами 1,2,4,8,16 и 1,2,3,5,7. Объедините эти списки. Отсортируйте по возрастанию. Выведите первые четыре элемента."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "edf94dc6",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "d5288d04",
   "metadata": {},
   "source": [
    "### 3.3 Кортежи "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a717e4dc",
   "metadata": {},
   "source": [
    "Кортежи tuple похожи на списки, но являются неизменяемыми, т.е. в них нельзя изменить значение элемента, добавить или удалить элементы. Создаются при помощи () в которых прописываются значения."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "fa09c39f",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1, 2, 3)\n"
     ]
    }
   ],
   "source": [
    "tup = (1,2,3)\n",
    "print(tup)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ce3c3c6b",
   "metadata": {},
   "source": [
    "Кортеж можно распаковать в несколько переменных:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "46eac85a",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1 2 3\n"
     ]
    }
   ],
   "source": [
    "var_1, var_2, var_3 = tup\n",
    "\n",
    "print(var_1, var_2, var_3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8d60661f",
   "metadata": {},
   "source": [
    "В кортеже можно применять индексирование и срезы"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "a7083481",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2\n",
      "(1, 2)\n"
     ]
    }
   ],
   "source": [
    "print(tup[1])\n",
    "print(tup[:2])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "df14ad2e",
   "metadata": {},
   "source": [
    "### 4 Множества"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b265a0fd",
   "metadata": {},
   "source": [
    "Множество set это набор уникальных элементов. Создается при помощи {} и перечисления в нем элементов."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "f399d973",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'b', 'c', 'a'}\n"
     ]
    }
   ],
   "source": [
    "s = {'a', 'b', 'c'}\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e6a7fa80",
   "metadata": {},
   "source": [
    "Применяя set к последовательностям можно получить набор уникальных неупорядоченных значений:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "64e77321",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{0, 1, 2, 3}\n",
      "{' ', 'd', 'o', 'T', 'h', 'n', 'r', '!', 'e', 'H', 'q', 's', 'i', 'g', 't', 'l', ',', 'u'}\n"
     ]
    }
   ],
   "source": [
    "l = [0,1,0,0,2,2,3]\n",
    "s = 'Hello, dude! This is unique string!'\n",
    "\n",
    "print(set(l))\n",
    "print(set(s))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5efd9471",
   "metadata": {},
   "source": [
    "У множества нельзя вызывать элементы по индексу и нельзя работать со срезами. Для этого его нужно приводить к типу список list!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "4e1a9077",
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'set' object is not subscriptable",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_11148/2180189257.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;31m# выведет ошибку\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 2\u001b[1;33m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mset\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0ml\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[1;31mTypeError\u001b[0m: 'set' object is not subscriptable"
     ]
    }
   ],
   "source": [
    "# выведет ошибку\n",
    "print(set(l)[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "61a8976e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n"
     ]
    }
   ],
   "source": [
    "print(list(set(l))[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0c595015",
   "metadata": {},
   "source": [
    "### Задание\n",
    "\n",
    "Даны два списка [1,5,1,1,2,3,7,12,3,6,14,11,11] и [11,6,4,3,3,5,7,18]. Найдите симметрическую разницу этих двух списков. Отсортируйте по возрастанию и выведете первые два элемента."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4d3964a0",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "af3ff378",
   "metadata": {},
   "source": [
    "### 5 Словари"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2398289a",
   "metadata": {},
   "source": [
    "Словарь dict представляет собой набор ключей keys и соответствующих им значений values. \n",
    "Ключи являются уникальными и должны задаваться неизменяемым типом данных, значения могут быть любыми. Создается при помощи {} и требуемых пар key:value.  Применим для быстрого доступа к значениям ключей. Для этого вызывается объект словаря с [] где указывается наименование ключа."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "786ac7ce",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "value_1\n",
      "value_2\n"
     ]
    }
   ],
   "source": [
    "d = {'key_1': 'value_1', 'key_2': 'value_2'}\n",
    "print(d['key_1'])\n",
    "print(d['key_2'])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7a37c83b",
   "metadata": {},
   "source": [
    "### Задание\n",
    "Даны два списка [1,2,3,4,5,6] и ['a','b','c','d','e','f']. Создайте словарь, где ключи будут представлены первым списком, а значения вторым, в том же порядке в каком они представлены."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2df8c86b",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "f4b71a89",
   "metadata": {},
   "source": [
    "### 6 Логический тип"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d4673d7a",
   "metadata": {},
   "source": [
    "Логический (булев) тип задается двумя ключевыми словами True и False. Данный тип нужен для работы с условными конструкциями (будут рассмотрены далее). True и False могут быть заменены int значениями 1 и 0 соответственно (при явном приведении к целочисленному типу). При приведении любого числа кроме 0 к bool будет получено True, для 0 соответственно False."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "c0d701c8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "1\n"
     ]
    }
   ],
   "source": [
    "b = True\n",
    "print(b)\n",
    "print(int(b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "ff7a5c34",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "b = False\n",
    "print(b)\n",
    "print(int(b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "869bacb7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3123123\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "b = 3123123\n",
    "print(b)\n",
    "print(bool(b))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "ba29c37c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "b = 0\n",
    "print(b)\n",
    "print(bool(b))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "84ecc8ca",
   "metadata": {},
   "source": [
    "## Условные конструкции"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "fd09c338",
   "metadata": {},
   "source": [
    "В Python представлены следующие условные операторы:\n",
    "- операции сравнения \n",
    " - \\> больше\n",
    " - < меньше\n",
    " - == равно\n",
    " - \\>= больше или равно\n",
    " - <= меньше или равно\n",
    " - != не равно\n",
    "- логические операторы\n",
    " - and логическое И\n",
    " - or логическое ИЛИ\n",
    " - not логическое отрицание\n",
    "- оператор вхождение in\n",
    "- оператор сравнения объектов is"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9aa66791",
   "metadata": {},
   "source": [
    "Условная конструкция в Python задается ключевыми словами if, elif и else. Имеет следующий вид: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "id": "bb397d89",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "var is greater than zero\n"
     ]
    }
   ],
   "source": [
    "var = 10\n",
    "\n",
    "if var > 0:\n",
    "    print('var is greater than zero')\n",
    "elif var == 0:\n",
    "    print('var is equal zero')\n",
    "else:\n",
    "    print('var is less than zero')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "23fe0fa6",
   "metadata": {},
   "source": [
    "elif и else не являются обязательными"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "50faeef9",
   "metadata": {},
   "source": [
    "оператор if поддерживает вложенность:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "db24f837",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "var is greater than 7\n",
      "var is greater than 5\n",
      "var is greater than 0\n"
     ]
    }
   ],
   "source": [
    "if var > 0:\n",
    "    if var > 5:\n",
    "        if var > 7:\n",
    "            print('var is greater than 7')\n",
    "        print('var is greater than 5')\n",
    "    print('var is greater than 0')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2cf55c9e",
   "metadata": {},
   "source": [
    "Логические операторы являются представлением булевой алгебры"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "d85a5907",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print(True and True)\n",
    "print(True and False)\n",
    "print(False and False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "1404d6d8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print(True or True)\n",
    "print(True or False)\n",
    "print(False or False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "id": "be78702c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print(not(False))\n",
    "print(not(True))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4d0d66c5",
   "metadata": {},
   "source": [
    "При помощи оператора in можно определять наличие элемента в какой-либо последовательности"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "a8cae1d8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print('s' in 'super')\n",
    "print('s' in 'puper')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ef8bf41a",
   "metadata": {},
   "source": [
    "При помощи оператора is определяется являются ли объекты слева и справа одним и тем же объектом"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "id": "07f833d7",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "a = ['a','b']\n",
    "b = a\n",
    "print(a is b)\n",
    "\n",
    "b = a.copy()\n",
    "print(a is b)\n",
    "\n",
    "# но они будут равны по значениям\n",
    "print(a == b)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9cc1a047",
   "metadata": {},
   "source": [
    "### Задание\n",
    "Создайте список цифр любой длины. Определите длину списка. Для случаев больше, равно и меньше 5 выведите соответствующие сообщения. Если список длиннее 5 и в нем есть цифра 3, выведите сообщение \"bingo!\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "94fd3c8b",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "0c13e96d",
   "metadata": {},
   "source": [
    "## Циклы"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "19630981",
   "metadata": {},
   "source": [
    "Циклы в Python представлены операторами while и for."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7ea09094",
   "metadata": {},
   "source": [
    "Оператор while принимает условное выражение, если оно true - оператор будет выполнять операции вложенные в его тело."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "id": "ee8cb56b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0\n",
      "1\n",
      "2\n",
      "3\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "stepper = 0\n",
    "\n",
    "while(stepper < 5):\n",
    "    print(stepper)\n",
    "    stepper += 1 # увеличиваем значение stepper на 1 каждый шаг"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6d860aee",
   "metadata": {},
   "source": [
    "оператор for используется для итерирования по последовательностям, пока не достигнет их конца. \n",
    "\n",
    "Имеет конструкцию: for имя_переменной in имя_последовательности\n",
    "\n",
    "в переменную будет записываться каждый шаг следующий элемент из последовательности начиная с нулевого"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "id": "393942e1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "3\n",
      "4\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "seq = [1, 2, 3, 4, 5]\n",
    "\n",
    "for elem in seq:\n",
    "    print(elem)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "id": "2478ea32",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "s\n",
      "o\n",
      "m\n",
      "e\n",
      " \n",
      "s\n",
      "t\n",
      "r\n",
      "i\n",
      "n\n",
      "g\n"
     ]
    }
   ],
   "source": [
    "s = 'some string'\n",
    "\n",
    "for sym in s:\n",
    "    print(sym)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "053c128d",
   "metadata": {},
   "source": [
    "### Задание\n",
    "\n",
    "Дана строка: \n",
    "\n",
    "Habitasse est. Sodales ultricies. Imperdiet sit nunc odio. Non ultricies. Dapibus risus mattis dui tempus arcu elit. Imperdiet in e.\n",
    "\n",
    "Посчитайте количество упоминаний каждого символа (любой регистр) в этой строке и выведите результат.\n",
    "\n",
    "Подсказка: Используйте для решения set и dict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c679b4bc",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "6c081b8d",
   "metadata": {},
   "source": [
    "## Функции"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ff4a4c3b",
   "metadata": {},
   "source": [
    "Функции представляют собой обособленную совокупность кода, выполняющего какую-то специфическую задачу, с возможностью бесконечного вызова этого кода без надобности его перезаписи. В Python представляется в виде конструкции:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "9b1cff42",
   "metadata": {},
   "outputs": [],
   "source": [
    "def name_function(arg1, arg2):\n",
    "    \"\"\"\n",
    "    Тут какой-то код\n",
    "    \"\"\"\n",
    "    return 0 # функция при любом корректном вызове вернет 0"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "26c1d91a",
   "metadata": {},
   "source": [
    "1) Имя функции лучше указывать максимально емким, чтобы при его прочтении было понятно что делает эта функция в контексте\n",
    "\n",
    "2) Функция может не принимать никаких значений, т.е. arg1, arg2, arg... могут отсутствовать\n",
    "\n",
    "3) Функция может ничего не возвращать, т.е. отсутствует оператор return"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6d43660b",
   "metadata": {},
   "source": [
    "Напишем функцию которая считает время, через которое упадет тело на поверхность земли с нулевой начальной скоростью с заданной высоты: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "f696aa45",
   "metadata": {},
   "outputs": [],
   "source": [
    "def fall_time(height):\n",
    "    time = (2 * height / 9.81) ** 0.5\n",
    "    return time"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b64bccea",
   "metadata": {},
   "source": [
    "Вызовем нашу функцию:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "c367e153",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.4278431229270645\n"
     ]
    }
   ],
   "source": [
    "print(fall_time(10))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4284c744",
   "metadata": {},
   "source": [
    "Можно в аргументах задать ускорение свободного падения с значением по умолчанию, если его не задает пользователь:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "279ecbda",
   "metadata": {},
   "outputs": [],
   "source": [
    "def fall_time_2(height, g=9.81):\n",
    "    time = (2 * height / g) ** 0.5\n",
    "    return time"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "id": "db4d028b",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.4278431229270645\n",
      "2.23606797749979\n"
     ]
    }
   ],
   "source": [
    "print(fall_time_2(10))\n",
    "print(fall_time_2(10, 4))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "caba560d",
   "metadata": {},
   "source": [
    "Можно явно указывать каким аргументам мы присваиваем передаваемые значения (тогда их последовательность можно менять)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "315c047e",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2.23606797749979\n"
     ]
    }
   ],
   "source": [
    "print(fall_time_2(g=4, height=10))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "27bd15a5",
   "metadata": {},
   "source": [
    "### Задание\n",
    "1) Реализуйте функцию, которая считает квадрат разницы между двумя величинами и возвращает полученное значение\n",
    "\n",
    "\n",
    "2) Дан список чисел:\n",
    "\n",
    "   [12,32,1,67,2,15,12,68,90]\n",
    "\n",
    "   Реализуйте функцию, которая найдет максимальное значение в этом списке и вернет его."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "4b41854a",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "6af84bc7",
   "metadata": {},
   "source": [
    "## Классы"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "9234c823",
   "metadata": {},
   "source": [
    "Класс представляет собой некоторую абстрактную сущность, которая имеет свое поведение (методы) и атрибуты. \n",
    "\n",
    "Для создания требуется следующая конструкция:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "97e1fa2e",
   "metadata": {},
   "outputs": [],
   "source": [
    "class class_name:\n",
    "    def __init__(self, atr_1, atr_2):\n",
    "        self.atr_1 = atr_1\n",
    "        self.atr_2 = atr_2"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5cd8734d",
   "metadata": {},
   "source": [
    "В классе требуется описать метод __init__() который ОБЯЗАТЕЛЬНО принимает self. Атрибуты в нем необязательны (но зачем вам тогда такой класс?).\n",
    "\n",
    "Для примера создадим класс автомобиль, который принимает в качестве атрибутов количество колес и количество дверей, и у которого по этим атрибутам упрощенно будет определяться что это за тип машины, а так же метод drive сообщающий нам что данный автомобиль едет по дороге:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "db7bf658",
   "metadata": {},
   "outputs": [],
   "source": [
    "class car:\n",
    "    \n",
    "    def __init__(self, \n",
    "                 wheels_count, \n",
    "                 doors_count):\n",
    "        self.wheels_count = wheels_count\n",
    "        self.doors_count = doors_count\n",
    "        self.car_type = self.__car_type()\n",
    "    \n",
    "    def __car_type(self):\n",
    "        if self.wheels_count  < 2:\n",
    "            return 'wtf?'\n",
    "        elif self.wheels_count == 3:\n",
    "            return 'tricycle'\n",
    "        elif self.wheels_count == 4:\n",
    "            if self.doors_count == 4:\n",
    "                return 'sedan'\n",
    "            elif self.doors_count == 3:\n",
    "                return 'hatchback'\n",
    "            elif self.doors_count == 2:\n",
    "                return 'coupe'\n",
    "        elif self.wheels_count > 4 and self.wheels_count % 2:\n",
    "            return 'truck'\n",
    "        else:\n",
    "            return 'wtf?'\n",
    "    def drive(self):\n",
    "        print(f'{self.car_type} drives on the road')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "f888a191",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "coupe\n",
      "sedan\n"
     ]
    }
   ],
   "source": [
    "# создадим объект класса car с именем coupe и проверим что находится в поле car_type\n",
    "coupe = car(wheels_count=4, doors_count=2)\n",
    "print(coupe.car_type)\n",
    "\n",
    "# проделаем то же самое для sedan\n",
    "sedan = car(wheels_count=4, doors_count=4)\n",
    "print(sedan.car_type)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "b41ab2ac",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "coupe drives on the road\n",
      "sedan drives on the road\n"
     ]
    }
   ],
   "source": [
    "# вызовем метод drive у обоих классов\n",
    "coupe.drive()\n",
    "sedan.drive()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ff8f4316",
   "metadata": {},
   "source": [
    "### Задание\n",
    "Создайте класс Plane который будет иметь атрибуты length, wingspan, engines_count. Эти атрибуты должны быть проинициализированы в конструкторе. Так же создайте метод класса, который будет выводить характеристики вашего самолета (нафантазируйте в каком виде).\n",
    "\n",
    "Создайте объект этого класса с разными значениями атрибутов и вызовите у объекта метод показа характеристик."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8b9cefa9",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "79e4fbec",
   "metadata": {},
   "source": [
    "## Чтение и запись в файл"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "975dc833",
   "metadata": {},
   "source": [
    "Для чтения или записи в файл используется следующая конструкция:\n",
    "\n",
    "f = open('путь_к_файлу', 'флаг_открытия')\n",
    "\n",
    "через методы f появится возможность считывать или записывать в открытый файл то, что нам требуется"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "96c79cf5",
   "metadata": {},
   "source": [
    "Откроем файл с флагом на запись для того, чтобы он создался, если его нет"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "e206bf83",
   "metadata": {},
   "outputs": [],
   "source": [
    "f = open('test.txt', 'w')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b70e3d5f",
   "metadata": {},
   "source": [
    "запишем в него пару строк:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "0379af24",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "11"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f.write('First line')\n",
    "f.write('\\n')\n",
    "f.write('Second line')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "68f251ed",
   "metadata": {},
   "source": [
    "закроем поток работы с файлом, чтобы увидеть в нем изменения"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "fcf018d7",
   "metadata": {},
   "outputs": [],
   "source": [
    "f.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cb81334e",
   "metadata": {},
   "source": [
    "Для чтения из файла воспользуемся флагом r"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "4e3ec3d7",
   "metadata": {},
   "outputs": [],
   "source": [
    "f = open('test.txt', 'r')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e93c60e0",
   "metadata": {},
   "source": [
    "Считаем из файла все что в нем есть в список"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "4e24cd48",
   "metadata": {},
   "outputs": [],
   "source": [
    "l_file = f.readlines()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "ead61f25",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['First line\\n', 'Second line']\n"
     ]
    }
   ],
   "source": [
    "print(l_file)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "b0dd8bf6",
   "metadata": {},
   "outputs": [],
   "source": [
    "f.close()"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "58c428ed",
   "metadata": {},
   "source": [
    "Чтобы не закрывать вручную поток чтения/записи лучше использовать следующую конструкцию, которая делает это за вас:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "12c9deda",
   "metadata": {},
   "outputs": [],
   "source": [
    "with open('test.txt', 'r') as f:\n",
    "    \"\"\"\n",
    "    делаем что угодно с данными из файла\n",
    "    \"\"\"\n",
    "    pass"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ecb80b7b",
   "metadata": {},
   "source": [
    "### Задание\n",
    "Создайте поток записи в файл (чтобы файл создался при исполнении кода), назовите как хотите. Запишите в него следующую строку:\n",
    "\n",
    "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.\n",
    "\n",
    "Закройте поток записи.\n",
    "\n",
    "Откройте поток чтения и считайте из этого файла содержимое. Приведите текст к нижнему регистру, удалите запятые и сохраните его в переменной. Закройте поток чтения.\n",
    "\n",
    "Откройте поток записи и ДОПИШИТЕ с новой строки результат прошлого шага в файл. Закройте поток записи. Проверьте корректность данных в файле.\n",
    "\n",
    "Должно быть быть по итогу в файле:\n",
    "\n",
    "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua.\n",
    "\n",
    "lorem ipsum dolor sit amet consectetur adipiscing elit sed do eiusmod tempor incididunt ut labore et dolore magna aliqua."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5ef95e3e",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "a290c046",
   "metadata": {},
   "source": [
    "## Импорт модулей"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2281db7a",
   "metadata": {},
   "source": [
    "Для многих узких задач существуют готовые оптимальные с точки зрения скорости и времени решения, собранные в отдельные логические объединения (например математические преобразования, работа с матрицами, работа с изображениями и т.д.), называемые модулями.\n",
    "\n",
    "Их подключение выглядит следующим образом:\n",
    "\n",
    "import название_модуля\n",
    "\n",
    "Если он поставляется в пакете, то требуется оказать что он извлекается из определенного пакета\n",
    "\n",
    "from название_пакета import название_модуля\n",
    "\n",
    "Если название слишком длинное, то можно добавить сокращенное название модуля\n",
    "\n",
    "import названия_модуля as нзвн_мдл"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "6a6c8ec4",
   "metadata": {},
   "outputs": [],
   "source": [
    "# модуль для работы с матрицами, векторами и математическими операциями\n",
    "# np общепринятое сокращение для удобства использования в коде модуля numpy\n",
    "import numpy as np\n",
    "\n",
    "# из пакета matplotlib нам потребуется модуль pyplot, к которому мы будем\n",
    "# обращаться по сокращенному общепринятому имени plt\n",
    "from matplotlib import pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c21e6945",
   "metadata": {},
   "source": [
    "Теперь возможно обращение к методам данных модулей, например найдем косинус угла 90, \n",
    "\n",
    "для этого вызовем метод cos() из модуля np, в который передадим значение угла домноженного на константу Пи, которую так же можно взять из данного модуля:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "38446409",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.cos(90 * np.pi)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cf82ceaf",
   "metadata": {},
   "source": [
    "Многих модулей в базовом питоне нет, поэтому их требуется установить отдельно. Это можно сделать через командную строку используя pip:\n",
    "\n",
    "Введем в консоль \n",
    "\n",
    "##### pip install название_модуля\n",
    "\n",
    "Так же возможна установка модулей прямо из jupyter, используя ! pip\n",
    "\n",
    "##### !pip install название_модуля"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "0ee309a5",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: opencv-python in c:\\users\\firsov\\appdata\\local\\programs\\python\\python39\\lib\\site-packages (4.6.0.66)\n",
      "Requirement already satisfied: numpy>=1.19.3 in c:\\users\\firsov\\appdata\\local\\programs\\python\\python39\\lib\\site-packages (from opencv-python) (1.21.1)\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING: Ignoring invalid distribution -illow (c:\\users\\firsov\\appdata\\local\\programs\\python\\python39\\lib\\site-packages)\n",
      "WARNING: Ignoring invalid distribution -illow (c:\\users\\firsov\\appdata\\local\\programs\\python\\python39\\lib\\site-packages)\n",
      "WARNING: Ignoring invalid distribution -illow (c:\\users\\firsov\\appdata\\local\\programs\\python\\python39\\lib\\site-packages)\n",
      "WARNING: Ignoring invalid distribution -illow (c:\\users\\firsov\\appdata\\local\\programs\\python\\python39\\lib\\site-packages)\n",
      "WARNING: Ignoring invalid distribution -illow (c:\\users\\firsov\\appdata\\local\\programs\\python\\python39\\lib\\site-packages)\n",
      "WARNING: Ignoring invalid distribution -illow (c:\\users\\firsov\\appdata\\local\\programs\\python\\python39\\lib\\site-packages)\n",
      "WARNING: You are using pip version 21.1.3; however, version 22.2.2 is available.\n",
      "You should consider upgrading via the 'c:\\users\\firsov\\appdata\\local\\programs\\python\\python39\\python.exe -m pip install --upgrade pip' command.\n"
     ]
    }
   ],
   "source": [
    "!pip install opencv-python"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6229876b",
   "metadata": {},
   "source": [
    "### Задание\n",
    "Установите модули pandas, numpy и matplotlib если их нет. Проверить установлены они или нет можно с помощью команды:\n",
    "\n",
    "##### !pip show название_модуля"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "052d5979",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.9.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}