sem01_intro/sem01_group08.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "wl7YinM3VhtJ"
   },
   "source": [
    "<center>\n",
    "<img src=\"http://i0.kym-cdn.com/photos/images/original/000/234/765/b7e.jpg\" height=\"300\" width=\"300\">\n",
    "</center>\n",
    "\n",
    "# Первому семинару приготовиться"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "dwXAVUnZVhtN"
   },
   "source": [
    "__Наша цель на сегодня:__ \n",
    "\n",
    "* Запустить python быстрее, чем за 20 минут. \n",
    "* Попробовать python на вкус\n",
    "* Решить пару простых задач и залить их в Яндекс.Контест"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      " _______ \r\n",
      "< Hello >\r\n",
      " ------- \r\n",
      "        \\   ^__^\r\n",
      "         \\  (oo)\\_______\r\n",
      "            (__)\\       )\\/\\\r\n",
      "                ||----w |\r\n",
      "                ||     ||\r\n"
     ]
    }
   ],
   "source": [
    "!cowsay 'Hello'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "v3Zb97mxVhtP"
   },
   "source": [
    "## 0. Куда это я попал? \n",
    "\n",
    "__Jupyter Notebook__ - это штука для интеракктивного запуска кода в браузере. Много где используют. Можно писать код, выполнять его и смотреть на результат.\n",
    "\n",
    "Напиши в ячейке ниже `2 + 2` и нажми на кнопки __Shift__ и __Enter__ одновременно. Твой код выполнится и ты увидишь ответ. Дальше так и будем писать код. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "id": "yjM36eeOVhtQ"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# напиши код прямо тут вместо трёх точек\n",
    "2 + 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "D5t9mAu1VhtR"
   },
   "source": [
    "> Ещё у ячеек бывает разный тип. В этой части семинара ваш семинарист немного поучит вас работать в тетрадках с Markdown. \n",
    "\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "moKA3s1rVhtR"
   },
   "source": [
    "### Markdown\n",
    "\n",
    "- [10-минутный урок по синтаксису](https://www.markdowntutorial.com/)\n",
    "- [Короткий гайд по синтаксису](https://guides.github.com/features/mastering-markdown/)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "I2czxQPZVhtR"
   },
   "source": [
    "## 1. Python как калькулятор\n",
    "\n",
    "Можно складывать, умножать, делить и так далее..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "id": "btWQRnoDVhtS",
    "outputId": "27bdf569-e6e3-4c29-9cbf-bcd2d521f8c1"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "28"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "4 * 7"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "id": "lFmqoEYoVhtT",
    "outputId": "480fd1ea-5fe3-4d8d-89b6-f38826889572"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "21"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3 * (2 + 5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "id": "OfCjcKmWVhtU",
    "outputId": "e7443fd1-c661-4874-d507-cce71c5df82e"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "125"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5 ** 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "id": "K6xz7iikVhtU",
    "outputId": "21d4b330-ffd4-4853-d578-78766bb21f6d"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.5"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5 / 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "mKNGXehiVhtV",
    "outputId": "5a16557a-5009-4a39-ebb2-90d492bb897d"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5 // 2 #Человек против машины: раунд 1, угадайте, что получится?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "rbzqaELPVhtV",
    "outputId": "9e4d6040-451e-4020-f709-01937f673477"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "5 % 2 #а тут?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "iTptTDz4VhtV"
   },
   "source": [
    "Как обстоят дела с другими операциями? Попробуем извлечь квадратный корень:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "id": "It7Xia4RVhtW",
    "outputId": "1b74ed0d-272c-4fb4-eff1-c4079a12e241"
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'sqrt' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[13], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43msqrt\u001b[49m(\u001b[38;5;241m4\u001b[39m)\n",
      "\u001b[0;31mNameError\u001b[0m: name 'sqrt' is not defined"
     ]
    }
   ],
   "source": [
    "sqrt(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "fORyYDEcVhtW"
   },
   "source": [
    "Извлечение квадратного корня не входит в комплект математических операций, доступных в Python по умолчанию, поэтому вместо ответа мы получили какую-то непонятную ругань. \n",
    "\n",
    "Эта непонятная ругань называется исключением, когда-нибудь мы научимся их обрабатывать, а сейчас обратим внимание на последнюю строчку: `NameError: name 'sqrt' is not defined` — то есть «я не понимаю, что такое sqrt». Однако, не всё так плохо: соответствующая функция есть в модуле math. Чтобы ей воспользоваться, нужно импортировать этот модуль. Это можно сделать разными способами."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "id": "rfMxPyJyVhtW",
    "outputId": "bde5c5b0-e0ac-4adf-d763-512c84893bef"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.0"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import math\n",
    "math.sqrt(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "svQSwv6SVhtX"
   },
   "source": [
    "После того, как модуль `math` импортирован, вы можете узнать, какие ещё в нём есть функции. В __IPython Notebook__ для этого достаточно ввести имя модуля, поставить точку и нажать кнопку __«Tab»__. Вот, например, синус:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ?math.sqrt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "id": "FXufoeLWVhtX",
    "outputId": "8918632d-1fa0-4009-f374-3e7e325b97b6"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.sin(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "22026.465794806718"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "math.exp(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "8VQ-PdGCVhtX"
   },
   "source": [
    "Приведенный синтаксис может оказаться неудобным, если вам часто приходится вызывать какие-то математические функции. Чтобы не писать каждый раз слово «math», можно импортировать из модуля конкретные функции."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "LZIkavJ9VhtY",
    "outputId": "4f1998d2-0a06-4529-ab3e-3452f0973dd1"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.0"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from math import sqrt\n",
    "sqrt(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "E90bv9LyVhtY"
   },
   "source": [
    "Также можно подгрузить какой-нибудь модуль или пакет, но при этом изменить у него название на более короткое и пользоваться им."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "px68pdYUVhtY",
    "outputId": "15a05951-da70-48fe-c388-92337661aa7e"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2.0"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import math as mh\n",
    "mh.sqrt(4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "HcbxVTrwVhtY"
   },
   "source": [
    "## 2. Переменные\n",
    "\n",
    "Понятие «переменной» в программировании похоже на аналогичное понятие в математике. Переменная — это ячейка памяти, обозначаемая каким-то именем. В этой ячейке могут храниться числа, строки и более сложные объекты. Мы пока поработаем немножко с числовыми переменными."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "id": "yevGNmciVhtY",
    "outputId": "acb87e6e-8175-409e-abf9-32dcf1c78799"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "4\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "sofiya = 4\n",
    "print(sofiya)\n",
    "print(sofiya)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "id": "O1e-7T0pVhtZ",
    "outputId": "0207836c-f31d-4640-977d-954f3537a77e"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sofiya = sofiya + 2\n",
    "sofiya"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "FdaFbZRjVhtZ"
   },
   "source": [
    "А что будет в $x$, если запусстить ячейку ещё раз? "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "od7lLm3rVhtZ"
   },
   "source": [
    "## 3. Типы\n",
    "\n",
    "Попробуем записать числа по-разному"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "vXZXxj8sVhtZ",
    "outputId": "6e696722-7afa-46d8-d7b6-e87c97693bde"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "168"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "4 * 42"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "vLVm2WlbVhtZ",
    "outputId": "2a025b1f-8488-4f7d-ae63-42055730b1d4"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'444444444444444444444444444444444444444444'"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "'4' * 42 #Человек против машины: раунд 2, угадайте, что получится?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "K889IJ66VhtZ"
   },
   "source": [
    "Для каждого типа арифметика работает по-своему!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "rxQiRmc5VhtZ",
    "outputId": "4edddf3d-597e-47a6-c6d7-00a83a76ff13"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'ёжик'"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a = 'ёж'\n",
    "b = 'ик'\n",
    "a + b"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "kQuxsujAVhtZ",
    "outputId": "cd4e8e17-d736-4894-91a2-19fb12c7826c"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "int"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "YctgnUtnVhtZ",
    "outputId": "1e146298-82eb-4db3-fe6e-1f9440c8603d"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "str"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type('4')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "hFjSylsDVhta",
    "outputId": "03955f57-4bc3-4423-87cf-4da020db0629"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "float"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(4.0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "DfIlyu1LVhta",
    "outputId": "87014562-7f39-43c0-9ec7-1368941cf2fa"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "bool"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "p3BCwxkwVhta"
   },
   "source": [
    "- `str` - текстовый\n",
    "- `int` - целочисленный\n",
    "- `float` - число с плавающей запятой (обычное действительное число)\n",
    "- `bool` - булева переменная"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "DzwR6v97Vhta"
   },
   "source": [
    "Иногда можно переходить от одного типа переменной к другому."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "id": "cBBv-pp8Vhtb",
    "outputId": "587d5867-28ba-484b-ca58-fdc9ef17a999"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'str'>\n",
      "<class 'int'>\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "42"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = '42'\n",
    "print(type(x))\n",
    "\n",
    "x = int(x)\n",
    "print(type(x))\n",
    "x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "F34JPzLdVhtb"
   },
   "source": [
    "А иногда нет. Включайте логику :)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "id": "kwgHkqJXVhtb",
    "outputId": "ccaf3afc-de30-4c83-a58e-6df367ff3722"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "<class 'str'>\n"
     ]
    },
    {
     "ename": "ValueError",
     "evalue": "invalid literal for int() with base 10: 'Люк, я твой отец'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[30], line 4\u001b[0m\n\u001b[1;32m      1\u001b[0m x \u001b[38;5;241m=\u001b[39m \u001b[38;5;124m'\u001b[39m\u001b[38;5;124mЛюк, я твой отец\u001b[39m\u001b[38;5;124m'\u001b[39m\n\u001b[1;32m      2\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;28mtype\u001b[39m(x))\n\u001b[0;32m----> 4\u001b[0m x \u001b[38;5;241m=\u001b[39m \u001b[38;5;28;43mint\u001b[39;49m\u001b[43m(\u001b[49m\u001b[43mx\u001b[49m\u001b[43m)\u001b[49m\n\u001b[1;32m      5\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;28mtype\u001b[39m(x))\n",
      "\u001b[0;31mValueError\u001b[0m: invalid literal for int() with base 10: 'Люк, я твой отец'"
     ]
    }
   ],
   "source": [
    "x = 'Люк, я твой отец'\n",
    "print(type(x))\n",
    "\n",
    "x = int(x)\n",
    "print(type(x))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "v8b6bl30Vhtb"
   },
   "source": [
    "Булевы переменные возникают при разных сравнениях, их мы будем активно использовать на следующем семинаре."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "id": "DAee1KGDVhtb",
    "outputId": "86cf039e-206b-44e2-88a1-c872c933ba0f"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 + 2 == 4"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "id": "oQxTM7t6Vhtb",
    "outputId": "05924e84-580b-477e-ea07-acd21e8266b6"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 + 2 == 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "id": "KG1twBsTVhtc",
    "outputId": "6bd87f4c-7276-4b55-8455-6b43f0c6959c"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 5\n",
    "x < 8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 10\n",
    "(x > 5) + (x*2 != 19)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "f14MuR3HVhtc"
   },
   "source": [
    "## 4. Вещественные числа и погрешности\n",
    "\n",
    "Вещественные числа в программировании не так просты. Вот, например, посчитаем синус числа $\\pi$:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "id": "l3PQbWqUVhtc",
    "outputId": "d7b9efaf-915d-4aac-e7cf-cf7690a36f2f"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.2246467991473532e-16"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from math import pi, sin\n",
    "sin(pi)  #думаете, получится 0? Ха-ха!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "QFebvgjRVhtc"
   },
   "source": [
    "Непонятный ответ? Во-первых, это так называемая [компьютерная форма экспоненциальной записи чисел.](https://ru.wikipedia.org/wiki/Экспоненциальная_запись#.D0.9A.D0.BE.D0.BC.D0.BF.D1.8C.D1.8E.D1.82.D0.B5.D1.80.D0.BD.D1.8B.D0.B9_.D1.81.D0.BF.D0.BE.D1.81.D0.BE.D0.B1_.D1.8D.D0.BA.D1.81.D0.BF.D0.BE.D0.BD.D0.B5.D0.BD.D1.86.D0.B8.D0.B0.D0.BB.D1.8C.D0.BD.D0.BE.D0.B9_.D0.B7.D0.B0.D0.BF.D0.B8.D1.81.D0.B8) Она удобна, если нужно уметь записывать очень большие или очень маленькие числа:`1.2E2` означает `1.2⋅102`, то есть `1200`, а `2.4e-3` — то же самое, что `2.4⋅10−3=00024`. \n",
    "\n",
    "Результат, посчитанный Python для $\\sin \\pi$, имеет порядок `10−16` — это очень маленькое число, близкое к нулю. Почему не «настоящий» ноль? Все вычисления в вещественных числах делаются компьютером с некоторой ограниченной точностью, поэтому зачастую вместо «честных» ответов получаются такие приближенные. К этому надо быть готовым."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "id": "5bhIkvocVhtc",
    "outputId": "19a289f8-6d8d-4f08-9d56-c8e190685c44"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#Человек против машины: раунд 3, угадайте, что получится?\n",
    "0.4 - 0.3 == 0.1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "id": "lnWEkEM3Vhtc",
    "outputId": "2e15c39b-49f9-430d-921b-1f433696c5c0"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.10000000000000003"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "0.4 - 0.3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = 0.4 - 0.3\n",
    "abs(x - 0.1) < 1e-12"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "AHAy4A5RVhtc"
   },
   "source": [
    "Когда сравниваете вещественные числа будьте осторожнее. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "z7TvsPwQVhtc"
   },
   "source": [
    "## 5. Ввод-вывод ~~и мы опять играем в любимых~~\n",
    "\n",
    "Работа в Jupyter редко требует писать код, который сам по себе запрашивает данные с клавиатуры, но для других приложений (и в частности для домашних работ) это может потребоваться. К тому же, написание интерактивных приложений само по себе забавное занятие. Напишем, например, программу, которая здоровается с нами по имени."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "id": "S10wq8UKVhtd"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Введите ваше имя: Соня\n",
      "Привет, Соня\n"
     ]
    }
   ],
   "source": [
    "name = input(\"Введите ваше имя: \")\n",
    "print(\"Привет,\", name)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "id": "DsDQq8mEVhtd"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'СоняСоняСоняСоня'"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "name * 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "CZ_RQEj5Vhtd"
   },
   "source": [
    "Что здесь произшло? В первой строчке мы использовали функцию `input`. Она вывела на экран строчку, которую ей передали (обязательно в кавычках) и запросила ответ с клавиатуры. Я его ввёл, указав своё имя. После чего `input` вернула строчку с именем и присвоила её переменной `name`.\n",
    "\n",
    "После этого во второй строке была вызвана функция `print` и ей были переданы две строчки — \"Привет,\" и то, что хранилось в переменной `name` Функция `print` вывела эти две строчки последовательно, разделив пробелом. Заметим, что в переменной `name` по-прежнему лежит та строчка, которую мы ввели с клавиатуры."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Cai9n9d0Vhtd"
   },
   "source": [
    "Попробуем теперь написать программу «удвоитель». Она должна будет принимать на вход число, удваивать его и возвращать результат."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "id": "wpOxFIzAVhtd"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Введите какое-нибудь число: 42\n",
      "84\n"
     ]
    }
   ],
   "source": [
    "x = input(\"Введите какое-нибудь число: \")\n",
    "y = int(x) * 2\n",
    "print(y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "p1TqDLR5Vhtd"
   },
   "source": [
    "Что-то пошло не так. Что именно? Как это исправить?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "JVYsdZO1Vhtd"
   },
   "source": [
    "## 6. Учимся дружить с поисковиками\n",
    "\n",
    "__Задача:__ я хочу сгенерировать рандомное число, но я не знаю как это сделать. \n",
    "\n",
    "В этом месте ваш семинарист совершит смертельный номер. Он загуглит у вас на глазах как сгенерировать случайное число и найдёт код для этого."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "id": "VMWHMbAzVhtd"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "39\n"
     ]
    }
   ],
   "source": [
    "# Местечко для маленького чуда\n",
    "import random\n",
    "\n",
    "num1 = random.randint(0, 100)\n",
    "print(num1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "HCMuuLNpVhtd"
   },
   "source": [
    "Увидели чудо? Давайте договоримся, что вы не будете стесняться гуглить нужные вам команды и искать ответы на свои вопросы в интернете. Если уж совсем не выходит, задавайте их в наш чат технической поддержки в Телеграм. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "uzNI2wl2Vhtd"
   },
   "source": [
    "## 7. Контест\n",
    "\n",
    "Яндекс.Контест - это система для автоматического тестирования кода. Вы будете сталкиваться с ней в течение всего нашего курса. Давайте попробуем поработать с ней и перенесём туда решение задачки с вводом имени. \n",
    "\n",
    "> Задачи для первого семинара доступны тут: https://contest.yandex.ru/contest/48080/problems/\n",
    "\n",
    "Всё оставшееся время мы будем решать задачи из контеста. Рекомендуемый список: B,H,O,X, любые другие :)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "id": "ICrMfRF9Vhtd"
   },
   "outputs": [],
   "source": [
    "### ╰( ͡° ͜ʖ ͡° )つ▬▬ι═══════  bzzzzzzzzzz\n",
    "# will the code be with you"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "44\n",
      "1975308641975308641975308641975308641975308641975308641975308641975308641975308641975308641975308641975308641975308641975308641975308641975308641975308641975308641975308641975308641975308641975308641935802469135802469135802469135802469135802469135802469135802469135802469135802469135802469135802469135802469135802469135802469135802469135802469135802469135802469135802469135802469135802469135802469136\n"
     ]
    }
   ],
   "source": [
    "# Задача O\n",
    "x = input()\n",
    "z = int(str(x) * 100)\n",
    "print(z ** 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "220\n",
      "4\n"
     ]
    }
   ],
   "source": [
    "# Задача H\n",
    "a = int(input())\n",
    "ans = a // 100 + (a // 10) % 10 + a % 10\n",
    "print(ans)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "17\n"
     ]
    }
   ],
   "source": [
    "a = input()\n",
    "print(sum([int(item) for item in a]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "XBhmK67DVhtd"
   },
   "source": [
    "## 8. Дзен Python и PEP-8\n",
    "\n",
    "Как мы увидели выше, команда `import` позволяет подгрузить различные пакеты и модули. Один из модулей, который обязательно нужно подгрузить на первой же паре - это модуль `this`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {
    "id": "VjlNpF-EVhte",
    "outputId": "93db51d2-0377-48a1-b202-6d1208ce229c"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The Zen of Python, by Tim Peters\n",
      "\n",
      "Beautiful is better than ugly.\n",
      "Explicit is better than implicit.\n",
      "Simple is better than complex.\n",
      "Complex is better than complicated.\n",
      "Flat is better than nested.\n",
      "Sparse is better than dense.\n",
      "Readability counts.\n",
      "Special cases aren't special enough to break the rules.\n",
      "Although practicality beats purity.\n",
      "Errors should never pass silently.\n",
      "Unless explicitly silenced.\n",
      "In the face of ambiguity, refuse the temptation to guess.\n",
      "There should be one-- and preferably only one --obvious way to do it.\n",
      "Although that way may not be obvious at first unless you're Dutch.\n",
      "Now is better than never.\n",
      "Although never is often better than *right* now.\n",
      "If the implementation is hard to explain, it's a bad idea.\n",
      "If the implementation is easy to explain, it may be a good idea.\n",
      "Namespaces are one honking great idea -- let's do more of those!\n"
     ]
    }
   ],
   "source": [
    "import this"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "vlAdvtxMVhte"
   },
   "source": [
    "Разработчики языка Python придерживаются определённой философии программирования, называемой «The Zen of Python» («Дзен Питона», или «Дзен Пайтона»). Выше мы вывели на экран именно её. Изучите эту философию и тоже начните её придерживаться.\n",
    "\n",
    "Более того, мы рекомендуем вам изучить [стайлгайд по написанию кода PEP 8.](https://pythonworld.ru/osnovy/pep-8-rukovodstvo-po-napisaniyu-koda-na-python.html) В конце курса вас будет ждать домашка с код-ревью. В ней мы будем требовать, чтобы вы придерживались PEP 8. Код должен быть читаемым :) "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Wm58Hw6xVhte"
   },
   "source": [
    "## Ваше задание\n",
    "\n",
    "* Пройдите первые уроки [с pythontutor](https://pythontutor.ru/lessons/inout_and_arithmetic_operations/)\n",
    "* Попытаться дорешать все задачи из [первого контеста.](https://contest.yandex.ru/contest/48080/problems/) Постарайтесь решить половину их них. Задачи, где нужно включать логику и придумывать формулы, можно пропускать. \n",
    "\n",
    "Решение этих заданий нами никак не проверяется. Они нужны для практики, чтобы впоследствии вам было легче решать домашние работы и самостоятельные работы. \n",
    "\n",
    "> Более того, можно просить разбирать на семинарах и консультациях задачи, которые вы не смогли решить либо не поняли. Об этом можно попросить своего семинариста или ассистентов. "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "9Ovnpr6OVhte"
   },
   "source": [
    "![](https://raw.githubusercontent.com/FUlyankin/stickers/master/2-itog_stickers/zen.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "fNXcmsjSVhte"
   },
   "source": [
    " "
   ]
  }
 ],
 "metadata": {
  "colab": {
   "name": "sem01_intro.ipynb",
   "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.10.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}