<commit_before><commit_msg>Add notebook for ifs<commit_after>{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "toc": true
   },
   "source": [
    "<h1>Содержание<span class=\"tocSkip\"></span></h1>\n",
    "<div class=\"toc\"><ul class=\"toc-item\"><li><span><a href=\"#Условный-оператор-if\" data-toc-modified-id=\"Условный-оператор-if-1\">Условный оператор if</a></span></li><li><span><a href=\"#Логический-тип-bool\" data-toc-modified-id=\"Логический-тип-bool-2\">Логический тип bool</a></span></li><li><span><a href=\"#Логические-операции-(<,-==,-...)\" data-toc-modified-id=\"Логические-операции-(<,-==,-...)-3\">Логические операции (&lt;, ==, ...)</a></span></li><li><span><a href=\"#Логические-выражения\" data-toc-modified-id=\"Логические-выражения-4\">Логические выражения</a></span></li></ul></div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Условный оператор и логические выражения"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Условный оператор if"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Для проверки истинности выражений в Python используется оператор `if`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ложь\n"
     ]
    }
   ],
   "source": [
    "if 5 < 3:\n",
    "    print(\"Правда\")\n",
    "else:\n",
    "    print(\"Ложь\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Особенности синтаксиса:\n",
    "\n",
    "* После условия в `if` ставится `:`\n",
    "* После `else` ставится `:`\n",
    "* Принадлежащий `if`'у блок обозначается отступом в 4 пробела\n",
    "* Скобки вокруг условия не нужны\n",
    "\n",
    "Пример вложненного `if`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1\n",
      "2\n",
      "5\n"
     ]
    }
   ],
   "source": [
    "if 10 > 5:\n",
    "    print(\"1\")\n",
    "    print(\"2\")\n",
    "    if 5 < 4:\n",
    "        print(\"3\")\n",
    "        print(\"4\")\n",
    "    else:\n",
    "        print(\"5\")\n",
    "else:\n",
    "    print(\"6\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "По отступам очень удобно отслеживать, какой else к какому if относится. Если не ставить двоеточие или отступы, то программа будет выдавать ошибку и не запустится."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (<ipython-input-3-31e60e34f7f6>, line 1)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-3-31e60e34f7f6>\"\u001b[0;36m, line \u001b[0;32m1\u001b[0m\n\u001b[0;31m    if 6 > 5\u001b[0m\n\u001b[0m            ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "if 6 > 5\n",
    "    print(\"Пропущено двоеточие!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "ename": "IndentationError",
     "evalue": "expected an indented block (<ipython-input-4-e9ee115d8323>, line 2)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  File \u001b[0;32m\"<ipython-input-4-e9ee115d8323>\"\u001b[0;36m, line \u001b[0;32m2\u001b[0m\n\u001b[0;31m    print(\"Пропущен отступ!\")\u001b[0m\n\u001b[0m        ^\u001b[0m\n\u001b[0;31mIndentationError\u001b[0m\u001b[0;31m:\u001b[0m expected an indented block\n"
     ]
    }
   ],
   "source": [
    "if 6 > 5:\n",
    "print(\"Пропущен отступ!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Конструкция `elif` позволяет рассматривать множественные случаи без вложенных `if ... else` в ветке `else`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 or 3\n"
     ]
    }
   ],
   "source": [
    "x = 3\n",
    "if x < 2:\n",
    "    print(\"0 or 1\")\n",
    "else:\n",
    "    if x < 4:\n",
    "        print(\"2 or 3\")\n",
    "    else:\n",
    "        print(\"4+\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Тот же код с использованием `elif` выглядит так:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2 or 3\n"
     ]
    }
   ],
   "source": [
    "x = 3\n",
    "if x < 2:\n",
    "    print(\"0 or 1\")\n",
    "elif x < 4:\n",
    "    print(\"2 or 3\")\n",
    "else:\n",
    "    print(\"4+\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Логический тип bool"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "У **булевского (bool)** логического типа существуют 2 возможных значения: `True` (истина) и `False` (ложь)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ветка if\n"
     ]
    }
   ],
   "source": [
    "if True:\n",
    "    print(\"Ветка if\")\n",
    "else:\n",
    "    print(\"Ветка else\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ветка else\n"
     ]
    }
   ],
   "source": [
    "if False:\n",
    "    print(\"Ветка if\")\n",
    "else:\n",
    "    print(\"Ветка else\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Переменные также могут быть булевского типа:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "a = True\n",
    "b = False\n",
    "print(a, b)\n",
    "if a:\n",
    "    print(a)\n",
    "if b:\n",
    "    print(b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Понятно, что после `if` может стоять не только значение `True` или `False`. Посмотрим, что делает Python, если после `if` стоит нечто более странное?\n",
    "\n",
    "Одни типы данных могут приводиться к другим, если это возможно (если Python позволяет). Такое преобразование называется **преобразованием типов** (или приведением типов).\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Например, `0` преобразуется в `False`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ветка else\n"
     ]
    }
   ],
   "source": [
    "if 0:                     \n",
    "    print(\"Ветка if\")\n",
    "else:\n",
    "    print(\"Ветка else\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Любое другое число (в том числе и нецелое), отличное от `0` преобразуется в `True`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ветка if\n"
     ]
    }
   ],
   "source": [
    "if 3.5:\n",
    "    print(\"Ветка if\")\n",
    "else:\n",
    "    print(\"Ветка else\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ветка else\n"
     ]
    }
   ],
   "source": [
    "if 0.0:\n",
    "    print(\"Ветка if\")\n",
    "else:\n",
    "    print(\"Ветка else\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ветка if\n"
     ]
    }
   ],
   "source": [
    "if -1:\n",
    "    print(\"Ветка if\")\n",
    "else:\n",
    "    print(\"Ветка else\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Пустая строка `\"\"` преобразуется в `False`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ветка else\n"
     ]
    }
   ],
   "source": [
    "if \"\":\n",
    "    print(\"Ветка if\")\n",
    "else:\n",
    "    print(\"Ветка else\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Непустая строка — в `True`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ветка if\n"
     ]
    }
   ],
   "source": [
    "if \"abc\":\n",
    "    print(\"Ветка if\")\n",
    "else:\n",
    "    print(\"Ветка else\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Логические операции (<, ==, ...)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Посмотрим, как устроены логические операции и операции сравнения в Python."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Список основных операторов сравнения, которые вам понадобятся:\n",
    "\n",
    "| Действие | Обозначение в Python | Аналог в C++ | Аналог в Pascal | Приоритет |\n",
    "| --- | --- | --- | --- | --- |\n",
    "| Равенство | `a == b` | `a == b` | `a = b` | 4 |\n",
    "| Неравенство | `a != b` | `a != b` | `a != b` | 4 |\n",
    "| Меньше | `a < b` | `a < b` | `a < b` | 4 |\n",
    "| Меньше либо равно | `a <= b` | `a <= b` | `a <= b` | 4 |\n",
    "| Больше | `a > b` | `a > b` | `a > b` | 4 |\n",
    "| Больше либо равно | `a >= b` | `a >= b` | `a >= b` | 4 |"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Список основных логических операторов, которые вам понадобятся:\n",
    "\n",
    "<table>\n",
    "<thead><tr>\n",
    "<th>Действие</th>\n",
    "<th>Обозначение в Python</th>\n",
    "<th>Аналог в C++</th>\n",
    "<th>Аналог в Pascal</th>\n",
    "<th>Приоритет</th>\n",
    "</tr>\n",
    "</thead>\n",
    "<tbody>\n",
    "<tr>\n",
    "<td>Логическое отрицание</td>\n",
    "<td><code>not a</code></td>\n",
    "<td><code>!a</code></td>\n",
    "<td><code>not a</code></td>\n",
    "<td>5</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>Логическое и</td>\n",
    "<td><code>a and b</code></td>\n",
    "<td><code>a &amp;&amp; b</code></td>\n",
    "<td><code>a and b</code></td>\n",
    "<td>6</td>\n",
    "</tr>\n",
    "<tr>\n",
    "<td>Логическое или</td>\n",
    "<td><code>a or b</code></td>\n",
    "<td><code>a &vert;&vert; b</code></td>\n",
    "<td><code>a or b</code></td>\n",
    "<td>7</td>\n",
    "</tr>\n",
    "</tbody>\n",
    "</table>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Примеры:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n"
     ]
    }
   ],
   "source": [
    "print(5 > 2)\n",
    "print(not 5 > 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "a = 5\n",
    "b = 2\n",
    "print(b == a)\n",
    "print(b != a)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "a = True\n",
    "b = False\n",
    "print(not b)\n",
    "print(a and b)\n",
    "print(a or b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Логические выражения"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Как и во многих других языках программирования, вы можете составлять большие выражения из `True`, `False`, булевых переменных, операций сравнения, логических операций и скобок (для изменения приоритета). Например:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n",
      "True\n",
      "Обратите внимание, в if не нужны скобки вокруг условия\n"
     ]
    }
   ],
   "source": [
    "a = 5\n",
    "b = 2\n",
    "print(True and a > 2)\n",
    "print(False or b >= 2)\n",
    "\n",
    "if a >= 2 and b >= 2:\n",
    "    print(\"Обратите внимание, в if не нужны скобки вокруг условия\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "x = 4\n",
    "print(1 < x and x <= 6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Вообще говоря, сравнения можно соединять в цепочки, например предыдущий пример можно переписать так:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True\n"
     ]
    }
   ],
   "source": [
    "x = 4\n",
    "print(1 < x <= 6)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "В таких случаях для читаемости кода полезно упорядочивать сравнения так, чтобы использовать только знаки `<` и `<=`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Никогда не сравнивайте напрямую с `True` или `False`. Вместо этого используйте саму переменную или её отрицание. То же самое для сложных выражений."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ай-ай\n",
      "Так хорошо\n",
      "Так тоже хорошо\n"
     ]
    }
   ],
   "source": [
    "bool_var = True\n",
    "if bool_var == True:\n",
    "    print(\"Ай-ай\")\n",
    "\n",
    "if bool_var:\n",
    "    print(\"Так хорошо\")\n",
    "    \n",
    "bool_var = False\n",
    "if not bool_var:\n",
    "    print(\"Так тоже хорошо\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Конечно, в условии после `if` чаще всего приходится использовать логические операции. В качестве примера, давайте напишем программу, проверяющую является ли данный год високосным:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "2018\n",
      "NO\n"
     ]
    }
   ],
   "source": [
    "year = int(input())\n",
    "\n",
    "if (year % 4 == 0 and year % 100 != 0) or year % 400 == 0:\n",
    "    print(\"YES\")\n",
    "else:\n",
    "    print(\"NO\")"
   ]
  }
 ],
 "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.6.3"
  },
  "toc": {
   "base_numbering": 1,
   "nav_menu": {},
   "number_sections": false,
   "sideBar": true,
   "skip_h1_title": true,
   "title_cell": "Содержание",
   "title_sidebar": "Содержание",
   "toc_cell": true,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "396px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
{'fraction_non_alphanumeric': 0.23393128610519914, 'fraction_numerical': 0.020249315901489814, 'mean_word_length': 2.1367537669273315, 'pattern_counts': {'":': 304, '<': 132, '<?xml version=': 0, '>': 127, 'https://': 0, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'dir': 'git-commits-cleaned', 'id': '5386447', 'n_tokens_mistral': 7266, 'n_tokens_neox': 7291, 'n_words': 1249}