{
  "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": []
    }
  ]
}