text: {
    "nbformat": 4,
    "nbformat_minor": 0,
    "metadata": {
      "colab": {
        "name": "python_basics.ipynb",
        "version": "0.3.2",
        "provenance": [],
        "collapsed_sections": [
          "qoHHrmtJGwzG",
          "YfhDEhg_GwzM",
          "-tXSqvRRGwzN",
          "Hf0cK9ejGwzd",
          "YFD8l2XuGwzq",
          "Ra7b2HeOzM7C",
          "sGGkrmM0Gwz1",
          "r_y-TEM3Gw0A",
          "knjcsCbVGw0Z",
          "P7kqThRsGw1S",
          "e6LOqPpYGw1T",
          "KgSZ7GuFzM8N",
          "TE6KBa0HzM8P",
          "2mnxxvHxGw0c",
          "04VwiGfkGw3t",
          "25O4dyOezM8l",
          "70QerwaDGw3y",
          "ZPIwoJneGw37",
          "8f3c96Y3Gw4f",
          "i0xyAzGiGw4s",
          "79dYvUBLGw5A",
          "Ka2gG8QizM9L",
          "-kYdwvhLGw5F"
        ]
      },
      "kernelspec": {
        "display_name": "Python 3",
        "language": "python",
        "name": "python3"
      }
    },
    "cells": [
      {
        "metadata": {
          "colab_type": "text",
          "id": "eOivSghfGwy-"
        },
        "cell_type": "markdown",
        "source": [
          "<h2 style=\"text-align: center;\"><b>Python. Занятие 1: Основы</b></h2>"
        ]
      },
      {
        "metadata": {
          "colab_type": "text",
          "id": "_kqD6lQ7GwzA"
        },
        "cell_type": "markdown",
        "source": [
          "<img align=left src=\"https://cdn.fedoramagazine.org/wp-content/uploads/2015/11/Python_logo.png\" style=\"height:160px;\" />\n",
          "\n",
          "<img align=center src=\"https://1.bp.blogspot.com/-16utHnlB3Ao/V4tpG8NBX0I/AAAAAAAAA7M/vDQ1p40JpE8M34eCr-UdriSV04Dn8au7QCLcB/s1600/jupyter-logo.png\" style=\"height:90px;\" />"
        ]
      },
      {
        "metadata": {
          "colab_type": "text",
          "id": "wBxC0NK1GwzB"
        },
        "cell_type": "markdown",
        "source": [
          "---"
        ]
      },
      {
        "metadata": {
          "colab_type": "text",
          "id": "iKkG2y23GwzC"
        },
        "cell_type": "markdown",
        "source": [
          "\n",
          "Перед тем как начать складывать уровни нейросеточек как блинчики или предсказывать кредитоспособность клиентов, нужно быть хорошо знакомым с нужными библиотеками и языком, на котором они написаны. \n",
          "В нашем курсе мы будем использовать язык **Python**, так как он является оптимальным сочетанием простоты, силы и количества полезных библиотек, написанных для него. "
        ]
      },
      {
        "metadata": {
          "colab_type": "text",
          "id": "LYwDm-Y7GwzD"
        },
        "cell_type": "markdown",
        "source": [
          "На этом занятии мы научимся писать программы на Python, изучив его основы.  "
        ]
      },
      {
        "metadata": {
          "colab_type": "text",
          "id": "qoHHrmtJGwzG"
        },
        "cell_type": "markdown",
        "source": [
          "## Основы Python"
        ]
      },
      {
        "metadata": {
          "colab_type": "text",
          "id": "EpMCDIheGwzH"
        },
        "cell_type": "markdown",
        "source": [
          "Сейчас существуют две часто используемые версии Питона — **Python 2** и **Python 3**. Эти версии довольно похожи, но есть отличия, из-за которых они **не являются совместимыми** - программы, написанные на одной версии языка, могут не работать в другой.  \n",
          "\n",
          "В нашем курсе мы будем писать на **Python 3**. Точная версия не принципиальна, но она должна быть >= 3.5  \n",
          "\n",
          "Если Вы пользуетесь каким-либо из дистрибутивов Linux, то Python скорее всего уже установлен.\n",
          "Попробуйте в терминале следующие команды для запуска интерактивного режима работы:\n",
          "\n",
          "`python` или `python3` или `python2`\n",
          "\n",
          "Выход: `Ctrl+D`\n",
          "\n",
          "Режим работы, в котором выполнится код из файла main.py\n",
          "\n",
          "`python main.py`\n",
          "\n",
          "Помощь: **`help(X)`**, где `X` — то, по чему нужна помощь.  \n",
          "Выход из помощи: `q`."
        ]
      },
      {
        "metadata": {
          "colab_type": "text",
          "id": "8N0y9NugGwzI"
        },
        "cell_type": "markdown",
        "source": [
          "## Общая информация о языке\n",
          "\n",
          "**Название** - **«Питон» или «Пайтон»** (в честь комедийных серий BBC «Летающий цирк Монти-Пайтона»)  \n",
          "**Создатель** - **голландец Гвидо ван Россум (Guido van Rossum)** (в 1991 году)  \n",
          "\n",
          "**Особенности**:  \n",
          "- интерпретируемый\n",
          "- объектно-ориентированный\n",
          "- высокоуровневый язык\n",
          "- встроенные высокоуровневые структуры данных\n",
          "- динамическая типизация\n",
          "- синтаксис прост в изучении\n",
          "- поддержка модулей и пакетов (большинство библиотек\n",
          "бесплатны)\n",
          "- универсальный\n",
          "- интеграция с другими языками (C (Cython), C++, Java (JPython))  \n",
          "\n",
          "**Стиль оформления кода** - **PEP8** (если Вы хороший человек).  \n",
          "\n",
          "*Самое главное из PEP8:*  \n",
          "- отступ – 4 пробела\n",
          "- длина строки < 80 символов\n",
          "- переменные: var_recommended\n",
          "- константы: CONST_RECOMMENDED"
        ]
      },
      {
        "metadata": {
          "colab_type": "text",
          "id": "scLkWzB7Gw5s"
        },
        "cell_type": "markdown",
        "source": [
          "## Список материалов для самостоятельного изучения\n",
          "\n",
          "Данный ноутбук не претендует на полный охват всех тем и нюансов языка, поэтому ниже для удобства предоставлены ссылки на внешние ресурсы, которые могут помочь лучше изучить язык:\n",
          "\n",
          "* *Сайт языка Python* - https://www.python.org/\n",
          "\n",
          "\n",
          "* *Базовый курс синтаксиса Python с практикой* - https://www.codecademy.com/learn/learn-python\n",
          "\n",
          "\n",
          "* *Курс Python с нуля, можно выполнять задания в интерактивном режиме* - http://pythontutor.ru/\n",
          "\n",
          "\n",
          "* *Очень много задач на практику из разных областей, сделано по типу соцсети* - https://codesignal.com\n",
          "\n",
          "\n",
          "* *Новый онлайн-курс по Питону на Coursera от Mail.Ru Group* - https://www.coursera.org/learn/programming-in-python\n",
          "\n",
          "\n",
          "* *Самоучитель Python* - https://pythonworld.ru/samouchitel-python\n",
          "\n",
          "\n",
          "* *Статья про коварности Python* - https://habrahabr.ru/company/mailru/blog/337364/\n",
          "\n",
          "\n",
          "* *Очень полезные трюки в Jupyter Notebook*: https://www.dataquest.io/blog/jupyter-notebook-tips-tricks-shortcuts/"
        ]
      },
      {
        "metadata": {
          "colab_type": "text",
          "id": "YfhDEhg_GwzM"
        },
        "cell_type": "markdown",
        "source": [
          "### Типы"
        ]
      },
      {
        "metadata": {
          "colab_type": "text",
          "id": "PJA-KLzvGwzN"
        },
        "cell_type": "markdown",
        "source": [
          "**Все типы данных** в Python относятся к одной из **2-х категорий**: **изменяемые (mutable)** и **неизменяемые (immutable)**.   \n",
          "\n",
          "*Неизменяемые объекты*:  \n",
          "* числовые данные (int, float), \n",
          "* bool,\n",
          "* None,\n",
          "* символьные строки (class 'str'), \n",
          "* кортежи (tuple).  \n",
          "\n",
          "*Изменяемые объекты*:  \n",
          "* списки (list), \n",
          "* множества (set), \n",
          "* словари (dict).  \n",
          "\n",
          "Вновь определяемые пользователем типы (классы) могут быть определены как неизменяемые или изменяемые. Изменяемость объектов определённого типа является принципиально важной характеристикой, определяющей, может ли объект такого типа **выступать в качестве ключа для словарей (dict)** или нет."
        ]
      },
      {
        "metadata": {
          "id": "YbuXsGcgzM6P",
          "colab_type": "text"
        },
        "cell_type": "markdown",
        "source": [
          "----------"
        ]
      },
      {
        "metadata": {
          "id": "6MGS0RGPzM6Q",
          "colab_type": "text"
        },
        "cell_type": "markdown",
        "source": [
          "Начнем наше знакомство с языком с примитивных типов переменных:"
        ]
      },
      {
        "metadata": {
          "colab_type": "text",
          "id": "-tXSqvRRGwzN"
        },
        "cell_type": "markdown",
        "source": [
          "### int"
        ]
      },
      {
        "metadata": {
          "id": "9SQmEOL6zM6T",
          "colab_type": "text"
        },
        "cell_type": "markdown",
        "source": [
          "**Целочисленный тип переменной в питоне**\n",
          "\n",
          "Чтобы задать переменную, не нужно указывать ее тип -- достаточно присвоить ей значение. При этом тип определится автоматически.\n",
          "\n",
          "Давайте попробуем завести переменную, присвоить ей значение -- целое число, и вывести на экран ее значение и тип (type):"
        ]
      },
      {
        "metadata": {
          "colab_type": "code",
          "id": "MN-lZNJ4GwzO",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "x = 5\n",
          "\n",
          "print(x, '|', type(x))"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "id": "SxxwaqB-zM6a",
          "colab_type": "text"
        },
        "cell_type": "markdown",
        "source": [
          "Как видно, тип получившейся переменной -- int.\n",
          "\n",
          "C int'овыми переменными можно производить стандартные матеатические операции -- сложение, вычитание, умножение, деление, возведение в степень, взятие остатка при делении на число\n",
          "\n",
          "Деление переменных типа int бывает двух типов -- целочисленное (с помощью символа //) и нецелочисленное (символ /). Результатом первого типа деления будет целое число, второго -- дробное. "
        ]
      },
      {
        "metadata": {
          "colab_type": "code",
          "id": "4fRsWXp7GwzS",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "a = 4 + 5\n",
          "b = 4 * 5\n",
          "c = 5 // 4\n",
          "d = 5 / 4\n",
          "e = 5**4 # 5 в степени 4\n",
          "f = 5%4 # остаток при делении 5 на 4\n",
          "\n",
          "print(a, b, c, d, e)"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "id": "XyZYWE9YzM6g",
          "colab_type": "text"
        },
        "cell_type": "markdown",
        "source": [
          "Также язык питон удобен в работе с большими числами:\n",
          "\n",
          "Давайте попробуем положить в переменную число 5000000000000000000000000001:"
        ]
      },
      {
        "metadata": {
          "colab_type": "code",
          "id": "FnsWAhPMGwza",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "x = 5 * 1000000000 * 1000000000 * 10**9 + 1\n",
          "print(x, '|', type(x))"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "id": "4GTO4cU0zM6l",
          "colab_type": "text"
        },
        "cell_type": "markdown",
        "source": [
          "Как видите, все получилось: полученная переменная типа int и с ней можно работать как с обычными числами. Во многих других языках (например, С++) положить такое большое число в переменную бы не вышло -- возникло бы переполнение."
        ]
      },
      {
        "metadata": {
          "colab_type": "text",
          "id": "Hf0cK9ejGwzd"
        },
        "cell_type": "markdown",
        "source": [
          "### float"
        ]
      },
      {
        "metadata": {
          "id": "-ETlGwx6zM6n",
          "colab_type": "text"
        },
        "cell_type": "markdown",
        "source": [
          "**Тип переменной для хранения дробных чисел в питоне**:"
        ]
      },
      {
        "metadata": {
          "colab_type": "code",
          "id": "IJcKX6iPGwzd",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "y = 12.345\n",
          "\n",
          "print(y, '|', type(y))"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "id": "hdrWEQ6OzM6p",
          "colab_type": "text"
        },
        "cell_type": "markdown",
        "source": [
          "С этим типом также можно выполнять арифметические операции (даже целочисленное деление):"
        ]
      },
      {
        "metadata": {
          "colab_type": "code",
          "id": "qjBbYiC0Gwzg",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "a = 4.2 + 5.1\n",
          "b = 4.2 * 5.1\n",
          "c = 5.0 / 4.0\n",
          "d = 5.25 // 4.25\n",
          "e = 5.25 ** 4.0\n",
          "\n",
          "print(a, b, c, d, e)"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "id": "7My0U1JSzM6t",
          "colab_type": "text"
        },
        "cell_type": "markdown",
        "source": [
          "Переменную типа int можно привести к типу float "
        ]
      },
      {
        "metadata": {
          "colab_type": "code",
          "id": "dWjoVU9OGwzj",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "a = 5\n",
          "print(a, '|', type(a))\n",
          "a = float(a)\n",
          "print(a, '|', type(a))"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "colab_type": "text",
          "id": "YFD8l2XuGwzq"
        },
        "cell_type": "markdown",
        "source": [
          "### bool"
        ]
      },
      {
        "metadata": {
          "id": "AnzNaVf8zM6w",
          "colab_type": "text"
        },
        "cell_type": "markdown",
        "source": [
          "**Логический тип переменной**: \n",
          "\n",
          "переменная типа bool может принимать два значения: `True` и `False`:"
        ]
      },
      {
        "metadata": {
          "colab_type": "code",
          "id": "f-kwu3wkGwzr",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "a = True\n",
          "b = False\n",
          "\n",
          "print(a, '|', type(a))\n",
          "\n",
          "print(b, '|', type(b))"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "id": "c0fVpjYyzM60",
          "colab_type": "text"
        },
        "cell_type": "markdown",
        "source": [
          "У типа bool существует связь с типом int -- переменная со значением True соответствует int'овой переменной со значением 1, а переменная со значением False -- int'овой переменной со значением 0.\n",
          "\n",
          "Давайте в этом убедимся, попробовав сложить значения переменных a и b:"
        ]
      },
      {
        "metadata": {
          "colab_type": "code",
          "id": "XOtoJKoOGwzu",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "print(a + b)\n",
          "print(a + a)\n",
          "print(b + b)"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "id": "h6cWbwGzzM65",
          "colab_type": "text"
        },
        "cell_type": "markdown",
        "source": [
          "Ну и просто приведем a и b к типу int:"
        ]
      },
      {
        "metadata": {
          "colab_type": "code",
          "id": "bxaoc7p_Gwzw",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "print(int(a), int(b))"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "id": "2E3YARdGzM67",
          "colab_type": "text"
        },
        "cell_type": "markdown",
        "source": [
          "Логические \"и\", \"или\", \"не\" в питоне обозначаюся ключевыми словами `and`, `or`, `not` соответственно:"
        ]
      },
      {
        "metadata": {
          "colab_type": "code",
          "id": "moSf59BmGwzz",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "print(True and False, '\\n')\n",
          "\n",
          "print(True or True, '\\n')\n",
          "\n",
          "print(not False, '\\n')"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "id": "W4kBXsmazM6-",
          "colab_type": "code",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "# в переменную a будет записан результат сравнения 2 и 3. т.е. False, потому что (2==3) неверно. \n",
          "a = (2 == 3)\n",
          "b = (4 < 5)\n",
          "\n",
          "print(a, '|', type(a))\n",
          "print(b, '|', type(b))"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "id": "10QGSb6ezM7A",
          "colab_type": "code",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "a or (a and not b)"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "id": "Ra7b2HeOzM7C",
          "colab_type": "text"
        },
        "cell_type": "markdown",
        "source": [
          "### If"
        ]
      },
      {
        "metadata": {
          "id": "oFKRUUbvzM7D",
          "colab_type": "text"
        },
        "cell_type": "markdown",
        "source": [
          "**Условный оператор**\n",
          "\n",
          "В коде часто приходится проверять выполнимость или невыполнимость каких-то условий. Синтаксис следующий\n",
          "\n",
          "```\n",
          "if <условие1 (булевское выражение)> :\n",
          "    <код, который выполнится, если условие верно>\n",
          "elif <условие2 (булевское выражение)>:\n",
          "    <код, который выполнится, если условие1 было неверно, а условие2 верно>\n",
          "else:\n",
          "    <код, который выполнится, если условие1 и условие2 были неверны>\n",
          "```\n",
          "\n",
          "Обратите внимание, что код, который должен выполняться внутри каждого условия, записывается с отступом в 4 пробела от уровня if, elif и else: в питоне области видимости переменных обозначаются отступами.\n",
          "\n",
          "*То есть, отступы позволяют понять, где начинается код, который должен выполняться при выполнении условия в if, и где заканчивается*\n",
          "\n",
          "Рассмотрим пример: пусть в нашем коде есть переменная x. Пусть мы хотим вывести на экран сообщение \"x отрицателен\", если x<0, \"x равен нулю\", если x=0 и \"x положителен\", если x>0. Код будет следующий:"
        ]
      },
      {
        "metadata": {
          "id": "zGSGj58YzM7E",
          "colab_type": "code",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "x = 10\n",
          "\n",
          "if x<0:\n",
          "    print(\"x отрицателен\")\n",
          "elif x==0:\n",
          "    print(\"x равен нулю\")\n",
          "else:\n",
          "    print(\"x положителен\")\n",
          "    \n",
          "# этот код уже не \"внутри\" else, потому что записан без отступа в 4 пробела. Поэтому он выполнится \n",
          "# в любом случае после отработки if-elif-else\n",
          "print(\"Done\")"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "id": "cdvOH6KDzM7G",
          "colab_type": "text"
        },
        "cell_type": "markdown",
        "source": [
          "Конечно, в `if` можно подставлять и более сложные булевские выражения:"
        ]
      },
      {
        "metadata": {
          "id": "N40FqjChzM7H",
          "colab_type": "code",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "if x>3 and x < 11 or x==5:\n",
          "    print(x)\n",
          "    # тоже выполнится при выполнения условия после if, так как этот код тоже записан с отступом в 4 пробела\n",
          "    print(\"nice\")"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "id": "G5QFZl5XzM7J",
          "colab_type": "code",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "# if внутри if:\n",
          "x = 3\n",
          "y = 5\n",
          "if x == 3:\n",
          "    if y > 6:\n",
          "        # отступ в 4 пробела от внутреннего if\n",
          "        print(\"y greater than 6\")\n",
          "    else:\n",
          "        print(\"y not grater than 6\")\n",
          "        \n",
          "    # отступ в 4 пробела от внешнего if, поэтому код выполнится если x==3 и при любом значении y\n",
          "    print(\"x is equal to 3\")"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "colab_type": "text",
          "id": "sGGkrmM0Gwz1"
        },
        "cell_type": "markdown",
        "source": [
          "### None"
        ]
      },
      {
        "metadata": {
          "id": "pjXxEdFKzM7L",
          "colab_type": "text"
        },
        "cell_type": "markdown",
        "source": [
          "**ничего, null**"
        ]
      },
      {
        "metadata": {
          "id": "at7Q5Ok8zM7M",
          "colab_type": "text"
        },
        "cell_type": "markdown",
        "source": [
          "Специальный тип в питоне, который обозначает *ничего*\n",
          "\n",
          "Его нельзя привести ни к одному другому типу языка. Проверить, является ли переменная param типом None, можно так:\n",
          "\n",
          "```\n",
          "if param is None\n",
          "```\n",
          "\n",
          "С первого взгляда может быть непонятно, зачем он нужен, но на самом деле это оченб удобный тип. Например, если вы где-то в коде создаете объект (базу данных, например), обращаясь к внешнему коду и хотите проверить, создалась ли ваша база данных, вы можете осуществить эту проверку, сравнив переменную базы данных с None. Примерно так:\n",
          "\n",
          "```\n",
          "database = MyDatabase(db_host, db_user, db_password, db_database)\n",
          "\n",
          "if database is None:\n",
          "```"
        ]
      },
      {
        "metadata": {
          "colab_type": "code",
          "id": "BMIBkyzcGwz6",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "z = None\n",
          "print(z, '|', type(z))"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "id": "K8JufXAxzM7O",
          "colab_type": "text"
        },
        "cell_type": "markdown",
        "source": [
          "Убедимся, что None нельзя привести к другому типу:"
        ]
      },
      {
        "metadata": {
          "colab_type": "code",
          "id": "KaBmiMneGwz8",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "int(z)"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "id": "ZqI8L0vrzM7R",
          "colab_type": "text"
        },
        "cell_type": "markdown",
        "source": [
          "Проверка переменной на None:"
        ]
      },
      {
        "metadata": {
          "colab_type": "code",
          "id": "8k4aCla1Gwz_",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "if z is None:\n",
          "    z = 'I am None!'\n",
          "z"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "colab_type": "text",
          "id": "r_y-TEM3Gw0A"
        },
        "cell_type": "markdown",
        "source": [
          "### str"
        ]
      },
      {
        "metadata": {
          "id": "lxN_IvU0zM7U",
          "colab_type": "text"
        },
        "cell_type": "markdown",
        "source": [
          "**строка**"
        ]
      },
      {
        "metadata": {
          "id": "mmVRb6X3zM7V",
          "colab_type": "text"
        },
        "cell_type": "markdown",
        "source": [
          "Тип переменной \"строка\". Нужен для хранения и выполнения операций с строками -- наборами символов. В питоне строку можно задавать как с помощью одинарных кавычек, так и с помощью двойных, разницы нет (главное, чтобы в начале и конце одной строки стояли одинаковые кавычки):"
        ]
      },
      {
        "metadata": {
          "colab_type": "text",
          "id": "NYLe3wFlGw0C"
        },
        "cell_type": "markdown",
        "source": [
          "В *python2.7* есть отдельный тип **unicode**. В *python3.5 (и выше)* (который будем использовать мы) всё это включено в тип **str**."
        ]
      },
      {
        "metadata": {
          "colab_type": "code",
          "id": "W5ZhY9r9Gw0C",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "x = \"abc\"\n",
          "y = 'xyz'\n",
          "print(x, '|', type(x))\n",
          "print(y, '|', type(y))"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "id": "wsjzmN8lzM7X",
          "colab_type": "text"
        },
        "cell_type": "markdown",
        "source": [
          "Со строками тоже можно выполнять некоторые операции. Например, можно сложить две строки -- тогда вторая припишется в конец первой:"
        ]
      },
      {
        "metadata": {
          "colab_type": "code",
          "id": "ZVTh7bPjGw0F",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "a = 'Андрей'\n",
          "b = \"Михайлович\"\n",
          "s = a + \" \" + b\n",
          "print(s)"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "id": "jU-tX-ZBzM7Z",
          "colab_type": "text"
        },
        "cell_type": "markdown",
        "source": [
          "Также у строк есть некоторое количество *методов*\n",
          "\n",
          "Метод -- это название для функций, которые вызываются от объекта. Например, у нас есть объект a -- строка, и у нее можно вызвать метод `.upper()`:\n",
          "\n",
          "```\n",
          "a.upper()\n",
          "```\n",
          "\n",
          "Методы деляится на те, которые изменяют сам объект, который их вызывает, и на те, которые возвращают результат, но не изменяют сам объект. \n",
          "\n",
          "Вот пример методов `.upper()` и `.lower()`, которые возвращают копию строки (не изменяя саму строку), от которой был вызван метод, приведенную к верхнему и нижнему регистру соответственно:"
        ]
      },
      {
        "metadata": {
          "colab_type": "text",
          "id": "dSyo8vW9Gw1K"
        },
        "cell_type": "markdown",
        "source": [
          "P.S. При вызове метода какого-то класса (или функции какого-то модуля) можно написать его имя и через точку нажать **tab**:  \n",
          "\n",
          "<имя\\_объекта\\_класса(модуля)>**.[tab]**  \n",
          "\n",
          "Тогда всплывёт меню, в котором можно выбрать из всех существующих в этом классе методов (функций модуля)."
        ]
      },
      {
        "metadata": {
          "colab_type": "code",
          "id": "r3L343d5Gw0H",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "print(a.upper())\n",
          "print(a.lower())"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "id": "oGTyecPezM7c",
          "colab_type": "text"
        },
        "cell_type": "markdown",
        "source": [
          "Можно получить длину строки с помощью функции `len`:"
        ]
      },
      {
        "metadata": {
          "colab_type": "code",
          "id": "YiFvXOaIGw0K",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "print(len(a))"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "id": "iCBY7czmzM7e",
          "colab_type": "text"
        },
        "cell_type": "markdown",
        "source": [
          "Можно обращаться к отдельным элементам строки через индексы (индексация в питоне с 0):"
        ]
      },
      {
        "metadata": {
          "colab_type": "code",
          "id": "5eSIiAI_Gw0Q",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "print(a)\n",
          "print(a[0])\n",
          "print(a[1])\n"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "id": "oB9lbV_TzM7i",
          "colab_type": "text"
        },
        "cell_type": "markdown",
        "source": [
          "А также можно получить *слайс* строки -- кусок строки с i-ого символа по j-ый. Делается это следующим образом:"
        ]
      },
      {
        "metadata": {
          "id": "6H-BHEmAzM7j",
          "colab_type": "code",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "i = 0\n",
          "j = 1\n",
          "print(a[i:j])"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "id": "gaZcGIeezM7k",
          "colab_type": "text"
        },
        "cell_type": "markdown",
        "source": [
          "Можно проверять наличие подстроки в строке:"
        ]
      },
      {
        "metadata": {
          "id": "bb4iUUSezM7l",
          "colab_type": "code",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "s = 'ya stroka'\n",
          "if 'ya' in s:\n",
          "    print(\"ya deistvitel\\'no stroka\")"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "id": "Es1yXyp_zM7m",
          "colab_type": "text"
        },
        "cell_type": "markdown",
        "source": [
          "А вот изменять уже существующие строки нельзя:"
        ]
      },
      {
        "metadata": {
          "id": "E0jm8V7szM7n",
          "colab_type": "code",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "s = 'ya stroka'\n",
          "s[0] = 'l'"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "colab_type": "text",
          "id": "knjcsCbVGw0Z"
        },
        "cell_type": "markdown",
        "source": [
          "### Метод `split()`:"
        ]
      },
      {
        "metadata": {
          "id": "ZT-ofQOqzM7o",
          "colab_type": "text"
        },
        "cell_type": "markdown",
        "source": [
          "У строк наряду с методами `.upper()`, `.lower()` и остальными есть метод `.split()`, который часто бывает очень полезен. Этот метод делит строку на несколько по символу, который ему указываешь, и возвращает набор полученных строк (точнее, массив полученных строк -- о том, что такое массив, ниже)\n",
          "\n",
          "Если символ не указывать, строка делится по пробелам:"
        ]
      },
      {
        "metadata": {
          "colab_type": "code",
          "id": "TuEP17vFGw0Z",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "splitted_line = \"Райгородский Андрей Михайлович\".split()\n",
          "print(splitted_line)"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "id": "xG3_3t13zM7q",
          "colab_type": "code",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "splitted_line = \"Райгородский Андрей Михайлович\".split('р')\n",
          "print(splitted_line)"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "colab_type": "text",
          "id": "P7kqThRsGw1S"
        },
        "cell_type": "markdown",
        "source": [
          "### Структуры данных и встроенные функции"
        ]
      },
      {
        "metadata": {
          "colab_type": "text",
          "id": "e6LOqPpYGw1T"
        },
        "cell_type": "markdown",
        "source": [
          "### list"
        ]
      },
      {
        "metadata": {
          "id": "oZDGb_E5zM7s",
          "colab_type": "text"
        },
        "cell_type": "markdown",
        "source": [
          "**массив, список, лист**"
        ]
      },
      {
        "metadata": {
          "id": "E949xtw7zM7t",
          "colab_type": "text"
        },
        "cell_type": "markdown",
        "source": [
          "Вот мы и добрались до типов языка python, которые представляют собой *контейнеры*, то есть, это типы данных, которые являют собой хранилища для других типов данных.\n",
          "\n",
          "Один из таких типов -- `list` (массив, список, лист). Это контейнер, куда можно положить сколько угодно других переменных, значений, и эти переменные даже могут быть разных типов и даже так же могут быть контейнерами! То есть, в list можно положить list:\n",
          "\n",
          "Чтобы задать list, надо в квадратные скобки `[]` положить нужные элементы. Пустые скобки задают пустой list. Пустой лист также можно задать, написав `list()`:"
        ]
      },
      {
        "metadata": {
          "colab_type": "code",
          "id": "pGXNzuLsGw1U",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "a = list()\n",
          "b = []\n",
          "\n",
          "# убедимся, что два варианта создания пустого массива эквивалентны:\n",
          "print(a == b)"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "id": "rWHlu6YgzM7v",
          "colab_type": "code",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "c = [2, 'a', [4, 'stroka', 6.56]]"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "id": "Yxs2uGIXzM7x",
          "colab_type": "text"
        },
        "cell_type": "markdown",
        "source": [
          "Что можно делать с list:"
        ]
      },
      {
        "metadata": {
          "id": "bmEriyu4zM7y",
          "colab_type": "text"
        },
        "cell_type": "markdown",
        "source": [
          "Можно положить элемент в конец массива:"
        ]
      },
      {
        "metadata": {
          "id": "L-Vp7SanzM7y",
          "colab_type": "code",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "c.append(4.67)\n",
          "c"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "id": "LjkI3QWAzM70",
          "colab_type": "text"
        },
        "cell_type": "markdown",
        "source": [
          "можно удалить элемент с конца массива:"
        ]
      },
      {
        "metadata": {
          "id": "UxkgZ0bezM70",
          "colab_type": "code",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "c.pop()\n",
          "c"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "id": "MRXHuVjPzM71",
          "colab_type": "text"
        },
        "cell_type": "markdown",
        "source": [
          "**Методы list, которые мы рассмотрим ниже, будут работать для всех iterable контейнеров **\n",
          "\n",
          "(что значит iterabel, можно прочитать тут: http://pythonz.net/references/named/iterable/\n",
          "\n",
          "кратко -- это структуры данных, поддерживающие поочередный проход по своим элементам)"
        ]
      },
      {
        "metadata": {
          "id": "kJ40tjpZzM72",
          "colab_type": "text"
        },
        "cell_type": "markdown",
        "source": [
          "По индексам можно получить доступ к элементам массива (индексация, как обычно, с 0):"
        ]
      },
      {
        "metadata": {
          "id": "reuh72cxzM72",
          "colab_type": "code",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "print(c[0])\n",
          "print(c[2])\n",
          "# да, индексы могут быть отрицательные: -i есть i-ый с конца элемент массива (в нумерации с 1)\n",
          "print(c[-1])"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "id": "bqiG7q_UzM74",
          "colab_type": "text"
        },
        "cell_type": "markdown",
        "source": [
          "Можно не только получать по 1 элементу массива, но и *слайс* -- элементы массива с индексами между i (включительно) и j (не включительно):"
        ]
      },
      {
        "metadata": {
          "id": "oRI6NY-azM74",
          "colab_type": "code",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "# в d будет записан новый массив, в котором будут 1 и 2 элементы массива c\n",
          "d = c[1:3]\n",
          "print(d)"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "id": "GnG6b9m8zM76",
          "colab_type": "text"
        },
        "cell_type": "markdown",
        "source": [
          "А еще можно сделать операцию наоборот -- не по индексу получить элемент массива, а по элементу массива получить его индекс.\n",
          "\n",
          "`L.index(element)` - возвращает индекс элемента `element` в списке `L`, если он там присутствует, `None` иначе (вот еще один пример использования None)"
        ]
      },
      {
        "metadata": {
          "id": "UFv9nYtpzM77",
          "colab_type": "code",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "c.index('a')"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "id": "BP9nnUXnzM78",
          "colab_type": "text"
        },
        "cell_type": "markdown",
        "source": [
          "Можно проверять принадлежность элемента массиву:"
        ]
      },
      {
        "metadata": {
          "id": "O8IqdA3mzM79",
          "colab_type": "code",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "5 in c"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "id": "Vp6eCldzzM7-",
          "colab_type": "code",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "if 'a' in c:\n",
          "    print(\"element \\'a\\' in c\")"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "id": "-JB5GFn9zM7_",
          "colab_type": "text"
        },
        "cell_type": "markdown",
        "source": [
          "Можно еще сложнее: получить каждый k-й элемент массива c, начиная с элемента с индексом i (включительно) и заканчивая элементом с индексом j (не включительно):"
        ]
      },
      {
        "metadata": {
          "id": "z78Oct4EzM8A",
          "colab_type": "code",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "c = [1, 2, 3, 4, 5, 6, 7, 8, 9]\n",
          "d = c[1:7:2]\n",
          "print(d)"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "id": "4fJ74N-uzM8B",
          "colab_type": "text"
        },
        "cell_type": "markdown",
        "source": [
          "С помощью слайсов можно перевернуть массив, например:"
        ]
      },
      {
        "metadata": {
          "id": "RSQ5v-yazM8C",
          "colab_type": "code",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "print(c)\n",
          "# получим каждый минус первый элемент массива начиная с 0 индекса и заканчивая последним\n",
          "d = c[::-1]\n",
          "print(d)"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "id": "AU3Q3GyhzM8D",
          "colab_type": "text"
        },
        "cell_type": "markdown",
        "source": [
          "Элементы массива также можно изменять, обращаясь к ним по индексу или слайсу:"
        ]
      },
      {
        "metadata": {
          "id": "NwFLWigrzM8E",
          "colab_type": "code",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "print(c)\n",
          "c[0] = 100500\n",
          "print(c)"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "id": "FA3BxaIBzM8F",
          "colab_type": "code",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "# вместо 2, 3 и 4 элементов массива запишем  число 80\n",
          "c[2:5] = [80]\n",
          "print(c)\n",
          "# вместо 2, 3 и 4 элементов массива запишем  числа 80, 90\n",
          "c[2:5] = [80, 90]\n",
          "print(c)"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "id": "VpIbWfF-zM8G",
          "colab_type": "text"
        },
        "cell_type": "markdown",
        "source": [
          "Также массивы можно складывать. Результатом сложения двух массивов будет новый массив, в котором сначала будут записаны элементы первого массива, затем -- второго:"
        ]
      },
      {
        "metadata": {
          "id": "a_z8So57zM8G",
          "colab_type": "code",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "d = [9, 0]\n",
          "c+d"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "id": "VhaJ_zzlzM8I",
          "colab_type": "text"
        },
        "cell_type": "markdown",
        "source": [
          "А вот вычитать нельзя:"
        ]
      },
      {
        "metadata": {
          "id": "JsmAsyn8zM8I",
          "colab_type": "code",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "c-d"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "id": "kDleFDsdzM8K",
          "colab_type": "text"
        },
        "cell_type": "markdown",
        "source": [
          "С помощью `len()` можно получить размер листа (и вообще любого iterable объекта):"
        ]
      },
      {
        "metadata": {
          "id": "1Q9Pz4YYzM8K",
          "colab_type": "code",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "len(c)"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "id": "k2Ru4gCJzM8L",
          "colab_type": "text"
        },
        "cell_type": "markdown",
        "source": [
          "можно отсортировать элементы массива, вызвав метод .sort():"
        ]
      },
      {
        "metadata": {
          "id": "fpo8b9g8zM8M",
          "colab_type": "code",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "# вызов метода sort изменяет сам объект c, а не возвращает копию:\n",
          "c.sort()\n",
          "c"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "id": "KgSZ7GuFzM8N",
          "colab_type": "text"
        },
        "cell_type": "markdown",
        "source": [
          "### Задание 1\n",
          "\n",
          "Напишите код, который проверяет, является ли переменная x строкой, и если да, то если в строке больше одного слова (слово--последовательность подряд идущих символов без пробелов), то выводит на экран количество слов в этой строке и сами слова в алфавитном порядке"
        ]
      },
      {
        "metadata": {
          "id": "_otFvfPGzM8N",
          "colab_type": "code",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "# your code here"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "id": "TE6KBa0HzM8P",
          "colab_type": "text"
        },
        "cell_type": "markdown",
        "source": [
          "### Задание 2\n",
          "\n",
          "Напишите код, который все элементы массива x с **нечетными** индексами переставит в обратном порядке.\n",
          "\n",
          "Т.е. если x = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9], то код должен получать [0, 9, 2, 7, 4, 5, 6, 3, 8, 1]"
        ]
      },
      {
        "metadata": {
          "id": "kiVny47HzM8P",
          "colab_type": "code",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "# your code here"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "colab_type": "text",
          "id": "2mnxxvHxGw0c"
        },
        "cell_type": "markdown",
        "source": [
          "### tuple"
        ]
      },
      {
        "metadata": {
          "id": "6o4C3V2AzM8R",
          "colab_type": "text"
        },
        "cell_type": "markdown",
        "source": [
          "**кортеж**\n",
          "\n",
          "этот тип данных очень похож на list, имеет ту же структуру, но отличается тем, что он неизменяемый\n",
          "\n",
          "это нужно, например, чтобы `tuple` мог выступать в качестве ключей словаря (о них ниже). list в качестве ключей словаря выступать не может."
        ]
      },
      {
        "metadata": {
          "id": "MsRtEw8IzM8R",
          "colab_type": "text"
        },
        "cell_type": "markdown",
        "source": [
          "Задать tuple можно круглыми скобками:"
        ]
      },
      {
        "metadata": {
          "colab_type": "code",
          "id": "pCgzsWT-Gw0d",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "t = ('a', 5, 12.345, (2, 'b'))\n",
          "t"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "id": "c3c0r0eVzM8S",
          "colab_type": "text"
        },
        "cell_type": "markdown",
        "source": [
          "Tuple нельзя изменять. Давайте в этом убедимся:"
        ]
      },
      {
        "metadata": {
          "colab_type": "code",
          "id": "dDtHlkzIGw0f",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "t.append(5)"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "id": "F55yIy87zM8U",
          "colab_type": "code",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "t[0] = 9"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "id": "KPEftqeszM8V",
          "colab_type": "text"
        },
        "cell_type": "markdown",
        "source": [
          "Но получать элементы по индексу и слайсам, конечно, можно (tuple же iterable):"
        ]
      },
      {
        "metadata": {
          "colab_type": "code",
          "id": "p1Um9EKeGw0m",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "print(t[2])\n",
          "print(t.index(5))\n",
          "print(t[:2])"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "id": "HXhrxv8KzM8W",
          "colab_type": "text"
        },
        "cell_type": "markdown",
        "source": [
          "Как и list, кортежи можно складывать и работает сложение так же, как в list \n",
          "\n",
          "(вообще, с кортежами можно делать все, что можно делать с list, если это не изменяет кортеж)"
        ]
      },
      {
        "metadata": {
          "colab_type": "code",
          "id": "CIWPvGkiGw0p",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "m = (1, 2, 3)\n",
          "# складывать\n",
          "print(t + m)\n",
          "# узнать размер \n",
          "print(len(t))\n",
          "# проверить наличие элемента\n",
          "print(5 in t)"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "colab_type": "text",
          "id": "hcaipS17Gw1I"
        },
        "cell_type": "markdown",
        "source": [
          "---"
        ]
      },
      {
        "metadata": {
          "colab_type": "text",
          "id": "04VwiGfkGw3t"
        },
        "cell_type": "markdown",
        "source": [
          "### Циклы - for и while"
        ]
      },
      {
        "metadata": {
          "id": "MPzD7aIfzM8Z",
          "colab_type": "text"
        },
        "cell_type": "markdown",
        "source": [
          "iterable стректуры данных так называются, потому что по ним можно *итерироваться* -- последовательно получать значения последовательных элементов этой структуры данных. Итерироваться можно с помощью циклов `for` или `while`.\n",
          "\n",
          "Синтаксис следующий:\n",
          "\n",
          "```\n",
          "for element in iterable:\n",
          "    <code>\n",
          "```\n",
          "\n",
          "здесь каждую новую итерацию цикла в element будет записываться очередное значение из контейнера iterable и с ним можно будет работать внутри тела цикла (`code`). Когда код внутри тела цикла отработает, начнется новая итерация цикла -- в переменную element запишется следующее значение из iterable и опять будет выполняться code.\n",
          "\n",
          "Код, который будет выполняться каждую итерацию цикла, записывается после двоеточия с отступом 4 пробела от строчки c `for`.\n",
          "\n",
          "Посмотрим на примере:"
        ]
      },
      {
        "metadata": {
          "colab_type": "code",
          "id": "RGyfjAhGGw3u",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "# создадим list элементов\n",
          "models = ['decision tree', 'linear model', 'svm', 'ensemble']\n",
          "\n",
          "# итерируемся по названиям модели: каждую итерацию цикла в переменную model будет\n",
          "# записываться новое значение из models и оно будет использоваться для print(model)\n",
          "for model in models:\n",
          "    # тело цикла. Здесь с отступом в 4 пробела нужно описать код, который будет выполняться на каждой итерации цикла.\n",
          "    print(model)\n",
          "    \n",
          "# этот код уже будет выполняться ПОСЛЕ цикла, потому что он записан без отступа в 4 пробела после for:\n",
          "print(\"Done\")"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "id": "ku2Q6dvvzjrE",
          "colab_type": "text"
        },
        "cell_type": "markdown",
        "source": [
          "**P.S.** Зметим, что каждую итерацию цикла в переменную model **копируется** очередное значение из models. Это значит, что если вы внутри цикла измените переменную model, соответствующее значение в массиве models изменено **не будет**"
        ]
      },
      {
        "metadata": {
          "id": "GFRz-l-WzM8b",
          "colab_type": "text"
        },
        "cell_type": "markdown",
        "source": [
          "Синтаксис `while`:\n",
          "\n",
          "```\n",
          "while <условие (булевское выражение)>:\n",
          "    <code>\n",
          "```\n",
          "\n",
          "Здесь код, написанный вместо `code` будет выполняться каждую итерацию цикла, пока условие после `while` будет выполняться.\n",
          "\n",
          "Посмотрим на примере: Напишем цикл, в котором будем выводить переменную x и увеличивать x на 1, пока x не станет больше 10:"
        ]
      },
      {
        "metadata": {
          "colab_type": "code",
          "id": "qwWXAn2zGw3v",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "x = 1\n",
          "\n",
          "while x <= 10:\n",
          "    print(x)\n",
          "    # более удобный способ записи x = x + 1\n",
          "    x += 1"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "id": "LIeDwUhRzM8d",
          "colab_type": "text"
        },
        "cell_type": "markdown",
        "source": [
          "Иногда бывает нужно прервать выполнение цикла при выполнении какого-то условия\n",
          "\n",
          "Например, мы хотим итерироваться по массиву строк, на каждой итерации выводить строку на экран и прервать цико (перестать выводить строки), если мы встретили строку stop.\n",
          "\n",
          "Это делается с помощью ключевого слова `break`:"
        ]
      },
      {
        "metadata": {
          "id": "-sXQ20WhzM8d",
          "colab_type": "code",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "mas = ['stroka1', 'stroka2', 'stroka3', 'stop', 'stroka4']\n",
          "\n",
          "for s in mas:\n",
          "    if s == 'stop':\n",
          "        break\n",
          "    print(s)"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "id": "mV0nKWbvzM8e",
          "colab_type": "text"
        },
        "cell_type": "markdown",
        "source": [
          "Иногда же хочется не прервать выполнение всего цикла, а прервать выполнение именно одной итерации цикла и продолжить цикл со следующей итерации.\n",
          "\n",
          "Например, мы так же, как в предыдущем примере, хотим итерироваться по массиву строк и выводить строку на каждой итерации на экран, но не хотим выводить строку на экран, если эта строка равна 'null'.\n",
          "\n",
          "Это делается с помощью ключевого слова `continue`:"
        ]
      },
      {
        "metadata": {
          "id": "vNZTe8fczM8f",
          "colab_type": "code",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "mas = ['stroka1', 'null', 'stroka3', 'stop', 'null']\n",
          "\n",
          "for s in mas:\n",
          "    if s == 'null':\n",
          "        continue\n",
          "    print(s)"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "id": "B2Y6F2QozM8g",
          "colab_type": "text"
        },
        "cell_type": "markdown",
        "source": [
          "#### range\n",
          "\n",
          "Для работы с циклами в питоне есть очень полезная функция `range()`. Допустим, вы хотите написать цикл, который бы отработал 100 раз. Можно сделать это следующим образом:\n",
          "\n",
          "```\n",
          "i = 0\n",
          "while i < 100:\n",
          "    i += 1\n",
          "    <code>\n",
          "```\n",
          "\n",
          "но это неудобно: нужно завести вспомогательную переменную i, написать лишние 2 строчки кода (i=0 и i+=1). Так код терядет в понятности и читабельности. Гораздо проще записать этот цикл с помощью range.\n",
          "\n",
          "`range()` принимает 3 аргумента: начало интервала begin, конец интервала end и шаг step, с которым будет двигаться по игтервалу, и возвращает iterable объект -- по сути, массив чисел начиная с begin включительно, заканчивая end не включительно, числа в массиве идут с шагом step.\n",
          "\n",
          "Посмотрим на пример:"
        ]
      },
      {
        "metadata": {
          "id": "WjVT0aODzM8h",
          "colab_type": "code",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "r = range(1, 100, 10)\n",
          "#приведем возвращаемый iterable к list и выведем на экран:\n",
          "print(list(r))"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "id": "aKbCXQUjzM8i",
          "colab_type": "text"
        },
        "cell_type": "markdown",
        "source": [
          "Теперь легко записать цикл:"
        ]
      },
      {
        "metadata": {
          "id": "zz-i2EOLzM8i",
          "colab_type": "code",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "for i in range(1, 100, 1):\n",
          "    print(i)"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "id": "6IJfBuVUzM8j",
          "colab_type": "text"
        },
        "cell_type": "markdown",
        "source": [
          "Если у range не указывать последний алгумент step, он по умолчанию будет 1.\n",
          "\n",
          "А если указать всего один аргумент, то range выдаст iterable с началом в 0 и концом в этом аргументе:"
        ]
      },
      {
        "metadata": {
          "id": "mqFuX8aqzM8j",
          "colab_type": "code",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "list(range(4, 8))"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "id": "-lBrG1q6zM8k",
          "colab_type": "code",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "list(range(8))"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "id": "ZJrtKwFu0Cam",
          "colab_type": "text"
        },
        "cell_type": "markdown",
        "source": [
          "С помощью range нетрудно переписать цикл, который мы писали выше, где итерировались по названиям моделей, так, чтобы элементы массива models  можно было изменять внутри цикла:"
        ]
      },
      {
        "metadata": {
          "id": "GKD2yNLD0C_J",
          "colab_type": "code",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "# создадим list элементов\n",
          "models = ['decision tree', 'linear model', 'svm', 'ensemble']\n",
          "\n",
          "# итерируемся по индексам массива models\n",
          "for i in range(len(models)):\n",
          "    # тут если вы поменяете models[i], то значение в models тоже изменится\n",
          "    print(models[i])\n",
          "    \n",
          "# этот код уже будет выполняться ПОСЛЕ цикла, потому что он записан без отступа в 4 пробела после for:\n",
          "print(\"Done\")"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "id": "25O4dyOezM8l",
          "colab_type": "text"
        },
        "cell_type": "markdown",
        "source": [
          "### Задание 3\n",
          "\n",
          "Напишите цикл, который выводит все числа от 0 до 500, делящиеся на 7, если в них есть цифра 8\n",
          "\n",
          "*Подсказка*: переменную типа int можно привести к типу str:\n",
          "```\n",
          "x = 5\n",
          "y = str(x)\n",
          "```"
        ]
      },
      {
        "metadata": {
          "id": "GI8_HgH1zM8m",
          "colab_type": "code",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "# your code here"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "colab_type": "text",
          "id": "USIIpRQeGw3N"
        },
        "cell_type": "markdown",
        "source": [
          "---"
        ]
      },
      {
        "metadata": {
          "colab_type": "text",
          "id": "70QerwaDGw3y"
        },
        "cell_type": "markdown",
        "source": [
          "### enumerate, zip"
        ]
      },
      {
        "metadata": {
          "id": "__U7hz9izM8n",
          "colab_type": "text"
        },
        "cell_type": "markdown",
        "source": [
          "`zip()` принимает два iterable аргумента и возвращает iterable из пар соответствующих элементов этих двух iterable:"
        ]
      },
      {
        "metadata": {
          "colab_type": "code",
          "id": "Ywi776zAGw3y",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "first = 'a b c d e f g'.split(' ')\n",
          "second = '1 2 3 4 5 6 7'.split(' ')\n",
          "\n",
          "list(zip(first, second))"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "id": "8eFmeb8rzM8o",
          "colab_type": "text"
        },
        "cell_type": "markdown",
        "source": [
          "Что будет, если один из iterable короче, чем другой:"
        ]
      },
      {
        "metadata": {
          "id": "7L6rqFE1zM8o",
          "colab_type": "code",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "first = 'a b c d e f g'.split(' ')\n",
          "second = '1 2 3 4 5'.split(' ')\n",
          "\n",
          "list(zip(first, second))"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "id": "2pqNxHMYzM8s",
          "colab_type": "text"
        },
        "cell_type": "markdown",
        "source": [
          "Это опять же полезно для использования в циклах:"
        ]
      },
      {
        "metadata": {
          "id": "Pthn6bm4zM8t",
          "colab_type": "code",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "models = ['decision tree', 'linear model', 'svm', 'ensemble']\n",
          "\n",
          "# zip dвозвращает пару элементов, которые можно записать в 2 разные переменные в цикле for. \n",
          "# например, здесб мы записываем первый элемент пары в num, второй -- в model.\n",
          "for num, model in zip(range(len(models)), models):\n",
          "    print(str(num+1)+'\\'s model is:', model)"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "id": "CarxOU_dzM8u",
          "colab_type": "text"
        },
        "cell_type": "markdown",
        "source": [
          "Однако в этом коде мы хотели просто пронумеровать элементы списка models, но нам для этого пришлось писать zip(range(...))\n",
          "\n",
          "Именно для такого случая, когда надо пронумервать элементы какого-то iterable, существует функция `enumerate`:\n",
          "\n",
          "`enumerate(iterable)` возвращает пары номер-элемент iterable:"
        ]
      },
      {
        "metadata": {
          "id": "M4xO9xWpzM8v",
          "colab_type": "code",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "models = ['decision tree', 'linear model', 'svm', 'ensemble']\n",
          "\n",
          "# zip dвозвращает пару элементов, которые можно записать в 2 разные переменные в цикле for. \n",
          "# например, здесб мы записываем первый элемент пары в num, второй -- в model.\n",
          "for num, model in enumerate(models):\n",
          "    print(str(num+1)+'\\'s model is:', model)"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "colab_type": "text",
          "id": "ZPIwoJneGw37"
        },
        "cell_type": "markdown",
        "source": [
          "---\n",
          "\n",
          "### Задание 4\n",
          "\n",
          "1. Создайте список `a`, состоящий из каких-то элементов.\n",
          "2. Создайте список `b` такого же размера, как `a`, состоящий из каких-то элементов.\n",
          "3. Выведите **нумерованный список пар** из элементов списков `a` и `b`."
        ]
      },
      {
        "metadata": {
          "colab_type": "code",
          "id": "rucloO5QGw37",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "# Ваш код здесь"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "colab_type": "text",
          "id": "MJJxXLh2Gw37"
        },
        "cell_type": "markdown",
        "source": [
          "---"
        ]
      },
      {
        "metadata": {
          "colab_type": "text",
          "id": "8f3c96Y3Gw4f"
        },
        "cell_type": "markdown",
        "source": [
          "### set"
        ]
      },
      {
        "metadata": {
          "id": "rtYFS6xgzM8y",
          "colab_type": "text"
        },
        "cell_type": "markdown",
        "source": [
          "**Множество**"
        ]
      },
      {
        "metadata": {
          "id": "TqwLw40MzM8z",
          "colab_type": "text"
        },
        "cell_type": "markdown",
        "source": [
          "Множество -- это массив, в котором элементы не могут повторяться (то есть, как и в математическом определении множества)\n",
          "\n",
          "Внутри языка множество устроено совсем не так, как массив или кортеж, элементы множества хранятся не последовательно, поэтому к элементам множества нельзя обрашаться по индексу.\n",
          "\n",
          "Пустое множество можно создать с помощью set():"
        ]
      },
      {
        "metadata": {
          "colab_type": "code",
          "id": "7FsYEdL-Gw4f",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "s = set()\n",
          "\n",
          "print(s, '|', type(s))"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "id": "HKeW3FtyzM80",
          "colab_type": "text"
        },
        "cell_type": "markdown",
        "source": [
          "А можно привести список к множеству:\n",
          "\n",
          "Обратите внимание, что элементы set'а выводятся в отсортированном порядке!"
        ]
      },
      {
        "metadata": {
          "id": "ILQAHDMVzM81",
          "colab_type": "code",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "s = set([5, 2, 3, 2])\n",
          "s"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "id": "Y2LfOQbdzM82",
          "colab_type": "text"
        },
        "cell_type": "markdown",
        "source": [
          "Можно добавлять элементы в множество с помощью метода `.add()`:"
        ]
      },
      {
        "metadata": {
          "colab_type": "code",
          "id": "nZ7OwvJoGw4m",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "s.add(1)\n",
          "s.add('a')\n",
          "# None тоже можно добавить =)\n",
          "s.add(None)\n",
          "s.add('bullet')\n",
          "print(s)"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "id": "S4ZNpCc_zM83",
          "colab_type": "text"
        },
        "cell_type": "markdown",
        "source": [
          "Метод .difference() позволяет получить элементы, которые есть в одном сете, но нет в другом:"
        ]
      },
      {
        "metadata": {
          "colab_type": "code",
          "id": "xuSORJBVGw4n",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "s1 = set(range(0, 10))\n",
          "s2 = set(range(5, 15))\n",
          "\n",
          "print('s1: ', s1, '\\ns2: ', s2)"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "colab_type": "code",
          "id": "XHt0SFi3Gw4o",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "# элементы, которые есть в s1, но нет в s2\n",
          "print(s1.difference(s2))\n",
          "print()\n",
          "# элементы, которые есть в s2, но нет в s1\n",
          "print(s2.difference(s1))"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "colab_type": "code",
          "id": "tx1o8_2kGw4p",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "# пересечение множеств s1 и s2 можно записать двумя способами:\n",
          "print(s1.intersection(s2))\n",
          "print(s1 & s2)"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "colab_type": "code",
          "id": "SgxbKT7KGw4p",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "# объединение множеств s1 и s2 тоже можно записать двумя способами:\n",
          "print(s1.union(s2))\n",
          "print(s1 | s2)"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "id": "FF2LsBh8zM87",
          "colab_type": "text"
        },
        "cell_type": "markdown",
        "source": [
          "Из сета можно удалить элемент по значению:"
        ]
      },
      {
        "metadata": {
          "id": "dUA5ljbpzM88",
          "colab_type": "code",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "s1.discard(0)\n",
          "s1"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "colab_type": "text",
          "id": "i0xyAzGiGw4s"
        },
        "cell_type": "markdown",
        "source": [
          "### dict"
        ]
      },
      {
        "metadata": {
          "id": "EVTS3oSEzM89",
          "colab_type": "text"
        },
        "cell_type": "markdown",
        "source": [
          "**словарь, ассоциативный массив**"
        ]
      },
      {
        "metadata": {
          "id": "7yd8E4ojzM89",
          "colab_type": "text"
        },
        "cell_type": "markdown",
        "source": [
          "Словарь -- это структура данных, которая представляет отображение из одного типа данных в другой. Представляет собой набор пар ключ-значение, в качестве ключа могут выступать immutable типы данных (int, str, tuple, ...)\n",
          "\n",
          "Массивы, которые мы до этого рассматривали, были отображением непрерывного отрезка [0, n] в другой тип данных. `dict` может быть гораздо удобнее, когда нужно использовать в качестве ключа другой тип данных (например, сопоставить именам людей (str) их даты рождения) или когда в качестве ключа хочется использовать int, но не все значения из промежутка [0, n] нужны. Например, если хочется сопоставить года рождения великих писателей их именам. "
        ]
      },
      {
        "metadata": {
          "id": "h959mSWOzM89",
          "colab_type": "text"
        },
        "cell_type": "markdown",
        "source": [
          "Пустой словарь можно создать либо с помощью `{}`, либо с `dict()`:"
        ]
      },
      {
        "metadata": {
          "colab_type": "code",
          "id": "8mGEtp7BGw4s",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "d = {}\n",
          "dd = dict()\n",
          "\n",
          "print(d == dd, '|', type(d))"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "id": "hqVj1lbjzM8-",
          "colab_type": "text"
        },
        "cell_type": "markdown",
        "source": [
          "Добавим значение value по ключу key в словарь:"
        ]
      },
      {
        "metadata": {
          "colab_type": "code",
          "id": "Tasup1rwGw4w",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "key = 'a'\n",
          "value = 100\n",
          "\n",
          "d[key] = value\n",
          "d"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "id": "f0V06tdwzM8_",
          "colab_type": "text"
        },
        "cell_type": "markdown",
        "source": [
          "Непустой словарь можно создать несколькими способами:"
        ]
      },
      {
        "metadata": {
          "id": "teTfaLXAzM9A",
          "colab_type": "code",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "d = {\n",
          "    'short': 'dict',\n",
          "    'long': 'dictionary'\n",
          "}\n",
          "d"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "colab_type": "code",
          "id": "V4PNtLrtGw4y",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "d = dict(short='dict', long='dictionary')\n",
          "d"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "colab_type": "code",
          "id": "SiejuQPWGw41",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "d = dict([(1, 1), (2, 4)])\n",
          "d"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "id": "jKrmEdzZzM9C",
          "colab_type": "text"
        },
        "cell_type": "markdown",
        "source": [
          "Создать дефолтный словарь с ключами из списка, значениями None:"
        ]
      },
      {
        "metadata": {
          "colab_type": "code",
          "id": "hKzBkSEPGw44",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "d = dict.fromkeys(['a', 'b'])\n",
          "d"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "id": "-ymWrpRHzM9D",
          "colab_type": "text"
        },
        "cell_type": "markdown",
        "source": [
          "Создать дефолтный словарь с ключами из списка, всеми значениями по умолчанию 100:"
        ]
      },
      {
        "metadata": {
          "colab_type": "code",
          "id": "ul5ln-nHGw46",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "d = dict.fromkeys(['a', 'b'], 100)\n",
          "d"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "colab_type": "text",
          "id": "YwySNULzGw4_"
        },
        "cell_type": "markdown",
        "source": [
          "**dict comprehensions**"
        ]
      },
      {
        "metadata": {
          "id": "k-w8FqD4zM9E",
          "colab_type": "text"
        },
        "cell_type": "markdown",
        "source": [
          "Еще один способ объявления словаря: создадим словарь, где каждому целому числу от 0 до 6 поставим в соответствие квадрат этого числа:"
        ]
      },
      {
        "metadata": {
          "colab_type": "code",
          "id": "WYE28ZQcGw4_",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "d = {a: a ** 2 for a in range(7)}\n",
          "d"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "colab_type": "text",
          "id": "79dYvUBLGw5A"
        },
        "cell_type": "markdown",
        "source": [
          "### !"
        ]
      },
      {
        "metadata": {
          "colab_type": "text",
          "id": "BacZFsy-Gw5A"
        },
        "cell_type": "markdown",
        "source": [
          "Будьте осторожны, если ключа, по которому поступил запрос, нет в словаре, то выбросит исключение:"
        ]
      },
      {
        "metadata": {
          "colab_type": "code",
          "id": "m9Z8UVuHGw5A",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "d = {1: 100, 2: 200, 3: 300}\n",
          "d['a']"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "colab_type": "text",
          "id": "ldTDId4IGw5B"
        },
        "cell_type": "markdown",
        "source": [
          "Поэтому безопаснее использовать **get(key)**. Тогда, если нужно, можно проверить на **None**:"
        ]
      },
      {
        "metadata": {
          "colab_type": "code",
          "id": "-sz0nIsXGw5B",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "d.get(1)"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "colab_type": "code",
          "id": "IB7VemHiGw5D",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "d.get('a') == None"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "colab_type": "text",
          "id": "nU8c9PouGw5E"
        },
        "cell_type": "markdown",
        "source": [
          "Самое часто используемое - получение ключей, получение значений и получение всего вместе:"
        ]
      },
      {
        "metadata": {
          "colab_type": "code",
          "id": "_cC8rqn-Gw5E",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "# получить список ключей\n",
          "print(d.keys(), '|', type(d.keys()))\n",
          "\n",
          "# чтобы вывести ключи, нужно привести d.keys() к списку\n",
          "print(list(d.keys()))"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "colab_type": "code",
          "id": "pvh7EPaQGw5E",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "# получить список значений\n",
          "print(d.values(), '|', type(d.values()))\n",
          "\n",
          "# то же самое -- чтобы вывести значения, нужно привести d.values() к списку\n",
          "print(list(d.values()))"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "colab_type": "code",
          "id": "sz6vs1_nGw5F",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "# получить список пар ключ-значение\n",
          "print(d.items(), '|', type(d.items()))\n",
          "\n",
          "# то же самое -- чтобы вывести пары ключ-значения, нужно привести d.items() к списку\n",
          "print(list(d.items()))"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "id": "eLi473W8B131",
          "colab_type": "code",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          ""
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "id": "Ka2gG8QizM9L",
          "colab_type": "text"
        },
        "cell_type": "markdown",
        "source": [
          "---\n",
          "\n",
          "### Задание 5\n",
          "Дан массив строк mas. Одной строкой создайте словарь, в котором по ключу строки будет записана пара (кортеж длины 2) (индекс строки в массиве mas, длина строки)"
        ]
      },
      {
        "metadata": {
          "id": "qQxkKs_KzM9M",
          "colab_type": "code",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "# Ваш код здесь"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "colab_type": "text",
          "id": "-kYdwvhLGw5F"
        },
        "cell_type": "markdown",
        "source": [
          "### modules"
        ]
      },
      {
        "metadata": {
          "colab_type": "text",
          "id": "i8oVrMMOGw5G"
        },
        "cell_type": "markdown",
        "source": [
          "**Модули** - это \"библиотеки\" Python. То есть это самостоятельные, объединённые технически и логически, именованные части Python кода\n",
          "\n",
          "Можно рассматривать их как код, функции, записанные в других файлах (модулях), и чтобы использовать их в своем коде, нужно подключить эти файлы (модули)"
        ]
      },
      {
        "metadata": {
          "colab_type": "text",
          "id": "8VsaBB8CGw5G"
        },
        "cell_type": "markdown",
        "source": [
          "* О модулях необходимо знать только одно - как их импортировать:"
        ]
      },
      {
        "metadata": {
          "colab_type": "code",
          "id": "HyDhkTUYGw5H",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "import collections"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "colab_type": "text",
          "id": "KCOahn9JGw5H"
        },
        "cell_type": "markdown",
        "source": [
          "* Импортировать только какой-то компонент из модуля:"
        ]
      },
      {
        "metadata": {
          "colab_type": "code",
          "id": "GFTwj3EEGw5H",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "# импортируем структуру данных Counter из библиотеки collections\n",
          "from collections import Counter"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "colab_type": "text",
          "id": "VXFVpvqwGw5I"
        },
        "cell_type": "markdown",
        "source": [
          "* Импортировать с другим именем (чаще всего используется для локаничности кода):"
        ]
      },
      {
        "metadata": {
          "colab_type": "code",
          "id": "pDR1RfkAGw5I",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "import collections as cool_lib"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "colab_type": "code",
          "id": "NXIY7m_zGw5J",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "count = cool_lib.Counter()"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "colab_type": "text",
          "id": "YxuJA1qgGw5K"
        },
        "cell_type": "markdown",
        "source": [
          "Жизненный пример:"
        ]
      },
      {
        "metadata": {
          "colab_type": "code",
          "id": "db7fca4LGw5K",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "import numpy as np"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "colab_type": "code",
          "id": "FdY3rE9uzS7_",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          "На этом самый базовый ноутбук закончен. Если здесь что-то было непонятно/не хватило информации по какой-то из освеченных тем, можно перейти по ссылкам в начале ноутбука и изучить больше!"
        ],
        "execution_count": 0,
        "outputs": []
      },
      {
        "metadata": {
          "id": "EpxasdTIEJLs",
          "colab_type": "code",
          "colab": {}
        },
        "cell_type": "code",
        "source": [
          ""
        ],
        "execution_count": 0,
        "outputs": []
      }
    ]
  }