{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Основы программирования в Python\n",
    "\n",
    "*Алла Тамбовцева, НИУ ВШЭ*\n",
    "\n",
    "*Данный ноутбук основан на [лекции](http://nbviewer.math-hse.info/github/ischurov/pythonhse/blob/master/Lecture%203.ipynb#%D0%9F%D1%80%D0%BE%D0%B2%D0%B5%D1%80%D0%BA%D0%B0-%D1%83%D1%81%D0%BB%D0%BE%D0%B2%D0%B8%D0%B9) Щурова И.В., курс «Программирование на языке Python для сбора и анализа данных» (НИУ ВШЭ).*"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Условные конструкции, множества, цикл `while`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Проверка условий"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Начнем с известных всем операторов. Проверим, \n",
    "\n",
    "* правда ли, что 8 меньше 9; \n",
    "* правда ли, что 9 больше 10."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "8 < 9 # правда"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "9 > 10 # неправда"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Результат такой проверки имеет логический тип (*boolean*). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "res = 8 < 9\n",
    "res"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Как мы уже обсуждали, переменные такого типа могут принимать два значения True или False. Обратите внимание, что True и False не заключены в кавычки ‒ добавив кавычки, мы получим строки \"True\" и \"False\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"True\" == True"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "При проверке равенства двух частей (переменных, списков и так далее) используется двойной знак \"равно\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "6 == 6"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Одинарный знак \"равно\" используется для присваивания значений. Так ничего не сравним, но сохраним в переменную `a` число 6:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 6 \n",
    "a "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "А так уже проверим условия:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print(a == 6) \n",
    "print(a == 9) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Неравенство, то есть отрицание равенства, в Python обозначается с помощью оператора `!=` (вообще `!` в программировании используется для отрицания). "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "6 != 7"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Стоит отметить, что Python достаточно лояльно относится к разделению между типам данных. Например, если мы сравним целое число и то же число, но с плавающей точкой (с дробной частью равной 0), Python сообщит, что эти числа совпадают."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "6 == 6.0 # верно"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Условные конструкции"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Условные конструкции ‒ конструкции с операторами условия. Условная конструкция обычно предполагает \"развилку\": если условие выполняется, то должен выполняться один набор действий, если нет ‒ другой набор действий. Давайте напишем программу, которая будет просить пользователя ввести целое число, и если это число менее 10, на экран будет выводиться сообщение \"Мало\", иначе ‒ \"Много\". И заодно познакомимся с конструкцией *if-else*."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Введите число: 10\n"
     ]
    }
   ],
   "source": [
    "x = int(input(\"Введите число: \"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Много\n"
     ]
    }
   ],
   "source": [
    "if x < 10:\n",
    "    print(\"Мало\")\n",
    "else:\n",
    "    print(\"Много\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В части с `if` мы прописываем условие, в зависимости от которого Python будет делать выбор, что выводить на экран, а после двоеточия перечисляем действия, которые будут выполняться в случае, если `x` удовлетворяет условию. В части с `else` мы уже не пишем никакого условия ‒ оператор `else` сам по себе означает \"в случае, если условие в выражении с `if` не выполнено\".\n",
    "\n",
    "Часть с `else` является необязательной: программа может существовать только с условием `if`. Тогда в случае невыполнения условия ничего происходить не будет, Python просто перейдет к следующим строкам кода."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Как быть, если условий несколько? Например, мы просим пользователя ввести оценку, и если оценка больше 10, на экране должно быть сообщение \"Много\", если ровно 10 ‒ \"В самый раз\", если меньше ‒ \"Мало\". Можно воспользоваться оператором `elif`, который по смыслу является сочетанием `else + if`: если предыдущее условие невыполнено, то, нужно проверить следующее условие, и если оно тоже не выполнено, то уже перейти к ветке с `else`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Введите оценку: 3\n"
     ]
    }
   ],
   "source": [
    "mark = int(input(\"Введите оценку: \"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Мало\n"
     ]
    }
   ],
   "source": [
    "if mark > 10:\n",
    "    print(\"Много\")\n",
    "elif mark == 10:\n",
    "    print(\"В самый раз\")\n",
    "else:\n",
    "    print(\"Мало\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ответвлений с `elif` может быть несколько: сколько условий, столько и выражений с `elif`. Добавим еще одно условие:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Плохо\n"
     ]
    }
   ],
   "source": [
    "if mark > 10:\n",
    "    print(\"Много\")\n",
    "elif mark > 6:\n",
    "    print(\"Хорошо\")\n",
    "elif mark > 4:\n",
    "    print(\"Неплохо\")\n",
    "else:\n",
    "    print(\"Плохо\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Законный вопрос: а можно ли обойтись совсем без `elif`, просто записав несколько выражений с `if`? Тут все зависит от ситуации. Иногда решения использовать `elif` и `if` будут равнозначными. Если мы перепишем код в примере выше, заменив `elif` на `if`, ничего не изменится, так как условия будут проверяться последовательно в любом случае: если оценка больше 10, будет выведено слово \"Много\", если нет ‒ программа перейдет к следующему условию, и так далее. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Плохо\n"
     ]
    }
   ],
   "source": [
    "if mark > 10:\n",
    "    print(\"Много\")\n",
    "if mark > 6:\n",
    "    print(\"Хорошо\")\n",
    "if mark > 4:\n",
    "    print(\"Неплохо\")\n",
    "else:\n",
    "    print(\"Плохо\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В случае, когда условия как-то связаны между собой, нужно быть более внимательными. Рассмотрим такой пример. \n",
    "\n",
    "**Случай 1.** "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Это нормально\n",
      "Плохо\n"
     ]
    }
   ],
   "source": [
    "if mark < 10:\n",
    "    print(\"Это нормально\")\n",
    "elif mark == 10:\n",
    "    print(\"Отлично\")\n",
    "if mark < 6:\n",
    "    print(\"Плохо\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Если оценка меньше 10, мы выводим на экран сообщение \"Это нормально\", если нет, то проверяем, равна ли она 10: если да, то выводим \"Отлично\", если нет ‒ ничего не делаем. При этом, *после* всех этих действий делаем дополнительную проверку: если оценка меньше 6, выводим \"Плохо\". "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Случай 2.** "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Это нормально\n"
     ]
    }
   ],
   "source": [
    "if mark < 10:\n",
    "    print(\"Это нормально\")\n",
    "elif mark == 10:\n",
    "    print(\"Отлично\")\n",
    "elif mark < 6:\n",
    "    print(\"Плохо\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Если оценка меньше 10, мы выводим на экран сообщение \"Это нормально\", если нет, то проверяем, равна ли она 10: если да, то выводим \"Отлично\", если нет ‒ сравниваем ее с 6. Если оценка меньше 6, выводим \"Плохо\". "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Почему во втором случае мы не увидели сообщение \"Плохо\"? Потому что из-за второго `elif` мы попросту до него не дошли! На ветку со вторым `elif` мы попадаем в случае, если предыдущее условие не выполняется, то есть если оценка  не равна 10. А на ветку с первым `elif` мы попадем, в случае, если оценка не менее 10. Получается, что мы должны выводить слово \"Плохо\" в случае, когда оценка более 10 и при этом менее 6, чего в природе не бывает. Использовав `elif` необдуманно, мы добавили лишнее условие, которое никогда не будет выполняться! Тут будет полезно вспомнить схемы, которые многие, наверное, видели на уроках информатики в школе. Запоминать их необязательно, просто они хорошо иллюстрируют различия между двумя случаями."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Случай 1**\n",
    "\n",
    "![title](1.png)\n",
    "\n",
    "**Случай 2**\n",
    "\n",
    "![title](2.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Возможно, предыдущее обсуждение `if` и `elif` могло вас чуть-чуть запутать, но это не повод расстраиваться. Важно просто помнить, что разница между этими операторами есть. Остальное можно проверить экспериментально на конкретном примере :) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Сложные условия"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Пусть у нас есть три целочисленные переменные `a`, `b` и `c`, и мы планируем составлять сложные, составные уcловия, касающиеся этих переменных."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = 3\n",
    "b = 7\n",
    "c = 1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Помогут операторы `and` и `or`. Оператор `and` соответствует одновременному выполнению условий, оператор `or` соответствует ситуации, когда хотя бы одно из условий выполняется. Оператор `or` в Python ‒ обычное \"или\", не исключающее: либо верно первое условие, либо второе, либо оба."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(a < b) and (b > c) # оба верны"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(a < b) and (c > b) # второе неверно -> все неверно"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(a < b) or (a > c) # первое верное -> хотя бы одно верно"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(a < b) or (c > b) # первое верное -> хотя бы одно верно"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Можем работать с элементами списков:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "l1 = [1, 3, 6, 8]\n",
    "l2 = [0, 9, 6, 8]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "l1[0] > l2[0] # 1 больше 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(l1[0] > l2[0]) and (l1[2] == l2[2]) # оба верны"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(l1[0] > l2[0]) or (l1[2] == l2[2]) # оба верны"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Давайте пройдемся по парам элементов в списках `l1` и `l2`, и если значения элементов, которые стоят на одном и том же месте, просто в разных списках, совпадают, мы будем выводить сообщение \"It's true! They are equal!\", а если нет ‒ сообщение \"It's false! They are not equal!\".\n",
    "\n",
    "Сначала посмотрим на длину списков:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "print(len(l1))\n",
    "print(len(l2))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Списки одинаковой длины, это хорошо! Напишем цикл."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "It's false! They are not equal!\n",
      "It's false! They are not equal!\n",
      "It's true! They are equal!\n",
      "It's true! They are equal!\n"
     ]
    }
   ],
   "source": [
    "for i in range(0, len(l1)):\n",
    "    if l1[i] == l2[i]:\n",
    "        print(\"It's true! They are equal!\")\n",
    "    else:\n",
    "        print(\"It's false! They are not equal!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "А теперь предлагаю вам такую задачу. Есть список оценок `marks`, и для каждой оценки нужно вывести комментарий (Отлично, Хорошо, Удовлетворительно, Плохо) с новой строки. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "marks = [2, 7, 8, 10, 5, 8, 1, 6]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Решение:**"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Плохо!\n",
      "Хорошо!\n",
      "Отлично!\n",
      "Отлично!\n",
      "Удовлетворительно!\n",
      "Отлично!\n",
      "Плохо!\n",
      "Хорошо!\n"
     ]
    }
   ],
   "source": [
    "for mark in marks:\n",
    "    if mark >= 8:\n",
    "        print(\"Отлично!\")\n",
    "    elif (mark >= 6) and (mark < 8):\n",
    "        print(\"Хорошо!\")\n",
    "    elif (mark >= 4) and (mark < 6):\n",
    "        print(\"Удовлетворительно!\")\n",
    "    else:\n",
    "        print(\"Плохо!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Можно написать аналогичный код, но оценку теперь будет вводить пользователь с клавиатуры. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Введите оценку: 6\n",
      "Хорошо!\n"
     ]
    }
   ],
   "source": [
    "mark = int(input(\"Введите оценку: \"))\n",
    "if mark >= 8:\n",
    "    print(\"Отлично!\")\n",
    "elif (mark >= 6) and (mark < 8):\n",
    "    print(\"Хорошо!\")\n",
    "elif (mark >= 4) and (mark < 6):\n",
    "    print(\"Удовлетворительно!\")\n",
    "else:\n",
    "    print(\"Плохо!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Небольшое лирическое отступление, не связанное с условиями.* В Python есть функция `eval()`, которая позволяет исполнять код, который записан в виде строки. Например, мы сохранили в текстовый файл какие-то списки. Открываем файл, и Python считывает наши списки как обычные строки:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "s = \"[2,5,6,8]\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'[2,5,6,8]'"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "s"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Если мы применим к строке `s` функцию `eval()`, мы получим список."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 5, 6, 8]"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "L = eval(s)\n",
    "L"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Работает это не только для списков:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "eval(\"a == 8\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Внимание: использование функции `eval()` считается небезопасным в том смысле, что она исполняет любой код, заключенный в строке, не проверяя при этом, является ли код хорошим, правильным. Более корректно было бы использовать функцию `literal_eval()`, которую вы можете встретить в автоматических тестах в домашних заданиях. Эту функцию нужно импортировать из модуля`ast`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [],
   "source": [
    "from ast import literal_eval"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3]"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "literal_eval(\"[1,2,3]\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Кроме `and` и `or` в Python есть еще полезные операторы: оператор принадлежности `in` и оператор отрицания `not`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Пусть у нас есть списки отличных, хороших, удовлетворительных и плохих оценок."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [],
   "source": [
    "excel = [8, 9, 10]\n",
    "good = [6, 7]\n",
    "sat = [4, 5]\n",
    "bad = [1, 2, 3]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Проверим, лежит ли оценка 8 в плохих:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "8 in bad"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Применим отрицание:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "8 not in bad # верно!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Множества"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Иногда возникает необходимость проверять разные отношения между двумя наборами элементов. Например, проверить, есть ли у двух списков общие элементы. Для этого можно воспользоваться уже известным оператором `in`: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "L1 = [1, 3, 4]\n",
    "L2 = [1, 4, 5, 6]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "for i in L2:\n",
    "    if i in L1:\n",
    "        print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Но иногда удобно превратить списки в множества (*sets*) и выполнять операции, которые определены для множеств в математике: пересечение, объединение, разность и так далее. \n",
    "\n",
    "Важно иметь в виду, что в множествах (как в программировании, так и в математике) не может быть повторяющихся элементов. Поэтому, если в списке есть повторяющиеся значения, и они важны, превращать спискок в множество не стоит, так как можно потерять элементы."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "numbers = [1, 1, 0, 2, 4, 3, 3] # 7 элементов"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0, 1, 2, 3, 4}"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set(numbers) # в множестве осталось 5 элементов + отсортированы по возрастанию"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Множества из строк тоже существуют (вообще их можно создавать из любых объектов):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [],
   "source": [
    "words = [\"one\", \"one\", \"two\", \"three\"] # пока список"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'one', 'three', 'two'}"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "set(words) # множество"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "А теперь превратим два числовых списка в множества A и B и попробуем произвести некоторые операции."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [],
   "source": [
    "A = set([0, 2, 4, 7])\n",
    "B = set([0, 1, 4, 5])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Пересечение множеств A и B ‒ общие элементы этих двух множеств:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0, 4}"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B.intersection(A) # метод intersection"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Объединение множеств A и B ‒ все элементы множества A и множества B (но, конечно, без повторений):"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0, 1, 2, 4, 5, 7}"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.union(B) # метод union"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Разность множеств B и A ‒ все элементы множества B, которых нет в A."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{1, 5}"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B.difference(A) # метод difference"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "*Обратите внимание:* результат, полученный после использования методов для множеств, тоже является множеством ‒ элементы перечислены в фигурных скобках. Но при желании результат можно превратить в список:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[2, 7]"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "list(A.difference(B))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Множество в Python, наверное, не такой распространенный объект как список, кортеж или словарь (о них поговорим позже), но знать о них полезно, потому что в некоторых задачах использовать методы для множеств гораздо эффективнее, чем писать какие-то циклы с разными условиями."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Цикл `while`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "С циклом `for` мы уже знакомы. Сейчас мы познакомимся с циклом `while`, логика которого отличается от `for`. Конструкции с циклом `while` устроены следующим образом: действия, которые указаны в теле цикла, должны выполняться до тех пор, пока верно условие, прописанное после `while` (отсюда и название). Если в цикле `for` мы указывали некоторый промежуток, по которому в ходе цикла мы будем \"пробегаться\", то в случае с циклом `while` мы просто фиксируем стартовую точку, а конечную точку никак не указываем: программа сама остановится, когда условие в цикле перестанет выполняться."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "nums = [1, 0, 9, 10, -1, 8]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Давайте, используя цикл `while`, будем выводить на экран элементы списка `nums` до тех пор, пока не столкнемся с отрицательным значением."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "0\n",
      "9\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "i = 0 # начинаем с индекса i=0\n",
    "\n",
    "while nums[i] >= 0: # пока элемент nums[i] >= 0\n",
    "    print(nums[i]) # выводим элемент на экран\n",
    "    i = i + 1 # переходим к следующему элементу"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "На значении 10 мы остановились: за ним идет значение -1, для которого условие `nums[i] > = 0` не выполняется. \n",
    "\n",
    "Давайте теперь попробуем переписать код так, чтобы он работал точно так же, но только чтобы в нем использовался цикл `for`, а не `while`. Вообще почти любой код с `while` можно переписать через `for`, и иногда это полезно: код с циклом `while` обычно более медленный, плюс, склонен к зацикливанию."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "0\n",
      "9\n",
      "10\n"
     ]
    }
   ],
   "source": [
    "for n in nums:\n",
    "    if n >= 0:\n",
    "        print(n)\n",
    "    else:\n",
    "        break # выходим из цикла"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В коде выше мы использовали оператор `break`, который позволяет выйти из цикла, то есть закончить исполнение строк кода в теле цикла и перейти к коду дальше.  \n",
    "\n",
    "А теперь напишем маленькую игру-угадайку. Программа будет загадывать целое число от 1 до 100, а пользователь его угадывать. Как программа будет загадывать число? Выбирать случайным образом из интервала [1, 100] (на самом деле псевдослучайным образом, так как абсолютной случайности не получится, генерирование чисел происходит по фиксированным алгоритмам)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "from random import randrange # импортируем модуль для функии randrange"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [],
   "source": [
    "n = randrange(1, 101) # n и есть загаданное число"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Осталось написать цикл. До тех пор, пока пользователь не угадает число, программа не будет останавливаться, но зато она будет давать подсказки: если введенное пользователем число больше загаданного, то будет выводиться сообщение \"Вы ввели слишком большое число.\", если меньше ‒ \"Вы ввели слишком маленькое число.\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ваша попытка:23\n",
      "Вы ввели слишком большое число.\n",
      "Ваша попытка:11\n",
      "Вы ввели слишком маленькое число.\n",
      "Ваша попытка:15\n",
      "Вы ввели слишком маленькое число.\n",
      "Ваша попытка:20\n",
      "Вы ввели слишком большое число.\n",
      "Ваша попытка:18\n",
      "Вы ввели слишком большое число.\n",
      "Ваша попытка:17\n",
      "Вы ввели слишком большое число.\n",
      "Ваша попытка:16\n",
      "Вы выиграли!\n"
     ]
    }
   ],
   "source": [
    "while True:\n",
    "    guess = int(input(\"Ваша попытка:\"))\n",
    "    if guess == n:\n",
    "        print(\"Вы выиграли!\")\n",
    "        break\n",
    "    elif guess > n:\n",
    "        print(\"Вы ввели слишком большое число.\")\n",
    "    else: \n",
    "        print(\"Вы ввели слишком маленькое число.\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В коде выше в `while` мы не написали никакого условия явно, вместо этого мы написали `while True`. Это выражение означает \"до тех пор, пока мы не вышли из цикла\". В нашем случае это равносильно \"до тех пор, пока не столкнулись с `break`, пока наш ответ не совпал с загаданным числом."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}