lecture_1-checkpoint.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Python\n",
    "\n",
    "## Начальный уровень\n",
    "\n",
    "### Раздел 1. Общие соображения\n",
    "\n",
    "#### Мотивация для изучения Python\n",
    "\n",
    "Несколько плюсов языка Python:\n",
    "\n",
    "- Python - один из самых широко используеммых языков программирования. В рейтингах популярности и востребованности языков он давно уже не опускается ниже 5 позиции.\n",
    "\n",
    "- Python очень гибкий с точки зрения используеммых конструкций и подходов. Он позволяет вам писать классический императивный (процедурный код), объектно-ориентированный код, функциональный код или любую их комбинацию. Эта особенность способствует очень высокой скорости разработки (при этом, на мой взгляд, снижает читаемость по сравнению с \"чистыми\" языками программирования, где есть возможность придерживаться только одной парадигмы).\n",
    "\n",
    "- Python очень требователен к оформлению кода по сравнению с другими языками программирования. К тому же, есть документ [PEP 8](https://www.python.org/dev/peps/pep-0008/), который содержит соглашения относительно оформления кода, которые не являются обязательными, но строго рекомендуются к исполнению. Все это влечет к простоте прочтения кода на Python.\n",
    "\n",
    "- Python обладает невероятно большим списком областей применения: утилитарные скрипты; анализ, обработка, хранение, визуализация и передача данных; web- и сетевое программирование; программирование приложений для desktop- и mobile-систем; web-scrapping, offensive-security и тестирование приложений; программирование микроконтроллеров — и многие другие задачи могут быть эффективно решены при помощи Python.\n",
    "\n",
    "Основными недостатками Python можно назвать:\n",
    "\n",
    "- Ограниченный набор базовых конструкций языка и ограниченный функционал стандартной библиотеки.\n",
    "\n",
    "- Низкая скорость выполнения кода.\n",
    "\n",
    "- Реализация многих реальных механизмов взаимодействия в коде скрывается \"под капотом\" от пользователя.\n",
    "\n",
    "#### Литература для этого курса\n",
    "\n",
    "Единственная книга, которая является обязательной для этого курса:\n",
    "\n",
    "**Programming in Python 3 : a complete introduction to the Python language / Mark Summerfield. — 2nd ed.**\n",
    "\n",
    "В природе существует ее *перевод на русский язык*.\n",
    "\n",
    "Еще книги, которые будут полезны:\n",
    "\n",
    "- **Learning Python, Fifth Edition by Mark Lutz** — какое-то издание точно переведено на русский.\n",
    "\n",
    "- **Python Pocket Reference, Fifth Edition by Mark Lutz** — какое-то издание точно переведено на русский.\n",
    "\n",
    "- **Python Cookbook, Second Edition Edited by Alex Martelli, Anna Martelli Ravenscroft, and David Ascher** — не встречал, но наверняка есть перевод.\n",
    "\n",
    "- Любая другая литература, которую найдете (с некоторыми оговорками).\n",
    "\n",
    "#### Темы и модули, которые будут затронуты в этом курсе.\n",
    "\n",
    "В ходе этих лекций мы постараемся затронуть как можно больше областей и модулей, поэтому характер изучения конкретных модулей может оказаться весьма поверхностным. Приведенный ниже список не является исчерпывающим.\n",
    "\n",
    "##### Работа с данными (получение, передача, хранение, выборка, визуализация)\n",
    "\n",
    "- sqlite3;\n",
    "- MySQLdb;\n",
    "- psycopg2;\n",
    "- pymongo;\n",
    "- Pandas;\n",
    "- Vedis;\n",
    "- matplotlib;\n",
    "- bokeh.\n",
    "\n",
    "##### Обработка данных\n",
    "\n",
    "- NumPy;\n",
    "- SymPy;\n",
    "- SciPy.\n",
    "\n",
    "*Более подробное изучение этой области смотрите в курсе \"Машинное обучение на Python\" (ссылка появится позже)*\n",
    "\n",
    "##### Web\n",
    "\n",
    "- pika;\n",
    "- CherryPy;\n",
    "- Django;\n",
    "- Flask;\n",
    "- Sphinx.\n",
    "\n",
    "##### Тестирование\n",
    "\n",
    "- selenium.\n",
    "\n",
    "##### Web-scrapping\n",
    "\n",
    "- BeautifulSoup;\n",
    "- scrapy.\n",
    "\n",
    "#### Варианты установки и запуска Python\n",
    "\n",
    "На момент написания курса у меня стоит версия Python 3.6.5, на нее и будем ориентироваться.\n",
    "\n",
    "Основных способов написания Python-кода 3:\n",
    "\n",
    "1. Скачать один из дистрибутивов, который будет содержать сразу IDE и интерпретатор.\n",
    "\n",
    "2. Скачать отдельно интерпретатор и писать код в текстовом редакторе или IDE по выбору.\n",
    "\n",
    "3. Пользоваться сервисом Jupyter с онлайн-доступом, ничего не скачивая.\n",
    "\n",
    "##### 1. Дистрибутивы\n",
    "\n",
    "- [Официальный дистрибутив с IDLE](https://www.python.org/downloads/).\n",
    "- [Anaconda — очень популярный дистрибутив](https://www.anaconda.com/download/).\n",
    "- [Python(x, y) — дистрибутив, ориентированный на научные вычисления и визуализацию](https://python-xy.github.io/).\n",
    "\n",
    "##### 2. Интерпретатор\n",
    "\n",
    "В Windows скачиваем [официальный дистрибутив](https://www.python.org/downloads/), после чего создаем свои файлы с расширением .py и запускаем в командной строке команду python, передавая ей в качестве аргумента путь (абсолютный или относительный) к файлу .py.\n",
    "\n",
    "В Linux-based системах, скачиваем пакет python3 (иногда называется python) с помощью своего пакетного менеджера, после чего создаем свои файлы с расширением .py и запускаем в командной строке команду python3 (или python), передавая ей в качестве аргумента путь (абсолютный или относительный) к файлу .py. Также необходимо поставить менеджер пакетов для python — pip (как правило, пакет python3-pip).\n",
    "\n",
    "Сам интерпретатор можно запустить и без аргументов, тогда он запустится в интерактивном режиме.\n",
    "\n",
    "После того, как вы установили интерпретатор, вы можете воспользоваться любым удобным IDE (самые популярные: PyCharm и Visual Studio) или текстовым редактором (neovim, spacemacs, Sublime, Atom, Visual Studio Code и др.).\n",
    "\n",
    "##### 3. Jupyter notebook\n",
    "\n",
    "Jupyter можно [использовать онлайн без установки](http://jupyter.org/try). Просто загрузите свой iPython notebook файл и эксперементируйте!\n",
    "\n",
    "#### Где искать информацию?\n",
    "\n",
    "Загугли!\n",
    "\n",
    "Если не получилось загуглить — спроси в канале Slack #python.\n",
    "\n",
    "Стесняешься спросить — напиши мне в личку в ВК, телеге, твиттере или слаке (@devsagul).\n",
    "\n",
    "Совсем не стесняешься спросить — сделай mention в твиттере, может отвечу :)\n",
    "\n",
    "#### Куда слать домашку?\n",
    "\n",
    "Если ты вдруг что-то сделал и хочешь похвастаться — залей на github или gitlab, а ссылку присылай мне. Как прислать? Смотри пункт выше + почта [s.guliaev@lambda-it.ru](mailto:s.guliaev@lambda-it.ru)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Раздел 2. It's time to get our hands dirty или императивное (процедурное) программирование в Python\n",
    "\n",
    "#### Hello, World!\n",
    "\n",
    "Изучение любого языка программирования начинается с программы \"Hello, World!\", давайте не отходить от этой славной традиции:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Hello, World!\n"
     ]
    }
   ],
   "source": [
    "print(\"Hello, World!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Сразу можно отметить, что функция вывода сообщения на экран в Python вызывается как совершенно обычная функция. Также видно, что никаких точек запятой после завершения утверждения нет. В Python точка с запятой используется только для разделения нескольких утверждений на одной строке."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Типы данных в Python\n",
    "\n",
    "Python содержит огромное количество разнообразных типов данных, но пока мы сосредоточим свое внимание на двух из них:\n",
    "целочисленный и строковый тип. Целочисленный тип обозначается ключевым словом int, а строковый — ключевым словом str. Исходя из названия, легко понять, что целочисленный тип предназначен для хранения целых чисел, а строковый — строковых литералов. Вот примеры нескольких литералов:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'It is really useful, что можно использовать символы Юникода в строковых литералах. Εύρηκα!'"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "123\n",
    "3141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825342117067\n",
    "0\n",
    "-12\n",
    "\"Hello, World!\"\n",
    "'I prefer Python over PHP'\n",
    "''\n",
    "'It is really useful, что можно использовать символы Юникода в строковых литералах. Εύρηκα!'"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Как можно заключить по второму числу, тип int в Python не ограничен каким-то конкретным размером, а зависит от объема памяти на вашем компьютере. Строковые литералы можно заключать в одинарные или двойные кавычки и использовать в них символы Юникода. Пустая строка обозначается просто парой кавычек."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Строки в Python можно рассматривать как массивы символов. Следовательно, для них есть операции получения элемента по индексу и получения среза:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "N\n",
      "Do\n",
      "P\n"
     ]
    }
   ],
   "source": [
    "print(\"The New York Times\"[4])\n",
    "print(\"Hot Dogs\"[4:6])\n",
    "print(\"Python\"[0])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Нумерация индексов начинается с нуля, отрицательные индексы отсчитываются с конца в обратном направлении. Более подробно операция получения среза будет рассмотрена позже."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Для перевода данных их одного типа в другой, нужно вызвать этот тип данных в качестве функции и передать ему значение, которое будем переводить:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1605"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "int('45')\n",
    "str(10000)\n",
    "int(' 1605 ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Как видно из последнего примера, int при переводе строкового литерала удаляет все лидирующие и завершающие пробельные символы."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Переменные\n",
    "\n",
    "Python — язык со слабой (утиной) типизацией. Более того, нет необходимости указывать тип переменной. Более того, переменная может принять значение любого другого типа в любой момент:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = 1605\n",
    "x = \"November fifth\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Соглашения относительно именования различных сущностей можно посмотреть в [PEP 8](https://www.python.org/dev/peps/pep-0008/#naming-conventions)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Типы данных-коллекции\n",
    "\n",
    "Все типы данных в Python делятся на *изменяемые* и *неизменяемые*. Многие типы, которые мы будем рассматривать, можно будет разделить на пары, очень близкие по смыслу, но отличающиеся только тем, что одни изменяемы, а другие — нет. С практической точки зрения, неизменяемые типы необходимы для того, чтобы их можно было хешировать.\n",
    "\n",
    "Первая коллекция которую мы рассмотрим — *кортежи*. Кортежи — неизменяемые упорядоченные последовательности элементов. Для получения кортежа можно просто выражения через запятую:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('HTML', 'CSS', 'JavaScript')"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"HTML\", \"CSS\", \"JavaScript\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Также кортежи могут быть заключены в скобки. Для создания кортежа из одного элемента необходимо поставить запятую, даже если мы заключаем его в скобки:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('React',)"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "\"React\","
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "('Vue',)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(\"Vue\", )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Для создания пустого кортежа необходимо поставить скобки:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "()"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Списки — очень близкие родственники кортежей, но они изменяемы. Для создания списка необходимо перечислить его элементы в квадратных скобках через запятую:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[]"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "[4, 8, 15, 16, 23, 42]\n",
    "['Rust', 'Haskell', 'Racket']\n",
    "[-12, 'Farenheit', 451]\n",
    "[]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Последний пример — создание пустого списка."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Для получения количества элементов в коллекции используется функция len:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(['Rust', 'Haskell', 'Racket'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Для добавления элемента в список можно использовать метод append:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['Harris', 'Summerfield', 'Tanenbaum', 'Ritchie']\n"
     ]
    }
   ],
   "source": [
    "x = ['Harris', 'Summerfield']\n",
    "x.append('Tanenbaum')\n",
    "list.append(x, 'Ritchie')\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Как и было сказано выше, у коллекций есть возможность обращаться к элементу по индексу:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Summerfield'"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "x = ['Harris', 'Summerfield']\n",
    "x[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Логические операторы\n",
    "\n",
    "Оператор тождественности (идентичности), или оператор is, проверяет, являются ли две сущности ссылками на один объект:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "a = [451, \"Farenheit\"]\n",
    "b = [451, \"Farenheit\"]\n",
    "print(a is b)\n",
    "b = a\n",
    "print(a is b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Наиболее распространенный способ использования оператора is — сравнение со встроенным Null-объектом, None:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "False True\n"
     ]
    }
   ],
   "source": [
    "a = 100\n",
    "b = None\n",
    "print(a is None, b is None)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Операторы сравнения\n",
    "\n",
    "В питоне присутствует вполне обычный набор операторов сравнения:\n",
    "\n",
    "- < — меньше;\n",
    "\n",
    "- <= — меньше или равно;\n",
    "\n",
    "- == — равно;\n",
    "\n",
    "- != — не равно;\n",
    "\n",
    "- \\>= — больше или равно;\n",
    "\n",
    "- \\> — больше."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(True, True, False, False)"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 < 3, 4 != 16, 1 >= 8, 8 > 12"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Оператор вхождения\n",
    "\n",
    "Для типов данных, которые являются наборами данных, существует проверка на вхождение:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True False True False\n"
     ]
    }
   ],
   "source": [
    "Nebuchadnezzar = ['Neo', 'Trinity', 'Morpheus', 'Mouse',\n",
    "                  'Dozer', 'Tank', 'Cypher', 'Apoc', 'Switch']\n",
    "print('Neo' in Nebuchadnezzar, 'Smith' in Nebuchadnezzar,\n",
    "      'V' in 'Vendetta', 'Я' in 'Команда')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Логические операторы\n",
    "\n",
    "В Python есть следующие логические операторы:\n",
    "\n",
    "- not — логическое НЕ;\n",
    "\n",
    "- or — логическое ИЛИ;\n",
    "\n",
    "- and — логическое И;"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "True False\n",
      "False True True\n",
      "False False True\n"
     ]
    }
   ],
   "source": [
    "print(not False, not True)\n",
    "print(False or False, False or True, True or True)\n",
    "print(False and False, False and True, True and True)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Выражения, контролирующие порядок выполнения программы\n",
    "\n",
    "Конструкции, которые мы изучили на данный момент, хоть и позволяют строить простейшие программы, но все же предоставляют весьма ограниченный инструментарий. Нам необходимы конструкции, которые позволяют анализировать ход выполнения программы и передавать управления тем или иным инструкциям. Сейчас мы рассмотрим ветвление, циклы и исключения.\n",
    "\n",
    "\n",
    "##### Ветвление (if, if-else, if-elif, if-elif-else)\n",
    "\n",
    "Конструкция ветвления if позволяет проверить выполнение условия и, в зависимости от того, является ли утверждение истинным, выполнить тот или иной блок операторов:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Don't worry, everythin is alright!\n"
     ]
    }
   ],
   "source": [
    "if 'PHP' is 'Viable Programming Language':\n",
    "    print('It must be snowing!')\n",
    "else:\n",
    "    print(\"Don't worry, everythin is alright!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Обратите внимание, что вложенный блок отделяется четыремя пробелами. Так в Python форматируются все вложенные блоки, что позволяет писать крайне читаемый код без каких-либо фигурных скобок.\n",
    "\n",
    "Конструкция if предусматривает использование без else. К тому же между if и else можно расположить любое количество elif (сокращенный вариант словосочетания \"else if\"). В таком случае также можно опустить последний else:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I don't know that color!\n"
     ]
    }
   ],
   "source": [
    "color = 'magenta'\n",
    "\n",
    "if color == 'blue':\n",
    "    print('Color is blue!')\n",
    "elif color == 'red':\n",
    "    print('Color is red!')\n",
    "elif color == 'green':\n",
    "    print('Color is green!')\n",
    "else:\n",
    "    print(\"I don't know that color!\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Цикл с предусловием (while)\n",
    "\n",
    "Конструкция while позволяет проверять на истинность некоторое выражение и выполнять некоторый блок кода, пока это выражение является истинным:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "100\n"
     ]
    }
   ],
   "source": [
    "i = 1\n",
    "while i < 100:\n",
    "    i += 1\n",
    "print(i)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Итеративный цикл (for ... in ...)\n",
    "\n",
    "Итеративный цикл позволяет проходить все члены некоторой последовательности, например мы задались целью перечислить всех членов экипажа Навуходоносора:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Neo\n",
      "Trinity\n",
      "Morpheus\n",
      "Mouse\n",
      "Dozer\n",
      "Tank\n",
      "Cypher\n",
      "Apoc\n",
      "Switch\n"
     ]
    }
   ],
   "source": [
    "Nebuchadnezzar = ['Neo', 'Trinity', 'Morpheus', 'Mouse',\n",
    "                  'Dozer', 'Tank', 'Cypher', 'Apoc', 'Switch']\n",
    "for crew_member in Nebuchadnezzar:\n",
    "    print(crew_member)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### Обработка исключительных ситуаций\n",
    "\n",
    "Python содержит в себе механизм исключений. Это специальный механизм, который позволяет обрабатывать исключительные ситуации, возникающие в ходе выполнения программы не вместе, где эта исключительная ситуация возникла, а там, где нам это удобно. Например, давайте попробуем привести пользовательский ввод к целому числу, а если не получится — сообщим ему, что именно нас не устраивает:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Введите целое число: 3.1415\n",
      "Не было введено целое число\n",
      "invalid literal for int() with base 10: '3.1415'\n"
     ]
    }
   ],
   "source": [
    "in_s = input(\"Введите целое число: \")\n",
    "try:\n",
    "    i = int(in_s)\n",
    "    print(\"Все верно, введено число \", i)\n",
    "except ValueError as e:\n",
    "    print(\"Не было введено целое число\")\n",
    "    print(e)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Пока остановися на такой базовой обработке исключений. Отметим, что ValueError — специальный класс исключений, предназначений для обработки ошибок значений, передаваемых в некоторую функцию. Более подробно исключения будут рассмотрены позже."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Арифметические операторы\n",
    "\n",
    "Очевидно, в Python есть базовые арифметические операторы:\n",
    "\n",
    "- \\+ — сложение;\n",
    "\n",
    "- \\- — вычитание;\n",
    "\n",
    "- \\* — умножение;\n",
    "\n",
    "- / — деление.\n",
    "\n",
    "К тому же для каждого из этих операторов есть комбинированный оператор присваивания:\n",
    "\n",
    "- += — присваивание с суммированием;\n",
    "\n",
    "- -= — присваивание с вычитанием;\n",
    "\n",
    "- \\*= — присваивание с умножением;\n",
    "\n",
    "- /= — присваивание с делением.\n",
    "\n",
    "Есть и другие арифметические операторы, а также модуль math, содержащий много всего интересного, но пока мы остановимся на этом."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "7\n",
      "3\n",
      "10\n",
      "2.5\n",
      "11\n",
      "7\n",
      "70\n",
      "35.0\n"
     ]
    }
   ],
   "source": [
    "a = 5\n",
    "b = 2\n",
    "\n",
    "print(a + b)\n",
    "print(a - b)\n",
    "print(a * b)\n",
    "print(a / b)\n",
    "\n",
    "a += 6\n",
    "print(a)\n",
    "\n",
    "a -= 4\n",
    "print(a)\n",
    "\n",
    "a *= 10\n",
    "print(a)\n",
    "\n",
    "a /= 2\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Хотелось бы отметить, что в отношении последовательностий операция + имеет смысл \"конкатенации\", а операция * — повторения. Например, рассмотрим на строках:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "I love Python\n",
      "I love Python 3\n",
      "Python Python \n",
      "Python Python Python Python Python Python Python Python Python Python \n"
     ]
    }
   ],
   "source": [
    "s = \"I love \" + \"Python\"\n",
    "print(s)\n",
    "\n",
    "s += \" 3\"\n",
    "print(s)\n",
    "\n",
    "s = \"Python \" * 2\n",
    "print(s)\n",
    "\n",
    "s *= 5\n",
    "print(s)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Ввод и вывод данных\n",
    "\n",
    "Мы уже столкнулись с фукциями input и print, но давайте рассмотрим их подробно. Функция input может вызываться с аргументом или без аргументов. Смысл этого аргумента в том, что это будет строка подсказки при вводе. Например:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Как тебя зовут: Семен\n",
      "Приветствую тебя, Семен!\n"
     ]
    }
   ],
   "source": [
    "name = input('Как тебя зовут: ')\n",
    "print('Приветствую тебя, ' + name + '!')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Функция считает строку с потока чтения, пока не встретит последовательность символов, означающую конец строки или символ конца файла (EOF)\n",
    "\n",
    "Для вывода данных используется функция print, которой передается любое количество аргументов, которые будут приведены к строкам:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "None True False 12 Просто строка ('Кортеж', 'из', '4', 'строк')\n"
     ]
    }
   ],
   "source": [
    "print(None, True, False, 12, 'Просто строка', ('Кортеж', 'из', '4', 'строк'))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Написание и вызов функций\n",
    "\n",
    "Функции предназначены для тех ситуациий, когда один и тот же участок программного кода необходимо выполнить, но с разными входными параметрами. Для определения функции используется конструкция def, после нее идет имя функции, потом в скобках ее аргументы и во вложенном блоке тело функции. Соединим все знания, которые мы получили за сегодня и напишем функцию, которая считывает целое число, ввобдимое пользователем. При этом в качестве аргумента мы ей передадим строку-подсказку. Если пользователь не вводит целое число, то мы выведем ему сообщение о том, что это необходимо. Наша функция будет выполняться, пока число не будет получено:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Введите количество дверей в вашем автомобиле: 3\n",
      "Количество дверей равно  3\n"
     ]
    }
   ],
   "source": [
    "def get_int_from_input(message):\n",
    "    while True:\n",
    "        try:\n",
    "            i = input(message)\n",
    "            i = int(i)\n",
    "            return i\n",
    "        except ValueError as e:\n",
    "            print('Не было введено целое число!')\n",
    "            print(e)\n",
    "            \n",
    "doors = get_int_from_input('Введите количество дверей в вашем автомобиле: ')\n",
    "print('Количество дверей равно ', doors)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Обратите внимание, что для возвращения значения из функции используется конструкция return."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Раздел 3. Домашнее задание\n",
    "\n",
    "Прочитать первую главу Саммерфилда, выполнить упражения из нее.\n",
    "\n",
    "Написать игру 'быки и коровы'.\n",
    "\n",
    "Решить [задачу](https://lambda-it.ru/post/20).\n",
    "\n",
    "Почитать на вики про циклы, рекурсию.\n",
    "\n",
    "Найти информацию о классификациях языков программирования.\n",
    "\n",
    "Поискать сравнительный анализ интерпретируемых, частично-интерпретируемых и компилируемых языков программирования.\n",
    "\n",
    "Прочитать [PEP 8](https://www.python.org/dev/peps/pep-0008/?)\n",
    "\n",
    "Дойти до нашего Slack. Задавать все вопросы мне, либо своим пирам (товарищам, проходящим этот курс), либо просто в канале #python. Не согласен с чем-то — напиши мне. Хочешь помочь — тоже пиши."
   ]
  }
 ],
 "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.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}