{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "ae80cf73",
   "metadata": {
    "id": "ae80cf73"
   },
   "source": [
    "# Введение в Python"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0ddcb484",
   "metadata": {
    "id": "0ddcb484"
   },
   "source": [
    "Jupyter Lab - интерактивная среда для запуска программного кода в браузере. Удобный инструмент для анализа данных, который используется многими специалистами по data science."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c3481f74",
   "metadata": {
    "id": "c3481f74"
   },
   "source": [
    "## Функции и вывод на экран\n",
    "\n",
    "\n",
    "_Функция_ -- это какой-то скрытый от вас программный код, который можно применять для решения конкретной задачи.\n",
    "\n",
    "Например, познакомимся с функцией `print`:\n",
    "- нужна для того, чтобы выводить на экран текст / числа / что угодно ещё\n",
    "- формат вызова: `print(<первое, что хотите вывести на экран>, <второе, что хотите вывести на экран>, ...)`\n",
    "\n",
    "То, что перечисляется внутри скобок и разделяется запятыми, называется *аргументами*  функции"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "66bfa322",
   "metadata": {
    "id": "66bfa322",
    "outputId": "60506bad-acf9-4de1-e962-1bb0ecbd5d5a"
   },
   "outputs": [],
   "source": [
    "print(67+87)\n",
    "print(42+146)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8f66e705",
   "metadata": {
    "id": "8f66e705",
    "outputId": "6cf4703e-4e13-48d1-9d9e-cce6b56d9963"
   },
   "outputs": [],
   "source": [
    "print('Hello world!')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6af4c4bc",
   "metadata": {
    "id": "6af4c4bc"
   },
   "source": [
    "Попробуем вывести результат сложения чисел 42 и 146:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "aaa8e501",
   "metadata": {
    "id": "aaa8e501",
    "outputId": "f20ef12b-3598-47f7-fb1d-c75a00888d74"
   },
   "outputs": [],
   "source": [
    "print(42+146)\n",
    "# всё, что пишется за знаком #, воспринимается как комментарий и не выполняется в рамках программы"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "21abed7a",
   "metadata": {
    "id": "21abed7a"
   },
   "source": [
    "## Типы данных: Целые числа - INT (INTEGER)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d1a44ebd",
   "metadata": {
    "id": "d1a44ebd"
   },
   "source": [
    "Python сам понимает, какой тип у данных. Однако, можно так же и запросить у него данную информацию"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fd5993bc",
   "metadata": {
    "id": "fd5993bc",
    "outputId": "19f14588-2261-4b7b-a173-68ae08ca4d20"
   },
   "outputs": [],
   "source": [
    "print(type(5))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7ebcc29b",
   "metadata": {
    "id": "7ebcc29b"
   },
   "source": [
    "Разумеется, в python представлены все возможные арифметические операции:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3c0fb3b4",
   "metadata": {
    "id": "3c0fb3b4",
    "outputId": "b7f32c43-d559-4d3d-c16d-915f2743823f"
   },
   "outputs": [],
   "source": [
    "# сложение\n",
    "print(4 + 2)\n",
    "# вычитание\n",
    "print(4 - 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "12d34c84",
   "metadata": {
    "id": "12d34c84",
    "outputId": "d8a3135c-3e32-48c4-ec74-c078b7a2fde6"
   },
   "outputs": [],
   "source": [
    "# умножение\n",
    "print(4 * 2)\n",
    "# деление\n",
    "print(4 / 2)\n",
    "# целочисленное деление\n",
    "print(5 // 2)\n",
    "# взятие остатка от деления\n",
    "print(3 % 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f2c7a60a",
   "metadata": {
    "id": "f2c7a60a",
    "outputId": "0c98453c-0c4d-4d02-b68d-c039d321e48d"
   },
   "outputs": [],
   "source": [
    "# возведение в степень\n",
    "print(3 ** 2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "29da8466",
   "metadata": {
    "id": "29da8466"
   },
   "source": [
    "Заметим, что здесь у нас в ответах получились не только целые числа, но также дроби."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "727c030b",
   "metadata": {
    "id": "727c030b"
   },
   "source": [
    "## Типы данных: Вещественные числа - FLOAT"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "36fd4ce0",
   "metadata": {
    "id": "36fd4ce0",
    "outputId": "d6ffa5da-19c7-4145-f3d4-dc774fda4b49"
   },
   "outputs": [],
   "source": [
    "type(1.5)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3998fd93",
   "metadata": {
    "id": "3998fd93"
   },
   "source": [
    "На что обратить внимание:\n",
    "- числа с десятичной частью, например, $1.43$, в отличие от Excel, в Python пишутся не через запятую `,`, а через точку `.`.\n",
    "\n",
    "Почувствуйте разницу:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7635af06",
   "metadata": {
    "id": "7635af06",
    "outputId": "30ae80f9-d666-46e9-a8dc-c691a81c35db"
   },
   "outputs": [],
   "source": [
    "print(2,6 / 2)  # печатает два числа\n",
    "print(2, 6 / 2)  # и так тоже два числа, пробел в данном случае неважен\n",
    "print(2.6 / 2)  # печатает одно число"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dd546029",
   "metadata": {
    "id": "dd546029"
   },
   "source": [
    "Иногда результаты могут быть довольно неожиданные. Может показаться, что python совершенно не умеет считать:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "96b69a4f",
   "metadata": {
    "id": "96b69a4f",
    "outputId": "00a7ccad-3d2d-4cf1-97b7-b0c7018f37bd"
   },
   "outputs": [],
   "source": [
    "print(0.1+0.2)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "931370ad",
   "metadata": {
    "id": "931370ad"
   },
   "source": [
    "## Типы данных: Строки (текст) - STR (STRING)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "dc0c089c",
   "metadata": {
    "id": "dc0c089c"
   },
   "source": [
    "С помощью `print` можно печатать не только числа. Например, текст:\n",
    "- текстовая строка в питоне -- это любое выражение, заключённое в двойные `\"` или одинарные `'` кавычки\n",
    "- с точки зрения пользователя ничем не отличается от привычного текста\n",
    "\n",
    "Например:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2b5d04a7",
   "metadata": {
    "id": "2b5d04a7",
    "outputId": "a6d55fbf-a445-4ea1-85dc-687135e3421a"
   },
   "outputs": [],
   "source": [
    "print('Моё имя:')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8083a5a2",
   "metadata": {
    "id": "8083a5a2",
    "outputId": "f2cd1c00-751a-46fc-943e-6460ebd16423"
   },
   "outputs": [],
   "source": [
    "type('Маргарита')"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "de2fd59b",
   "metadata": {},
   "source": [
    "Строки можно складывать и умножать на число:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "75b20d08",
   "metadata": {
    "id": "75b20d08",
    "outputId": "a9d70b64-da4f-48fe-cdcd-195981e53e80"
   },
   "outputs": [],
   "source": [
    "print('Сегодня'+'среда')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7cf0a7a3",
   "metadata": {
    "id": "7cf0a7a3",
    "outputId": "15e56f51-53dd-491c-bc75-577e94343ae1"
   },
   "outputs": [],
   "source": [
    "print('У меня '+ 'проблема'*20)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b4f553db",
   "metadata": {
    "id": "b4f553db"
   },
   "source": [
    "На что обратить внимание:\n",
    "- выражение `1` это число\n",
    "- выражение `'1'` это строка\n",
    "\n",
    "Почувствуйте разницу:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "17cc4717",
   "metadata": {
    "id": "17cc4717",
    "outputId": "0b412037-a96d-4dda-a25d-817371dd4aa5"
   },
   "outputs": [],
   "source": [
    "print(1 + 2)  # печатает число\n",
    "print('1' + '2')  # печатает результат склеивания строк\n",
    "print(str(1) + str(2))  # функция str преобразует аргумент в строку"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "63614001",
   "metadata": {},
   "source": [
    "### Индексирование строк"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5e2e6ce6",
   "metadata": {},
   "outputs": [],
   "source": [
    "s = 'Сегодня отличный день'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2093fbad",
   "metadata": {},
   "outputs": [],
   "source": [
    "s[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "a719767a",
   "metadata": {},
   "outputs": [],
   "source": [
    "s[1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c05f38d7",
   "metadata": {},
   "outputs": [],
   "source": [
    "s[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e58ce63d",
   "metadata": {},
   "outputs": [],
   "source": [
    "s[1:3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7cbf7537",
   "metadata": {},
   "outputs": [],
   "source": [
    "s[1:10:2]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ea1f6460",
   "metadata": {
    "id": "ea1f6460"
   },
   "source": [
    "## Типы данных: Логические переменные - boolean"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "c1efc857",
   "metadata": {
    "id": "c1efc857",
    "outputId": "4933472e-435e-4de5-e2ef-57e565e58357"
   },
   "outputs": [],
   "source": [
    "print(type(False))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "48a0d2cf",
   "metadata": {
    "id": "48a0d2cf",
    "outputId": "a4cd7775-6b17-4c1c-fe4f-926da672acc9"
   },
   "outputs": [],
   "source": [
    "print(type('True'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5b313a2f",
   "metadata": {
    "id": "5b313a2f",
    "outputId": "0f2be819-8c01-45ce-fef0-28d4cdd395d0"
   },
   "outputs": [],
   "source": [
    "print(34 == 30+4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7c058f7c",
   "metadata": {
    "id": "7c058f7c",
    "outputId": "d6fa5788-633e-4849-f0dd-4e1794ce0d3b"
   },
   "outputs": [],
   "source": [
    "print(35 == 30-5)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "bf1da279",
   "metadata": {},
   "source": [
    "Логические выражения можно комбинировать с помощью следующих логических операторов:\n",
    "\n",
    "* логическое И (and) - выражение истинно, только когда обе части истинны, иначе оно ложно\n",
    "* логическое ИЛИ (or) - выражение ложно, только когда обе части ложны, иначе оно истинно\n",
    "* логическое отрицание (not) - превращает True в False и наоборот"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cd1753fe",
   "metadata": {},
   "outputs": [],
   "source": [
    "print((1 == 1) and ('1' == 1))\n",
    "print((1 == 1) or ('1' == 1))\n",
    "print(not(1 == 1))\n",
    "print(((1 == 1) or ('1' == 1)) and (2 == 2))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "10c93a2f",
   "metadata": {
    "id": "10c93a2f"
   },
   "source": [
    "## Переменные"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ee9631a0",
   "metadata": {
    "id": "ee9631a0"
   },
   "source": [
    "В Python мы можем записывать в переменные какие-либо значения (или наборы значений):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "07280e73",
   "metadata": {
    "id": "07280e73"
   },
   "outputs": [],
   "source": [
    "number = 99\n",
    "my_name = 'Маргарита'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "40c5b441",
   "metadata": {
    "id": "40c5b441",
    "outputId": "1937555b-c7e5-45aa-fab4-b24f258808b5"
   },
   "outputs": [],
   "source": [
    "print(number)\n",
    "print(my_name)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6780c3ab",
   "metadata": {
    "id": "6780c3ab"
   },
   "source": [
    "Если мы будем реализовывать какие-то действия с переменными, то они будут осуществляться со значениями, которые записаны в эти переменные:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3d03b121",
   "metadata": {
    "id": "3d03b121",
    "outputId": "d4a6fd4f-772c-4519-a60f-989cb6f94d4f",
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "print(number*my_name)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4ab13f3a",
   "metadata": {
    "id": "4ab13f3a"
   },
   "source": [
    "## Ввод данных с клавиатуры"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9911e5b1",
   "metadata": {
    "id": "9911e5b1",
    "outputId": "bf0a1144-c640-474f-ea9d-016b7871cf6e"
   },
   "outputs": [],
   "source": [
    "name = input()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8d8d36e5",
   "metadata": {
    "id": "8d8d36e5",
    "outputId": "03264140-53b5-491d-9823-c0b6eef43c33"
   },
   "outputs": [],
   "source": [
    "print(name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "05aa1b43",
   "metadata": {
    "id": "05aa1b43",
    "outputId": "eda7752d-0b15-48e4-c9f9-3bc1b631f77a"
   },
   "outputs": [],
   "source": [
    "age = input()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "efa585fc",
   "metadata": {
    "id": "efa585fc",
    "outputId": "689b484b-63d5-446f-ac12-a06b08ecf959"
   },
   "outputs": [],
   "source": [
    "print(age*2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2b4929fc",
   "metadata": {
    "id": "2b4929fc",
    "outputId": "3091905b-2159-4c4d-a665-ba16d8b770d4"
   },
   "outputs": [],
   "source": [
    "print(type(age))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "3cc539db",
   "metadata": {
    "id": "3cc539db",
    "outputId": "1a13c11b-9bd9-4398-8fc8-828995dd44fd"
   },
   "outputs": [],
   "source": [
    "age2 = int(input())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7e05e6be",
   "metadata": {
    "id": "7e05e6be",
    "outputId": "c3f23143-d760-408e-9831-95cbfea723fa",
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "print(age2*3)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a6cc4771",
   "metadata": {
    "id": "a6cc4771"
   },
   "source": [
    "## Условные конструкции"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5293f5be",
   "metadata": {
    "id": "5293f5be"
   },
   "source": [
    "Иногда бывает нужно выполнять какую-то часть программы только при выполнении определенных условий."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "36237b5c",
   "metadata": {
    "id": "36237b5c"
   },
   "source": [
    "![](http://krivaksin.ru/wp-content/uploads/2015/11/2015-11-11-11-51-19-Microsoft-PowerPoint-Prezentatsiya1.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5a467c52",
   "metadata": {
    "id": "5a467c52"
   },
   "source": [
    "Синтаксис в питоне: <br />\n",
    "**if** условие1:<br />\n",
    "&emsp; команды<br />\n",
    "**elif** условие2:<br />\n",
    "&emsp; команды<br />\n",
    "**elif** условие3:<br />\n",
    "&emsp; команды<br />\n",
    "**else**: <br />\n",
    "&emsp; команды<br />\n",
    "\n",
    "Все команды пишутся с отступом."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5e356dfb",
   "metadata": {
    "id": "5e356dfb"
   },
   "source": [
    "### Операторы сравнения"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f24c82af",
   "metadata": {
    "id": "f24c82af"
   },
   "source": [
    "Как правило, в качестве проверяемого условия используется результат вычисления одного из следующих операторов сравнения:\n",
    "\n",
    "<center> \n",
    "    <table>\n",
    "        <tr>\n",
    "            <th>Логическое выражение </th>\n",
    "            <th> Значение </th>\n",
    "        </tr> \n",
    "        <tr><td>&lt;</td><td> Первый операнд меньше второго </td></tr>\n",
    "        <tr><td>&gt;</td><td> Первый операнд больше второго</td></tr>\n",
    "        <tr><td>&lt;=</td><td> Меньше или равно</td></tr>\n",
    "        <tr><td>&gt;=</td><td> Больше или равно</td></tr>\n",
    "        <tr><td>==</td><td> Два операнда равны </td></tr>\n",
    "        <tr><td>!=</td><td> Два операнда не равны</td></tr>\n",
    "    </table>\n",
    "</center>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "2ad3c9e7",
   "metadata": {},
   "outputs": [],
   "source": [
    "x = int(input(\"Введите число: \"))\n",
    "if x < 10:\n",
    "    print(\"Мало\")\n",
    "else:\n",
    "    print(\"Много\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "55c80b1b",
   "metadata": {},
   "source": [
    "В части с `if` мы прописываем условие, в зависимости от которого Python будет делать выбор, что выводить на экран, а после двоеточия перечисляем действия, которые будут выполняться в случае, если `x` удовлетворяет условию. В части с `else` мы уже не пишем никакого условия – оператор `else` сам по себе означает «в случае, если условие в выражении с `if` не выполнено».\n",
    "\n",
    "Часть с `else` является необязательной: программа может существовать только с условием `if`. Тогда в случае невыполнения условия ничего происходить не будет, Python просто перейдет к следующим строкам кода."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0d412207",
   "metadata": {},
   "source": [
    "Как быть, если условий несколько? Например, мы просим пользователя ввести число, и если число больше 10, на экране должно быть сообщение \"Много\", если ровно 10 – \"В самый раз\", если меньше – \"Мало\". Условные конструкции можно вкладывать друг друга, главное не забывать при этом про отступы:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ce17b03f",
   "metadata": {},
   "outputs": [],
   "source": [
    "if x < 10:\n",
    "    print(\"Мало\")\n",
    "else:\n",
    "    if x == 10:\n",
    "        print(\"В самый раз\")\n",
    "    else: \n",
    "        print(\"Много\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d3455022",
   "metadata": {
    "id": "d3455022"
   },
   "source": [
    "\n",
    "\n",
    "Попробуем написать программу, которая получает от пользователя два числа и определяет, какое из них больше. Для ввода данных пользователем используется функция `input()`. Т.к. в рамках этой задачи мы ожидаем от пользователя число, мы сразу преобразуем введенную им строку в тип `int` : `int(input())`. Теперь, если пользователь введет не число, мы получим ошибку.\n",
    "\n",
    "После того, как мы получили от пользователя два числа и записали их в переменные x и y, мы проверяем, какое из чисел больше, и выводим результат сравнения."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "364afa75",
   "metadata": {
    "id": "fb8626ff"
   },
   "outputs": [],
   "source": [
    "x = int(input()) # пользователь вводит число, мы присваиваем переменной x соответствующее значение\n",
    "y = int(input()) # пользователь вводит второе число, мы присваиваем переменной y соответствующее значение\n",
    "if x > y:\n",
    "    print('X больше Y')\n",
    "    print(x - y)\n",
    "elif y > x:\n",
    "    print('Y больше X')\n",
    "    print(y - x)\n",
    "else:\n",
    "    print('X равно Y')\n",
    "print(\"Всё!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "6556871a",
   "metadata": {
    "id": "6556871a"
   },
   "source": [
    "## Задача\n",
    "### Распродажа\n",
    "\n",
    "В магазине проходит акция:\n",
    "* На все товары за 1000 и дешевле 1000 рублей скидка 15%\n",
    "* На все товары дороже 1000, но дешевле 5000 рублей скидка 20%\n",
    "* На все товары за 5000 дороже 5000 рублей скидка 25%\n",
    "\n",
    "**Ввод**  \n",
    "Целое неотрицательное число - цена товара в рублях\n",
    "\n",
    "**Вывод**  \n",
    "Целое неотрицательное число - скидка на товар в рублях"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "24e44fed",
   "metadata": {
    "id": "24e44fed"
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "2615a014",
   "metadata": {},
   "source": [
    "# Цикл while"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d1a31040",
   "metadata": {},
   "source": [
    "Довольно часто задачи требуют от нас несколько раз выполнить однотипный код.\n",
    "\n",
    "Если писать несколько раз одни и те же строки, это загромождает программу. Иногда несколько раз превращается в много (100 или 10000).\n",
    "А иногда это число вообще зависит от параметров ввода.\n",
    "\n",
    "Справиться с этим помогают **циклы**. На этом семинаре мы поработаем с циклом **while (пока)**"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "28e8b3e6",
   "metadata": {},
   "source": [
    "Принцип использования цикла while: записываем логическое выражение и некоторый код. Код будет выполняться до тех пор, пока логическое выражение верно.\n",
    "\n",
    "Например, давайте напечатаем все целые числа от 1 до 10."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "834017c8",
   "metadata": {},
   "outputs": [],
   "source": [
    "i = 1 \n",
    "while i <= 10:\n",
    "    print(i) \n",
    "    i += 1 "
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1f9f5e17",
   "metadata": {},
   "source": [
    "Здесь мы использовали запись i += 1. Она эквивалентна i = i + 1.  \n",
    "Аналогично можно записывать и другие арифметические операции: например, -="
   ]
  },
  {
   "cell_type": "markdown",
   "id": "3626cb6e",
   "metadata": {},
   "source": [
    "Обратите внимание, что код внутри цикла (тот, который мы хотим повторно выполнять), выделяется отступом."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "8aa4a630",
   "metadata": {},
   "source": [
    "## Задача\n",
    "Вася начал бегать и в первый день он пробежал X километров и выдохся. Вася поставил себе цель Y километров и решил узнать, когда он ее достигнет, если каждый день будет бегать дистанцию на 10% больше, чем в предыдущий.\n",
    "\n",
    "**Формат ввода**\n",
    "\n",
    "Программа получает на вход целые числа X, Y\n",
    "\n",
    "**Формат вывода**\n",
    "\n",
    "Одно целое число (день, когда Вася пробежит свою цель)\n",
    "\n",
    "**Примеры**  \n",
    "**Ввод:**  \n",
    "10  \n",
    "21\n",
    "\n",
    "**Вывод:**  \n",
    "9"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "037b5c21",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "36b61fc0",
   "metadata": {},
   "source": [
    "## Списки"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "331ad531",
   "metadata": {},
   "source": [
    "Список — это упорядоченный набор объектов, хранящихся в одной переменной. В отличие от массивов в других языках, у списков нет никаких ограничений на тип переменных, поэтому в них могут храниться разные объекты, в том числе и другие коллекции."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "20a4d6b3-9b9c-4a6e-aaf1-44152349bbed",
   "metadata": {},
   "source": [
    "### Создание списков"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "f8310eb4-0473-4ab5-a165-79eed8321931",
   "metadata": {},
   "source": [
    "Давайте для начала попробуем создать список из 3 студентов."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0993246e-df9b-4642-aaa2-f652dbbb3087",
   "metadata": {},
   "outputs": [],
   "source": [
    "students = ['Ivan Ivanov', 'Tatiana Sidorova', 'Maria Smirnova']\n",
    "print(students)\n",
    "print(type(students))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "74adde82-b610-4ae1-9e3a-ad59cac0cca1",
   "metadata": {},
   "source": [
    "Пустой список можно создать двумя способами - оператором [] и функцией list()."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "426a2deb-06f5-45ad-894d-b6b10c77d3ff",
   "metadata": {},
   "outputs": [],
   "source": [
    "print([])\n",
    "print(list())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "42bfc39c-4894-4c78-bc96-2446672a620b",
   "metadata": {},
   "outputs": [],
   "source": [
    "a = list()\n",
    "a"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "73e89aa7-f94d-43c8-85ae-16472a59962a",
   "metadata": {},
   "source": [
    "Список может содержать любые данные - например, числа.  \n",
    "Давайте создадим список оценок студента."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "70f5697c-fda6-48cc-a577-82527427c65c",
   "metadata": {},
   "outputs": [],
   "source": [
    "notes = [6, 5, 7, 5, 8]\n",
    "print(notes)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "1ee6587e-85b8-42f9-b515-fb4d312a7b7c",
   "metadata": {},
   "outputs": [],
   "source": [
    "student1 = ['Ivan Ivanov', 1987, 7.5, True]\n",
    "print(student1)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7012e978-8c30-437f-8b93-fb7bd761ba1e",
   "metadata": {},
   "source": [
    "Список может даже содержать другие списки.  \n",
    "Давайте создадим еще одного студента по аналогии со student1 и положим этих двух студентов в еще один список."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9a8991c3-a36d-483a-a468-46c1f84623cf",
   "metadata": {},
   "outputs": [],
   "source": [
    "student2 = ['Maria Smirnova', 1991, 7.9, False]\n",
    "students = [student1, student2]\n",
    "print(students)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "10d6b37d",
   "metadata": {},
   "source": [
    "Список также можно получить из строки:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "ea10bdce",
   "metadata": {},
   "outputs": [],
   "source": [
    "lst = 'круассан булочка зефирка'.split()\n",
    "print(lst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "24d69959",
   "metadata": {},
   "outputs": [],
   "source": [
    "lst = 'Ночь.Улица.Фонарь.Аптека'.split('.')\n",
    "print(lst)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "55832799-e231-40d7-952e-f34625411418",
   "metadata": {},
   "source": [
    "### Срезы списков"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "51d6b5c1-dfd8-42ba-a57d-865db12718f3",
   "metadata": {},
   "source": [
    "Элементы списков нумеруются, начиная с 0. Мы можем получить доступ к элементу списка по его индексу."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "5553830c-70e0-4e8e-83ef-2e158cc4e0e2",
   "metadata": {},
   "outputs": [],
   "source": [
    "students = ['Ivan Ivanov', 'Tatiana Sidorova', 'Maria Smirnova']\n",
    "print(students[0]) # первый элемент\n",
    "print(students[1]) # второй элемент\n",
    "print(students[-2]) # предпоследний элемент"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d25b73b7-573b-404b-bf02-1035c6765f6e",
   "metadata": {},
   "source": [
    "Способ расширить список - метод .append(), который добавляет аргумент в список в качестве последнего элемента."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "23de2ad4-7f38-471f-b0fc-2846d06e9719",
   "metadata": {},
   "outputs": [],
   "source": [
    "lst = [0, 1, 2, 3, 4, 'cat', 'dog','cat']\n",
    "\n",
    "lst.append(5)\n",
    "print(lst)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "43af52ee-912b-4743-bfac-a7d44f7bd5e3",
   "metadata": {},
   "source": [
    "Удалить элемент из списка можно с помощью метода .remove() "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "fcab1b1d-b95f-47e8-8362-adefcc54aa13",
   "metadata": {},
   "outputs": [],
   "source": [
    "lst.remove('cat') # аргумент - объект, который ходим удалить\n",
    "print(lst)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "06cec914-e06f-4bfb-87b0-740163e4b371",
   "metadata": {},
   "source": [
    "Поиском в списках занимается метод .index(), который вернет индекс объекта, переданного в качестве аргумента."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "01634ac5-d5bd-4a4a-a76e-0e027cd6bd25",
   "metadata": {},
   "outputs": [],
   "source": [
    "lst.append('dog')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8bfacfab-7cd0-41fe-935e-c65a96cabc1b",
   "metadata": {},
   "outputs": [],
   "source": [
    "lst"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "87b4876f-2c4f-4bd9-8e77-8750d6091687",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(lst.index('dog'))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "67a56a84-b72b-4b95-8e1a-bfb987c6b335",
   "metadata": {},
   "source": [
    "Если говорить еще о полезных методах, то это .count(), который подсчитывает количество элементов. Ниже еще отдельно поговорим о сортировке."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "d90badda-c3fe-46fc-9cb6-ec4f0817e140",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(lst.count('dog'))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "cc50d7e6-28da-4fa8-a544-4443a3c9c17c",
   "metadata": {},
   "source": [
    "Все методы списков [здесь](https://docs.python.org/3/tutorial/datastructures.html)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b5d035a8-ff1a-4f13-8168-d1da120f6a26",
   "metadata": {},
   "source": [
    "### Сортировки"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "f92fba57-df26-4005-9768-f4b41f8745ea",
   "metadata": {},
   "outputs": [],
   "source": [
    "b = [1,2,3,4,5]\n",
    "b.reverse()\n",
    "b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0cdc6e71-598a-4e02-a6d5-7c35839bb96e",
   "metadata": {},
   "outputs": [],
   "source": [
    " # считаем количество 'dog' в списке\n",
    "lst.reverse() # разворачиваем список. Осторожно - метод меняет список!\n",
    "print(lst)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7e8d4fc5-8095-4c63-8daf-80b60d48901a",
   "metadata": {},
   "source": [
    "Отдельно следует рассказать про метод **sort()**. Метод производит сортировку списка.\n",
    "Задачи сортировки - очень распространены в программировании. \n",
    "В общем случае, они сводятся к выстроению элементов списка в заданном порядке.\n",
    "В Python есть встроенные методы для сортировки объектов для того, чтобы программист \n",
    "мог не усложнять себе задачу написанием алгоритма сортировки. \n",
    "Метод **list.sort()** - как раз, один из таких случаев."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "6e048a11-d145-4602-a810-4821403c0f5a",
   "metadata": {},
   "outputs": [],
   "source": [
    "test_list = [5, 8, 1, 4, 3, 7, 2]\n",
    "print(test_list)  # Элементы списка расположены в хаотичном порядке\n",
    "test_list.sort()\n",
    "print(test_list)  # Теперь элементы списка теперь расположены по возрастанию"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "9a29ca67-4f4c-4800-a8b2-4f16a50ee201",
   "metadata": {},
   "outputs": [],
   "source": [
    "test_list.sort(reverse = True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "932d33d2-62b4-4f10-8340-428ba6708c39",
   "metadata": {},
   "outputs": [],
   "source": [
    "test_list"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c0c52040-551c-47cf-8bae-4b051d2a5311",
   "metadata": {},
   "source": [
    "Таким образом, метод **list.sort()** упорядочил элементы списка test_list\n",
    "Если нужно отсортировать элементы в обратном порядке, то можно использовать именнованный параметр reverse. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "085b6128-fbb9-4f0d-acac-7d9237b8960c",
   "metadata": {},
   "outputs": [],
   "source": [
    "test_list.sort(reverse=True)  # параметр reverse указывает на то, что нужно отсортировать список в обратном порядке\n",
    "print(test_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "4e7a9fd3-5899-4cd5-9e4c-fe003739fd60",
   "metadata": {},
   "source": [
    "Следует обратить внимание, что метод **list.sort()** изменяет сам список, на котором его вызвали. \n",
    "Таким образом, при каждом вызове метода \"**sort()**\", наш список \"test_list\" изменяется. \n",
    "Это может быть удобно, если нам не нужно держать в памяти исходный список. \n",
    "Однако, в противном случае, или же - в случае неизменяемого типа данных (например, кортежа или строки) - \n",
    "этот метод не сработает. В таком случае, на помощь приходит встроенная в питон функция **sorted()**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0f923ce6-38ac-4bbd-a713-0596fb7ea138",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(sorted(test_list))  # Сам список при сортировке не изменяется"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "e01059d5-bf56-465c-b2a7-09de97278f4f",
   "metadata": {},
   "outputs": [],
   "source": [
    "test_list"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "1d218570-40ac-4f3c-bd53-26431e267467",
   "metadata": {},
   "source": [
    "Так как sorted() функция, а не метод, то будет работать и с другими типами данных."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "363cbbcd-4f20-44e3-9be9-cf95454a0768",
   "metadata": {},
   "outputs": [],
   "source": [
    "print(sorted('something'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "7c13d158-2f68-44be-8abc-3574c2ab917e",
   "metadata": {},
   "outputs": [],
   "source": [
    "# print(sorted('something')) отсортирует буквы в строке, но выведет список\n",
    "print(''.join(sorted('something'))) # с помощью метода join можно собрать отсортированную строку, чуть ниже подробнее про него"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "MuGX6CE5XCe8",
   "metadata": {
    "id": "MuGX6CE5XCe8"
   },
   "source": [
    "## Циклы For\n",
    "\n",
    "* Список - это хранилище для произвольного числа элементов. Список задается квадратными скобками: letters = [\"a\", \"b\", \"c\"]. Внутри элементы перечисляются через запятую.\n",
    "* Цикл задается с помощью команды for, например: for number in [1, 2, 3]:\n",
    "* Все, что выполняется внутри цикла, пишется с отступом в 4 пробела (или Tab)\n",
    "* Цикл позволяет перебирать элементы последовательности (например, списка) и повторять для них одни и те же действия.\n",
    "Пример:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "wH5C9TZmXCe8",
   "metadata": {
    "id": "wH5C9TZmXCe8",
    "outputId": "f1700044-53e8-4052-d79e-c420e93d483f"
   },
   "outputs": [],
   "source": [
    "for number in [1, 2, 3]:\n",
    "    print(\"Hello!\")\n",
    "    print(number)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "d0e41106",
   "metadata": {},
   "source": [
    "## Задача\n",
    "\n",
    "Согласно политике безопасности банка, пароль не может содержать года рождения клиента — иначе вероятность подобрать пароль увеличивается. Напишите программу, которая будет проводить такую проверку. \n",
    "\n",
    "**ФОРМАТ ВВОДА** \n",
    "\n",
    "На первой строке — полный год рождения клиента (то есть 4 символа, например, «1968»). \n",
    "На второй строке — три варианта пароля, придуманных клиентом, записанных через пробел. \n",
    "\n",
    "**ФОРМАТ ВЫВОДА** \n",
    "\n",
    "True, если в пароле есть подстрока с годом рождения, и False, если нет. \n",
    "Ответ по каждому варианту пароля нужно выводить с новой строки."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0d88394e",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "83d2ca05-d4ff-476c-af90-0751de094702",
   "metadata": {},
   "source": [
    "## Задача \n",
    "\n",
    "Дано 10 целых чисел. Вычислите их сумму. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bd8f9e7d-000e-4c8d-99a2-44d7910aca0f",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "colab": {
   "provenance": []
  },
  "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.13"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}