[seminar]python_basics.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "[seminar]python_basics.ipynb",
      "provenance": [],
      "collapsed_sections": [
        "P7kqThRsGw1S",
        "Rq1vFhrLGw5O",
        "6leMOqzKGw5R",
        "eh9SR61aGw5U",
        "n8z_sEhyGw5V",
        "n0KYZdNcGw5b",
        "FRMkmKXIGw5d"
      ],
      "include_colab_link": true
    },
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/MacJei/dlschool/blob/master/%5Bseminar%5Dpython_basics.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1oGBdbb2Gwy9",
        "colab_type": "text"
      },
      "source": [
        "<p style=\"align: center;\"><img align=center src=\"https://s8.hostingkartinok.com/uploads/images/2018/08/308b49fcfbc619d629fe4604bceb67ac.jpg\" style=\"height:90px;\" width=500/></p>\n",
        "\n",
        "<h3 style=\"text-align: center;\"><b>Физтех-Школа Прикладной математики и информатики (ФПМИ) МФТИ</b></h3>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eOivSghfGwy-",
        "colab_type": "text"
      },
      "source": [
        "<h2 style=\"text-align: center;\"><b>Python. Занятие 1: Основы</b></h2>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_kqD6lQ7GwzA",
        "colab_type": "text"
      },
      "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;\" />"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "wBxC0NK1GwzB",
        "colab_type": "text"
      },
      "source": [
        "---"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "iKkG2y23GwzC",
        "colab_type": "text"
      },
      "source": [
        "\n",
        "Перед тем как начать складывать уровни нейросеточек как блинчики или предсказывать кредитоспособность клиентов, нужно быть хорошо знакомым с нужными библиотеками и языком, на котором они написаны. \n",
        "В нашем курсе мы будем использовать язык **Python**, так как он является оптимальным сочетанием простоты, силы и количества полезных библиотек, написанных для него. "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "LYwDm-Y7GwzD",
        "colab_type": "text"
      },
      "source": [
        "На этом занятии мы научимся писать программы на Python, изучив его основы.  "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "qoHHrmtJGwzG",
        "colab_type": "text"
      },
      "source": [
        "## Основы Python"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EpMCDIheGwzH",
        "colab_type": "text"
      },
      "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`."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "JlUbz5X4GwzH",
        "colab_type": "text"
      },
      "source": [
        "<img align=center src=\"http://images7.memedroid.com/images/UPLOADED973/596e4c96650e5.jpeg\" style=\"height:400px;\"/>"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8N0y9NugGwzI",
        "colab_type": "text"
      },
      "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"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hmG1eJIjGwzJ",
        "colab_type": "code",
        "outputId": "1a7d21ee-2804-4f89-b673-d16a4761b271",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 370
        }
      },
      "source": [
        "import this"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "The Zen of Python, by Tim Peters\n",
            "\n",
            "Beautiful is better than ugly.\n",
            "Explicit is better than implicit.\n",
            "Simple is better than complex.\n",
            "Complex is better than complicated.\n",
            "Flat is better than nested.\n",
            "Sparse is better than dense.\n",
            "Readability counts.\n",
            "Special cases aren't special enough to break the rules.\n",
            "Although practicality beats purity.\n",
            "Errors should never pass silently.\n",
            "Unless explicitly silenced.\n",
            "In the face of ambiguity, refuse the temptation to guess.\n",
            "There should be one-- and preferably only one --obvious way to do it.\n",
            "Although that way may not be obvious at first unless you're Dutch.\n",
            "Now is better than never.\n",
            "Although never is often better than *right* now.\n",
            "If the implementation is hard to explain, it's a bad idea.\n",
            "If the implementation is easy to explain, it may be a good idea.\n",
            "Namespaces are one honking great idea -- let's do more of those!\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YfhDEhg_GwzM",
        "colab_type": "text"
      },
      "source": [
        "## Типы"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "PJA-KLzvGwzN",
        "colab_type": "text"
      },
      "source": [
        "**Все типы данных** в Python относятся к одной из **2-х категорий**: **изменяемые (mutable)** и **неизменяемые (unmutable)**.   \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)** или нет."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-tXSqvRRGwzN",
        "colab_type": "text"
      },
      "source": [
        "### int"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "MN-lZNJ4GwzO",
        "colab_type": "code",
        "outputId": "379ee76c-03f9-4ec7-b8fd-91879beea32e",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "x = 5\n",
        "\n",
        "print(x, '|', type(x))"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "5 | <class 'int'>\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4fRsWXp7GwzS",
        "colab_type": "code",
        "outputId": "a23db531-e3f4-4b2c-87d6-0ec916d49d8a",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "a = 4 + 5\n",
        "b = 4 * 5\n",
        "c = 5 // 4\n",
        "\n",
        "print(a, b, c)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "9 20 1\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-7yyX2wcGwzV",
        "colab_type": "code",
        "outputId": "fc36506f-4eb8-476b-e3aa-72b480022e48",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "print( -(5 // 4) )"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "-1\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cKNwlQ9OGwzX",
        "colab_type": "code",
        "outputId": "f3d034ce-d300-4223-cf5d-993219223730",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "print( -5 // 4 )"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "-2\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FnsWAhPMGwza",
        "colab_type": "code",
        "outputId": "911f83d3-3df4-4174-99bf-2efc01988319",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "x = 5 * 1000000000 * 1000000000 * 10**9 + 1\n",
        "print(x, '|', type(x))"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "5000000000000000000000000001 | <class 'int'>\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Hf0cK9ejGwzd",
        "colab_type": "text"
      },
      "source": [
        "### float"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IJcKX6iPGwzd",
        "colab_type": "code",
        "outputId": "1ced2a4d-14e2-4fba-e8f8-14200dc1bb2a",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "y = 12.345\n",
        "\n",
        "print(y, type(y))"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "12.345 <class 'float'>\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qjBbYiC0Gwzg",
        "colab_type": "code",
        "outputId": "9bf8a026-bb54-4ce3-e28c-f50a25c7748d",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "a = 4.2 + 5.1\n",
        "b = 4.2 * 5.1\n",
        "c = 5.0 / 4.0\n",
        "\n",
        "print(a, b, c)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "9.3 21.419999999999998 1.25\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dWjoVU9OGwzj",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "a = 5\n",
        "b = 4\n",
        "print(float(a) / float(b))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ro4_LzARGwzo",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "print(a / b)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YFD8l2XuGwzq",
        "colab_type": "text"
      },
      "source": [
        "### bool"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "f-kwu3wkGwzr",
        "colab_type": "code",
        "outputId": "b8536c6c-5011-452b-aec3-23b78b974d63",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 51
        }
      },
      "source": [
        "a = True\n",
        "b = False\n",
        "\n",
        "print(a, '|', type(a))\n",
        "\n",
        "print(b, '|', type(b))"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "True | <class 'bool'>\n",
            "False | <class 'bool'>\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XOtoJKoOGwzu",
        "colab_type": "code",
        "outputId": "36222ee6-c00d-4a49-ad3d-b25de377797b",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 68
        }
      },
      "source": [
        "print(a + b)\n",
        "print(a + a)\n",
        "print(b + b)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1\n",
            "2\n",
            "0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bxaoc7p_Gwzw",
        "colab_type": "code",
        "outputId": "f129e051-8263-429d-e468-1278ddabc8c2",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "print(int(a), int(b))"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "1 0\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "moSf59BmGwzz",
        "colab_type": "code",
        "outputId": "e97e47ed-32b3-4f07-8ebb-1de7d36bb5c3",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 119
        }
      },
      "source": [
        "print(True and False, '\\n')\n",
        "\n",
        "print(True or True, '\\n')\n",
        "\n",
        "print(not False, '\\n')"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "False \n",
            "\n",
            "True \n",
            "\n",
            "True \n",
            "\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sGGkrmM0Gwz1",
        "colab_type": "text"
      },
      "source": [
        "### None"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BMIBkyzcGwz6",
        "colab_type": "code",
        "outputId": "7a0e60f3-e057-46e6-a457-f8af8d05f880",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "z = None\n",
        "print(z, '|', type(z))"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "None | <class 'NoneType'>\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KaBmiMneGwz8",
        "colab_type": "code",
        "outputId": "bb6a8f7b-ebfa-410c-bd69-26d935534ea3",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 164
        }
      },
      "source": [
        "int(z)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "error",
          "ename": "TypeError",
          "evalue": "ignored",
          "traceback": [
            "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
            "\u001b[0;32m<ipython-input-13-af352a0618bc>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mz\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
            "\u001b[0;31mTypeError\u001b[0m: int() argument must be a string, a bytes-like object or a number, not 'NoneType'"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8k4aCla1Gwz_",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "if z is None:\n",
        "    z = 'I am None!'\n",
        "z"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "r_y-TEM3Gw0A",
        "colab_type": "text"
      },
      "source": [
        "### str"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NYLe3wFlGw0C",
        "colab_type": "text"
      },
      "source": [
        "В *python2.7* есть отдельный тип **unicode**. В *python3.5 (и выше)* (который будем использовать мы) всё это включено в тип **str**."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "W5ZhY9r9Gw0C",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "x = \"abc\"\n",
        "y = 'xyz'\n",
        "print(x, '|', type(x))\n",
        "print(y, '|', type(y))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ZVTh7bPjGw0F",
        "colab_type": "code",
        "outputId": "0fdd9614-f36e-4c0e-a987-f13a5d22ceea",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "a = 'Андрей'\n",
        "b = \"Михайлович\"\n",
        "s = a + \" \" + b\n",
        "print(s)"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Андрей Михайлович\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "r3L343d5Gw0H",
        "colab_type": "code",
        "outputId": "e8b377db-d70a-4c91-f5e7-250f5857ca60",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 50
        }
      },
      "source": [
        "print(a.upper())\n",
        "print(a.lower())"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "АНДРЕЙ\n",
            "андрей\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "YiFvXOaIGw0K",
        "colab_type": "code",
        "outputId": "27d12202-5c80-461e-dc96-71ceaeb80b1f",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "print(len(a))"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "6\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ii16mZGRGw0N",
        "colab_type": "code",
        "outputId": "97822bfc-d615-4bc0-9445-afe36ad8b039",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 50
        }
      },
      "source": [
        "print(bool(a))\n",
        "print(bool(\"\" + ''))"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "True\n",
            "False\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5eSIiAI_Gw0Q",
        "colab_type": "code",
        "outputId": "6df2d888-b94d-4d5f-aad6-cb92cfd27065",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 84
        }
      },
      "source": [
        "print(a)\n",
        "print(a[0])\n",
        "print(a[1])\n",
        "print(a[0:3])"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Андрей\n",
            "А\n",
            "н\n",
            "Анд\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "yxSnm0uPGw0S",
        "colab_type": "code",
        "outputId": "3491b8e1-8b50-454a-ab8b-3c83fbe4f688",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 34
        }
      },
      "source": [
        "print(a[0:4:2])"
      ],
      "execution_count": 0,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Ад\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "kpYdcXQJGw0V",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "x = 'Роберт Дауни Младший'\n",
        "print(x, type(x))\n",
        "y = x.encode('utf-8')\n",
        "print(y, type(y))\n",
        "z = y.decode('utf-8')\n",
        "print(z, type(z))\n",
        "q = y.decode('cp1251')\n",
        "print(q, type(q))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "knjcsCbVGw0Z",
        "colab_type": "text"
      },
      "source": [
        "### Метод `split()`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "TuEP17vFGw0Z",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "splitted_line = \"Райгородский Андрей Михайлович\".split(' ')\n",
        "print(splitted_line)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "2mnxxvHxGw0c",
        "colab_type": "text"
      },
      "source": [
        "### tuple"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pCgzsWT-Gw0d",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "t = ('a', 5, 12.345)\n",
        "t"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "dDtHlkzIGw0f",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "t.append(5)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "M7cLx8voGw0i",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "dir(t)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "g5H4PakiGw0k",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "t.index('a')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "p1Um9EKeGw0m",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "t[2]"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CIWPvGkiGw0p",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "m = (1, 2, 3)\n",
        "\n",
        "t + m"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UbRjhPXgGw0q",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "t - m"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HoKY7OS5Gw0t",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "len(m)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "QrloQ6pcGw0w",
        "colab_type": "text"
      },
      "source": [
        "#### Поменять переменные местами"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BP7tJfrwGw0x",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "a = -5\n",
        "b = 100\n",
        "\n",
        "a, b = b, a\n",
        "\n",
        "print('a:', a, '\\nb:', b)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "woS_SaYrGw00",
        "colab_type": "text"
      },
      "source": [
        "### Немного про встроенные функции"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RgJU9VTkGw00",
        "colab_type": "text"
      },
      "source": [
        "В Python есть так называем **магические** (или служебные) методы - они начинаются и заканчиваются на двойное нижнее подчёркивание: \\__len\\__, \\__add\\__ ..."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "68GdSBNSGw01",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "__builtin__"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "NPt6sw70Gw08",
        "colab_type": "text"
      },
      "source": [
        "Также в Python есть **встроенные** функции и методы, которые являются в некотором смысле универсальными.  \n",
        "Функция `dir()` выводит список всех атрибутов (имён - методы, функции, классы..), которые есть у модуля/класса/объекта:"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "RA8Q3ptXGw09",
        "colab_type": "text"
      },
      "source": [
        "Давайте посмотрим на встроенные и служебные имена Python (не все):"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "v3u4Ga2QGw1A",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "dir(__builtin__)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3w6SCqq2Gw1D",
        "colab_type": "text"
      },
      "source": [
        "---\n",
        "### Задание 1\n",
        "\n",
        "Выведите список атрибутов класса Exception."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JvOx73jRGw1F",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Ваш код здесь"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hcaipS17Gw1I",
        "colab_type": "text"
      },
      "source": [
        "---"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "aLlY0jGkGw1J",
        "colab_type": "text"
      },
      "source": [
        "### Полезно"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dSyo8vW9Gw1K",
        "colab_type": "text"
      },
      "source": [
        "- При вызове метода какого-то класса (или функции какого-то модуля) можно написать его имя и через точку нажать **tab**:  \n",
        "\n",
        "<имя\\_объекта\\_класса(модуля)>**.[tab]**  \n",
        "\n",
        "Тогда всплывёт меню, в котором можно выбрать из всех существующих в этом классе методов (функций модуля)."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "oocSKWGhGw1K",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "__builtin__."
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "sj4LWvuxGw1P",
        "colab_type": "text"
      },
      "source": [
        "- Получение быстрой справки (help()) для любого объекта Python:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wr0ieLrFGw1Q",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "?__builtin__"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "P7kqThRsGw1S",
        "colab_type": "text"
      },
      "source": [
        "### Структуры данных и встроенные функции"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "e6LOqPpYGw1T",
        "colab_type": "text"
      },
      "source": [
        "### list"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pGXNzuLsGw1U",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "a = list()\n",
        "b = []\n",
        "\n",
        "print(a == b)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bj2nfMarGw1Y",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "my_list = ['string', 100, 5.678, None]\n",
        "my_list"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "_0VofYBDGw1Z",
        "colab_type": "text"
      },
      "source": [
        "* `list(range(start, end[, step]))` - получить последовательность (список) целых чисел, начинающуюся со `start`, заканчивающуюся в `end-1` и шагом `step`"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9wj-fsL5Gw1a",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "array = range(1, 10, 2)\n",
        "print(array, '|', type(array))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bYJBlGn3Gw1i",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "array = list(array)\n",
        "print(array, '|', type(array))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nJAGzNrMGw1k",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "array[1]"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lccw9vyNGw1p",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "array[-1]"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Oa7FXqyrGw1r",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "for i in range(5):\n",
        "    print(i)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5kWpqBrgGw1t",
        "colab_type": "text"
      },
      "source": [
        "* Перевернуть список:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "J0BYX4JXGw1v",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "array = array[::-1]\n",
        "array"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4VKPt0CwGw1z",
        "colab_type": "text"
      },
      "source": [
        "* Срезы (`slice`'s) - это объекты языка Python, позволяющие получить какую-то часть итерируемого объекта.  \n",
        "Пример:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HBULSoIXGw1z",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "foo = list(range(10))\n",
        "foo"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "THekTQaHGw11",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "foo[:5]"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "j642PY8CGw15",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "foo[5:]"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zGfCADqAGw17",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "foo[2:5]"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "k_UVyPZOGw1-",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "slice_2_5 = slice(2, 5)\n",
        "print(slice_2_5, '|', type(slice_2_5))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rrUM9yvEGw2A",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "foo[slice_2_5]"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "mMqdf9s1Gw2D",
        "colab_type": "text"
      },
      "source": [
        "* `S.join(iterable)` - возвращает строку, которая является конкатенацией строк из `iterable`. Разделитель между строками - строка `S`"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9FqDIIhfGw2E",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "str_array = ['a', 'b', 'c', 'd', 'e']"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hhPsibd6Gw2G",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "' '.join(str_array)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SIUdX4uTGw2I",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "'!_and_!'.join(str_array)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4-_DSyd8Gw2K",
        "colab_type": "text"
      },
      "source": [
        "* Списки можно \"склеивать\":"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "v6LX530dGw2K",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "a = [1, 2, 3]\n",
        "b = [4, 5, 6]\n",
        "\n",
        "print(a + b)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "n6G2F8ZHGw2O",
        "colab_type": "text"
      },
      "source": [
        "### Методы класса list"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lYIDEl_NGw2O",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "dir(list)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6eSCqxCeGw2Q",
        "colab_type": "text"
      },
      "source": [
        "* `L.append(element)` - добавляет элемент `element` в список `L`"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Jrnu0bDAGw2R",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "l = [4, 5, 1, 3, 2]\n",
        "\n",
        "l.append('BANG!')\n",
        "l"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "rsWorHB2Gw2T",
        "colab_type": "text"
      },
      "source": [
        "* `sorted(iterable, key)` - возвращает объект, являющийся отсортированной в соответствии с компаратором (по ключу) `key` версией объекта `iterable`. **НЕ изменяет начальный объект!**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tTPZWRmGGw2U",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "print(sorted(l), '|', l)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ccp7jFb2Gw2Y",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "l.pop()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rwsG5uIsGw2c",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "print(sorted(l), '|', l)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "e6DfAfEcGw2j",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def cmp(string):\n",
        "    return len(string)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rcN9rXiiGw2l",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "names = ['Александр', 'Василий', 'Анастасия', 'Соня', 'Френк', 'Оля']\n",
        "sorted(names, key=cmp)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pllKkf23Gw2p",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "names = ['Александр', 'Василий', 'Анастасия', 'Соня', 'Френк', 'Оля']\n",
        "sorted(names, key=lambda x: len(x))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8n55sk6nGw2u",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "names"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Ci84651GGw2w",
        "colab_type": "text"
      },
      "source": [
        "* `L.sort(key)` - сортирует лист L в соответствии с компаратором (по ключу) key. **Изменяет начальный объект!**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qBtxCB2pGw2x",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "l = [1, 2, 3, 4, 5]\n",
        "\n",
        "l.append('BANG!')\n",
        "l\n",
        "\n",
        "l.sort()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "I7Zuo1hgGw2z",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "l.pop()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "b0voXsJQGw23",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "l"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_skPHJ2IGw25",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "l.sort(reverse=True)\n",
        "l"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "3XbUrbRTGw27",
        "colab_type": "text"
      },
      "source": [
        "* `L.count(element)` - возвращает количество вхождений элемента `element` в список `L`"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6HKrl1hRGw29",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "l.count(1)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zk_xk_sMGw3A",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "l.count('padabum')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "konkZu60Gw3D",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "len(l)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "z-1Xw-VsGw3H",
        "colab_type": "text"
      },
      "source": [
        "`L.index(element)` - возвращает индекс элемента `element` в списке `L`, если он там присутствует, `None` иначе"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3wzJgl6AGw3I",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "l.index(3)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "USIIpRQeGw3N",
        "colab_type": "text"
      },
      "source": [
        "---"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HA7rCsAcGw3O",
        "colab_type": "text"
      },
      "source": [
        "### Задание 2\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5F8N8lYHGw3P",
        "colab_type": "text"
      },
      "source": [
        "1. Даны два списка одинаковых размеров из одинаковых элементов:  \n",
        "`items = [1 5 6 9 8 7 2 3 4]`  \n",
        "`shuffled_items = [2 3 4 1 6 5 7 9 8]`  \n",
        "\n",
        "2. Расставьте элементы (с помощью функции `sort()`) в списоке `items` так, чтобы получился список `shuffled_items`  "
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "cnSSg6bjGw3P",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Ваш код здесь"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MXFzodUsGw3s",
        "colab_type": "text"
      },
      "source": [
        "---"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "04VwiGfkGw3t",
        "colab_type": "text"
      },
      "source": [
        "### Циклы - for и while"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RGyfjAhGGw3u",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "models = ['decision tree', 'linear model', 'svm', 'ensemble']\n",
        "\n",
        "for model in models:\n",
        "    print(model)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qwWXAn2zGw3v",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "x = 100\n",
        "\n",
        "while x > 50:\n",
        "    x -= 10\n",
        "    print(x)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "70QerwaDGw3y",
        "colab_type": "text"
      },
      "source": [
        "### enumerate, zip"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ywi776zAGw3y",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "first = 'a b c d e f g'.split(' ')\n",
        "second = '1 2 3 4 5 6 7'.split(' ')\n",
        "\n",
        "zip(first, second)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "grtoIeZnGw31",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "list(zip(first, second))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pU1pECP1Gw33",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "methods = dir(__builtin__)\n",
        "\n",
        "for num, method in enumerate(methods):\n",
        "    if num % 5 == 0:\n",
        "        print(num, method)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ye3s-FKvGw34",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "enum = enumerate(first)\n",
        "list(enum)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "9W4TJ9iOGw35",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "enum = enumerate(first)\n",
        "zip_style = zip(range(0, len(first)), first)\n",
        "\n",
        "print(list(enum) == list(zip_style))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ZPIwoJneGw37",
        "colab_type": "text"
      },
      "source": [
        "---\n",
        "\n",
        "### Задание 3\n",
        "\n",
        "1. Создайте список `a`, состоящий из каких-то элементов.\n",
        "2. Создайте список `b` такого же размера, как `a`, состоящий из каких-то элементов.\n",
        "3. Выведите нумерованный список пар из элементов списков `a` и `b`."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rucloO5QGw37",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Ваш код здесь"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "MJJxXLh2Gw37",
        "colab_type": "text"
      },
      "source": [
        "---"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "fXwUimADGw38",
        "colab_type": "text"
      },
      "source": [
        "### list comprehensions"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CD07ruuWGw38",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "a = [x for x in range(1, 6)]\n",
        "a"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "BUtpf0EGGw3-",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def f(x):\n",
        "    return x ** 2"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LLz_Z3yTGw4B",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "b = [f(x) for x in range(1, 10)]\n",
        "c = [x ** 2 for x in range(1, 10)]\n",
        "print(b, '==', c)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Y-PG0lZyGw4C",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "[x if x in 'aeiou' else '*' for x in 'apple']"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pxaLFok8Gw4E",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def foo(i):\n",
        "    return i, i + 1\n",
        "\n",
        "l = []\n",
        "for i in range(3):\n",
        "    for x in foo(i):\n",
        "        l.append(str(x))\n",
        "        \n",
        "l"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4VIKA8NHGw4G",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "l = [str(x) for i in range(3) for x in foo(i)]\n",
        "l"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "u6xV9d3WGw4I",
        "colab_type": "text"
      },
      "source": [
        "---"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "obbVEyk5Gw4I",
        "colab_type": "text"
      },
      "source": [
        "### Задание 4"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Px2HOqD9Gw4J",
        "colab_type": "text"
      },
      "source": [
        "*Выведите* список из 100 чисел *через запятую*. **Чистыми циклами пользоваться нельзя.** (list comprehensions можно)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "fN5BeHS3Gw4J",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Ваш код здесь"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "F9iEYYVWGw4K",
        "colab_type": "text"
      },
      "source": [
        "---"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "354ivCzAGw4L",
        "colab_type": "text"
      },
      "source": [
        "### functions, lambdas"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gOPbxDezjW5B",
        "colab_type": "text"
      },
      "source": [
        "* function:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "wppdwV3AGw4L",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "def make_coffee(size, sugar_dose=3, **kwargs):\n",
        "    if sugar_dose > 5:\n",
        "        return 'Too much sugar! Be careful! :('\n",
        "    else:\n",
        "        return 'Done: cup of {0} ml size; amount of sugar = {1}'.format(size, sugar_dose)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "inDy5yYCGw4M",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "make_coffee(100)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bFMvn-vrGw4O",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "make_coffee(200, 1)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zoc4wDmAGw4R",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "make_coffee(100, 6)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "1esIuPDaGw4S",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "make_coffee(120, 5, name='Ilya', gender='male')  # kwargs"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "kGIyyMeCjW5E",
        "colab_type": "text"
      },
      "source": [
        "* lambda:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "6RBIMsgNGw4U",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "negation = lambda x: -x\n",
        "a = 5\n",
        "print(negation(a))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HK1TYlFQGw4V",
        "colab_type": "text"
      },
      "source": [
        "### map, reduce, filter"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "w8Vi6DG3Gw4W",
        "colab_type": "text"
      },
      "source": [
        "* `map(func, iterables)` - выполняет преобразование func над элементами iterables и возвращает **новый** `iterable`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FXvofaljGw4W",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "words = dir(list)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ngRHxS_1Gw4X",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "letter_counts = list(map(lambda x: len(x), words))\n",
        "\n",
        "print(letter_counts)\n",
        "print()\n",
        "print(words)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OgT1pUomGw4X",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "l1 = [1,2,3,4]\n",
        "l2 = [11, 12, 13, 14, 15]\n",
        "l3 = [101, 102, 103]\n",
        "\n",
        "triple_sum = list(map(lambda x, y, z: x + y + z, l1, l2, l3))\n",
        "print(triple_sum)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "l3yvma4DGw4Y",
        "colab_type": "text"
      },
      "source": [
        "* `reduce(func, iterables)` - производит вычисление с элементами последовательности, результатом которого является **одно значение**:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Ti1K4bsGGw4Y",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "from functools import reduce"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "DlX_nviwGw4a",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "sum_of_counts = reduce(lambda x, y: x + y, letter_counts)\n",
        "print(sum_of_counts)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8nIyNHN1Gw4b",
        "colab_type": "text"
      },
      "source": [
        "* `filter(predicate, iterable)` - оставляет только те элементы, для которых **верен** предикат (функция, возвращающая bool):"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "LfIPgcNgGw4b",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "mixed = ['мак', 'просо', 'мак', 'мак', 'просо', 'мак', 'просо', 'просо', 'просо', 'мак']\n",
        "only_mac = list(filter(lambda x: x == 'мак', mixed))\n",
        "print(only_mac)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "g3cWsZwOGw4e",
        "colab_type": "text"
      },
      "source": [
        "---"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "uugRKJebGw4e",
        "colab_type": "text"
      },
      "source": [
        "### Задание 5\n",
        "\n",
        "1. Дан массив строк: `['agfkd.,f', 'Qksdf;sb&..', 'asdoo*', 'bgf...d', 're54()kj[]].'] `\n",
        "2. Создайте список, состоящий из количества точек в каждой строке. Выведите его\n",
        "3. Создайте новый список, в котором будут **только строки, в которых более 2-х точек**. Выведите его  \n",
        "\n",
        "Циклами пользоваться нельзя."
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "3noLimKfGw4e",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Ваш код здесь"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "oqHHZkqkGw4f",
        "colab_type": "text"
      },
      "source": [
        "---"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8f3c96Y3Gw4f",
        "colab_type": "text"
      },
      "source": [
        "### set"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7FsYEdL-Gw4f",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "s = set()\n",
        "s"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "P4VHzWWcGw4j",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "dir(s)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "nZ7OwvJoGw4m",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "s.add(1)\n",
        "s.add('a')\n",
        "s.add(None)\n",
        "s.add('bullet')\n",
        "print(s)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "xuSORJBVGw4n",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "s1 = set(range(0, 10))\n",
        "s2 = set(range(5, 15))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "XHt0SFi3Gw4o",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "print(s1.difference(s2))\n",
        "print()\n",
        "print(s2.difference(s1))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "tx1o8_2kGw4p",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "s1.intersection(s2)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SgxbKT7KGw4p",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "s1.union(s2)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "CtzRiAgAGw4q",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "print('s1: ', s1, '\\ns2: ', s2)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "i0xyAzGiGw4s",
        "colab_type": "text"
      },
      "source": [
        "### dict"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8mGEtp7BGw4s",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "d = {}\n",
        "dd = dict()\n",
        "\n",
        "print(d == dd, '|', type(d))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "b-dGPNI6Gw4t",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "dir(dict)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Tasup1rwGw4w",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "d['a'] = 100\n",
        "d"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "V4PNtLrtGw4y",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "d = dict(short='dict', long='dictionary')\n",
        "d"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "SiejuQPWGw41",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "d = dict([(1, 1), (2, 4)])\n",
        "d"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hKzBkSEPGw44",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "d = dict.fromkeys(['a', 'b'])\n",
        "d"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ul5ln-nHGw46",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "d = dict.fromkeys(['a', 'b'], 100)\n",
        "d"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YwySNULzGw4_",
        "colab_type": "text"
      },
      "source": [
        "**dict comprehensions**"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "WYE28ZQcGw4_",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "d = {a: a ** 2 for a in range(7)}\n",
        "d"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "79dYvUBLGw5A",
        "colab_type": "text"
      },
      "source": [
        "### !"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "BacZFsy-Gw5A",
        "colab_type": "text"
      },
      "source": [
        "Будьте осторожны, если ключа, по которому поступил запрос, нет в словаре, то выбросит исключение:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "m9Z8UVuHGw5A",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "d = {1: 100, 2: 200, 3: 300}\n",
        "d['a']"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "ldTDId4IGw5B",
        "colab_type": "text"
      },
      "source": [
        "Поэтому безопаснее использовать **get(key)**. Тогда, если нужно, можно проверить на **None**:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-sz0nIsXGw5B",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "d.get(1)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "IB7VemHiGw5D",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "d.get('a') == None"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "nU8c9PouGw5E",
        "colab_type": "text"
      },
      "source": [
        "Самое часто используемое - получение ключей, получение значений и получение всего вместе:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "_cC8rqn-Gw5E",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "print(d.keys(), '|', type(d.keys()))\n",
        "\n",
        "\n",
        "print(list(d.keys()))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pvh7EPaQGw5E",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "print(d.values(), '|', type(d.values()))\n",
        "\n",
        "\n",
        "print(list(d.values()))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "sz6vs1_nGw5F",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "print(d.items(), '|', type(d.items()))\n",
        "\n",
        "\n",
        "print(list(d.items()))"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "-kYdwvhLGw5F",
        "colab_type": "text"
      },
      "source": [
        "### modules"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "i8oVrMMOGw5G",
        "colab_type": "text"
      },
      "source": [
        "**Модули** - это \"библиотеки\" Python. То есть это самостоятельные, объединённые технически и логически, именованные части Python кода"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8VsaBB8CGw5G",
        "colab_type": "text"
      },
      "source": [
        "* О модулях необходимо знать только одно - как их импортировать:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "HyDhkTUYGw5H",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import collections"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "KCOahn9JGw5H",
        "colab_type": "text"
      },
      "source": [
        "* Импортировать только какой-то компонент из модуля:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "GFTwj3EEGw5H",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "from collections import Counter"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "VXFVpvqwGw5I",
        "colab_type": "text"
      },
      "source": [
        "* Импортировать с другим именем (чаще всего используется для локаничности кода):"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "pDR1RfkAGw5I",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import collections as cool_lib"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NXIY7m_zGw5J",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "count = cool_lib.Counter()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YxuJA1qgGw5K",
        "colab_type": "text"
      },
      "source": [
        "Жизненный пример:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "db7fca4LGw5K",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import numpy as np"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1q8IsL0_Gw5L",
        "colab_type": "text"
      },
      "source": [
        "### files"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "8ps9pgh_Gw5L",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "path = './20_newsgroups/sci.space/62478'"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ivXBlu9EGw5M",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "file = open(path, mode='r')\n",
        "print([line for line in file][0])\n",
        "file.close()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FR3dNC56Gw5N",
        "colab_type": "text"
      },
      "source": [
        "| Режим | Обозначение |\n",
        "|-------|-------------|\n",
        "| **'r'**  | Открытие на **чтение** (является значением по умолчанию) |\n",
        "| **'rb'** | Открытие на **чтение**, в предположении, что будут считываться **байты** |\n",
        "| **'w'** | Открытие на **запись**, содержимое файла удаляется. Если файла не существует, создается новый |\n",
        "| **'wb**' | Открытие на **запись байтов**, содержимое файла удаляется. Если файла не существует, создается новый |\n",
        "| **'a'** | Открытие на **дозапись**, информация добавляется **в конец файла** |\n",
        "| **'r+'** | Открыть файл на **чтение И запись**. Если файла нет, **новый НЕ создаётся** |\n",
        "| **'a+'** | Открыть файл на **чтение И запись в конец файла**. Если файла нет, **новый создаётся** |\n",
        "| **'t'** | Открытие файла **как текстового** (по умолчанию) |"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "NYRCktzbGw5N",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "with open(path, mode='r') as test_file:\n",
        "    for line in test_file:\n",
        "        print(line)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Rq1vFhrLGw5O",
        "colab_type": "text"
      },
      "source": [
        "### classes"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iqyjT3nEGw5P",
        "colab_type": "code",
        "collapsed": true,
        "colab": {}
      },
      "source": [
        "class Human:\n",
        "    def __init__(self, name='', age=None, deep_learning_specialist=False):\n",
        "        self.name = name\n",
        "        self.age = age\n",
        "        self.deep_learning_specialist = deep_learning_specialist\n",
        "    \n",
        "    def set_age(self, age):\n",
        "        self.age = age\n",
        "    \n",
        "    def get_age(self):\n",
        "        return self.age\n",
        "    \n",
        "    def __str__(self):\n",
        "        return 'Name: {}\\nAge: {} \\\n",
        "                \\nIs deep learning specialist: {}'.format(self.name, self.age, \n",
        "                                                          self.deep_learning_specialist)\n",
        "\n",
        "class DLSchoolStudent(Human):\n",
        "    def __init__(self, name='', age=None, deep_learning_specialist=False):\n",
        "        super().__init__(name, age, deep_learning_specialist)\n",
        "        self.total_grade = None\n",
        "        self.deep_learning_specialist = True\n",
        "    \n",
        "    def __str__(self):\n",
        "        return super().__str__()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7rcUa2c6Gw5Q",
        "colab_type": "code",
        "collapsed": true,
        "colab": {}
      },
      "source": [
        "human = Human('Person', 17)\n",
        "print(human)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ClXD89RBGw5R",
        "colab_type": "code",
        "collapsed": true,
        "colab": {}
      },
      "source": [
        "student = DLSchoolStudent('Good Person', 18)\n",
        "print(student)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "6leMOqzKGw5R",
        "colab_type": "text"
      },
      "source": [
        "### exceptions"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "lqdK9vpIGw5R",
        "colab_type": "code",
        "collapsed": true,
        "colab": {}
      },
      "source": [
        "dir(__builtin__)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "4fvhuqHWGw5S",
        "colab_type": "code",
        "collapsed": true,
        "colab": {}
      },
      "source": [
        "raise KeyboardInterrupt()"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "e-ixo9KZGw5T",
        "colab_type": "code",
        "collapsed": true,
        "colab": {}
      },
      "source": [
        "my_dict = {1: 100, 2: 200}\n",
        "print(my_dict['NEW'])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "AHvxS46MGw5U",
        "colab_type": "code",
        "collapsed": true,
        "colab": {}
      },
      "source": [
        "try:\n",
        "    my_dict = {1: 100, 2: 200}\n",
        "    print(my_dict['NEW'])\n",
        "except KeyError:\n",
        "    print('Caught KeyError!')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "eh9SR61aGw5U",
        "colab_type": "text"
      },
      "source": [
        "### Полезные библиотеки Python"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "n8z_sEhyGw5V",
        "colab_type": "text"
      },
      "source": [
        "### glob"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "5KYnQ6ARGw5V",
        "colab_type": "code",
        "collapsed": true,
        "colab": {}
      },
      "source": [
        "import glob"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rtqbatDNGw5W",
        "colab_type": "code",
        "collapsed": true,
        "colab": {}
      },
      "source": [
        "!dir"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-DWVWSFDGw5W",
        "colab_type": "code",
        "collapsed": true,
        "colab": {}
      },
      "source": [
        "glob.glob('./[0-9].*')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ymlN5XWwGw5X",
        "colab_type": "code",
        "collapsed": true,
        "colab": {}
      },
      "source": [
        "glob.glob('*.png')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "B9aZ6xpVGw5Y",
        "colab_type": "code",
        "collapsed": true,
        "colab": {}
      },
      "source": [
        "glob.glob('?.jpg')"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VnI6S7BSGw5Z",
        "colab_type": "code",
        "collapsed": true,
        "colab": {}
      },
      "source": [
        "glob.glob('./**/', recursive=True)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "7cowug2JGw5a",
        "colab_type": "code",
        "collapsed": true,
        "colab": {}
      },
      "source": [
        "glob.glob('**/*.txt', recursive=True)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "n0KYZdNcGw5b",
        "colab_type": "text"
      },
      "source": [
        "### tqdm"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "YM9NS9PeGw5c",
        "colab_type": "text"
      },
      "source": [
        "* Устанавливаем виджеты:\n",
        "\n",
        "`pip install ipywidgets`  \n",
        "\n",
        "(или `conda install -c conda-forge ipywidgets`)\n",
        "\n",
        "* Разрешаем их использование в Jupyter Notebook:  \n",
        "\n",
        "`jupyter nbextension enable --py --sys-prefix widgetsnbextension`  \n",
        "\n",
        "* Перезагружаем ядро (Restart Kernel)  \n",
        "\n",
        "\n",
        "* Устанавливаем tqdm:  \n",
        "\n",
        "`pip install tqdm`  \n",
        "\n",
        "(или `conda install -c conda-forge tqdm`)  \n",
        "\n",
        "Больше про tqdm: https://pypi.python.org/pypi/tqdm"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Gjf3-0CDGw5c",
        "colab_type": "code",
        "collapsed": true,
        "colab": {}
      },
      "source": [
        "from tqdm import tqdm\n",
        "from tqdm import tnrange, tqdm_notebook\n",
        "from time import sleep"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "a3b80N6rGw5c",
        "colab_type": "code",
        "collapsed": true,
        "colab": {}
      },
      "source": [
        "cnt = 0\n",
        "for i in tqdm(range(1000)):\n",
        "    sleep(0.01)\n",
        "    cnt += 1"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "bHFdvioAGw5d",
        "colab_type": "code",
        "collapsed": true,
        "colab": {}
      },
      "source": [
        "for i in tnrange(10, desc='1st loop'):\n",
        "    for j in tqdm_notebook(range(100), desc='2nd loop', leave=False):\n",
        "        sleep(0.01)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "FRMkmKXIGw5d",
        "colab_type": "text"
      },
      "source": [
        "### collections"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "gLqohQ5rGw5f",
        "colab_type": "text"
      },
      "source": [
        "* `defaultdict()` - класс словаря, у которого есть значение по умолчанию - порой очень пригождается:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "G39co0rLGw5h",
        "colab_type": "code",
        "collapsed": true,
        "colab": {}
      },
      "source": [
        "from collections import defaultdict"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "Z-QskRLbGw5i",
        "colab_type": "code",
        "collapsed": true,
        "colab": {}
      },
      "source": [
        "d = defaultdict(int)\n",
        "\n",
        "print(d['key'])\n",
        "\n",
        "d['key'] = 5\n",
        "print(d['key'])  # 5"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "esQdFR58Gw5j",
        "colab_type": "code",
        "collapsed": true,
        "colab": {}
      },
      "source": [
        "d = defaultdict(lambda: 'empty')\n",
        "print(d['key'])\n",
        "\n",
        "d['key'] = 'full'\n",
        "print(d['key'])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "RWMWkplPGw5m",
        "colab_type": "code",
        "collapsed": true,
        "colab": {}
      },
      "source": [
        "d = defaultdict(list)\n",
        "print(d)\n",
        "\n",
        "d['list1'].append(100)\n",
        "d['list1'].append(200)\n",
        "print(d)\n",
        "print(d['list1'])"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "w4XJ967YGw5n",
        "colab_type": "text"
      },
      "source": [
        "* `Counter()` - класс словаря, предназначенного для счётчиков. По сути, `== defaultdict(int)`:"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "qQ-NZSr8Gw5o",
        "colab_type": "code",
        "collapsed": true,
        "colab": {}
      },
      "source": [
        "from collections import Counter"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "e1DjIXd1Gw5p",
        "colab_type": "code",
        "collapsed": true,
        "colab": {}
      },
      "source": [
        "counter = Counter()\n",
        "\n",
        "for word in dir(__builtin__):\n",
        "    for letter in word:\n",
        "        counter[letter] += 1  # или .update(value)\n",
        "    \n",
        "print(counter)"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "AdU2IypUGw5q",
        "colab_type": "text"
      },
      "source": [
        "---"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "EhuZgDRMGw5q",
        "colab_type": "text"
      },
      "source": [
        "### Задание 6\n",
        "\n",
        "1. Создайте словарь счётчиков\n",
        "2. Создайте переменную, в которую сохраните все пути к нужным текстовым файлам *(расположены по адресу `'./20_newsgroups/sci.space/'`, папка лежит в гугл-доке)*\n",
        "3. Для каждого текста (текстового файла) посчитайте сколько каждое слово (из этого текста) встретилось в этом тексте (используйте предыдущие пункты)"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "R6HLSewSGw5r",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Ваш код здесь"
      ],
      "execution_count": 0,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "HN5aManjGw5r",
        "colab_type": "text"
      },
      "source": [
        "---"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "UjW3DsbRGw5s",
        "colab_type": "text"
      },
      "source": [
        "То, что Вы реализовали выше, есть ни что иное, как простая реализация **bag-of-words (мешок слов)** для корпуса из 9 документов."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "8gk03Q3jjW6M",
        "colab_type": "text"
      },
      "source": [
        "Мы познакомились языком Python. Дальше нас ждёт знакомство с библиотеками **NumPy, SciPy** и **Matplotlib**, часто используемыми в анализе данных.  "
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "dZWe7o1yGw5s",
        "colab_type": "text"
      },
      "source": [
        "## Список материалов для самостоятельного изучения"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "scLkWzB7Gw5s",
        "colab_type": "text"
      },
      "source": [
        "* *Сайт языка Python* - https://www.python.org/"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5sid19J1Gw5s",
        "colab_type": "text"
      },
      "source": [
        "* *Курс Python с нуля, можно выполнять задания в интерактивном режиме* - http://pythontutor.ru/"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "d3VWwzy-Gw5t",
        "colab_type": "text"
      },
      "source": [
        "* *Новый онлайн-курс по Питону на Coursera от Mail.Ru Group* - https://www.coursera.org/learn/programming-in-python"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "hUkTs8N5Gw5t",
        "colab_type": "text"
      },
      "source": [
        "* *Самоучитель Python* - https://pythonworld.ru/samouchitel-python"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "THosV0wvGw5t",
        "colab_type": "text"
      },
      "source": [
        "* *Статья про коварности Python* - https://habrahabr.ru/company/mailru/blog/337364/"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "clIKUWycGw5t",
        "colab_type": "text"
      },
      "source": [
        "* *Очень полезные трюки в Jupyter Notebook*: https://www.dataquest.io/blog/jupyter-notebook-tips-tricks-shortcuts/"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "1nkIBTyojW6O",
        "colab_type": "text"
      },
      "source": [
        "## Домашнее задание №1"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "IcU_qRc5jW6O",
        "colab_type": "text"
      },
      "source": [
        "- Всем прорешать этот ноутбук (сделать все  6 заданий)\n",
        "- Для тех, кто только начал знакомиться с Python: 2 ссылка выше - сделать как можно больше заданий \n",
        "- Для тех, кто \"я уже всё знаю (наверное)\": 5 и 6 ссылки выше (познакомиться с jupyter notebook, если не владеете)  \n",
        "- Для тех, кто \"я уже точно всё знаю про Python\": пора идти работать Python-разработчиком"
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "FdY3rE9uzS7_",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": 0,
      "outputs": []
    }
  ]
}