diff --git a/.codespellignore b/.codespellignore deleted file mode 100644 index 8b137891..00000000 --- a/.codespellignore +++ /dev/null @@ -1 +0,0 @@ - diff --git a/.flake8 b/.flake8 new file mode 100644 index 00000000..905c8bbe --- /dev/null +++ b/.flake8 @@ -0,0 +1,2 @@ +[flake8] +max-line-length = 160 \ No newline at end of file diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml index 6341a1aa..2e9ce276 100644 --- a/.pre-commit-config.yaml +++ b/.pre-commit-config.yaml @@ -97,7 +97,7 @@ repos: hooks: - id: nbqa-flake8 args: - - --ignore=E501,E712,W291,F632,E203,F821,F403,W391,F401 + - --ignore=E501,E712,W291,F632,E203,F821,F403,W391,F401,VNE001,VNE002,VNE003,N816,FNE008,E731,E741,F811 - --exclude=.*,__init__.py name: nbqa-flake8 description: Run 'flake8' on a Jupyter Notebook @@ -115,7 +115,7 @@ repos: hooks: - id: flake8 args: - - --ignore=E501,E712,W291,F632,E203,F821,F403,W391,F401 + - --ignore=E501,E712,W291,F632,E203,F821,F403,W391,F401,VNE001,VNE002,VNE003,N816,FNE008,F811 - --exclude=.*,__init__.py additional_dependencies: - flake8-variables-names @@ -220,7 +220,7 @@ repos: - --ignore=no_check*,__init__.py - --max-line-length=120 - --const-naming-style=any - - --disable=E0401,W0104,R0903,R1721,E1101,E0611,F0002,C0305,C0303,E2515 + - --disable=E0401,W0104,R0903,R1721,E1101,E0611,F0002,C0305,C0303,E2515,C3001,C0121,E0602,C0209 - repo: https://github.com/pylint-dev/pylint @@ -251,6 +251,8 @@ repos: require_serial: true types_or: [jupyter, markdown] additional_dependencies: [pydocstyle] + args: + - --ignore=D100,D101,D102,D103,D105,D107,D400,D401,D415,D205,D209,D213 # - repo: https://github.com/christophmeissner/pytest-pre-commit # rev: 1.0.0 # hooks: diff --git a/.pydocstyle b/.pydocstyle new file mode 100644 index 00000000..7e55644c --- /dev/null +++ b/.pydocstyle @@ -0,0 +1,2 @@ +[pydocstyle] +ignore = D100,D205,D209,D213 diff --git a/.pylintrc b/.pylintrc new file mode 100644 index 00000000..42306656 --- /dev/null +++ b/.pylintrc @@ -0,0 +1,36 @@ +[MASTER] +ignore-patterns=^\..*,__init__\.py + +[MESSAGES CONTROL] +disable= + C0103, + C0114, + C0115, + C0116, + C0117, + C0200, + C0208, + C0121, + C0325, + C3002, + E0102, + E0601, + E0602, + E1121, + E1137, + R0124, + R0133, + R1703, + R1705, + R1716, + R1719, + R1724, + R0801, + R1732, + R1734, + W0106, + W0130, + W0601, + W0621, + W0622, + W1514 diff --git a/06_Functions.makarov.ipynb b/06_Functions.makarov.ipynb new file mode 100644 index 00000000..30acef59 --- /dev/null +++ b/06_Functions.makarov.ipynb @@ -0,0 +1,2096 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "0AoPSXyUTTLc" + }, + "source": [ + "## Функции в Питоне" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "W3QeADnwrI_g" + }, + "source": [ + "### Встроенные функции" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "mmuSaN9wrMpL" + }, + "outputs": [ + { + "ename": "ModuleNotFoundError", + "evalue": "No module named 'matplotlib'", + "output_type": "error", + "traceback": [ + "\u001b[31m---------------------------------------------------------------------------\u001b[39m", + "\u001b[31mModuleNotFoundError\u001b[39m Traceback (most recent call last)", + "\u001b[36mCell\u001b[39m\u001b[36m \u001b[39m\u001b[32mIn[1]\u001b[39m\u001b[32m, line 2\u001b[39m\n\u001b[32m 1\u001b[39m \u001b[38;5;66;03m# импортируем библиотеки\u001b[39;00m\n\u001b[32m----> \u001b[39m\u001b[32m2\u001b[39m \u001b[38;5;28;01mimport\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mmatplotlib\u001b[39;00m\u001b[34;01m.\u001b[39;00m\u001b[34;01mpyplot\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mas\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mplt\u001b[39;00m\n\u001b[32m 3\u001b[39m \u001b[38;5;28;01mimport\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mnumpy\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mas\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[34;01mnp\u001b[39;00m\n\u001b[32m 5\u001b[39m \u001b[38;5;66;03m# установим точку отсчета\u001b[39;00m\n", + "\u001b[31mModuleNotFoundError\u001b[39m: No module named 'matplotlib'" + ] + } + ], + "source": [ + "# импортируем библиотеки\n", + "import matplotlib.pyplot as plt\n", + "\n", + "# перед вызовом функции нужно не забыть импортировать соответствующую библиотеку\n", + "import numpy as np\n", + "\n", + "# установим точку отсчета\n", + "np.random.seed(42)\n", + "# и снова сгенерируем данные о росте (как мы делали на восьмом занятии вводного курса)\n", + "height = list(np.round(np.random.normal(180, 10, 1000)))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "4R42tP5dJflr" + }, + "source": [ + "#### Параметры и аргументы функции" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 430 + }, + "id": "GZzCE-GXsD8H", + "outputId": "0a6e6454-e150-48b1-bc92-e54be971a738" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# теперь построим гистограмму передав ей два параметра, данные о росте и количество интервалов\n", + "# первый параметр у нас позиционный, второй - именованный\n", + "plt.hist(height, bins=10)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 430 + }, + "id": "If9utZiWZYeq", + "outputId": "47fde034-9efb-4986-ce67-ae2bf202e257" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# первый параметр можно также сделать именованным (данные обозначаются через x)\n", + "# и тогда порядок параметров можно менять\n", + "plt.hist(bins=10, x=height)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 430 + }, + "id": "5rM2p7inZ4gh", + "outputId": "da7b573e-eaea-437a-8400-6d9cf7c44da5" + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# у параметра bins есть аргумент по умолчанию (как раз 10 интервалов),\n", + "# а значит, этот параметр можно не указывать\n", + "plt.hist(height)\n", + "plt.show()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "t6UAoUmwag2c", + "outputId": "ef4a2fe2-25e4-4cb4-de2d-e55464101797" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Первая строка\n", + "\n", + "Третья строка\n" + ] + } + ], + "source": [ + "# функция может не принимать параметров\n", + "print(\"Первая строка\")\n", + "print()\n", + "print(\"Третья строка\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "-QM-A2zzJhIn" + }, + "source": [ + "#### Функции и методы" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 35 + }, + "id": "o_fZPD7XJjFy", + "outputId": "80d76b59-0838-44a2-a700-873b19e9e02f" + }, + "outputs": [ + { + "data": { + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "string" + }, + "text/plain": [ + "'Machine Learning'" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# дана строка\n", + "some_string = \"machine learning\"\n", + "\n", + "# применим метод .title()\n", + "some_string.title()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 176 + }, + "id": "uVPQU3PoKwpR", + "outputId": "72d66e92-3184-4c44-a758-651f7f13b9a7" + }, + "outputs": [ + { + "ename": "AttributeError", + "evalue": "'list' object has no attribute 'title'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mAttributeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 3\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 4\u001b[0m \u001b[0;31m# этот метод не применить\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 5\u001b[0;31m \u001b[0msome_list\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mtitle\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;31mAttributeError\u001b[0m: 'list' object has no attribute 'title'" + ] + } + ], + "source": [ + "# к списку\n", + "some_list = [\"machine\", \"learning\"]\n", + "\n", + "# этот метод не применить\n", + "some_list.title()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "lIM5gFo4TbUg" + }, + "source": [ + "### Собственные функции в Питоне" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "CgGpEK0AwM2k" + }, + "source": [ + "#### Объявление и вызов функции" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "IjjLVSbWqDpE" + }, + "outputs": [], + "source": [ + "# создадим функцию, которая удваивает любое передаваемое ей значение\n", + "\n", + "\n", + "def double(x):\n", + " res = x * 2\n", + " return res" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "EW6-h1F8ufBG", + "outputId": "115c5e57-2e1c-4102-ff92-ddade6454602" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "4" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# и вызовем ее, передав число 2\n", + "double(2)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "mS-C-sJePhVf" + }, + "source": [ + "#### Пустое тело функции" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "40pnqSnoTR0Z" + }, + "outputs": [], + "source": [ + "# тело функции не может быть пустым\n", + "\n", + "\n", + "def only_return():\n", + "\n", + " # нужно либо указать ключевое слово return\n", + " return" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "HuYLHkX7TZnt" + }, + "outputs": [], + "source": [ + "only_return()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "tihYzRyawYD8" + }, + "outputs": [], + "source": [ + "# либо оператор pass\n", + "\n", + "\n", + "def only_pass():\n", + " pass" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "dP_fIG04TLad" + }, + "outputs": [], + "source": [ + "only_pass()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "u06oHGCNK6Rm", + "outputId": "48a7322c-cc8c-455f-f8a3-445c9619b9c7" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "None\n" + ] + } + ], + "source": [ + "# такая функция вернет тип данных None (отсутствие значения)\n", + "print(only_return())" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "08Pbq-5VREZk" + }, + "source": [ + "#### Функция print() вместо return" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "Jaj1wdaAYFF-" + }, + "outputs": [], + "source": [ + "# можно использовать print(), но есть нюансы (см. на странице урока)\n", + "\n", + "\n", + "def double_print(x):\n", + " res = x * 2\n", + " print(res)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "XgtVgq_HYKyh", + "outputId": "53140a9c-9829-4d6c-dcd9-863b9811b037" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "10\n" + ] + } + ], + "source": [ + "double_print(5)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "zmJv5y8dLUJK" + }, + "source": [ + "#### Параметры собственных функций" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "uhOnVbWhuis_" + }, + "outputs": [], + "source": [ + "# объявим функцию с параметрами x и y\n", + "\n", + "\n", + "def calc_sum(x, y):\n", + "\n", + " # и выведем их сумму\n", + " return x + y" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "KTEhuHaYwWLQ", + "outputId": "2e3085e6-fe3c-456b-d4a0-e7e9a3ad46ac" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "3" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# вызовем эту функцию с одним позиционным и одним именованным параметром\n", + "calc_sum(1, y=2)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "baCYb7BbT46W", + "outputId": "a46fc104-cdc3-49cc-ec5c-1ccd7894905f" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "3" + ] + }, + "execution_count": 19, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# параметрам функции можно задать аргументы по умолчанию\n", + "\n", + "\n", + "def calc_sum_default(x=1, y=2):\n", + " return x + y\n", + "\n", + "\n", + "# и при вызове тогда их указывать не обязательно\n", + "calc_sum_default()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "2DQF4G9w_JUW", + "outputId": "96859e9d-1785-4d78-81f2-9f2b19ccb072" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Some string\n" + ] + } + ], + "source": [ + "# функция может не иметь параметров\n", + "\n", + "\n", + "def print_string():\n", + " print(\"Some string\")\n", + "\n", + "\n", + "print_string()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "jZABsfhPx9wd" + }, + "source": [ + "#### Аннотация функции" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "TAoI_kYPyB44" + }, + "outputs": [], + "source": [ + "# укажем, что на входе функция принимает тип float, а возвращает int\n", + "# значение 3,5 - это значение параметра x по умолчанию\n", + "\n", + "\n", + "def f(x: float = 3.5) -> int:\n", + " return int(x)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "QaNrg6kZyW8Y", + "outputId": "4afa6d5c-eaa7-4651-e9c1-aa704dd19f3e" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "{'x': float, 'return': int}" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# желаемый тип данных можно посмотреть через атрибут __annotations__\n", + "f.__annotations__" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "-iKjBO501oYJ", + "outputId": "d6e6c8d3-89c3-4d12-9979-f323f45b82c4" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "3" + ] + }, + "execution_count": 27, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# вызовем функцию без параметров\n", + "f()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "ziFM30EY2Auj" + }, + "outputs": [], + "source": [ + "# сохраним аннотации, но изменим суть функции\n", + "\n", + "\n", + "def f(x: float) -> int:\n", + " # теперь вместо int она будет возвращать float\n", + " return float(x)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "AdpR-rb92Qmn", + "outputId": "e5f3fb8c-5172-46e2-af70-ccfedce19921" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "3.0" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# вновь вызовем функцию, передав ей на входе int, и ожидая на выходе получить float\n", + "f(3)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "vlOHQZGZ_ESX" + }, + "source": [ + "#### Дополнительные возможности" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "QittQ3qiK8S4", + "outputId": "8b2c99f0-f61d-4fe5-e015-22c1762ddea6" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "6" + ] + }, + "execution_count": 30, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# вызов функции можно совмещать с арифметическими\n", + "calc_sum(1, 2) * 2" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "83RysL9MMQCw", + "outputId": "45598627-36e6-47f3-d456-9e650ba74450" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 31, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# и логическими операциями\n", + "calc_sum(1, 2) > 2" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 35 + }, + "id": "YL1UrXNFb84A", + "outputId": "395474c0-41a3-4146-a978-2e450c2ab8b7" + }, + "outputs": [ + { + "data": { + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "string" + }, + "text/plain": [ + "'P'" + ] + }, + "execution_count": 32, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# можно и так\n", + "\n", + "\n", + "def first_letter():\n", + " return \"Python\"\n", + "\n", + "\n", + "first_letter()[0]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "WC59uMaoWy8u", + "outputId": "6773f697-f6b8-4cf9-edaa-3ddcff1ac057" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Введите число: 5\n" + ] + }, + { + "data": { + "text/plain": [ + "25" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# функция может не принимать параметров, но использовать input()\n", + "\n", + "\n", + "def use_input():\n", + "\n", + " # запросим у пользователя число и переведем его в тип данных int\n", + " user_inp = int(input(\"Введите число: \"))\n", + "\n", + " # возведем число в квадрат\n", + " result = user_inp**2\n", + "\n", + " # вернем результат\n", + " return result\n", + "\n", + "\n", + "# вызовем функцию\n", + "use_input()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "7L2W-41oM6vK" + }, + "source": [ + "#### Результат вызова функции" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "zVLZODr-PazE", + "outputId": "af00da71-633a-4b23-c7ce-ed29d5ee7234" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[0, 1, 2, 3, 4]" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# функция может возвращать также список, кортеж, словарь и др.\n", + "\n", + "\n", + "# объявим функцию, которая на входе получает число,\n", + "# а на выходе формирует список чисел от 0 и до числа, предшествующего заданному\n", + "def create_list(x):\n", + "\n", + " # создадим пустой список\n", + " l = []\n", + "\n", + " # в цикле for создадим последовательность\n", + " for i in range(x):\n", + "\n", + " # и поместим ее в список\n", + " l.append(i)\n", + "\n", + " return l\n", + "\n", + "\n", + "# результатом вызова этой функции будет список\n", + "create_list(5)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "RI4Xl_CHNm3B" + }, + "outputs": [], + "source": [ + "# функция может возвращать сразу два значения\n", + "\n", + "\n", + "def tuple_f():\n", + " string = \"Python\"\n", + " x = 42\n", + " return string, x" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "e4AXnLEdNzMJ", + "outputId": "c34bf598-3e76-4128-96ca-494dc144bea1" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Python 42\n", + " \n" + ] + } + ], + "source": [ + "# если использовать две переменные\n", + "a, b = tuple_f()\n", + "\n", + "# на выходе мы получим строку и число\n", + "print(a, b)\n", + "print(type(a), type(b))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "n89-CN1pSlgP", + "outputId": "02b74687-471c-4a3e-e59c-c26440d25189" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "('Python', 42)\n", + "\n" + ] + } + ], + "source": [ + "# если одну\n", + "c = tuple_f()\n", + "\n", + "# получится кортеж\n", + "print(c)\n", + "print(type(c))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "bQzEDji5VFCY", + "outputId": "a9131375-4436-46a5-d27b-cc982a1ac1df" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "True" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# выводом может быть логическое значение (True или False)\n", + "\n", + "\n", + "def if_divisible(x):\n", + "\n", + " # если остаток от деления на два равен нулю\n", + " if x % 2 == 0:\n", + "\n", + " # вернем True\n", + " return True\n", + "\n", + " else:\n", + "\n", + " # в противном случае False\n", + " return False\n", + "\n", + "\n", + "if_divisible(10)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "uRNLyptXUoyj" + }, + "source": [ + "#### Использование библиотек" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "gFTdRnLlUt4Y" + }, + "outputs": [], + "source": [ + "# применим функцию mean() библиотеки Numpy для расчета среднего арифметического\n", + "\n", + "\n", + "# на входе наша функция примет список или массив x,\n", + "def mean_f(x):\n", + "\n", + " # рассчитает среднее арифметическое и прибавит единицу\n", + " return np.mean(x) + 1" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "OFeR_QpWU4i1", + "outputId": "a4f13201-904f-47c1-d97d-cc3d84598450" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "3.0" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# и подготовить данные\n", + "x = [1, 2, 3]\n", + "\n", + "mean_f(x)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "kY91ANMfXeRG" + }, + "source": [ + "#### Глобальные и локальные переменные" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "a4HSsRlBVBT2" + }, + "outputs": [], + "source": [ + "# создадим глобальную переменную вне функции\n", + "global_name = \"Петр\"\n", + "\n", + "# а затем используем ее внутри новой функции\n", + "\n", + "\n", + "def show_name():\n", + " print(global_name)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "_trqrh-zTjkk", + "outputId": "a436b20d-c6cf-42c2-c21a-f1ad43a70c91" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Петр\n" + ] + } + ], + "source": [ + "show_name()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "jmStHPcqTo3F" + }, + "outputs": [], + "source": [ + "# а теперь вначале создадим функцию,\n", + "# внутри которой объявим локальную переменную\n", + "\n", + "\n", + "def show_local_name():\n", + " local_name = \"Алена\"\n", + " print(local_name)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "9KMmXhAIUJkT", + "outputId": "19f7a460-1ba2-4b13-e72a-b25a74d4543a" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Алена\n" + ] + } + ], + "source": [ + "show_local_name()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 159 + }, + "id": "mcINdfP0UYt9", + "outputId": "352fad89-c4e3-49c7-a74f-64b0fb5192aa" + }, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'local_name' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;31m# при попытке обратиться к переменной вне функции мы получим ошибку\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mlocal_name\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;31mNameError\u001b[0m: name 'local_name' is not defined" + ] + } + ], + "source": [ + "# при попытке обратиться к переменной вне функции мы получим ошибку\n", + "local_name" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "GfAMDzGvUcZ8" + }, + "outputs": [], + "source": [ + "# превратить локальную переменную в глобальную можно через ключевое слово global\n", + "\n", + "\n", + "def make_global():\n", + " global local_name\n", + " local_name = \"Алена\"\n", + " print(local_name)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "glXQZMD9UpDf", + "outputId": "97d5d26f-7f28-4611-f6f7-006866a20068" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Алена\n" + ] + } + ], + "source": [ + "make_global()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 35 + }, + "id": "GSHkMhwXUxQK", + "outputId": "adda3989-248e-4c4e-8a41-0ed373aa4820" + }, + "outputs": [ + { + "data": { + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "string" + }, + "text/plain": [ + "'Алена'" + ] + }, + "execution_count": 48, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# теперь ошибки быть не должно\n", + "local_name" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "rDAqC_PlZr35" + }, + "outputs": [], + "source": [ + "# объявим глобальную переменную\n", + "global_number = 5\n", + "\n", + "\n", + "def print_number():\n", + " # затем объявим локальную переменную\n", + " local_number = 10\n", + " print(\"Local number:\", local_number)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "JvOjd91fGILS", + "outputId": "d7753061-9c05-49f6-c7d9-59fd4f299b30" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Local number: 10\n" + ] + } + ], + "source": [ + "# функция всегда \"предпочтет\" локальную переменную\n", + "print_number()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "306Y9HOWGIOf", + "outputId": "41ec6f6a-5d13-4412-e844-e63767eda086" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Global number: 5\n" + ] + } + ], + "source": [ + "# при этом значение глобальной переменной для остального кода не изменится\n", + "print(\"Global number:\", global_number)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "xLJn10TGXhlq" + }, + "source": [ + "### Lambda-функции" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "CFPwBvbYXrYR", + "outputId": "4b879d40-03cc-4851-df11-29a92136f043" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "6" + ] + }, + "execution_count": 52, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# создадим функцию, которая принимает два числа и перемножает их\n", + "lf = lambda a, b: a * b\n", + "\n", + "# вызовем функцию и передадим ей числа 2 и 3\n", + "lf(2, 3)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "65xVovHHXks9", + "outputId": "d3bdc43a-fed4-4f65-bb86-4dc388694488" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "6" + ] + }, + "execution_count": 53, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# этот же функционал можно поместить в обычную функцию\n", + "\n", + "\n", + "def normal_f(a, b):\n", + " return a * b\n", + "\n", + "\n", + "normal_f(2, 3)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "na0O4KAlE1Pk" + }, + "source": [ + "#### Lambda-функция внутри функции filter()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "RMNawYCas6ER", + "outputId": "0ccd1139-a50f-491c-f44b-43d8602f3c26" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[15, 27, 18]" + ] + }, + "execution_count": 54, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# создадим список\n", + "nums = [15, 27, 9, 18, 3, 1, 4]\n", + "\n", + "# напишем lambda-функцию, которая выведет True, если число больше 10, и False, если меньше\n", + "criterion = lambda n: True if (n > 10) else False\n", + "\n", + "# поместим список и lambda-функцию в функцию filter() и преобразуем результат в список\n", + "list(filter(criterion, nums))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Y86jO6CewXnU", + "outputId": "c380fd97-b591-4f5b-b9ca-e1c504d5cc49" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[15, 27, 18]" + ] + }, + "execution_count": 55, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# все это можно записать в одну строчку\n", + "list(filter(lambda n: True if (n > 10) else False, nums))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "VWAYPtGg0YQh", + "outputId": "9a81b80a-52c4-46c3-8bc1-07a445561738" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[15, 27, 18]" + ] + }, + "execution_count": 56, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# ту же задачу можно решить через обычную функцию,\n", + "# но придется написать больше кода\n", + "\n", + "\n", + "def criterion_2(n):\n", + " if n > 10:\n", + " return True\n", + " else:\n", + " return False\n", + "\n", + "\n", + "list(filter(criterion_2, nums))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "k9aPF9yVE9eF" + }, + "source": [ + "#### Lambda-функция внутри функции sorted()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "dMFSmXtJYb39", + "outputId": "20eb2b83-cad8-4fc5-fc11-fcbca0ea3725" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "[(901, 0.0), (1002, 0.22982440568634488), (442, 0.25401128310081567)]" + ] + }, + "execution_count": 57, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# напомню, что мы создали список из кортежей,\n", + "# и в каждом кортеже был индекс фильма и расстояние до него\n", + "indices_distances = [\n", + " (901, 0.0),\n", + " (1002, 0.22982440568634488),\n", + " (442, 0.25401128310081567),\n", + "]\n", + "\n", + "# lambda-функция возьмет каждый кортеж и вернет второй [1] его элемент\n", + "# передав эту функцию через параметр key, мы отсортируем список по расстоянию\n", + "sorted(indices_distances, key=lambda x: x[1], reverse=False)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "C8bwJf2oLI69" + }, + "source": [ + "#### Немедленно вызываемые функции" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "XjbG4yHOK9in", + "outputId": "178e510d-4aac-4ef5-b663-8b527bfb333d" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "100" + ] + }, + "execution_count": 58, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# lambda-функцию можно вызвать сразу в момент объявления\n", + "(lambda x: x * x)(10)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "pgeY1tf6U9PP" + }, + "source": [ + "### \\*args и \\**kwargs" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "uCX_-CWeYJeZ" + }, + "source": [ + "#### \\*args" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "QxlLBRqLW0Mu" + }, + "outputs": [], + "source": [ + "# напишем функцию для расчета среднего арифметического двух чисел\n", + "\n", + "\n", + "def mean(a, b):\n", + " return (a + b) / 2" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "EhuFz8wpXBVr", + "outputId": "db2f6e0a-3c22-464a-f071-2f8817d3b936" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "1.5" + ] + }, + "execution_count": 60, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "mean(1, 2)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "cyQLlIZLVIM3" + }, + "outputs": [], + "source": [ + "# объявим функцию, которой нужно передать список\n", + "\n", + "\n", + "def mean(list_):\n", + "\n", + " # зададим переменную для суммы,\n", + " total = 0\n", + "\n", + " # в цикле сложим все числа из списка\n", + " for i in list_:\n", + " total += i\n", + "\n", + " # и разделим на количество элементов\n", + " return total / len(list_)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "nh7pebndVIQU", + "outputId": "1436f42d-4a15-4d13-d917-bad885b440df" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "2.5" + ] + }, + "execution_count": 62, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# создадим список\n", + "list_ = [1, 2, 3, 4]\n", + "\n", + "# и передадим его в новую функцию\n", + "mean(list_)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 159 + }, + "id": "zy8lFJA9bkBc", + "outputId": "5311a807-f945-4c29-9422-adafa172e940" + }, + "outputs": [ + { + "ename": "TypeError", + "evalue": "mean() takes 1 positional argument but 2 were given", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;31m# однако новая функция уже не может работать с отдельными числами\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mmean\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\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: mean() takes 1 positional argument but 2 were given" + ] + } + ], + "source": [ + "# однако новая функция уже не может работать с отдельными числами\n", + "mean(1, 2)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "vwrIY7CqVIYO" + }, + "outputs": [], + "source": [ + "# объявим функцию с *args\n", + "\n", + "\n", + "def mean(*nums):\n", + "\n", + " # в данном случае мы складываем элементы кортежа\n", + " total = 0\n", + " for i in nums:\n", + " total += i\n", + "\n", + " return total / len(nums)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "P5Q1bhIVXz9p", + "outputId": "137523e1-03c8-49d5-ad5e-445879480dbf" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "2.5" + ] + }, + "execution_count": 65, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# теперь мы можем передать функции отдельные числа\n", + "mean(1, 2, 3, 4)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "bhHgfAZ-Ytmp", + "outputId": "a13075ac-6eef-4c70-b02b-fdd68cdf6be4" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "2.5" + ] + }, + "execution_count": 66, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# или список\n", + "mean(*list_)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "L3NKa556r5O0", + "outputId": "7523137c-3f2c-419c-81c0-3573b02993b0" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(1, 2, 3, 4) \n" + ] + } + ], + "source": [ + "# убедимся, что оператор распаковки * формирует кортеж\n", + "\n", + "\n", + "def test_type(*nums):\n", + " print(nums, type(nums))\n", + "\n", + "\n", + "test_type(1, 2, 3, 4)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "XHDvzgXFxql2", + "outputId": "05e55975-5e49-4bff-b0ee-e1fa91dad322" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "(1, 2, 3, 4) \n" + ] + } + ], + "source": [ + "# со списком происходит то же самое\n", + "test_type(*list_)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "JeLoABCMy_om", + "outputId": "3f00f8a2-8801-456a-9341-df12e3753e1d" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1, 2, 3, 4, 5, 6]\n" + ] + } + ], + "source": [ + "# для наглядности приведем еще один пример\n", + "a = [1, 2, 3]\n", + "b = [*a, 4, 5, 6]\n", + "\n", + "print(b)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "qh8xqKMwYLpH" + }, + "source": [ + "#### \\**kwargs" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "gzEpZF_13Vfq" + }, + "outputs": [], + "source": [ + "# **kwargs преобразует именованные параметры в словарь\n", + "\n", + "\n", + "def f(**kwargs):\n", + " return kwargs.items()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "rl4dALTK3plJ", + "outputId": "c317ee78-c259-4cff-cd33-110d73749b74" + }, + "outputs": [ + { + "data": { + "text/plain": [ + "dict_items([('a', 1), ('b', 2)])" + ] + }, + "execution_count": 71, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "f(a=1, b=2)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "Zd930nvoasfs" + }, + "outputs": [], + "source": [ + "# *nums превращается в кортеж, **params - в словарь\n", + "\n", + "\n", + "def simple_stats(*nums, **params):\n", + "\n", + " # если ключ 'mean' есть в словаре params и его значение == True\n", + " if \"mean\" in params and params[\"mean\"] == True:\n", + "\n", + " # рассчитаем среднее арифметическое и округлим\n", + " # \\t - это символ табуляции\n", + " print(f\"mean: \\t{np.round(np.mean(nums), 3)}\")\n", + "\n", + " # если ключ 'std' есть в словаре params и его значение == True\n", + " if \"std\" in params and params[\"std\"] == True:\n", + "\n", + " # рассчитаем СКО и округлим\n", + " print(f\"std: \\t{np.round(np.std(nums), 3)}\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "YQqRLpXvfYJZ", + "outputId": "d5a72bf9-363d-4204-e659-5d61c414ea88" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "mean: \t12.5\n", + "std: \t5.59\n" + ] + } + ], + "source": [ + "# вызовем функцию simple_stats() и передадим ей числа и именованные аргументы\n", + "simple_stats(5, 10, 15, 20, mean=True, std=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "h5VyRzsjn2ny", + "outputId": "a6762112-09d1-495c-f2e8-1b62fea3e20b" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "mean: \t12.5\n" + ] + } + ], + "source": [ + "# если для одного из параметров задать значение False,\n", + "# функция не выведет соответствующую метрику\n", + "simple_stats(5, 10, 15, 20, mean=True, std=False)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "J6TjmWJ3hbBv", + "outputId": "21d40d7d-9493-496c-86ac-2064f4b5b1a3" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "mean: \t12.5\n", + "std: \t5.59\n" + ] + } + ], + "source": [ + "# если мы хотим передать параметры списком и словарем,\n", + "list_ = [5, 10, 15, 20]\n", + "settings = {\"mean\": True, \"std\": True}\n", + "\n", + "# то нам нужно использовать операторы распаковки * и ** соответственно\n", + "simple_stats(*list_, **settings)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "55FDFsesoAOP", + "outputId": "0c09c820-dc81-4d04-d4e0-ce9ab1b1a1ea" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "mean: \t12.5\n", + "std: \t5.59\n" + ] + } + ], + "source": [ + "# ничто не мешает нам добавить еще один параметр\n", + "simple_stats(5, 10, 15, 20, mean=True, std=True, median=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "j4mcGPUgjKp4" + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "display_name": "data-science", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.13" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/06_Functions.makarov.py b/06_Functions.makarov.py new file mode 100644 index 00000000..6eaf8c8d --- /dev/null +++ b/06_Functions.makarov.py @@ -0,0 +1,706 @@ +# ## Функции в Питоне + +# ### Встроенные функции + +# In[ ]: + + +# импортируем библиотеки +import matplotlib.pyplot as plt + +# перед вызовом функции нужно не забыть импортировать соответствующую +# библиотеку +import numpy as np + +# установим точку отсчета +np.random.seed(42) +# и снова сгенерируем данные о росте (как мы делали на восьмом занятии +# вводного курса) +height = list(np.round(np.random.normal(180, 10, 1000))) + +# #### Параметры и аргументы функции + +# In[ ]: + + +# теперь построим гистограмму передав ей два параметра, данные о росте и количество интервалов +# первый параметр у нас позиционный, второй - именованный +plt.hist(height, bins=10) +plt.show() + +# In[ ]: + + +# первый параметр можно также сделать именованным (данные обозначаются через x) +# и тогда порядок параметров можно менять +plt.hist(bins=10, x=height) +plt.show() + +# In[ ]: + + +# у параметра bins есть аргумент по умолчанию (как раз 10 интервалов), +# а значит, этот параметр можно не указывать +plt.hist(height) +plt.show() + +# In[ ]: + + +# функция может не принимать параметров +print("Первая строка") +print() +print("Третья строка") + +# #### Функции и методы + +# In[ ]: + + +# дана строка +some_string = "machine learning" + +# применим метод .title() +some_string.title() + +# In[ ]: + + +# к списку +some_list = ["machine", "learning"] + +# этот метод не применить +some_list.title() + +# ### Собственные функции в Питоне + +# #### Объявление и вызов функции + +# In[ ]: + + +# создадим функцию, которая удваивает любое передаваемое ей значение +def double(x): + res = x * 2 + return res + + +# In[ ]: + + +# и вызовем ее, передав число 2 +double(2) + +# #### Пустое тело функции + +# In[ ]: + + +# тело функции не может быть пустым +def only_return(): + + # нужно либо указать ключевое слово return + return + + +# In[ ]: + + +only_return() + +# In[ ]: + + +# либо оператор pass +def only_pass(): + pass + + +# In[ ]: + + +only_pass() + +# In[ ]: + + +# такая функция вернет тип данных None (отсутствие значения) +print(only_return()) + +# #### Функция print() вместо return + +# In[ ]: + + +# можно использовать print(), но есть нюансы (см. на странице урока) +def double_print(x): + res = x * 2 + print(res) + + +# In[ ]: + + +double_print(5) + +# #### Параметры собственных функций + +# In[ ]: + + +# объявим функцию с параметрами x и y +def calc_sum(x, y): + + # и выведем их сумму + return x + y + + +# In[ ]: + + +# вызовем эту функцию с одним позиционным и одним именованным параметром +calc_sum(1, y=2) + +# In[ ]: + + +# параметрам функции можно задать аргументы по умолчанию +def calc_sum_default(x=1, y=2): + return x + y + + +# и при вызове тогда их указывать не обязательно +calc_sum_default() + +# In[ ]: + + +# функция может не иметь параметров +def print_string(): + print("Some string") + + +print_string() + +# #### Аннотация функции + +# In[ ]: + + +# укажем, что на входе функция принимает тип float, а возвращает int +# значение 3,5 - это значение параметра x по умолчанию +def f(x: float = 3.5) -> int: + return int(x) + + +# In[ ]: + + +# желаемый тип данных можно посмотреть через атрибут __annotations__ +f.__annotations__ + +# In[ ]: + + +# вызовем функцию без параметров +f() + +# In[ ]: + + +# сохраним аннотации, но изменим суть функции +def f(x: float) -> int: + # теперь вместо int она будет возвращать float + return float(x) + + +# In[ ]: + + +# вновь вызовем функцию, передав ей на входе int, и ожидая на выходе +# получить float +f(3) + +# #### Дополнительные возможности + +# In[ ]: + + +# вызов функции можно совмещать с арифметическими +calc_sum(1, 2) * 2 + +# In[ ]: + + +# и логическими операциями +calc_sum(1, 2) > 2 + +# In[ ]: + + +# можно и так +def first_letter(): + return "Python" + + +first_letter()[0] + +# In[ ]: + + +# функция может не принимать параметров, но использовать input() +def use_input(): + + # запросим у пользователя число и переведем его в тип данных int + user_inp = int(input("Введите число: ")) + + # возведем число в квадрат + result = user_inp**2 + + # вернем результат + return result + + +# вызовем функцию +use_input() + +# #### Результат вызова функции + +# In[ ]: + + +# функция может возвращать также список, кортеж, словарь и др. + + +# объявим функцию, которая на входе получает число, +# а на выходе формирует список чисел от 0 и до числа, предшествующего заданному +def create_list(x): + + # создадим пустой список + result = [] + + # в цикле for создадим последовательность + for i in range(x): + + # и поместим ее в список + result.append(i) + + return result + + +# результатом вызова этой функции будет список +create_list(5) + +# In[ ]: + + +# функция может возвращать сразу два значения +def tuple_f(): + string = "Python" + x = 42 + return string, x + + +# In[ ]: + + +# если использовать две переменные +a, b = tuple_f() + +# на выходе мы получим строку и число +print(a, b) +print(type(a), type(b)) + +# In[ ]: + + +# если одну +c = tuple_f() + +# получится кортеж +print(c) +print(type(c)) + +# In[ ]: + + +# выводом может быть логическое значение (True или False) +def if_divisible(x): + + # если остаток от деления на два равен нулю + if x % 2 == 0: + + # вернем True + return True + + else: + + # в противном случае False + return False + + +if_divisible(10) + +# #### Использование библиотек + +# In[ ]: + + +# применим функцию mean() библиотеки Numpy для расчета среднего арифметического + + +# на входе наша функция примет список или массив x, +def mean_f(x): + + # рассчитает среднее арифметическое и прибавит единицу + return np.mean(x) + 1 + + +# In[ ]: + + +# и подготовить данные +x = [1, 2, 3] + +mean_f(x) + +# #### Глобальные и локальные переменные + +# In[ ]: + + +# создадим глобальную переменную вне функции +global_name = "Петр" + + +# а затем используем ее внутри новой функции +def show_name(): + print(global_name) + + +# In[ ]: + + +show_name() + +# In[ ]: + + +# а теперь вначале создадим функцию, +# внутри которой объявим локальную переменную +def show_local_name(): + local_name = "Алена" + print(local_name) + + +# In[ ]: + + +show_local_name() + +# In[ ]: + + +# при попытке обратиться к переменной вне функции мы получим ошибку +local_name + +# In[ ]: + + +# превратить локальную переменную в глобальную можно через ключевое слово +# global +def make_global(): + global local_name + local_name = "Алена" + print(local_name) + + +# In[ ]: + + +make_global() + +# In[ ]: + + +# теперь ошибки быть не должно +local_name + +# In[ ]: + + +# объявим глобальную переменную +global_number = 5 + + +def print_number(): + # затем объявим локальную переменную + local_number = 10 + print("Local number:", local_number) + + +# In[ ]: + + +# функция всегда "предпочтет" локальную переменную +print_number() + +# In[ ]: + + +# при этом значение глобальной переменной для остального кода не изменится +print("Global number:", global_number) + +# ### Lambda-функции + +# In[ ]: + + +# создадим функцию, которая принимает два числа и перемножает их +def lf(a, b): + return a * b + + +# вызовем функцию и передадим ей числа 2 и 3 +lf(2, 3) + +# In[ ]: + + +# этот же функционал можно поместить в обычную функцию +def normal_f(a, b): + return a * b + + +normal_f(2, 3) + +# #### Lambda-функция внутри функции filter() + +# In[ ]: + + +# создадим список +nums = [15, 27, 9, 18, 3, 1, 4] + +# напишем lambda-функцию, которая выведет True, если число больше 10, и +# False, если меньше + + +def criterion(n): + return True if (n > 10) else False + + +# поместим список и lambda-функцию в функцию filter() и преобразуем +# результат в список +list(filter(criterion, nums)) + +# In[ ]: + + +# все это можно записать в одну строчку +list(filter(lambda n: True if (n > 10) else False, nums)) + +# In[ ]: + + +# ту же задачу можно решить через обычную функцию, +# но придется написать больше кода +def criterion_2(n): + if n > 10: + return True + else: + return False + + +list(filter(criterion_2, nums)) + +# #### Lambda-функция внутри функции sorted() + +# In[ ]: + + +# напомню, что мы создали список из кортежей, +# и в каждом кортеже был индекс фильма и расстояние до него +indices_distances = [ + (901, 0.0), + (1002, 0.22982440568634488), + (442, 0.25401128310081567), +] + +# lambda-функция возьмет каждый кортеж и вернет второй [1] его элемент +# передав эту функцию через параметр key, мы отсортируем список по расстоянию +sorted(indices_distances, key=lambda x: x[1], reverse=False) + +# #### Немедленно вызываемые функции + +# In[ ]: + + +# lambda-функцию можно вызвать сразу в момент объявления +(lambda x: x * x)(10) + +# ### \*args и \**kwargs + +# #### \*args + +# In[ ]: + + +# напишем функцию для расчета среднего арифметического двух чисел +def mean(a, b): + return (a + b) / 2 + + +# In[ ]: + + +mean(1, 2) + +# In[ ]: + + +# объявим функцию, которой нужно передать список +def mean(list_): + + # зададим переменную для суммы, + total = 0 + + # в цикле сложим все числа из списка + for i in list_: + total += i + + # и разделим на количество элементов + return total / len(list_) + + +# In[ ]: + + +# создадим список +list_ = [1, 2, 3, 4] + +# и передадим его в новую функцию +mean(list_) + +# In[ ]: + + +# однако новая функция уже не может работать с отдельными числами +mean(1, 2) + +# In[ ]: + + +# объявим функцию с *args +def mean(*nums): + + # в данном случае мы складываем элементы кортежа + total = 0 + for i in nums: + total += i + + return total / len(nums) + + +# In[ ]: + + +# теперь мы можем передать функции отдельные числа +mean(1, 2, 3, 4) + +# In[ ]: + + +# или список +mean(*list_) + +# In[ ]: + + +# убедимся, что оператор распаковки * формирует кортеж +def test_type(*nums): + print(nums, type(nums)) + + +test_type(1, 2, 3, 4) + +# In[ ]: + + +# со списком происходит то же самое +test_type(*list_) + +# In[ ]: + + +# для наглядности приведем еще один пример +a = [1, 2, 3] +b = [*a, 4, 5, 6] + +print(b) + +# #### \**kwargs + +# In[ ]: + + +# **kwargs преобразует именованные параметры в словарь +def f(**kwargs): + return kwargs.items() + + +# In[ ]: + + +f(a=1, b=2) + +# In[ ]: + + +# *nums превращается в кортеж, **params - в словарь +def simple_stats(*nums, **params): + + # если ключ 'mean' есть в словаре params и его значение == True + if "mean" in params and params["mean"]: + + # рассчитаем среднее арифметическое и округлим + # \t - это символ табуляции + print(f"mean: \t{np.round(np.mean(nums), 3)}") + + # если ключ 'std' есть в словаре params и его значение == True + if "std" in params and params["std"]: + + # рассчитаем СКО и округлим + print(f"std: \t{np.round(np.std(nums), 3)}") + + +# In[ ]: + + +# вызовем функцию simple_stats() и передадим ей числа и именованные аргументы +simple_stats(5, 10, 15, 20, mean=True, std=True) + +# In[ ]: + + +# если для одного из параметров задать значение False, +# функция не выведет соответствующую метрику +simple_stats(5, 10, 15, 20, mean=True, std=False) + +# In[ ]: + + +# если мы хотим передать параметры списком и словарем, +list_ = [5, 10, 15, 20] +settings = {"mean": True, "std": True} + +# то нам нужно использовать операторы распаковки * и ** соответственно +simple_stats(*list_, **settings) + +# In[ ]: + + +# ничто не мешает нам добавить еще один параметр +simple_stats(5, 10, 15, 20, mean=True, std=True, median=True) + +# In[ ]: diff --git a/commits.ipynb b/commits.ipynb new file mode 100644 index 00000000..827cabdf --- /dev/null +++ b/commits.ipynb @@ -0,0 +1,103 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\"\"\"Task commits.\"\"\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "1. Опишите своими словами назначение каждого\n", + " из этих типов коммитов:" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "feat - добавляет новую фичу в код\n", + "\n", + " fix - исправляет баг в коде\n", + "\n", + " docs - такой нужен в случае, \n", + " если изменения только в \n", + " документации\n", + "\n", + " style - не влияет на сам код \n", + "\n", + " refactor - помогает сделать код чище, т.е не влияет на фичи и\n", + " не чинит баг. Но делает код более читабельным и понятным.\n", + "\n", + " test - добавляет тесты или исправляет существующие\n", + "\n", + " build - влияет на систему сборки или внешние зависимости\n", + "\n", + " ci - добавляет изменения в файлах конфигурации CI и скриптах. \n", + "\n", + "То есть настраивает изменение процессов\n", + "сборки, тестирования и деплоя.\n", + "\n", + " perf - улучшается производительность \n", + "\n", + " chore - нужен для технического обслуживания проекта\n", + " " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "2) git commit -m \"fix: rounding error in round function \n", + "Now it correctly rounds numbers\"\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "3. git commit -m \"feat: add generateReport function\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "4. git commit -m \"style: fix indentation and formatting\"" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "5. git commit -m \"docs: update documentation for generateReport function\"" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "base", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.0" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/commits.py b/commits.py new file mode 100644 index 00000000..702c68ea --- /dev/null +++ b/commits.py @@ -0,0 +1,43 @@ +# """Task commits.""" + +# 1. Опишите своими словами назначение каждого +# из этих типов коммитов: + +# feat - добавляет новую фичу в код +# +# fix - исправляет баг в коде +# +# docs - такой нужен в случае, +# если изменения только в +# документации +# +# style - не влияет на сам код +# +# refactor - помогает сделать код чище, т.е не влияет на фичи и +# не чинит баг. Но делает код более читабельным и понятным. +# +# test - добавляет тесты или исправляет существующие +# +# build - влияет на систему сборки или внешние зависимости +# +# ci - добавляет изменения в файлах конфигурации CI и скриптах. +# +# То есть настраивает изменение процессов +# сборки, тестирования и деплоя. +# +# perf - улучшается производительность +# +# chore - нужен для технического обслуживания проекта +# + +# 2) git commit -m "fix: rounding error in round function +# Now it correctly rounds numbers" +# +# +# + +# 3. git commit -m "feat: add generateReport function" + +# 4. git commit -m "style: fix indentation and formatting" + +# 5. git commit -m "docs: update documentation for generateReport function" diff --git a/docs/git/git_command.py b/docs/git/git_command.py index ec244539..e26ee402 100644 --- a/docs/git/git_command.py +++ b/docs/git/git_command.py @@ -9,52 +9,3 @@ - Работа с GitHub - Дополнительные команды. """ - -# -# -# -# -# # Основные команды Git -# -# ## Базовые команды -# - `git init` - создать новый репозиторий -# - `git clone` - копировать существующий репозиторий -# - `git add <файл>` - добавить файл для отслеживания -# - `git add .` - добавить все файлы -# - `git commit -m "сообщение"` - сохранить изменения -# - `git commit -am "сообщение"` - добавить и сохранить изменения -# - `git status` - проверить статус файлов -# - `git --version` - проверить версию Git -# -# ## Просмотр изменений -# - `git diff` - показать несохраненные изменения -# - `git diff file.py` - изменения в конкретном файле -# - `git difftool` - открыть изменения в графическом интерфейсе -# -# ## Работа с журналом -# - `git log` - просмотр полного журнала -# - `git log --oneline` - сокращенный формат -# - `git log -n 3` - последние 3 коммита -# - `git show хеш:файл.txt` - содержимое файла в коммите -# -# ## Отмена изменений -# - `git restore file.txt` - отменить несохраненные изменения -# - `git restore --staged file.txt` - убрать из индекса -# - `git checkout .` - отменить все изменения -# - `git revert -n HEAD~3..HEAD` - отменить последние 3 коммита -# - `git checkout хеш -- файл.py` - вернуть к определенной версии -# -# ## Работа с файлами -# - `git rm file.txt` - удалить файл -# - `git mv старый.txt новый.txt` - переименовать/переместить файл -# -# ## Работа с GitHub -# - `git remote add origin URL` - привязать удаленный репозиторий -# - `git push -u origin master` - первая отправка на GitHub -# - `git push` - отправить изменения -# - `git clone URL` - клонировать репозиторий -# -# ## Дополнительные команды -# - `git help <команда>` - получить справку -# - `git <команда> --help` - альтернативный вызов справки -# - `git ls-files --other --ignored --exclude-standard` - показать игнорируемые файлы diff --git a/docs/git/intro_to_git.py b/docs/git/intro_to_git.py index a2d8e660..98d6c91a 100644 --- a/docs/git/intro_to_git.py +++ b/docs/git/intro_to_git.py @@ -1,806 +1 @@ """Git и организация программных проектов.""" - -#

Системы контроля версий представляют собой программные средства, которые регистрируют все изменения в исходном коде и позволяют легко восстановить старые версии.

-#

Система контроля версий управляет файлами при внесении в них изменений.

-#

Git, Mercurial и Subversion — популярные приложения контроля версий, хотя система Git остается самой популярной.

- -# ### Коммиты и репозитории -#

Git позволяет сохранить состояние файлов проекта при внесении в них изменений. Такие сохранения называются снимками (snapshots) или коммитами (commits).

-#

Системы контроля версий также позволяют команде разработчиков синхронизировать свою работу при внесении изменений в исходный код проекта. Когда каждый программист закрепляет свои изменения, другие могут извлекать эти обновления на своих компьютерах. Система контроля версий следит за тем, какие изменения были внесены, кто и когда их сделал, а также сохраняет комментарии разработчиков, описывающие эти изменения.

-#

Система контроля версий управляет исходным кодом проекта, который хранится в специальной папке — репозитории (repo). Как правило, для каждого проекта, над которым вы работаете, следует создать отдельный репозиторий Git. Предположим, вы работаете в основном самостоятельно над своей частью программы и вам не нужны расширенные возможности Git (такие как ветвление и слияние), упрощающие работу с остальными участниками. Но даже если вы работаете в одиночку, самый маленький проект все равно выиграет от применения системы контроля версий.

- -# ### Создание новых проектов Python с использованием Cookiecutter -#

В терминологии Git папка, содержащая весь исходный код, документацию, тесты и другие файлы, относящиеся к проекту, называется рабочим каталогом или рабочим деревом, а в более общей терминологии — папкой проекта. Файлы в рабочем каталоге в совокупности называются рабочей копией.

-# -#

Прежде чем создавать репозиторий Git, следует создать файлы для проекта Python.

-# -#

Для проектов Python действуют определенные соглашения по поводу имен папок и иерархий. Более простая программа может содержать один файл .py. Но когда проекты усложнятся, в них будут включаться дополнительные файлы .py, файлы данных, документация, модульные тесты и т. д. Как правило, корневая папка проекта содержит папку src для файлов с исходным кодом .py, папку tests для модульных тестов и папку docs для документации (например, сгенерированной системой документирования Sphinx). Другие файлы содержат информацию о проекте и конфигурации системы: README.md для общей информации, .coveragerc для конфигурации покрытия кода, LICENSE.txt для текста программной лицензии проекта и т. д.

-# -#

Чтобы ускорить выполнение рутинных операций, можно использовать модуль Python cookiecutter для автоматического создания этих файлов и папок. Полная документация по модулю и программе командной строки Cookiecutter доступна на https://cookiecutter.readthedocs.io/.

-# -#

Если вы не знаете, для чего нужны те или иные файлы, не огорчайтесь. Хотя полное описание назначения каждого файла выходит за рамки книги, на странице https://github.com/asweigart/cookiecutter-basicpythonproject присутствуют ссылки и нужная информация. Итак, базовые файлы созданы, и мы переходим к отслеживанию изменений в них в системе Git.

- -# ![image.png](attachment:image.png) - -# ### Установка Git -# -#

Git уже установлена на моем компьютере.

-# -#

Чтобы узнать это, введите команду `git --version` в командной строке.

-# -#

У меня выводится: `git version 2.45.0.windows.1`

- -# ## Работа с Git -# -# Работа с репозиторием Git состоит из нескольких этапов: -# -# 1. Создание репозитория: -# - Командой `git init` для нового проекта -# - Или `git clone` для копирования существующего -# -# 2. Добавление файлов для отслеживания: -# - Используется команда `git add <имя_файла>` -# - Можно добавить все файлы: `git add .` -# -# 3. Сохранение изменений: -# - Команда `git commit -am "<сообщение коммита>"` -# - В сообщении описывается содержание изменений -# - -# -# ### Справка по командам -# -# Для получения справки по любой команде используйте: -# -# Чтобы получить справку по командам в GitHub, можно использовать команду «git help». 24 Она предоставляет обзор доступных команд и способов их использования. -# -# Ещё несколько способов открыть страницу руководства по конкретной команде Git: -# -# git help <команда>. 45 Например, чтобы получить справку по команде commit, нужно выполнить: git help commit. -# git <команда> --help. Например, так можно открыть руководство по команде git config: git config --help. -# man git-<команда>. 45 Например, чтобы просмотреть страницу руководства по конкретной команде Git, нужно ввести: man git-config. -# -# Если нужна персональная помощь, можно попробовать поискать её на каналах #git и #github IRC сервера Libera Chat, который доступен по адресу libera.chat. - -# ## Как Git отслеживает статус файлов -# -# ### Основные состояния файлов -# -# 1. **Неотслеживаемые (Untracked)**: -# - Файлы, которые Git не видит -# - Для Git эти файлы не существуют -# - Нужно добавить через `git add` -# -# 2. **Отслеживаемые (Tracked)** файлы имеют три состояния: -# - **Сохраненные (Committed)**: идентичны последнему коммиту -# - **Измененные (Modified)**: отличаются от последнего коммита -# - **Индексированные (Staged)**: помечены для следующего коммита -# -# ### Переходы между состояниями -# -# 1. Неотслеживаемый → Индексированный: -# - Используется `git add <файл>` -# -# 2. Сохраненный → Измененный: -# - Происходит автоматически при изменении файла -# - Не требует команд Git -# -# 3. Измененный → Индексированный: -# - Используется `git add <файл>` -# -# 4. Индексированный → Сохраненный: -# - Используется `git commit` -# -# ### Проверка статуса -# Команда `git status` -# -# ### Важные заметки: -# - Команду `git status` рекомендуется использовать часто -# - Git подсказывает команды для изменения состояния файлов -# - Файл может находиться только в одном состоянии - -# -# - -# ## Для чего нужно индексирование? -# -# ### Сложности индексирования -# -# 1. **Особые случаи**: -# - Файл может быть одновременно в измененном и индексированном состоянии -# - Разные части файла могут иметь разные состояния -# - Технически индексируются не файлы, а описания изменений -# -# 2. **Проблемы для новичков**: -# - Вызывает недоумение -# - Создает путаницу -# - Усложняет понимание Git -# - Часто описывается неточно в документации -# -# ### Как упростить работу -# -# 1. **Использовать команду `git commit -am`**: -# - Объединяет индексирование и коммит -# - Файлы переходят сразу из измененного в чистое состояние -# - Упрощает процесс сохранения -# -# 2. **Рекомендации по работе**: -# - Сразу сохранять файлы после добавления -# - Немедленно коммитить после переименования -# - Не откладывать коммиты после удаления файлов -# -# 3. **Альтернативные решения**: -# - Использовать графические интерфейсы Git -# - Избегать сложных случаев -# - Придерживаться простых сценариев использования - -# ## Создание репозитория Git на компьютере -# -# ### Особенности Git как распределенной системы -# -# 1. **Локальное хранение**: -# - Все коммиты хранятся на компьютере -# - Метаданные в папке `.git` -# - Не требует подключения к интернету -# - Быстрая работа даже офлайн -# -# ### Создание нового репозитория - -# 1. **Создание папки и инициализация**: -# -# # Для Windows: -# md wizcoin -# -# # Для macOS/Linux: -# # mkdir wizcoin -# -# # Для всех систем: -# # cd wizcoin -# git init - -# 2. **Что происходит при инициализации (git init)**: -# - В папке создается скрытая подпапка `.git` -# - Эта папка превращается в Git-репозиторий -# - Все существующие файлы становятся неотслеживаемыми (untracked) -# - В `.git` хранятся все данные о версиях (не нужно редактировать вручную!) -# -# ### Типы репозиториев -# -# 1. **Локальный репозиторий**: -# - На вашем компьютере -# - Для личной работы -# -# 2. **Удаленный репозиторий**: -# - На другом компьютере -# - Для совместной работы -# -# ### Мониторинг статуса (watch) -# -# watch - это утилита, которая: Что делает: -# Автоматически повторяет команду -# Показывает результат каждые 2 секунды -# Обновляет экран автоматически -# Как "живой" мониторинг -# -# Зачем это нужно: -# Не надо постоянно вводить git status -# Видишь изменения сразу -# Удобно следить за репозиторием -# Как "радар" для Git -# -# -# 1. **Установка watch**: -# - Windows: скачать с https://inventwithpython.com/watch.exe -# - macOS: через MacPorts -# - Linux: предустановлен -# -# 2. **Использование**: -# watch "git status" # обновление каждые 2 секунды -# watch "git log --oneline" # мониторинг коммитов - -# - -# ### Добавление файлов для отслеживания -# -# 1. **Проверка статуса файлов**: -# - Команда `git status` показывает состояние файлов -# - Неотслеживаемые файлы помечены как "Untracked files" -# - Git не может сохранять неотслеживаемые файлы -# - Нужно сначала добавить их для отслеживания -# -# 2. **Процесс добавления файлов**: -# - Сначала `git add` (индексирование файлов) -# - Затем `git commit` (создание коммита) -# - После этого Git начинает отслеживать файлы -# -# 3. **Способы использования git add**: -# - `git add file.txt` - добавить один файл -# - `git add *.py` - добавить все Python файлы -# - `git add .` - добавить все файлы в текущей папке -# -# 4. **Создание коммита**: -# - `git commit -m "Сообщение коммита"` - сохраняет индексированные файлы -# - В сообщении описываем, какие изменения внесли -# - После коммита файлы становятся отслеживаемыми -# -# 5. **Важные замечания**: -# - Файлы из `.gitignore` автоматически пропускаются -# - Можно добавлять файлы группами -# - Каждый коммит требует сообщения -# - После успешного коммита рабочая директория "чистая" - -# - -# ### Игнорирование файлов в Git (.gitignore) -# -# 1. **Зачем игнорировать файлы**: -# - Временные файлы проекта -# - Компилированные файлы (`.pyc`, `.pyo`, `.pyd`) -# - Папки инструментов разработки (`.tox`, `htmlcov`) -# - Сгенерированные файлы (можно создать заново) -# - Файлы с конфиденциальными данными (пароли, токены) -# -# 2. **Как использовать .gitignore**: -# - Создать файл `.gitignore` в корне проекта -# - Записать в него шаблоны игнорируемых файлов -# - Git автоматически пропустит эти файлы при `git add` и `git commit` -# - Файлы не будут показываться в `git status` -# -# 3. **Синтаксис .gitignore**: -# ``` -# # Комментарий -# __pycache__/ # Игнорировать папку -# *.py[cod] # Игнорировать файлы по маске -# *$py.class # Конкретный шаблон -# ``` -# -# 4. **Важные моменты**: -# - Сам файл `.gitignore` нужно добавить в репозиторий -# - Используйте `*` для шаблонов файлов -# - Используйте `#` для комментариев -# - Проверить игнорируемые файлы: `git ls-files --other --ignored --exclude-standard` -# -# 5. **Документация**: https://git-scm.com/docs/gitignore - -# ### Сохранение изменений в Git -# -# 1. **Основные команды**: -# - `git commit -am "сообщение"` - сохранить все измененные файлы -# - `git commit -m "сообщение" file1.py file2.py` - сохранить конкретные файлы -# - `git commit --amend -m "новое_сообщение"` - исправить последний коммит -# -# 2. **Правила хороших сообщений**: -# - Подробно описывать изменения -# - Избегать общих фраз ("обновил код", "фикс") -# - Помогать себе в будущем понять изменения -# - Пример: "Fixed the currency conversion bug" -# -# 3. **Важные моменты**: -# - Нельзя сохранять пустые папки -# - Git автоматически включает папки с файлами -# - После коммита файлы готовы к новым изменениям -# - Vim открывается если забыть `-m "сообщение"` (выход: Esc + qa!) -# -# 4. **Хорошая практика**: -# - Делать частые коммиты -# - Писать понятные сообщения -# - Группировать связанные изменения -# - Изучать примеры больших проектов (например, Django) - -# - -# ### Просмотр изменений перед коммитом (git diff) -# -# 1. **Основное использование**: -# ```bash -# git diff # показать все несохраненные изменения -# git diff file.py # изменения в конкретном файле -# ``` -# -# 2. **Как читать вывод git diff**: -# - `-` красным: удаленные строки -# - `+` зеленым: добавленные строки -# - `@@ -13,7 +13,14 @@`: координаты изменений -# - Показывает контекст вокруг изменений -# -# 3. **Процесс работы**: -# 1. Внести изменения в файл -# 2. `git diff` - проверить изменения -# 3. Исправить ошибки если найдены -# 4. `git add` - добавить в индекс -# 5. `git commit` - сохранить изменения -# -# 4. **Преимущества использования**: -# - Можно поймать опечатки -# - Проверить все изменения -# - Убедиться в правильности кода -# - Не сохранять лишнее -# -# 5. **Пример рабочего процесса**: -# ```bash -# git diff # проверить изменения -# git add README.md # добавить файл -# git commit -m "Added example code to README.md" # сохранить -# ``` - -# ### Просмотр изменений через git difftool -# -# 1. **Установка инструментов сравнения**: -# - **Windows**: WinMerge (https://winmerge.org) -# - **Linux**: -# ```bash -# sudo apt-get install meld -# # или -# sudo apt-get install kompare -# ``` -# - **macOS**: -# ```bash -# # Установка Homebrew -# /bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install.sh)" -# # Установка tkdiff -# brew install tkdiff -# ``` -# -# 2. **Настройка Git**: -# ```bash -# # Выбор инструмента -# git config diff.tool winmerge # или meld, tkdiff, kompare -# -# # Отключение запроса подтверждения -# git config --global difftool.prompt false -# ``` -# -# 3. **Использование**: -# ```bash -# git difftool file.txt # открыть изменения в графическом интерфейсе -# ``` -# -# 4. **Преимущества**: -# - Удобный визуальный интерфейс -# - Легче сравнивать изменения -# - Больше возможностей для анализа -# - Интеграция с Git-клиентами - -# - -# ### Частота сохранения изменений в Git -# -# 1. **Когда делать коммиты**: -# - После завершения функционала -# - После исправления бага -# - После написания класса -# - Когда код работоспособен -# -# 2. **Чего избегать**: -# - Коммитов с синтаксическими ошибками -# - Неработающего кода -# - Слишком редких коммитов -# - Слишком частых коммитов -# -# 3. **Правила хорошего тона**: -# - Запускать тесты перед коммитом -# - Проверять работоспособность -# - Писать понятные сообщения -# - Группировать связанные изменения -# -# 4. **Баланс в размере коммитов**: -# - Может быть несколько строк -# - Может быть несколько сотен строк -# - Главное - логическая завершенность -# - Возможность отката к рабочей версии -# -# 5. **Важно помнить**: -# - Лучше коммитить чаще, чем реже -# - Каждый коммит должен быть осмысленным -# - Упоминать о непроходящих тестах -# - Сохранять возможность отката - -# ### Удаление файлов в Git -# -# 1. **Правильное удаление файлов**: -# ```bash -# git rm file.txt # удалить файл -# git commit -m "Удалил file.txt" # сохранить удаление -# ``` -# -# 2. **Чего НЕ делать**: -# - Не использовать `del` (Windows) -# - Не использовать `rm` (macOS/Linux) -# - Не удалять файлы вручную -# - Не забывать про коммит после удаления -# -# 3. **Если удалили файл вручную**: -# ```bash -# git restore file.txt # восстановить файл -# # или -# git rm file.txt # подтвердить удаление -# ``` -# -# 4. **Важные моменты**: -# - Файл остается в истории Git -# - Можно восстановить позже -# - Нужно коммитить удаление -# - Работает только с "чистыми" файлами -# -# 5. **Процесс удаления**: -# 1. `git rm file.txt` -# 2. Git индексирует удаление -# 3. Нужен коммит для завершения -# 4. Файл удаляется из рабочей копии - -# ### Переименование и перемещение файлов в Git -# -# 1. **Правильное переименование**: -# ```bash -# git mv старый.txt новый.txt -# git commit -m "Переименовал файл" -# ``` -# -# 2. **Перемещение файлов**: -# ```bash -# mkdir новая_папка -# git mv файл.txt новая_папка/файл.txt -# git commit -m "Переместил файл" -# ``` -# -# 3. **Комбинированные операции**: -# ```bash -# git mv старый_путь/старый.txt новый_путь/новый.txt -# git commit -m "Переместил и переименовал" -# ``` -# -# 4. **Чего НЕ делать**: -# - Не переименовывать через проводник -# - Не перемещать файлы вручную -# - Не забывать про коммит -# - Не игнорировать git mv -# -# 5. **Важные моменты**: -# - История файла сохраняется -# - Git отслеживает перемещения -# - Нужен коммит после операций -# - Можно комбинировать действия - -# ### Просмотр журнала коммитов (git log) -# -# 1. **Основные команды**: -# ```bash -# git log # полный журнал -# git log --oneline # сокращенный формат -# git log -n 3 # последние 3 коммита -# git show хеш:файл.txt # содержимое файла в коммите -# ``` -# -# 2. **Структура коммита**: -# - Хеш (40 символов) -# - Автор -# - Дата -# - Сообщение коммита -# -# 3. **Удобные опции**: -# - `--oneline`: краткий формат -# - `-n число`: ограничение количества -# - `q`: выход из просмотра -# - `↑` и `↓`: навигация по журналу -# -# 4. **Хеши коммитов**: -# - 40 символов (полный хеш) -# - Первые 7 символов (короткий) -# - Уникальные идентификаторы -# - Используются для возврата к версиям -# -# 5. **Важно знать**: -# - Журнал может быть длинным -# - Хеши уникальны -# - Можно использовать GUI клиенты -# - История сохраняется полностью - -# ### Просмотр журнала коммитов (git log) -# -# 1. **Базовый просмотр**: -# ```bash -# git log # полный журнал со всеми деталями -# ``` -# Показывает: -# - Полный хеш коммита -# - Автора и email -# - Дату и время -# - Сообщение коммита -# -# 2. **Сокращенный просмотр**: -# ```bash -# git log --oneline # краткий формат -# git log --oneline -n 3 # только последние 3 коммита -# ``` -# -# 3. **Просмотр содержимого**: -# ```bash -# git show хеш:файл.txt # содержимое файла в конкретном коммите -# ``` -# -# 4. **Навигация в журнале**: -# - `↑` и `↓`: прокрутка -# - `q`: выход из просмотра -# - `Space`: следующая страница -# -# 5. **Хеши коммитов**: -# - Полный: 40 символов (962a8baa29e452c74d40075d92b00897b02668fb) -# - Короткий: 7 символов (962a8ba) -# - Используются для идентификации коммитов -# - Нужны для возврата к предыдущим версиям - -# ### Отмена несохраненных изменений -# -# 1. **Основные команды**: -# ```bash -# git restore file.txt # отменить изменения в одном файле -# git checkout . # отменить все изменения во всех файлах -# ``` -# -# 2. **Важные моменты**: -# - Работает только для несохраненных изменений -# - Нельзя отменить restore -# - Возвращает к последнему коммиту -# - Будьте осторожны - изменения пропадут! -# -# 3. **Процесс отмены**: -# 1. Проверить статус (`git status`) -# 2. Убедиться, что файлы не в индексе -# 3. Использовать `git restore` -# 4. Проверить результат -# -# 4. **Когда использовать**: -# - Случайные изменения -# - Неудачный эксперимент -# - Возврат к чистой версии -# - До индексации файлов -# -# 5. **⚠️ Предупреждения**: -# - Отмена необратима -# - Проверяйте статус перед отменой -# - Сохраняйте важные изменения -# - Используйте с осторожностью - -# ### Деиндексирование файлов (unstage) -# -# 1. **Основная команда**: -# ```bash -# git restore --staged file.txt # убрать файл из индекса -# ``` -# -# 2. **Что происходит**: -# - Файл остается измененным -# - Убирается из индекса -# - Не попадет в следующий коммит -# - Статус меняется на "modified" -# -# 3. **Когда использовать**: -# - После случайного `git add` -# - При изменении планов -# - Перед новым коммитом -# - Для перегруппировки изменений -# -# 4. **Процесс**: -# 1. Файл изменен -# 2. `git add` (в индексе) -# 3. `git restore --staged` (из индекса) -# 4. Файл все еще изменен -# -# 5. **Важно помнить**: -# - Изменения в файле сохраняются -# - Можно снова добавить в индекс -# - Не влияет на сам файл -# - Только убирает из очереди на коммит - -# ### Отмена последних коммитов (git revert) -# -# 1. **Основная команда**: -# ```bash -# git revert -n HEAD~3..HEAD # отменить последние 3 коммита -# git add . # добавить изменения -# git commit -m "Отмена изменений" # сохранить отмену -# ``` -# -# 2. **Как это работает**: -# - Создает новый коммит -# - Отменяет указанные изменения -# - Сохраняет историю -# - Можно отменить отмену -# -# 3. **Пример истории**: -# ```bash -# faec20e (HEAD) Starting over from the plot twist -# de24642 Changed the setting to outer space -# 2be4163 Added a whacky sidekick -# 97c655e Renamed the detective to 'Snuggles' -# 8aa5222 Added an exciting plot twist -# ``` -# -# 4. **Важные моменты**: -# - Коммиты не удаляются -# - История сохраняется -# - Можно вернуться к любой версии -# - Безопасная операция -# -# 5. **Процесс отмены**: -# 1. Выбрать количество коммитов -# 2. Выполнить `git revert` -# 3. Добавить изменения -# 4. Создать коммит отмены - -# ### Возврат к определенной версии файла -# -# 1. **Просмотр старой версии**: -# ```bash -# git show хеш:файл.py # посмотреть содержимое -# ``` -# -# 2. **Восстановление файла**: -# ```bash -# git checkout хеш -- файл.py # вернуть к версии -# git add файл.py # добавить в индекс -# git commit -m "Откат к версии хеш" # сохранить -# ``` -# -# 3. **Пример истории**: -# ```bash -# d41e595 Rolled back eggs.py to 009b7c0 -# 895d220 Adding email support to cheese() -# df617da Renaming bacon() to cheese() -# ef1e4bb Refactoring bacon() -# 009b7c0 Adding better documentation to spam() -# ``` -# -# 4. **Важные моменты**: -# - Откат только одного файла -# - Остальные файлы не меняются -# - Создается новый коммит -# - История сохраняется -# -# 5. **Процесс отката**: -# 1. Найти нужный коммит -# 2. Проверить содержимое (`git show`) -# 3. Восстановить файл (`git checkout`) -# 4. Создать коммит с откатом - -# - -# ### Работа с конфиденциальными данными в Git -# -# 1. **Предотвращение утечек**: -# ```bash -# # .gitignore -# secrets.txt -# confidential.py -# *.key -# *.password -# ``` -# -# 2. **Если данные уже попали в репозиторий**: -# - Использовать `git filter-branch` -# - Или BFG Repo-Cleaner (рекомендуется) -# - Ссылка: https://help.github.com/en/articles/removing-sensitive-data-from-a-repository -# -# 3. **Правильный подход**: -# - Хранить секреты отдельно -# - Добавлять файлы в `.gitignore` -# - Использовать переменные окружения -# - Читать данные из внешних файлов -# -# 4. **Что НЕ делать**: -# - Не коммитить пароли -# - Не хранить ключи API -# - Не включать токены -# - Не добавлять личные данные -# -# 5. **Безопасные практики**: -# - Создавать `secrets.txt.example` -# - Использовать конфиг-файлы -# - Документировать процесс -# - Регулярно проверять историю - -# ### GitHub и публикация репозитория -# -# 1. **Что такое GitHub**: -# - Веб-сервис для Git репозиториев -# - Бесплатный хостинг кода -# - Платформа для совместной работы -# - Резервное копирование -# -# 2. **Создание репозитория на GitHub**: -# ```bash -# 1. Зайти на github.com -# 2. Нажать New Repository -# 3. Указать имя (например, wizcoin) -# 4. Добавить описание -# 5. Выбрать Public/Private -# 6. Create repository -# ``` -# -# 3. **Структура ссылок**: -# ``` -# https://github.com/username/repository -# # Пример: -# https://github.com/asweigart/wizcoin -# ``` -# -# 4. **Важные моменты**: -# - Git ≠ GitHub -# - Git = система контроля версий -# - GitHub = веб-сервис для Git -# - Можно работать оффлайн -# -# 5. **Преимущества GitHub**: -# - Совместная работа -# - Резервное копирование -# - Доступ из любого места -# - Публичное портфолио - -# ### Работа с GitHub репозиторием -# -# 1. **Отправка локального репозитория**: -# ```bash -# # Привязка удаленного репозитория -# git remote add origin https://github.com/username/repo.git -# -# # Первая отправка -# git push -u origin master -# -# # Последующие отправки -# git push -# ``` -# -# 2. **Клонирование с GitHub**: -# ```bash -# git clone https://github.com/username/repo.git -# ``` -# -# 3. **Важные моменты**: -# - Отправлять изменения регулярно -# - Проверять статус синхронизации -# - Использовать HTTPS или SSH -# - Хранить учетные данные безопасно -# -# 4. **Процесс работы**: -# 1. Создать репозиторий на GitHub -# 2. Привязать локальный репо -# 3. Отправить изменения -# 4. Регулярно синхронизировать -# -# 5. **Аварийное восстановление**: -# - Сохранить рабочие файлы -# - Удалить проблемный локальный репо -# - Заново клонировать с GitHub -# - Вернуть изменения - -# Оновные моменты: -# Git - это система контроля версий, которая позволяет: -# Отслеживать изменения в коде -# Возвращаться к предыдущим версиям -# Работать над проектом в команде -# -# Основные состояния файлов в Git: -# Неотслеживаемые (untracked) -# Отслеживаемые (tracked): -# Сохраненные (committed) -# Измененные (modified) -# Индексированные (staged) -# - -# # Основные команды Git: -# git init # создать новый репозиторий -# git add # добавить файлы для отслеживания -# git commit # сохранить изменения -# git status # проверить статус файлов -# git log # просмотреть историю коммитов -# git push # отправить изменения на GitHub - -# Для организации Python проектов рекомендуется: -# Использовать cookiecutter для создания структуры проекта -# Создавать отдельный репозиторий для каждого проекта -# Регулярно коммитить изменения -# Использовать .gitignore для исключения ненужных файлов -# GitHub позволяет: -# Хранить копию репозитория онлайн -# Делиться кодом с другими разработчиками -# Создавать резервные копии diff --git a/error_processing.ipynb b/error_processing.ipynb new file mode 100644 index 00000000..f8e0141b --- /dev/null +++ b/error_processing.ipynb @@ -0,0 +1,79 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "6354316e", + "metadata": {}, + "source": [ + "# Глава 1. Обработка ошибок (тезисно)\n", + "\n", + "## Основная идея\n", + "\n", + "* Обработка ошибок — это часть качества кода, а не внешнее дополнение.\n", + "* Чистый код делает ошибки понятными, предсказуемыми и удобными для обработки.\n", + "\n", + "## Используйте исключения, а не коды возврата\n", + "\n", + "* Коды возврата засоряют бизнес-логику.\n", + "* Исключения позволяют отделить нормальный поток выполнения от обработки ошибок.\n", + "* Код становится короче и читабельнее.\n", + "\n", + "## Не возвращайте `None` или `False` вместо ошибки\n", + "\n", + "* Скрытые ошибки приводят к трудноуловимым багам.\n", + "* Лучше явно выбрасывать исключение.\n", + "* Ошибка должна быть заметна сразу.\n", + "\n", + "## Создавайте собственные исключения\n", + "\n", + "* Именованные исключения лучше, чем общий `Exception`.\n", + "* Собственные исключения передают контекст ошибки.\n", + "* Упрощается отладка и логирование.\n", + "\n", + "## Не перехватывайте общие исключения без необходимости\n", + "\n", + "* `except Exception` скрывает реальные проблемы.\n", + "* Перехватывайте только те исключения, которые действительно можете обработать.\n", + "\n", + "## Сообщения об ошибках должны быть информативными\n", + "\n", + "* Сообщение должно объяснять, ЧТО произошло и ПОЧЕМУ.\n", + "* Избегайте пустых и абстрактных формулировок.\n", + "\n", + "## Не перегружайте код `try/except`\n", + "\n", + "* Блок `try` должен быть минимальным.\n", + "* Основную логику выносите в отдельные функции.\n", + "\n", + "## Не игнорируйте ошибки\n", + "\n", + "* Пустые `except` — плохая практика.\n", + "* Если ошибку нельзя обработать, её нужно пробросить выше.\n", + "\n", + "## `print` vs `logging`\n", + "\n", + "* `print` не подходит для продакшн-кода.\n", + "* Используйте `logging` с уровнями (`info`, `warning`, `error`).\n", + "\n", + "## Итог\n", + "\n", + "* Чистая обработка ошибок = надёжный и читаемый код.\n", + "* Ошибки должны быть явными, понятными и локализованными.\n", + "* Чем меньше хаотичных `try/except`, тем чище архитектура.\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "base", + "language": "python", + "name": "python3" + }, + "language_info": { + "name": "python", + "version": "3.13.5" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/error_processing.py b/error_processing.py new file mode 100644 index 00000000..742f7862 --- /dev/null +++ b/error_processing.py @@ -0,0 +1,69 @@ +# # Глава 1. Обработка ошибок (тезисно) +# +# ## Основная идея +# +# * Обработка ошибок — это часть качества кода, а не +# внешнее +# дополнение. +# * Чистый код делает ошибки понятными, предсказуемыми и +# удобными для обработки. +# +# ## Используйте исключения, а не коды возврата +# +# * Коды возврата засоряют бизнес-логику. +# * Исключения позволяют отделить нормальный поток выполнения +# от обработки ошибок. +# * Код становится короче и читабельнее. +# +# ## Не возвращайте `None` или `False` вместо ошибки +# +# * Скрытые ошибки приводят к трудноуловимым +# багам. +# * Лучше явно выбрасывать исключение. +# * Ошибка должна быть заметна сразу. +# +# ## Создавайте собственные исключения +# +# * Именованные исключения лучше, чем общий +# `Exception`. +# * Собственные исключения передают контекст +# ошибки. +# * Упрощается отладка и логирование. +# +# ## Не перехватывайте общие исключения без необходимости +# +# * `except Exception` скрывает реальные проблемы. +# * Перехватывайте только те исключения, которые действительно +# можете обработать. +# +# ## Сообщения об ошибках должны быть информативными +# +# * Сообщение должно объяснять, ЧТО произошло и +# ПОЧЕМУ. +# * Избегайте пустых и абстрактных +# формулировок. +# +# ## Не перегружайте код `try/except` +# +# * Блок `try` должен быть минимальным. +# * Основную логику выносите в отдельные +# функции. +# +# ## Не игнорируйте ошибки +# +# * Пустые `except` — плохая практика. +# * Если ошибку нельзя обработать, её нужно +# пробросить выше. +# +# ## `print` vs `logging` +# +# * `print` не подходит для продакшн-кода. +# * Используйте `logging` с уровнями +# (`info`, `warning`, `error`). +# +# ## Итог +# +# * Чистая обработка ошибок = надёжный и читаемый код. +# * Ошибки должны быть явными, понятными и локализованными. +# * Чем меньше хаотичных `try/except`, тем чище архитектура. +# diff --git a/lesson1.ipynb b/lesson1.ipynb new file mode 100644 index 00000000..3cd57b86 --- /dev/null +++ b/lesson1.ipynb @@ -0,0 +1,69 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "02fbf275", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'lesson1.ipynb.\\nКраткое описание: Урок 1 — вводный пример (сложение, переменные и т.д.).\\nАвтор: Otabek.'" + ] + }, + "execution_count": 1, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\"\"\"lesson1.ipynb.\n", + "Краткое описание: Урок 1 — вводный пример (сложение, переменные и т.д.).\n", + "Автор: Otabek.\"\"\"" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "d3564389", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "3" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "1 + 1 + 1" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/lesson1.py b/lesson1.py new file mode 100644 index 00000000..3af28e69 --- /dev/null +++ b/lesson1.py @@ -0,0 +1,10 @@ +# In[1]: +"""lesson1.ipynb. + +Краткое описание: Урок 1 — вводный пример (сложение, переменные и т.д.). Автор: Otabek. +""" + +# In[2]: + + +1 + 1 + 1 diff --git a/log.ipynb b/log.ipynb new file mode 100644 index 00000000..0e5ee2ee --- /dev/null +++ b/log.ipynb @@ -0,0 +1,37 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "id": "f6e917a5", + "metadata": {}, + "outputs": [], + "source": [ + "\"\"\"lesson1.ipynb.\n", + "Краткое описание: Урок 1 — вводный пример (сложение, переменные и т.д.).\n", + "Автор: Otabek.\"\"\"" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.11.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/log.py b/log.py new file mode 100644 index 00000000..29e5964b --- /dev/null +++ b/log.py @@ -0,0 +1,5 @@ +# In[ ]: +"""lesson1.ipynb. + +Краткое описание: Урок 1 — вводный пример (сложение, переменные и т.д.). Автор: Otabek. +""" diff --git a/makarov.chapter.2.ipynb b/makarov.chapter.2.ipynb new file mode 100644 index 00000000..6e66ee28 --- /dev/null +++ b/makarov.chapter.2.ipynb @@ -0,0 +1,644 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "cb18c30d", + "metadata": {}, + "source": [ + "## Типы данных в Питоне" + ] + }, + { + "cell_type": "markdown", + "id": "9520e699", + "metadata": {}, + "source": [ + "### Работа с числами" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "id": "857336db", + "metadata": {}, + "outputs": [], + "source": [ + "a = 25 # целое число (int)\n", + "b = 2.5 # число с плавающей точкой (float)\n", + "c = 3 + 25j # комплексное число (complex)" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "id": "fd86cf21", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2000.0\n", + "\n" + ] + } + ], + "source": [ + "# экспоненциальная запись, 2 умножить на 10 в степени 3\n", + "d = 2e3\n", + "print(d)\n", + "print(type(d))" + ] + }, + { + "cell_type": "markdown", + "id": "ff232361", + "metadata": {}, + "source": [ + "Арифметические операции" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "id": "9c42e549", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "4 2 4 2.0 8\n" + ] + } + ], + "source": [ + "# сложение, вычитание, умножение, деление, возведение в степень\n", + "print(2 + 2, 4 - 2, 2 * 2, 4 / 2, 2**3)" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "id": "b05fd3e5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3\n", + "1\n" + ] + } + ], + "source": [ + "# новая для нас операция: разделим 7 на 2, и найдем целую часть и остаток\n", + "\n", + "# целая часть\n", + "print(7 // 2)\n", + "\n", + "# остаток от деления\n", + "print(7 % 2)" + ] + }, + { + "cell_type": "markdown", + "id": "fb63bcca", + "metadata": {}, + "source": [ + "# Операторы сравнения" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "id": "0058c02b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True False True False\n" + ] + } + ], + "source": [ + "# больше, меньше, больше или равно и меньше или равно\n", + "print(4 > 2, 4 < 2, 4 >= 2, 4 <= 2)" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "id": "2d815606", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "False\n", + "True\n" + ] + } + ], + "source": [ + "# равенство\n", + "print(2 == 4)\n", + "\n", + "# и новый для нас оператор неравенства\n", + "print(2 != 4)" + ] + }, + { + "cell_type": "markdown", + "id": "ed1cb3d1", + "metadata": {}, + "source": [ + "### Логические операции" + ] + }, + { + "cell_type": "code", + "execution_count": 61, + "id": "efe006f2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "True\n", + "True\n", + "False\n" + ] + } + ], + "source": [ + "# логическое И, обе операции должны быть истинны\n", + "print(4 > 2 and 2 != 3)\n", + "\n", + "# логическое ИЛИ, хотя бы одна из операций должна быть истинна\n", + "print(4 < 2 or 2 == 2)\n", + "\n", + "# логическое НЕ, перевод истинного значения в ложное и наоборот\n", + "print(not (4 == 4))" + ] + }, + { + "cell_type": "markdown", + "id": "0b1fdca0", + "metadata": {}, + "source": [ + "#### Перевод чисел в другую систему счисления" + ] + }, + { + "cell_type": "code", + "execution_count": 62, + "id": "a54a7e65", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0b110110000000\n", + "3456\n" + ] + } + ], + "source": [ + "# создадим число в десятичной системе\n", + "d = 3456\n", + "\n", + "# переведем в двоичную (binary)\n", + "bin_d = bin(d)\n", + "print(bin_d)\n", + "\n", + "# переведем обратно в десятичную\n", + "print(int(bin_d, 2))" + ] + }, + { + "cell_type": "code", + "execution_count": 63, + "id": "e190e63b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0o31\n", + "25\n" + ] + } + ], + "source": [ + "# создадим число в десятичной системе\n", + "d = 25\n", + "\n", + "# переведем в восьмеричную (octal)\n", + "oct_d = oct(d)\n", + "print(oct_d)\n", + "\n", + "# переведем обратно в десятичную\n", + "print(int(oct_d, 8))" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "id": "46f5049d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0x19\n", + "25\n" + ] + } + ], + "source": [ + "# создадим число в десятичной системе\n", + "d = 25\n", + "\n", + "# переведем в шестандцатеричную (hexadecimal)\n", + "hex_d = hex(d)\n", + "print(hex_d)\n", + "\n", + "# переведем обратно в десятичную\n", + "print(int(hex_d, 16))" + ] + }, + { + "cell_type": "markdown", + "id": "7f300fad", + "metadata": {}, + "source": [ + "### Строковые данные" + ] + }, + { + "cell_type": "code", + "execution_count": 65, + "id": "f12affcf", + "metadata": {}, + "outputs": [], + "source": [ + "string_1 = \"это строка\"\n", + "string_2 = \"это тоже строка\"" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "id": "38d15cf4", + "metadata": {}, + "outputs": [], + "source": [ + "multi_string = \"\"\"Мы все учились понемногу\n", + "Чему-нибудь и как-нибудь,\n", + "Так воспитаньем, слава богу,\n", + "У нас немудрено блеснуть.\"\"\"" + ] + }, + { + "cell_type": "markdown", + "id": "2ca7f5cf", + "metadata": {}, + "source": [ + "Объединение строк" + ] + }, + { + "cell_type": "code", + "execution_count": 67, + "id": "f9176142", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'Программирование на Питоне'" + ] + }, + "execution_count": 67, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# создадим три строки\n", + "a, b, c = \"Программирование\", \"на\", \"Питоне\"\n", + "\n", + "# соединим с помощью + и добавим пробелы ' '\n", + "a + \" \" + b + \" \" + c" + ] + }, + { + "cell_type": "markdown", + "id": "c1b23439", + "metadata": {}, + "source": [ + "Индекс символа в строке" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "id": "8eb36c98", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "М\n", + "ы\n", + " \n", + "в\n", + "с\n", + "е\n", + " \n", + "у\n", + "ч\n", + "и\n", + "л\n", + "и\n", + "с\n", + "ь\n" + ] + } + ], + "source": [ + "# выведем первый элемент строки multi_string\n", + "print(multi_string[0])\n", + "\n", + "# теперь выведем последний элемент\n", + "print(multi_string[1])\n", + "\n", + "print(multi_string[2])\n", + "\n", + "print(multi_string[3])\n", + "print(multi_string[4])\n", + "print(multi_string[5])\n", + "print(multi_string[6])\n", + "print(multi_string[7])\n", + "print(multi_string[8])\n", + "print(multi_string[9])\n", + "print(multi_string[10])\n", + "print(multi_string[11])\n", + "print(multi_string[12])\n", + "print(multi_string[13])" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "id": "6965fc6a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "все\n" + ] + } + ], + "source": [ + "# выберем элементы с четвертого по шестой\n", + "print(multi_string[3:6])" + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "id": "34b8656b", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Мы\n", + "все учились понемногу\n", + "Чему-нибудь и как-нибудь,\n", + "Так воспитаньем, слава богу,\n", + "У нас немудрено блеснуть.\n" + ] + } + ], + "source": [ + "# выведем все элементы вплоть до второго\n", + "print(multi_string[:2])\n", + "\n", + "# а также все элементы, начиная с четвертого\n", + "print(multi_string[3:])" + ] + }, + { + "cell_type": "markdown", + "id": "fb7718c5", + "metadata": {}, + "source": [ + "Циклы в строках" + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "id": "6a4d765f", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "п\n", + "и\n", + "т\n", + "о\n", + "н\n" + ] + } + ], + "source": [ + "# выведем буквы в слове Питон\n", + "for i in \"питон\":\n", + " print(i)" + ] + }, + { + "cell_type": "markdown", + "id": "940673dc", + "metadata": {}, + "source": [ + "Методы .strip() и .split()" + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "id": "98d2c811", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "15 849 302\n", + "15 849 302\n" + ] + } + ], + "source": [ + "# применим метод .strip(), чтобы удалить *\n", + "print(\"***15 849 302*****\".strip(\"*\"))\n", + "\n", + "# если ничего не указать в качестве аргумента, то удаляются пробелы по краям строки\n", + "print(\" 15 849 302 \".strip())" + ] + }, + { + "cell_type": "code", + "execution_count": 73, + "id": "4772a0a7", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "['Мы', 'все', 'учились', 'понемногу', 'Чему-нибудь', 'и', 'как-нибудь,', 'Так', 'воспитаньем,', 'слава', 'богу,', 'У', 'нас', 'немудрено', 'блеснуть.']\n" + ] + } + ], + "source": [ + "# применим метод .split(), чтобы разделить строку на части\n", + "print(multi_string.split())" + ] + }, + { + "cell_type": "code", + "execution_count": 74, + "id": "27d0ec76", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "15" + ] + }, + "execution_count": 74, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# посчитаем количество слов в тексте (длину списка)\n", + "len(multi_string.split())" + ] + }, + { + "cell_type": "markdown", + "id": "3952ac73", + "metadata": {}, + "source": [ + "Замена символа в строке" + ] + }, + { + "cell_type": "code", + "execution_count": 75, + "id": "10066017", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "20.25\n", + "\n" + ] + } + ], + "source": [ + "# предположим данные содержатся вот в таком формате\n", + "data = \"20,25\"\n", + "\n", + "# теперь заменим ',' на '.'\n", + "data = data.replace(\",\", \".\")\n", + "\n", + "# и преобразуем в число\n", + "data = float(data)\n", + "print(data)\n", + "print(type(data))" + ] + }, + { + "cell_type": "markdown", + "id": "8d26604a", + "metadata": {}, + "source": [ + "### Логические значения" + ] + }, + { + "cell_type": "code", + "execution_count": 76, + "id": "b45ba014", + "metadata": {}, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'var' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[76], line 4\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;66;03m# напишем небольшую программу, которая будет показывать,\u001b[39;00m\n\u001b[1;32m 2\u001b[0m \u001b[38;5;66;03m# какое значение содержится в переменной var\u001b[39;00m\n\u001b[0;32m----> 4\u001b[0m \u001b[38;5;28;01mif\u001b[39;00m \u001b[43mvar\u001b[49m \u001b[38;5;241m==\u001b[39m \u001b[38;5;28;01mTrue\u001b[39;00m:\n\u001b[1;32m 5\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;124m'\u001b[39m\u001b[38;5;124mЗначение переменной истинно\u001b[39m\u001b[38;5;124m'\u001b[39m)\n\u001b[1;32m 6\u001b[0m \u001b[38;5;28;01melse\u001b[39;00m:\n", + "\u001b[0;31mNameError\u001b[0m: name 'var' is not defined" + ] + } + ], + "source": [ + "# напишем небольшую программу, которая будет показывать,\n", + "# какое значение содержится в переменной var\n", + "\n", + "if var == True:\n", + " print(\"Значение переменной истинно\")\n", + "else:\n", + " print(\"Значение переменной ложно\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.1" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/makarov.chapter.2.py b/makarov.chapter.2.py new file mode 100644 index 00000000..dc532b88 --- /dev/null +++ b/makarov.chapter.2.py @@ -0,0 +1,192 @@ +# ## Типы данных в Питоне + +# ### Работа с числами + +a = 25 # целое число (int) +b = 2.5 # число с плавающей точкой (float) +c = 3 + 25j # комплексное число (complex) + +# экспоненциальная запись, 2 умножить на 10 в степени 3 +d = 2e3 +print(d) +print(type(d)) + +# Арифметические операции + +# сложение, вычитание, умножение, деление, возведение в степень +print(2 + 2, 4 - 2, 2 * 2, 4 / 2, 2**3) + +# + +# новая для нас операция: разделим 7 на 2, и найдем целую часть и остаток + +# целая часть +print(7 // 2) + +# остаток от деления +print(7 % 2) +# - + +# # Операторы сравнения + +# больше, меньше, больше или равно и меньше или равно +print(4 > 2, 4 < 2, 4 >= 2, 4 <= 2) + +# + +# равенство +print(2 == 4) + +# и новый для нас оператор неравенства +print(2 != 4) +# - + +# ### Логические операции + +# + +# логическое И, обе операции должны быть истинны +print(4 > 2 and 2 != 3) + +# логическое ИЛИ, хотя бы одна из операций должна быть истинна +print(4 < 2 or 2 == 2) + +# логическое НЕ, перевод истинного значения в ложное и наоборот +print(not (4 == 4)) +# - + +# #### Перевод чисел в другую систему счисления + +# + +# создадим число в десятичной системе +d = 3456 + +# переведем в двоичную (binary) +bin_d = bin(d) +print(bin_d) + +# переведем обратно в десятичную +print(int(bin_d, 2)) + +# + +# создадим число в десятичной системе +d = 25 + +# переведем в восьмеричную (octal) +oct_d = oct(d) +print(oct_d) + +# переведем обратно в десятичную +print(int(oct_d, 8)) + +# + +# создадим число в десятичной системе +d = 25 + +# переведем в шестандцатеричную (hexadecimal) +hex_d = hex(d) +print(hex_d) + +# переведем обратно в десятичную +print(int(hex_d, 16)) +# - + +# ### Строковые данные + +string_1 = "это строка" +string_2 = "это тоже строка" + +multi_string = """Мы все учились понемногу +Чему-нибудь и как-нибудь, +Так воспитаньем, слава богу, +У нас немудрено блеснуть.""" + +# Объединение строк + +# + +# создадим три строки +a, b, c = "Программирование", "на", "Питоне" + +# соединим с помощью + и добавим пробелы ' ' +a + " " + b + " " + c +# - + +# Индекс символа в строке + +# + +# выведем первый элемент строки multi_string +print(multi_string[0]) + +# теперь выведем последний элемент +print(multi_string[1]) + +print(multi_string[2]) + +print(multi_string[3]) +print(multi_string[4]) +print(multi_string[5]) +print(multi_string[6]) +print(multi_string[7]) +print(multi_string[8]) +print(multi_string[9]) +print(multi_string[10]) +print(multi_string[11]) +print(multi_string[12]) +print(multi_string[13]) +# - + +# выберем элементы с четвертого по шестой +print(multi_string[3:6]) + +# + +# выведем все элементы вплоть до второго +print(multi_string[:2]) + +# а также все элементы, начиная с четвертого +print(multi_string[3:]) +# - + +# Циклы в строках + +# выведем буквы в слове Питон +for i in "питон": + print(i) + +# Методы .strip() и .split() + +# + +# применим метод .strip(), чтобы удалить * +print("***15 849 302*****".strip("*")) + +# если ничего не указать в качестве аргумента, то удаляются пробелы по краям строки +print(" 15 849 302 ".strip()) +# - + +# применим метод .split(), чтобы разделить строку на части +print(multi_string.split()) + +# посчитаем количество слов в тексте (длину списка) +len(multi_string.split()) + +# Замена символа в строке + +# + +# предположим данные содержатся вот в таком формате +data = "20,25" + +# теперь заменим ',' на '.' +data = data.replace(",", ".") + +# и преобразуем в число +data = float(data) +print(data) +print(type(data)) +# - + +# ### Логические значения + +# + +# напишем небольшую программу, которая будет показывать, +# какое значение содержится в переменной var + +if var == True: + print("Значение переменной истинно") +else: + print("Значение переменной ложно") diff --git a/makarov.chapter.4.ipynb b/makarov.chapter.4.ipynb new file mode 100644 index 00000000..67dcebcd --- /dev/null +++ b/makarov.chapter.4.ipynb @@ -0,0 +1,356 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "3144936c", + "metadata": {}, + "source": [ + "## Работа с файлами в Google Colab" + ] + }, + { + "cell_type": "markdown", + "id": "daa8316c", + "metadata": {}, + "source": [ + "### Этап 1. Подгрузка файлов" + ] + }, + { + "cell_type": "markdown", + "id": "4da26829", + "metadata": {}, + "source": [ + "Способ 1. Вручную через вкладку 'Файлы'\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "id": "ab22ddd5", + "metadata": { + "vscode": { + "languageId": "plaintext" + } + }, + "source": [ + "Способ 2. Через модуль files библиотеки google.colab" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "de3a41ff", + "metadata": {}, + "outputs": [], + "source": [ + "# импортируем модль os\n", + "import os\n", + "\n", + "# импортируем библиотеку\n", + "import pandas as pd\n", + "\n", + "# из google.colab import files\n", + "from google.colab import files" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ad861cca", + "metadata": {}, + "outputs": [], + "source": [ + "# создаем объект этого клласа, применяем метод .upload()\n", + "uploaded = files.upload()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "8629780d", + "metadata": {}, + "outputs": [], + "source": [ + "# посмотрим на содержимое словаря uploaded\n", + "# uploaded" + ] + }, + { + "cell_type": "markdown", + "id": "90d80dc4", + "metadata": {}, + "source": [ + "### Этап 2. Чтение файлов" + ] + }, + { + "cell_type": "markdown", + "id": "b0562ad7", + "metadata": {}, + "source": [ + "### просмотр содержимого папки/content/" + ] + }, + { + "cell_type": "markdown", + "id": "3bdff2e8", + "metadata": {}, + "source": [ + "#### модуль os и метод .walk()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "e7c18e06", + "metadata": {}, + "outputs": [], + "source": [ + "# выводим пути к папкам (dirpath) и на именования файлов (filenames) и послеэтого\n", + "for dirpath, _, filenames in os.walk(\"/content\"):\n", + " print(f\"В папке {dirpath} находятся файлы: {filenames}\")" + ] + }, + { + "cell_type": "markdown", + "id": "337f8224", + "metadata": {}, + "source": [ + "##### Команда `!ls`" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5d7578fc", + "metadata": {}, + "outputs": [], + "source": [ + "# посмотрим на содержимое папки content\n", + "!ls" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "5fceb1d9", + "metadata": {}, + "outputs": [], + "source": [ + "# заглянем внутрь sample_data\n", + "!ls /content/sample_data/" + ] + }, + { + "cell_type": "markdown", + "id": "8f7ef78e", + "metadata": {}, + "source": [ + "#### Чтение из переменной uploaded" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3f0674df", + "metadata": {}, + "outputs": [], + "source": [ + "# посмотрим на тип значений словаря uploaded\n", + "type(uploaded[\"test.csv\"])" + ] + }, + { + "cell_type": "markdown", + "id": "16f901b9", + "metadata": {}, + "source": [ + "Пример работы с объектом bytes" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "1b77b48f", + "metadata": {}, + "outputs": [], + "source": [ + "# обратимся к ключу словаря uploaded и применим метод .decode()\n", + "uploaded_str = uploaded[\"test.csv\"].decode()\n", + "\n", + "# на выходе получаем обычную строку\n", + "print(type(uploaded_str))" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "bbc0c04f", + "metadata": {}, + "outputs": [], + "source": [ + "# выведем первые 35 значений\n", + "print(uploaded_str[:35])" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "79173dac", + "metadata": {}, + "outputs": [], + "source": [ + "# если разбить строку методом .split() по символам \\r (возврат к началу строки) и \\n (новая строка)\n", + "uploaded_list = uploaded_str.split(\"\\r\\n\")\n", + "\n", + "# на выходе мы получим список\n", + "type(uploaded_list)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "19d2a7c4", + "metadata": {}, + "outputs": [], + "source": [ + "# пройдемся по этому списку, не забыв создать индекс с помощью функции enumerate()\n", + "for i, line in enumerate(uploaded_list):\n", + "\n", + " # начнем выводить записи\n", + " print(line)\n", + "\n", + " # когда дойдем до четвертой строки\n", + " if i == 3:\n", + "\n", + " # прервемся\n", + " break" + ] + }, + { + "cell_type": "markdown", + "id": "d7fbd2e8", + "metadata": {}, + "source": [ + "#### Использование функции open() и конструкции with open()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4a22103f", + "metadata": {}, + "outputs": [], + "source": [ + "# передадим функции open() адрес файла\n", + "# параметр 'r' означает, что мы хотим прочитать (read) файл\n", + "f1 = open(\"/content/train.csv\")\n", + "\n", + "# метод .read() помещает весь файл в одну строку\n", + "# выведем первые 142 символа (если параметр не указывать, выведется все содержимое)\n", + "print(f1.read(142))\n", + "\n", + "# в конце файл необходимо закрыть\n", + "f1.close()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d47dde77", + "metadata": {}, + "outputs": [], + "source": [ + "# снова откроем файл\n", + "f2 = open(\"/content/train.csv\")\n", + "\n", + "# пройдемся по нашему объекту в цикле for и параллельно создадим индекс\n", + "for i, line in enumerate(f2):\n", + "\n", + " # выведем строки без служебных символов по краям\n", + " print(line.strip())\n", + "\n", + " # дойдя до четвертой строки, прервемся\n", + " if i == 3:\n", + " break\n", + "\n", + "# не забудем закрыть файл\n", + "f2.close()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "11fddb70", + "metadata": {}, + "outputs": [], + "source": [ + "# скажем Питону: \"открой файл и назови его f3\"\n", + "with open(\"/content/test.csv\") as f3:\n", + "\n", + " # \"пройдись по строкам без служебных символов\"\n", + " for i, line in enumerate(f3):\n", + " print(line.strip())\n", + "\n", + " # и \"прервись на четвертой строке\"\n", + " if i == 3:\n", + " break" + ] + }, + { + "cell_type": "markdown", + "id": "7d6aef9d", + "metadata": {}, + "source": [ + "### Чтение через библиотеку Pandas" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "0e006c5d", + "metadata": {}, + "outputs": [], + "source": [ + "# применим функцию read_csv() и первый три записи файла train.csv\n", + "traun = pd.read_csv(\"/content/train.csv\")\n", + "train.head(3)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "44919398", + "metadata": {}, + "outputs": [], + "source": [ + "# сделаем то же самое с файлом test.csv\n", + "test = pd.read_csv(\"/content/test.csv\")\n", + "test.head(3)" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.1" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} \ No newline at end of file diff --git a/makarov.chapter.4.py b/makarov.chapter.4.py new file mode 100644 index 00000000..2229ffd6 --- /dev/null +++ b/makarov.chapter.4.py @@ -0,0 +1,139 @@ +# ## Работа с файлами в Google Colab + +# ### Этап 1. Подгрузка файлов + +# Способ 1. Вручную через вкладку 'Файлы' +# +# +# + +# Способ 2. Через модуль files библиотеки google.colab + +# + +# импортируем модль os +import os + +# импортируем библиотеку +import pandas as pd + +# из google.colab import files +from google.colab import files + +# - + +# создаем объект этого клласа, применяем метод .upload() +uploaded = files.upload() + +# + +# посмотрим на содержимое словаря uploaded +# uploaded +# - + +# ### Этап 2. Чтение файлов + +# ### просмотр содержимого папки/content/ + +# #### модуль os и метод .walk() + +# выводим пути к папкам (dirpath) и на именования файлов (filenames) и послеэтого +for dirpath, _, filenames in os.walk("/content"): + print(f"В папке {dirpath} находятся файлы: {filenames}") + +# ##### Команда `!ls` + +# посмотрим на содержимое папки content +# !ls + +# заглянем внутрь sample_data +# !ls /content/sample_data/ + +# #### Чтение из переменной uploaded + +# посмотрим на тип значений словаря uploaded +type(uploaded["test.csv"]) + +# Пример работы с объектом bytes + +# + +# обратимся к ключу словаря uploaded и применим метод .decode() +uploaded_str = uploaded["test.csv"].decode() + +# на выходе получаем обычную строку +print(type(uploaded_str)) +# - + +# выведем первые 35 значений +print(uploaded_str[:35]) + +# + +# если разбить строку методом .split() по символам \r (возврат к началу строки) и \n (новая строка) +uploaded_list = uploaded_str.split("\r\n") + +# на выходе мы получим список +type(uploaded_list) +# - + +# пройдемся по этому списку, не забыв создать индекс с помощью функции enumerate() +for i, line in enumerate(uploaded_list): + + # начнем выводить записи + print(line) + + # когда дойдем до четвертой строки + if i == 3: + + # прервемся + break + +# #### Использование функции open() и конструкции with open() + +# + +# передадим функции open() адрес файла +# параметр 'r' означает, что мы хотим прочитать (read) файл +f1 = open("/content/train.csv") + +# метод .read() помещает весь файл в одну строку +# выведем первые 142 символа (если параметр не указывать, выведется все содержимое) +print(f1.read(142)) + +# в конце файл необходимо закрыть +f1.close() + +# + +# снова откроем файл +f2 = open("/content/train.csv") + +# пройдемся по нашему объекту в цикле for и параллельно создадим индекс +for i, line in enumerate(f2): + + # выведем строки без служебных символов по краям + print(line.strip()) + + # дойдя до четвертой строки, прервемся + if i == 3: + break + +# не забудем закрыть файл +f2.close() +# - + +# скажем Питону: "открой файл и назови его f3" +with open("/content/test.csv") as f3: + + # "пройдись по строкам без служебных символов" + for i, line in enumerate(f3): + print(line.strip()) + + # и "прервись на четвертой строке" + if i == 3: + break + +# ### Чтение через библиотеку Pandas + +# применим функцию read_csv() и первый три записи файла train.csv +traun = pd.read_csv("/content/train.csv") +train.head(3) + +# сделаем то же самое с файлом test.csv +test = pd.read_csv("/content/test.csv") +test.head(3) diff --git a/makarov.chapter.5.ipynb b/makarov.chapter.5.ipynb new file mode 100644 index 00000000..cd6e3ce2 --- /dev/null +++ b/makarov.chapter.5.ipynb @@ -0,0 +1,109 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "970a65cd", + "metadata": {}, + "source": [ + "## Дата и время в Питоне" + ] + }, + { + "cell_type": "markdown", + "id": "854ca8e4", + "metadata": {}, + "source": [ + "### Модуль datetime" + ] + }, + { + "cell_type": "markdown", + "id": "0b7e2916", + "metadata": {}, + "source": [ + "Импорт модуля и класса datetime" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "0ebd737d", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-01-22 16:49:46.786470\n" + ] + } + ], + "source": [ + "# импортируем весь модуль\n", + "import datetime\n", + "\n", + "# часто из модуля datetime удобнее импортировать только класс datetime\n", + "from datetime import datetime\n", + "\n", + "# чтобы получить доступ к функции now(), сначала обратимся к модулю, потом к классу\n", + "print(datetime.datetime.now())" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "2b07425c", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2026-01-22 16:50:33.441516\n" + ] + } + ], + "source": [ + "# и обращаться непосредственно к нему\n", + "print(datetime.now())" + ] + }, + { + "cell_type": "markdown", + "id": "0913625e", + "metadata": {}, + "source": [ + "Объект datetime и функция `now()`" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "ecf8668d", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "base", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.5" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/makarov.chapter.5.py b/makarov.chapter.5.py new file mode 100644 index 00000000..f0d28436 --- /dev/null +++ b/makarov.chapter.5.py @@ -0,0 +1,21 @@ +# ## Дата и время в Питоне + +# ### Модуль datetime + +# Импорт модуля и класса datetime + +# + +# импортируем весь модуль +import datetime + +# часто из модуля datetime удобнее импортировать только класс datetime +from datetime import datetime + +# чтобы получить доступ к функции now(), сначала обратимся к модулю, потом к классу +print(datetime.datetime.now()) +# - + +# и обращаться непосредственно к нему +print(datetime.now()) + +# Объект datetime и функция `now()` diff --git a/makarov.chapter.6.ipynb b/makarov.chapter.6.ipynb new file mode 100644 index 00000000..02a69b39 --- /dev/null +++ b/makarov.chapter.6.ipynb @@ -0,0 +1,52 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "19d8655e", + "metadata": {}, + "source": [ + "1. Объявление класса\n", + "Класс создается с помощью ключевого слова class, а его название записывается в стиле CamelCase.\n", + "class Person:\n", + " # Описание чертежа будущего объекта\n", + " pass\n", + "2. Работа с атрибутами класса\n", + "Даже если класс пустой, он сам по себе является объектом и имеет встроенные («магические») свойства.\n", + "# Получение имени класса через магическое свойство __name__\n", + "print(Person.__name__) # Выведет: 'Person' [2]\n", + "\n", + "# Просмотр всех доступных атрибутов и методов класса\n", + "print(dir(Person)) [2]\n", + "3. Создание экземпляров (объектов) класса\n", + "Чтобы создать объект, нужно «вызвать» класс как функцию. Объекты, созданные на основе одного класса, имеют одинаковый набор характеристик, но разные состояния.\n", + "# Создание экземпляра класса Person\n", + "p = Person() [2]\n", + "\n", + "# Проверка типа объекта\n", + "print(type(p)) # Возвращает сам класс как объект [2]\n", + "4. Динамическое создание объекта и сравнение\n", + "Вы можете создать новый экземпляр того же типа, используя функцию type() от уже существующего объекта.\n", + "# Создание нового экземпляра того же типа, что и объект p\n", + "new_person = type(p)() [2]\n", + "\n", + "# Сравнение идентификаторов (ID) двух разных объектов\n", + "print(id(p))\n", + "print(id(new_person)) \n", + "\n", + "# Это разные объекты в памяти, несмотря на то что они одного класса [4]\n", + "Ключевые моменты из источников:\n", + "• Объект — это выделенная оперативная память для хранения значений и связанных с ними операций.\n", + "• Класс — это «чертеж» или описание, по которому Python создает объекты в памяти.\n", + "• Доступ к свойствам и методам объекта осуществляется через точку (dot notation).\n", + "• В Python абсолютно всё (включая сами классы, функции и модули) является объектами." + ] + } + ], + "metadata": { + "language_info": { + "name": "python" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/makarov.chapter.6.py b/makarov.chapter.6.py new file mode 100644 index 00000000..f21477cf --- /dev/null +++ b/makarov.chapter.6.py @@ -0,0 +1,34 @@ +# 1. Объявление класса +# Класс создается с помощью ключевого слова class, а его название записывается в стиле CamelCase. +# class Person: +# # Описание чертежа будущего объекта +# pass +# 2. Работа с атрибутами класса +# Даже если класс пустой, он сам по себе является объектом и имеет встроенные («магические») свойства. +# # Получение имени класса через магическое свойство __name__ +# print(Person.__name__) # Выведет: 'Person' [2] +# +# # Просмотр всех доступных атрибутов и методов класса +# print(dir(Person)) [2] +# 3. Создание экземпляров (объектов) класса +# Чтобы создать объект, нужно «вызвать» класс как функцию. Объекты, созданные на основе одного класса, имеют одинаковый набор характеристик, но разные состояния. +# # Создание экземпляра класса Person +# p = Person() [2] +# +# # Проверка типа объекта +# print(type(p)) # Возвращает сам класс как объект [2] +# 4. Динамическое создание объекта и сравнение +# Вы можете создать новый экземпляр того же типа, используя функцию type() от уже существующего объекта. +# # Создание нового экземпляра того же типа, что и объект p +# new_person = type(p)() [2] +# +# # Сравнение идентификаторов (ID) двух разных объектов +# print(id(p)) +# print(id(new_person)) +# +# # Это разные объекты в памяти, несмотря на то что они одного класса [4] +# Ключевые моменты из источников: +# • Объект — это выделенная оперативная память для хранения значений и связанных с ними операций. +# • Класс — это «чертеж» или описание, по которому Python создает объекты в памяти. +# • Доступ к свойствам и методам объекта осуществляется через точку (dot notation). +# • В Python абсолютно всё (включая сами классы, функции и модули) является объектами. diff --git a/makarov.chapter3.ipynb b/makarov.chapter3.ipynb new file mode 100644 index 00000000..ceede8d0 --- /dev/null +++ b/makarov.chapter3.ipynb @@ -0,0 +1,1491 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "D4hEPtRhhMqh" + }, + "source": [ + "## Условия и циклы. Продолжение" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "-vawFsPhhRgI" + }, + "source": [ + "### Еще раз про условия с if" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "rWIA_xr5Cq6K" + }, + "source": [ + "Множественные условия (multi-way decisions)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "KCMYjV0Cg3Zx", + "outputId": "2d3c5d62-2e77-4b09-c5fc-8a1a7471198a" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Medium\n" + ] + } + ], + "source": [ + "# напишем программу, которая разобьет все числа на малые, средние и большие\n", + "# импортируем библиотеку numpy\n", + "import numpy as np\n", + "\n", + "x = 42 # зададим число\n", + "\n", + "# и пропишем условия (не забывайте про двоеточие и отступ)\n", + "if x < 10:\n", + " print(\"Small\")\n", + "elif x < 100:\n", + " print(\"Medium\")\n", + "else:\n", + " print(\"Large\")" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Jik8GB36UWgh", + "outputId": "abb6e9a2-7d04-4a63-d59b-1312b36144e3" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Small\n" + ] + } + ], + "source": [ + "# запросим число у пользователя\n", + "x = input(\"Введите число: \")\n", + "\n", + "# преобразуем в тип int\n", + "x = int(x)\n", + "\n", + "# и наконец классифицируем\n", + "if x < 10:\n", + " print(\"Small\")\n", + "elif x < 100:\n", + " print(\"Medium\")\n", + "else:\n", + " print(\"Large\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "7i-2ADtRCv-Z" + }, + "source": [ + "Вложенные условия (nested decisions)" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "G45V7GOfUoKw", + "outputId": "51061495-88b6-499c-b263-95edd749b950" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Ввод пустой\n" + ] + } + ], + "source": [ + "# запрашиваем число\n", + "y = input(\"Введите число: \")\n", + "\n", + "# проверяем первое условие (не пустая ли строка), если оно выполняется\n", + "if len(y) != 0:\n", + "\n", + " # преобразуем в тип int\n", + " y = int(y)\n", + "\n", + " # и классифицируем\n", + " if x < 10:\n", + " print(\"Small\")\n", + " elif x < 100:\n", + " print(\"Medium\")\n", + " else:\n", + " print(\"Large\")\n", + "\n", + "# в противном, говорим, что ввод пустой\n", + "else:\n", + " print(\"Ввод пустой\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "M72PQIj48Igc" + }, + "source": [ + "Несколько условий в одном выражении с операторами and или or" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "ktlZYzKDE8Vr", + "outputId": "5b8ff016-c384-4023-a6c6-70202508f021" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Medium\n" + ] + } + ], + "source": [ + "# пример с and (логическим И)\n", + "z = 42\n", + "\n", + "# если z больше 10 и одновременно меньше 100\n", + "if z > 10 and z < 100:\n", + "\n", + " # у нас среднее число\n", + " print(\"Medium\")\n", + "\n", + "# в противном случае оно либо маленькое либо большое\n", + "else:\n", + " print(\"Small or Large\")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "BfUvmSq5E3m9", + "outputId": "1113ad79-e15d-4187-b635-3e091b070a59" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Small or Large\n" + ] + } + ], + "source": [ + "# пример с or (логическим ИЛИ)\n", + "z = 2\n", + "\n", + "# если z меньше 10 или больше 100\n", + "if z < 10 or z > 100:\n", + "\n", + " # оно либо маленькое либо большое\n", + " print(\"Small or Large\")\n", + "\n", + "# в противном случае оно среднее\n", + "else:\n", + " print(\"Medium\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "EGZZNNr-9Fn-" + }, + "source": [ + "Проверка вхождения элемента в объект с in / not in" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "LOpo6gje9Q-C", + "outputId": "a5c228ea-5f37-4907-dcdf-0eb6ee1140f3" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Слово найдено\n" + ] + } + ], + "source": [ + "# можно проверить вхождение слова в строку\n", + "sentence = \"To be, or not to be, that is the question\"\n", + "word = \"question\"\n", + "\n", + "if word in sentence:\n", + " print(\"Слово найдено\")" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "mHq-uEI4K2AI", + "outputId": "196d6df3-3d03-4edb-83af-7576dc68e844" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Такого числа в списке нет\n" + ] + } + ], + "source": [ + "# или отсутствие элемента в списке\n", + "number_list = [2, 3, 4, 6, 7]\n", + "number = 5\n", + "\n", + "if number not in number_list:\n", + " print(\"Такого числа в списке нет\")" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": { + "id": "gWjobfPGNzwg" + }, + "outputs": [], + "source": [ + "# кроме того, можно проверить вхождение ключа и значения в словарь\n", + "\n", + "# возьмем очень простой словарь\n", + "d = {\"apple\": 3, \"tomato\": 6, \"carrot\": 2}" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Z92L7WSTPF-P", + "outputId": "5306ceb6-18a2-4af0-aeb8-317444a088de" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Нашлись\n" + ] + } + ], + "source": [ + "# вначале поищем яблоки среди ключей словаря\n", + "if \"apple\" in d:\n", + " print(\"Нашлись\")" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "YhUXxjsUPTl2", + "outputId": "4c62a3e8-6b70-48c5-d79d-9df71d26809c" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Есть\n" + ] + } + ], + "source": [ + "# а затем посмотрим, нет ли числа 6 среди его значений\n", + "# с помощью метода .values()\n", + "if 6 in d.values():\n", + " print(\"Есть\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "fsCZohlkYH7k" + }, + "source": [ + "### Циклы в Питоне" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "z7-hyiTDYOv8" + }, + "source": [ + "#### Цикл for" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "SOp17Yl-fWhG" + }, + "source": [ + "##### Основные операции" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "A3GWvb12a6Ra", + "outputId": "c07c70f8-82e6-41b8-db48-1b5980e8ef35" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1\n", + "2\n", + "3\n" + ] + } + ], + "source": [ + "# поочередно выведем элементы списка\n", + "number_list = [1, 2, 3]\n", + "\n", + "# не забывая про двоеточие и отступ\n", + "for number in number_list:\n", + " print(number)" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "id": "nIrD5ArAb8ih" + }, + "outputs": [], + "source": [ + "# создадим словарь, значениями которого будут списки из двух элементов\n", + "d = {\"apple\": [3, \"kg\"], \"tomato\": [6, \"pcs\"], \"carrot\": [2, \"kg\"]}" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "QD9h9pplgDVI", + "outputId": "f20d59a5-5ab5-4af9-c7ae-ebd1b3549141" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "apple [3, 'kg']\n", + "tomato [6, 'pcs']\n", + "carrot [2, 'kg']\n" + ] + } + ], + "source": [ + "# затем создадим две переменные-контейнера и применим метод .items()\n", + "for k, v in d.items():\n", + " print(k, v)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "QV1uyoe0gFLh", + "outputId": "126701f4-c8c6-4ba5-bbcd-778c837dc5fd" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "3\n", + "6\n", + "2\n" + ] + } + ], + "source": [ + "# возьмем только одну переменную и применим метод .values()\n", + "for v in d.values():\n", + " # значение представляет собой список, выведем его первый элемент с индексом [0]\n", + " print(v[0])" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "4L5ktimCcbbJ", + "outputId": "7c17e543-7ff5-4eaf-d8a4-1cf3ca8372b2" + }, + "outputs": [ + { + "ename": "ModuleNotFoundError", + "evalue": "No module named 'numpy'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mModuleNotFoundError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[0;32mIn[15], line 2\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[38;5;66;03m# импортируем библиотеку numpy\u001b[39;00m\n\u001b[0;32m----> 2\u001b[0m \u001b[38;5;28;01mimport\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21;01mnumpy\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;28;01mas\u001b[39;00m\u001b[38;5;250m \u001b[39m\u001b[38;5;21;01mnp\u001b[39;00m\n\u001b[1;32m 4\u001b[0m \u001b[38;5;66;03m# создадим массив и поместим в переменную number_array\u001b[39;00m\n\u001b[1;32m 5\u001b[0m number_array \u001b[38;5;241m=\u001b[39m np\u001b[38;5;241m.\u001b[39marray([\u001b[38;5;241m1\u001b[39m, \u001b[38;5;241m2\u001b[39m, \u001b[38;5;241m3\u001b[39m])\n", + "\u001b[0;31mModuleNotFoundError\u001b[0m: No module named 'numpy'" + ] + } + ], + "source": [ + "# создадим массив и поместим в переменную number_array\n", + "number_array = np.array([1, 2, 3])\n", + "\n", + "# пройдемся по нему с помощью цикла for\n", + "for number in number_array:\n", + " print(number)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "8WzO673x-n7b" + }, + "outputs": [], + "source": [ + "# предположим, что у нас есть следующая база данных клиентов\n", + "clients = {\n", + " 1: {\"name\": \"Анна\", \"age\": 24, \"sex\": \"male\", \"revenue\": 12000},\n", + " 2: {\"name\": \"Илья\", \"age\": 18, \"sex\": \"female\", \"revenue\": 8000},\n", + "}" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "zYoothSRM7T9", + "outputId": "9485789d-3e10-4ffe-a990-63eb8249826d" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "client ID: 1\n", + "name: Анна\n", + "age: 24\n", + "sex: male\n", + "revenue: 12000\n", + "\n", + "client ID: 2\n", + "name: Илья\n", + "age: 18\n", + "sex: female\n", + "revenue: 8000\n", + "\n" + ] + } + ], + "source": [ + "# в первом цикле for поместим id и информацию о клиентах в переменные id и info\n", + "for id, info in clients.items():\n", + "\n", + " # выведем id клиента\n", + " print(\"client ID: \" + str(id))\n", + "\n", + " # во втором цикле возьмем информацию об этом клиенте (это тоже словарь)\n", + " for k, v in info.items():\n", + "\n", + " # и выведем каждый ключ (название поля) и значение (саму информацию)\n", + " print(k + \": \" + str(v))\n", + "\n", + " # добавим пустую строку после того, как выведем информацию об одном клиенте\n", + " print()" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Q3CB7PzqYZ_L" + }, + "source": [ + "##### Функция range()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "HtJWgzs2OEG_", + "outputId": "c82a607f-6477-4361-d7d7-a607a4ba6bdf" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n", + "1\n", + "2\n", + "3\n", + "4\n" + ] + } + ], + "source": [ + "# создадим последовательность от 0 до 4\n", + "for i in range(5):\n", + " print(i)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "UI24as2nYzR1", + "outputId": "07ac7689-d18c-4267-8b47-986c10086d33" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1\n", + "2\n", + "3\n", + "4\n", + "5\n" + ] + } + ], + "source": [ + "# от 1 до 5\n", + "for i in range(1, 6):\n", + " print(i)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "qN0SAaPXdILc", + "outputId": "b72a44c1-3c52-4f67-b635-4619ffae5366" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n", + "2\n", + "4\n" + ] + } + ], + "source": [ + "# и от 0 до 5 с шагом 2 (то есть будем выводить числа через одно)\n", + "for i in range(0, 6, 2):\n", + " print(i)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "8dUjujIG3cph", + "outputId": "e1ea261c-c714-4b25-a1c9-1b4a119fa550" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Январь 47\n", + "Февраль 75\n", + "Март 79\n", + "Апрель 94\n", + "Май 123\n", + "Июнь 209\n", + "Июль 233\n", + "Август 214\n", + "Сентябрь 197\n", + "Октябрь 130\n", + "Ноябрь 87\n", + "Декабрь 55\n" + ] + } + ], + "source": [ + "# возьмем месяцы года\n", + "months = [\n", + " \"Январь\",\n", + " \"Февраль\",\n", + " \"Март\",\n", + " \"Апрель\",\n", + " \"Май\",\n", + " \"Июнь\",\n", + " \"Июль\",\n", + " \"Август\",\n", + " \"Сентябрь\",\n", + " \"Октябрь\",\n", + " \"Ноябрь\",\n", + " \"Декабрь\",\n", + "]\n", + "\n", + "# и продажи мороженого в тыс. рублей в каждый из месяцев\n", + "sales = [47, 75, 79, 94, 123, 209, 233, 214, 197, 130, 87, 55]\n", + "\n", + "# задав последовательность через range(len()),\n", + "for i in range(len(months)):\n", + "\n", + " # мы можем вывести каждый из элементов обоих списков в одном цикле\n", + " print(months[i], sales[i])" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "0CFgV73qgUSd" + }, + "source": [ + "Последовательность в обратном порядке" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Jw0cFT6tgiPX" + }, + "source": [ + "**Способ 1**. Функция reversed()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "l51JXd5Egk8o", + "outputId": "ea9e0431-0789-4716-a272-479a95293e7d" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "4\n", + "3\n", + "2\n", + "1\n", + "0\n" + ] + } + ], + "source": [ + "# создадим список\n", + "my_list = [0, 1, 2, 3, 4]\n", + "\n", + "# передадим его функции reversed() и\n", + "# выведем каждый из элементов списка с помощью цикла for\n", + "for i in reversed(my_list):\n", + " print(i)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Dj4vHmXnhGZ1", + "outputId": "56b9b18b-a7fe-4242-a2e4-232aa351e880" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "4\n", + "3\n", + "2\n", + "1\n", + "0\n" + ] + } + ], + "source": [ + "for i in reversed(range(5)):\n", + " print(i)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "p_p9pohzgnXz" + }, + "source": [ + "**Способ 2**. Указать $-1$ в качестве параметра шага" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "cgL29MGlgzaa", + "outputId": "44596ce6-aef4-4625-88e3-8d5249d1f07a" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "4\n", + "3\n", + "2\n", + "1\n" + ] + } + ], + "source": [ + "# первым параметром укажем конечный элемент списка,\n", + "# а вторым - начальный\n", + "for i in range(4, 0, -1):\n", + " print(i)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "IZ6veVNThxIV", + "outputId": "7ecce7ec-e249-4f43-8960-edd4cb746fe6" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "4\n", + "3\n", + "2\n", + "1\n", + "0\n" + ] + } + ], + "source": [ + "# чтобы вывести 0, вторым параметром нужно указать -1\n", + "for i in range(4, -1, -1):\n", + " print(i)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "pKTDUkY3gz7-" + }, + "source": [ + "**Способ 3**. Функция sorted()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "l_FnBDBEg7dG", + "outputId": "cd1f0812-2641-450a-ef31-8282076a4c3c" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "4\n", + "3\n", + "2\n", + "1\n", + "0\n" + ] + } + ], + "source": [ + "# создадим последовательность от 0 до 4\n", + "r = range(5)\n", + "\n", + "# отсортируем ее по убыванию\n", + "sorted_values = sorted(r, reverse=True)\n", + "\n", + "# выведем элементы отсортированной последовательности\n", + "for i in sorted_values:\n", + " print(i)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "c4X4Nw2Yf2IH" + }, + "source": [ + "##### Функция enumerate()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "5a3gqF7-foJY", + "outputId": "358e0f57-cffa-434d-ef50-e811b2c822a2" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0 Понедельник\n", + "1 Вторник\n", + "2 Среда\n", + "3 Четверг\n", + "4 Пятница\n", + "5 Суббота\n", + "6 Воскресенье\n" + ] + } + ], + "source": [ + "# пусть дан список с днями недели\n", + "days = [\n", + " \"Понедельник\",\n", + " \"Вторник\",\n", + " \"Среда\",\n", + " \"Четверг\",\n", + " \"Пятница\",\n", + " \"Суббота\",\n", + " \"Воскресенье\",\n", + "]\n", + "\n", + "# выведем индекс (i) и сами элементы списка (day)\n", + "for i, day in enumerate(days):\n", + " print(i, day)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "qrn0qMjWlgg4", + "outputId": "7719b163-557d-4d68-9367-53e13d8cf714" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1 Понедельник\n", + "2 Вторник\n", + "3 Среда\n", + "4 Четверг\n", + "5 Пятница\n", + "6 Суббота\n", + "7 Воскресенье\n" + ] + } + ], + "source": [ + "# так же выведем индекс и элементы списка, но начнем с 1\n", + "for i, day in enumerate(days, 1):\n", + " print(i, day)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Nw5Km-XapZni" + }, + "source": [ + "#### Цикл while" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "7dWKX2p8pZCl", + "outputId": "b20690f5-36ff-464c-e3b2-ab185409b74a" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Текущее значение счетчика: 0\n", + "Новое значение счетчика: 1\n", + "\n", + "Текущее значение счетчика: 1\n", + "Новое значение счетчика: 2\n", + "\n", + "Текущее значение счетчика: 2\n", + "Новое значение счетчика: 3\n", + "\n" + ] + } + ], + "source": [ + "# зададим начальное значение счетчика\n", + "i = 0\n", + "\n", + "# пока счетчик меньше трех\n", + "while i < 3:\n", + "\n", + " # в каждом цикле будем выводить его текущее значение\n", + " print(\"Текущее значение счетчика: \" + str(i))\n", + "\n", + " # внутри цикла не забудем \"нарастить\" счетчик\n", + " i = i + 1\n", + "\n", + " # и выведем новое значение\n", + " print(\"Новое значение счетчика: \" + str(i))\n", + "\n", + " # добавим пустую строку\n", + " print()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "AsLYv9o-mpy2", + "outputId": "ca5a8611-81a4-45e1-f242-c1e6243b2a50" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n", + "1\n", + "2\n" + ] + } + ], + "source": [ + "# тот же код можно упростить\n", + "i = 0\n", + "\n", + "while i < 3:\n", + " print(i)\n", + " # в частности, оператор += сразу увеличивает и присваивает новое значение\n", + " i += 1" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "N6Djl9Shdkxh" + }, + "source": [ + "#### Break, continue" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ZCW-rwAFggXA" + }, + "source": [ + "Оператор break" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "RBHU-9AMtfWx", + "outputId": "8fb98266-36f9-417b-df63-956053999ae7" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1 {'name': 'Анна', 'age': 24, 'sex': 'male', 'revenue': 12000}\n" + ] + } + ], + "source": [ + "# вновь возьмем словарь clients\n", + "clients = {\n", + " 1: {\"name\": \"Анна\", \"age\": 24, \"sex\": \"male\", \"revenue\": 12000},\n", + " 2: {\"name\": \"Илья\", \"age\": 18, \"sex\": \"female\", \"revenue\": 8000},\n", + "}\n", + "\n", + "# в цикле пройдемся по ключам и значениям словаря\n", + "for id, info in clients.items():\n", + "\n", + " # и выведем их\n", + " print(id, info)\n", + "\n", + " # однако уже после первого исполнения цикла, прервем его\n", + " break" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "SFqkq_3lfqrn", + "outputId": "8a818f11-8359-4c0f-ad96-41b15f5f168c" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "6\n", + "5\n", + "4\n" + ] + } + ], + "source": [ + "# начальное значение счетчика\n", + "x = 6\n", + "\n", + "# будем исполнять цикл пока x не равен нулю\n", + "while x != 0:\n", + "\n", + " # выведем текущее значение счетчика\n", + " print(x)\n", + "\n", + " # и уменьшим (!) его на 1\n", + " x -= 1\n", + "\n", + " # если значение счетчика станет равным 3, прервем цикл\n", + " if x == 3:\n", + " break" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "L3Mf_VrMjX_9" + }, + "source": [ + "Оператор continue" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "fQOiiMyTjdic", + "outputId": "3eaceef2-657a-4bfc-bcdf-d0585ebbf851" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2\n", + "4\n", + "6\n", + "8\n", + "10\n" + ] + } + ], + "source": [ + "# выведем все четные числа в диапазоне от 1 до 10 включительно.\n", + "\n", + "# с помощью функции range() создадим последовательность от 1 до 10\n", + "for i in range(1, 11):\n", + "\n", + " # если остаток от деления на два не равен нулю (то есть число нечетное)\n", + " if i % 2 != 0:\n", + "\n", + " # идем к следующему числу последовательности\n", + " continue\n", + "\n", + " # в противном случае выводим число\n", + " else:\n", + " print(i)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "9mv5pBDHX3zT" + }, + "source": [ + "#### Форматирование строк через f-строки и метод .format()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 35 + }, + "id": "T3-9SwA5oyBw", + "outputId": "975ffcc1-101d-4849-bbab-f1819d3d2c3c" + }, + "outputs": [ + { + "data": { + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "string" + }, + "text/plain": [ + "'Понедельник'" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# снова возьмем список с днями недели\n", + "days = [\n", + " \"Понедельник\",\n", + " \"Вторник\",\n", + " \"Среда\",\n", + " \"Четверг\",\n", + " \"Пятница\",\n", + " \"Суббота\",\n", + " \"Воскресенье\",\n", + "]\n", + "\n", + "# и для простоты поместим слово \"Понедельник\" в переменную Monday\n", + "Monday = days[0]\n", + "Monday" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "sDm0FLLzYyqM", + "outputId": "0af15dd1-b565-485a-9010-8813efd8dfec" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Понедельник - день тяжелый\n" + ] + } + ], + "source": [ + "# теперь напишем фразу \"Понедельник - день тяжелый\" следующим образом\n", + "print(f\"{Monday} - день тяжелый\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "p85bCPM7Z2yz", + "outputId": "1f7f7c62-a86c-4a16-c234-e4d09d98eb98" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Понедельник - день тяжелый\n" + ] + } + ], + "source": [ + "# то же самое можно вывести с помощью метода .format()\n", + "print(\"{} - день тяжелый\".format(Monday))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "EYzsssCDwI5u" + }, + "source": [ + "### Ответы на вопросы к занятию" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "O8weTrT8w7qh" + }, + "source": [ + "**Вопрос**. Можно ли использовать цикл while с функцией range()?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "SZXmOJa7hI6K", + "outputId": "67589a76-8a23-419e-d30a-d2de8a2e393d" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Значение счетчика 1\n", + "Значение счетчика 2\n", + "Значение счетчика 3\n", + "Значение счетчика 4\n", + "Значение счетчика 5\n", + "Значение счетчика 6\n", + "Значение счетчика 7\n", + "Значение счетчика 8\n", + "Значение счетчика 9\n", + "Значение счетчика 10\n" + ] + } + ], + "source": [ + "# с функцией range() можно использовать цикл while, но такое решение не оптимально\n", + "# приведем пример с while\n", + "\n", + "i = 1 # создадим счетчик\n", + "\n", + "while i in range(1, 11): # пока счетчик в диапазоне от 1 до 10\n", + " print(\"Значение счетчика \", i) # выведем его значение и\n", + " i += 1 # увеличим счетчик на 1" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "T-7jFKw9wp0o", + "outputId": "6696e461-f0c5-451e-bcc3-8cdbd7f50f8e" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Значение счетчика 1\n", + "Значение счетчика 2\n", + "Значение счетчика 3\n", + "Значение счетчика 4\n", + "Значение счетчика 5\n", + "Значение счетчика 6\n", + "Значение счетчика 7\n", + "Значение счетчика 8\n", + "Значение счетчика 9\n", + "Значение счетчика 10\n" + ] + } + ], + "source": [ + "# более оптимальный код\n", + "for i in range(1, 11):\n", + " print(\"Значение счетчика \", i)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "yrouXtHk2BiB" + }, + "source": [ + "**Вопрос**. Можно ли обойтись без оператора continue в приведенном на занятии примере?" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "g-0ophfr2QXH", + "outputId": "f220b20b-6480-4bb5-978a-99c3c388821e" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2\n", + "4\n", + "6\n", + "8\n", + "10\n" + ] + } + ], + "source": [ + "for i in range(1, 11):\n", + " # если число четное, выведем его\n", + " if i % 2 == 0:\n", + " print(i)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "61Ih4ELB2gaC" + }, + "outputs": [], + "source": [] + } + ], + "metadata": { + "colab": { + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.1" + } + }, + "nbformat": 4, + "nbformat_minor": 0 +} diff --git a/makarov.chapter3.py b/makarov.chapter3.py new file mode 100644 index 00000000..dfe85841 --- /dev/null +++ b/makarov.chapter3.py @@ -0,0 +1,428 @@ +# ## Условия и циклы. Продолжение + +# ### Еще раз про условия с if + +# Множественные условия (multi-way decisions) + +# + +# напишем программу, которая разобьет все числа на малые, средние и большие +# импортируем библиотеку numpy +import numpy as np + +x = 42 # зададим число + +# и пропишем условия (не забывайте про двоеточие и отступ) +if x < 10: + print("Small") +elif x < 100: + print("Medium") +else: + print("Large") + +# + +# запросим число у пользователя +x = input("Введите число: ") + +# преобразуем в тип int +x = int(x) + +# и наконец классифицируем +if x < 10: + print("Small") +elif x < 100: + print("Medium") +else: + print("Large") +# - + +# Вложенные условия (nested decisions) + +# + +# запрашиваем число +y = input("Введите число: ") + +# проверяем первое условие (не пустая ли строка), если оно выполняется +if len(y) != 0: + + # преобразуем в тип int + y = int(y) + + # и классифицируем + if x < 10: + print("Small") + elif x < 100: + print("Medium") + else: + print("Large") + +# в противном, говорим, что ввод пустой +else: + print("Ввод пустой") +# - + +# Несколько условий в одном выражении с операторами and или or + +# + +# пример с and (логическим И) +z = 42 + +# если z больше 10 и одновременно меньше 100 +if z > 10 and z < 100: + + # у нас среднее число + print("Medium") + +# в противном случае оно либо маленькое либо большое +else: + print("Small or Large") + +# + +# пример с or (логическим ИЛИ) +z = 2 + +# если z меньше 10 или больше 100 +if z < 10 or z > 100: + + # оно либо маленькое либо большое + print("Small or Large") + +# в противном случае оно среднее +else: + print("Medium") +# - + +# Проверка вхождения элемента в объект с in / not in + +# + +# можно проверить вхождение слова в строку +sentence = "To be, or not to be, that is the question" +word = "question" + +if word in sentence: + print("Слово найдено") + +# + +# или отсутствие элемента в списке +number_list = [2, 3, 4, 6, 7] +number = 5 + +if number not in number_list: + print("Такого числа в списке нет") + +# + +# кроме того, можно проверить вхождение ключа и значения в словарь + +# возьмем очень простой словарь +d = {"apple": 3, "tomato": 6, "carrot": 2} +# - + +# вначале поищем яблоки среди ключей словаря +if "apple" in d: + print("Нашлись") + +# а затем посмотрим, нет ли числа 6 среди его значений +# с помощью метода .values() +if 6 in d.values(): + print("Есть") + +# ### Циклы в Питоне + +# #### Цикл for + +# ##### Основные операции + +# + +# поочередно выведем элементы списка +number_list = [1, 2, 3] + +# не забывая про двоеточие и отступ +for number in number_list: + print(number) +# - + +# создадим словарь, значениями которого будут списки из двух элементов +d = {"apple": [3, "kg"], "tomato": [6, "pcs"], "carrot": [2, "kg"]} + +# затем создадим две переменные-контейнера и применим метод .items() +for k, v in d.items(): + print(k, v) + +# возьмем только одну переменную и применим метод .values() +for v in d.values(): + # значение представляет собой список, выведем его первый элемент с индексом [0] + print(v[0]) + +# + +# создадим массив и поместим в переменную number_array +number_array = np.array([1, 2, 3]) + +# пройдемся по нему с помощью цикла for +for number in number_array: + print(number) +# - + +# предположим, что у нас есть следующая база данных клиентов +clients = { + 1: {"name": "Анна", "age": 24, "sex": "male", "revenue": 12000}, + 2: {"name": "Илья", "age": 18, "sex": "female", "revenue": 8000}, +} + +# в первом цикле for поместим id и информацию о клиентах в переменные id и info +for id, info in clients.items(): + + # выведем id клиента + print("client ID: " + str(id)) + + # во втором цикле возьмем информацию об этом клиенте (это тоже словарь) + for k, v in info.items(): + + # и выведем каждый ключ (название поля) и значение (саму информацию) + print(k + ": " + str(v)) + + # добавим пустую строку после того, как выведем информацию об одном клиенте + print() + +# ##### Функция range() + +# создадим последовательность от 0 до 4 +for i in range(5): + print(i) + +# от 1 до 5 +for i in range(1, 6): + print(i) + +# и от 0 до 5 с шагом 2 (то есть будем выводить числа через одно) +for i in range(0, 6, 2): + print(i) + +# + +# возьмем месяцы года +months = [ + "Январь", + "Февраль", + "Март", + "Апрель", + "Май", + "Июнь", + "Июль", + "Август", + "Сентябрь", + "Октябрь", + "Ноябрь", + "Декабрь", +] + +# и продажи мороженого в тыс. рублей в каждый из месяцев +sales = [47, 75, 79, 94, 123, 209, 233, 214, 197, 130, 87, 55] + +# задав последовательность через range(len()), +for i in range(len(months)): + + # мы можем вывести каждый из элементов обоих списков в одном цикле + print(months[i], sales[i]) +# - + +# Последовательность в обратном порядке + +# **Способ 1**. Функция reversed() + +# + +# создадим список +my_list = [0, 1, 2, 3, 4] + +# передадим его функции reversed() и +# выведем каждый из элементов списка с помощью цикла for +for i in reversed(my_list): + print(i) +# - + +for i in reversed(range(5)): + print(i) + +# **Способ 2**. Указать $-1$ в качестве параметра шага + +# первым параметром укажем конечный элемент списка, +# а вторым - начальный +for i in range(4, 0, -1): + print(i) + +# чтобы вывести 0, вторым параметром нужно указать -1 +for i in range(4, -1, -1): + print(i) + +# **Способ 3**. Функция sorted() + +# + +# создадим последовательность от 0 до 4 +r = range(5) + +# отсортируем ее по убыванию +sorted_values = sorted(r, reverse=True) + +# выведем элементы отсортированной последовательности +for i in sorted_values: + print(i) +# - + +# ##### Функция enumerate() + +# + +# пусть дан список с днями недели +days = [ + "Понедельник", + "Вторник", + "Среда", + "Четверг", + "Пятница", + "Суббота", + "Воскресенье", +] + +# выведем индекс (i) и сами элементы списка (day) +for i, day in enumerate(days): + print(i, day) +# - + +# так же выведем индекс и элементы списка, но начнем с 1 +for i, day in enumerate(days, 1): + print(i, day) + +# #### Цикл while + +# + +# зададим начальное значение счетчика +i = 0 + +# пока счетчик меньше трех +while i < 3: + + # в каждом цикле будем выводить его текущее значение + print("Текущее значение счетчика: " + str(i)) + + # внутри цикла не забудем "нарастить" счетчик + i = i + 1 + + # и выведем новое значение + print("Новое значение счетчика: " + str(i)) + + # добавим пустую строку + print() + +# + +# тот же код можно упростить +i = 0 + +while i < 3: + print(i) + # в частности, оператор += сразу увеличивает и присваивает новое значение + i += 1 +# - + +# #### Break, continue + +# Оператор break + +# + +# вновь возьмем словарь clients +clients = { + 1: {"name": "Анна", "age": 24, "sex": "male", "revenue": 12000}, + 2: {"name": "Илья", "age": 18, "sex": "female", "revenue": 8000}, +} + +# в цикле пройдемся по ключам и значениям словаря +for id, info in clients.items(): + + # и выведем их + print(id, info) + + # однако уже после первого исполнения цикла, прервем его + break + +# + +# начальное значение счетчика +x = 6 + +# будем исполнять цикл пока x не равен нулю +while x != 0: + + # выведем текущее значение счетчика + print(x) + + # и уменьшим (!) его на 1 + x -= 1 + + # если значение счетчика станет равным 3, прервем цикл + if x == 3: + break +# - + +# Оператор continue + +# + +# выведем все четные числа в диапазоне от 1 до 10 включительно. + +# с помощью функции range() создадим последовательность от 1 до 10 +for i in range(1, 11): + + # если остаток от деления на два не равен нулю (то есть число нечетное) + if i % 2 != 0: + + # идем к следующему числу последовательности + continue + + # в противном случае выводим число + else: + print(i) +# - + +# #### Форматирование строк через f-строки и метод .format() + +# + +# снова возьмем список с днями недели +days = [ + "Понедельник", + "Вторник", + "Среда", + "Четверг", + "Пятница", + "Суббота", + "Воскресенье", +] + +# и для простоты поместим слово "Понедельник" в переменную Monday +Monday = days[0] +Monday +# - + +# теперь напишем фразу "Понедельник - день тяжелый" следующим образом +print(f"{Monday} - день тяжелый") + +# то же самое можно вывести с помощью метода .format() +print(f"{Monday} - день тяжелый") + +# ### Ответы на вопросы к занятию + +# **Вопрос**. Можно ли использовать цикл while с функцией range()? + +# + +# с функцией range() можно использовать цикл while, но такое решение не оптимально +# приведем пример с while + +i = 1 # создадим счетчик + +while i in range(1, 11): # пока счетчик в диапазоне от 1 до 10 + print("Значение счетчика ", i) # выведем его значение и + i += 1 # увеличим счетчик на 1 +# - + +# более оптимальный код +for i in range(1, 11): + print("Значение счетчика ", i) + +# **Вопрос**. Можно ли обойтись без оператора continue в приведенном на занятии примере? + +for i in range(1, 11): + # если число четное, выведем его + if i % 2 == 0: + print(i) diff --git a/makarov.lists.tuples.ipynb b/makarov.lists.tuples.ipynb new file mode 100644 index 00000000..4676dc27 --- /dev/null +++ b/makarov.lists.tuples.ipynb @@ -0,0 +1,2486 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [], + "toc_visible": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "0AoPSXyUTTLc" + }, + "source": [ + "## Списки, кортежи и множества" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "lIM5gFo4TbUg" + }, + "source": [ + "### Списки" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "PPEbDV8hCAGO" + }, + "source": [ + "Основы работы со списками" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "x3wxNu5jthst", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "9ea10800-7ade-4833-d849-424f4252cab8" + }, + "source": [ + "# пустой список можно создать через [] или функцию list()\n", + "# импортируем класс стеммера и создаем объект\n", + "from nltk.stem import PorterStemmer\n", + "\n", + "some_list_1 = []\n", + "some_list_2 = list()\n", + "\n", + "print(some_list_1, some_list_2)" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "[] []\n" + ] + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "tLWO1t--thwP", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "bdba1e22-059a-4ae5-b5b7-f8cf32544eec" + }, + "source": [ + "# элементами списка могут, в частности, быть числа, строки, другие списки и словари\n", + "number_three = [3, \"число три\", [\"число\", \"три\"], {\"число\": 3}]\n", + "number_three" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "[3, 'число три', ['число', 'три'], {'число': 3}]" + ] + }, + "metadata": {}, + "execution_count": 2 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "_jEdnwKSkbSE", + "outputId": "c50a7419-d925-4a2c-ec7d-f705e2c988c0" + }, + "source": [ + "# длина списка рассчитывается через функцию len()\n", + "len(number_three)" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "4" + ] + }, + "metadata": {}, + "execution_count": 3 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "9KkaG7NJDOMW" + }, + "source": [ + "Индекс и срез списка" + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "b3GS578dDRSH", + "outputId": "76a19d40-7499-4467-efd0-8d07b1b5d968" + }, + "source": [ + "# у списка есть положительный и отрицательный индексы\n", + "abc_list = [\"a\", \"b\", \"c\", \"d\", \"e\"]\n", + "\n", + "# воспользуемся ими для вывода первого и последнего элементов\n", + "print(abc_list[0], abc_list[-1])" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "a e\n" + ] + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 35 + }, + "id": "LsfIU3Z3F6Qo", + "outputId": "ad2627b5-bc55-438f-ab49-be1c0ed9814e" + }, + "source": [ + "# при работе с вложенным списком\n", + "salary_list = [[\"Анна\", 90000], [\"Игорь\", 85000], [\"Алексей\", 95000]]\n", + "\n", + "# мы вначале указываем индекс вложенного списка, а затем индекс элемента в нем\n", + "salary_list[1][0]" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "'Игорь'" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "string" + } + }, + "metadata": {}, + "execution_count": 5 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "hzcsnn7LISyc", + "outputId": "8e597d24-f23d-41a7-d055-70220a1f033f" + }, + "source": [ + "# индекс можно узнать с помощью метода .index()\n", + "abc_list.index(\"c\")" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "2" + ] + }, + "metadata": {}, + "execution_count": 6 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# метод .index() можно применить и ко вложенному списку\n", + "salary_list[0].index(90000)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "ARwsxkVfrFOQ", + "outputId": "3137c4c5-16bd-4ccb-e448-81cb54de5270" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "1" + ] + }, + "metadata": {}, + "execution_count": 7 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "VvcCb_ZaItpp", + "outputId": "25c98c5c-e90b-4adc-b28d-94d4802ed786" + }, + "source": [ + "# создадим список с днями недели\n", + "days_list = [\"Пн\", \"Вт\", \"Ср\", \"Чт\", \"Пт\", \"Сб\", \"Вс\"]\n", + "\n", + "# и выведем со второго по пятый элемент включительно\n", + "days_list[1:5]" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "['Вт', 'Ср', 'Чт', 'Пт']" + ] + }, + "metadata": {}, + "execution_count": 8 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "vFJFJGigJ-kQ", + "outputId": "a0b65aff-7ef8-428c-ea4f-9bd14651f442" + }, + "source": [ + "# выведем каждый второй элемент в срезе с первого по пятый\n", + "days_list[:5:2]" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "['Пн', 'Ср', 'Пт']" + ] + }, + "metadata": {}, + "execution_count": 9 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "n6Q6not7t9GH", + "outputId": "57d9edce-4af6-4e33-b058-147d844289e7" + }, + "source": [ + "# проверим есть ли \"Пн\" в списке\n", + "\"Пн\" in days_list" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "True" + ] + }, + "metadata": {}, + "execution_count": 10 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "HpVMXHWDuXy7", + "outputId": "5fd5743a-2da3-41a3-f875-ae4276e1cd63" + }, + "source": [ + "# если \"Вт\" есть в списке\n", + "if \"Вт\" in days_list:\n", + "\n", + " # выведем сообщение\n", + " print(\"Такое слово есть\")" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Такое слово есть\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "msuaGJ1OLXrB" + }, + "source": [ + "Добавление, замена и удаление элементов списка" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "fEyyqpUDLcsY" + }, + "source": [ + "# создадим список\n", + "weekdays = [\"Понедельник\", \"Вторник\"]" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "2YK5UIHOnZwq", + "outputId": "5fa9a3c3-f203-458c-a4fa-befa0b0f36a9" + }, + "source": [ + "# добавим один элемент в конец списка с помощью метода .append()\n", + "weekdays.append(\"Четверг\")\n", + "weekdays" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "['Понедельник', 'Вторник', 'Четверг']" + ] + }, + "metadata": {}, + "execution_count": 13 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Yvrd-wOMnZ9d", + "outputId": "8e85dec1-5b22-47c3-be53-25b8c2f3aa42" + }, + "source": [ + "# добавим элемент в определенное место в списке через желаемый индекс этого элемента\n", + "weekdays.insert(2, \"Среда\")\n", + "weekdays" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "['Понедельник', 'Вторник', 'Среда', 'Четверг']" + ] + }, + "metadata": {}, + "execution_count": 14 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "zPEqoCsrzKEB", + "outputId": "c7214ad0-de20-4d05-e178-0ae0b29081fe" + }, + "source": [ + "# изменим четвертый элемент в списке\n", + "weekdays[3] = \"Пятница\"\n", + "weekdays" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "['Понедельник', 'Вторник', 'Среда', 'Пятница']" + ] + }, + "metadata": {}, + "execution_count": 15 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "gsWduacznqg4", + "outputId": "0ffc359c-e8dc-473a-d2dd-6bb573746afc" + }, + "source": [ + "# удалим элемент по его значению\n", + "weekdays.remove(\"Пятница\")\n", + "weekdays" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "['Понедельник', 'Вторник', 'Среда']" + ] + }, + "metadata": {}, + "execution_count": 16 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "D2bnKXNAxmq2", + "outputId": "94426985-ebca-423b-e80a-dc3f5bc0a8b1" + }, + "source": [ + "# удалим элемент по его индексу через ключевое слово del\n", + "del weekdays[2]\n", + "weekdays" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "['Понедельник', 'Вторник']" + ] + }, + "metadata": {}, + "execution_count": 17 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# сделаем то же самое с помощью метода .pop()\n", + "# этот метод выводит удаляемый элемент\n", + "weekdays.pop(1)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 35 + }, + "id": "CooE-D9ouFeP", + "outputId": "149a53e2-baf6-4e8e-85a4-630ce28819a5" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "'Вторник'" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "string" + } + }, + "metadata": {}, + "execution_count": 18 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# посмотрим, что осталось в нашем списке\n", + "weekdays" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "kM8rmPNXuyN6", + "outputId": "f1a810fc-ccb3-4ccf-8f25-480dbb83f25a" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "['Понедельник']" + ] + }, + "metadata": {}, + "execution_count": 19 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "MWP0v0fz0IQ4" + }, + "source": [ + "Сложение списков" + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "cwu9M49e0HlB", + "outputId": "66ef1e04-7468-47c7-9997-fd250cedf9f3" + }, + "source": [ + "# соединить два списка можно с помощью метода .extend()\n", + "more_weekdays = [\"Вторник\", \"Среда\", \"Четверг\", \"Пятница\"]\n", + "\n", + "weekdays.extend(more_weekdays)\n", + "weekdays" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "['Понедельник', 'Вторник', 'Среда', 'Четверг', 'Пятница']" + ] + }, + "metadata": {}, + "execution_count": 20 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "CE07IDeZx0cl", + "outputId": "e4674475-aa75-4468-a95b-f5a0c142300f" + }, + "source": [ + "weekend = [\"Суббота\", \"Воскресенье\"]\n", + "\n", + "# или просто сложив два списка\n", + "print(weekdays + weekend)" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "['Понедельник', 'Вторник', 'Среда', 'Четверг', 'Пятница', 'Суббота', 'Воскресенье']\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# иногда бывает полезно \"размножить\" элементы списка\n", + "[\"Понедельник\"] * 2" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "pJcSZ0jiz840", + "outputId": "7edd4ed0-2c01-4beb-ca00-f2e135746e97" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "['Понедельник', 'Понедельник']" + ] + }, + "metadata": {}, + "execution_count": 22 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# такие \"произведения\" также можно складывать\n", + "[\"Понедельник\"] * 2 + [\"Вторник\"] * 2" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "3MRsPPs30N1V", + "outputId": "5d0b022c-1487-43dc-b8dd-c4a5751187e0" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "['Понедельник', 'Понедельник', 'Вторник', 'Вторник']" + ] + }, + "metadata": {}, + "execution_count": 23 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "5zWQeyD4lsk9" + }, + "source": [ + "Распаковка списков" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "n6kQjWdPlv7P" + }, + "source": [ + "# дан список\n", + "week = [\n", + " \"Понедельник\",\n", + " \"Вторник\",\n", + " \"Среда\",\n", + " \"Четверг\",\n", + " \"Пятница\",\n", + " \"Суббота\",\n", + " \"Воскресенье\",\n", + "]" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 35 + }, + "id": "ZquIS9Lhl2z_", + "outputId": "4c532ff3-8e31-45e0-ac63-515e8b9b621d" + }, + "source": [ + "# указав индекс элемента, его можно записать в переменную\n", + "Mon = week[0]\n", + "Mon" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "'Понедельник'" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "string" + } + }, + "metadata": {}, + "execution_count": 25 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "1HAhG91Dl22z", + "outputId": "d0fd205e-f2c4-4888-fb93-7d0fa82464ba" + }, + "source": [ + "# срез можно поместить в несколько переменных\n", + "Mon, Tue, Wed = week[:3]\n", + "\n", + "# важно, чтобы количество элементов среза было равно количеству переменных\n", + "Mon, Tue, Wed" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "('Понедельник', 'Вторник', 'Среда')" + ] + }, + "metadata": {}, + "execution_count": 26 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 35 + }, + "id": "hfnnO_eUl25o", + "outputId": "cbf4587c-f1f0-445b-b973-64dd677f43f6" + }, + "source": [ + "# можно выделить первый элемент, а остальные поместить в переменную со звездочкой\n", + "Mon, *_ = week\n", + "Mon" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "'Понедельник'" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "string" + } + }, + "metadata": {}, + "execution_count": 27 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "7oVKz24-m9lY", + "outputId": "de4351b4-5e71-49b6-cb0b-beedca62c8c8" + }, + "source": [ + "# также можно поступить, например, с первым и последним элементом\n", + "Mon, *days, Sun = week\n", + "Mon, Sun" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "('Понедельник', 'Воскресенье')" + ] + }, + "metadata": {}, + "execution_count": 28 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "xgSI_44Mqlwv", + "outputId": "53e11e9b-8830-48e0-97c5-986219ff5dc0" + }, + "source": [ + "# посмотрим, какие элементы остались в переменной со звездочкой\n", + "days" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "['Вторник', 'Среда', 'Четверг', 'Пятница', 'Суббота']" + ] + }, + "metadata": {}, + "execution_count": 29 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "CZZ2Tq0yq4l5" + }, + "source": [ + "Сортировка списков" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "zTBWIYWZr80H" + }, + "source": [ + "# возьмем список чисел\n", + "nums = [25, 10, 30, 20, 5, 15]" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Zt9iwWx3q7IL", + "outputId": "b991cb38-26b3-4c26-a6d9-668056437217" + }, + "source": [ + "# и отсортируем с помощью функции sorted(), результат выводится сразу\n", + "sorted(nums)" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "[5, 10, 15, 20, 25, 30]" + ] + }, + "metadata": {}, + "execution_count": 31 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "vS7G44sVs0jv", + "outputId": "14debf29-01e2-48ba-9d67-120ac5d35748" + }, + "source": [ + "# исходный список при этом не изменился\n", + "nums" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "[25, 10, 30, 20, 5, 15]" + ] + }, + "metadata": {}, + "execution_count": 32 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Qbi91ZlWv116", + "outputId": "09bd4d25-2a75-4517-a261-df619a283929" + }, + "source": [ + "# если поместить результат в переменную, изменения сохранятся\n", + "sorted_nums = sorted(nums)\n", + "sorted_nums" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "[5, 10, 15, 20, 25, 30]" + ] + }, + "metadata": {}, + "execution_count": 33 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "J92cKG_ZsGJd" + }, + "source": [ + "# метод .sort() сохраняет результат, но не выводит его сразу\n", + "# reverse = True задает сортировку по убыванию\n", + "nums.sort(reverse=True)" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "tMLloVoxsdcW", + "outputId": "fa528c25-7eea-4131-dc2a-5ac2758bcc1f" + }, + "source": [ + "# выведем результат\n", + "nums" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "[30, 25, 20, 15, 10, 5]" + ] + }, + "metadata": {}, + "execution_count": 35 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "kU0tmatFulXn", + "outputId": "0ea3f3cf-fdd9-48dd-b7c5-b3aea0221c28" + }, + "source": [ + "# метод .reverse() задает обратный порядок, сохраняет, но не выводит результат\n", + "nums.reverse()\n", + "\n", + "# его также нужно вывести отдельно\n", + "nums" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "[5, 10, 15, 20, 25, 30]" + ] + }, + "metadata": {}, + "execution_count": 36 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# функция reversed() возвращает итератор\n", + "reversed(nums)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "BZfKDeRM3fbf", + "outputId": "163b97aa-7255-4e8d-fa57-4e932be32b20" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ] + }, + "metadata": {}, + "execution_count": 37 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# вывести результат можно с помощью функции list()\n", + "list(reversed(nums))" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "7piJhHSn8aUW", + "outputId": "e2da4c5b-f524-4926-ed00-b59dab91cab3" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "[30, 25, 20, 15, 10, 5]" + ] + }, + "metadata": {}, + "execution_count": 38 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# результат при этом не сохраняется\n", + "nums" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "ldVNvlbg8v3_", + "outputId": "bd43b64e-2679-4060-bd33-cc634c6189f1" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "[5, 10, 15, 20, 25, 30]" + ] + }, + "metadata": {}, + "execution_count": 39 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "_Xyi6IdeuA-4" + }, + "source": [ + "Преобразование списка в строку" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "iUoGSZMq0JFD" + }, + "source": [ + "# дан список из строковых элементов\n", + "str_list = [\"P\", \"y\", \"t\", \"h\", \"o\", \"n\"]" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "id": "KuKfbsZLuER1", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 35 + }, + "outputId": "70e66ff3-2188-42dc-e5cb-5a2f3d446c98" + }, + "source": [ + "# с помощью метода .join() можно соединить все элементы\n", + "joined_str = \"\".join(str_list)\n", + "joined_str" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "'Python'" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "string" + } + }, + "metadata": {}, + "execution_count": 41 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 35 + }, + "id": "WfMTmZcEzgky", + "outputId": "5e00ef97-a330-431f-c3c2-770330aaeaf3" + }, + "source": [ + "# если в кавычках ничего не указывать, элементы просто соединятся, но можно указать любой другой элемент\n", + "joined_str_ = \"_\".join(str_list)\n", + "joined_str_" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "'P_y_t_h_o_n'" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "string" + } + }, + "metadata": {}, + "execution_count": 42 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "uEFM3lgzzr_k" + }, + "source": [ + "Арифметика в списках" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "tGBnQ-mFzwJw" + }, + "source": [ + "# дан список чисел\n", + "nums_ = [3, 2, 1, 4, 5, 12, 3, 3, 7, 9, 11, 15]" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "VjwNZw2JzwUG", + "outputId": "e8586a86-a592-444e-9e3c-23ef494a040d" + }, + "source": [ + "# с помощью метода .count() мы можем посчитать частоту вхождения элемента в список\n", + "nums_.count(3)" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "3" + ] + }, + "metadata": {}, + "execution_count": 44 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "rrRSZEb13P0e", + "outputId": "d64be983-954e-44e2-cf3a-d801a61a848e" + }, + "source": [ + "# кроме того мы можем найти минимальное и максимальное значения и сумму элементов\n", + "print(min(nums_), max(nums_), sum(nums_))" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "1 15 75\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "zZKefwcpZ_rd" + }, + "source": [ + "List comprehension" + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "gKYUJua2aCdY" + }, + "source": [ + "# дан список имен\n", + "# оставим имена, начинающиеся с буквы \"А\"\n", + "names = [\"Артем\", \"Антон\", \"Александр\", \"Борис\", \"Виктор\", \"Геннадий\"]" + ], + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "iZhNYZ7raCw_", + "outputId": "c8806615-90af-4669-da6e-ff3083e1dcba" + }, + "source": [ + "# вначале решим эту задачу с помощью цикла for\n", + "\n", + "# создадим пустой список\n", + "a_names = []\n", + "\n", + "# пройдемся по исходному списку в цикле for\n", + "for name in names:\n", + "\n", + " # с помощью метода .startswith() проверим, начинается ли слово с \"А\"\n", + " if name.startswith(\"А\"):\n", + "\n", + " # если да, добавим в новый список\n", + " a_names.append(name)\n", + "\n", + "# выведем результат\n", + "a_names" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "['Артем', 'Антон', 'Александр']" + ] + }, + "metadata": {}, + "execution_count": 47 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "RfU5aFoia66k", + "outputId": "fb93053e-0d50-4df5-8941-2280ad774ed7" + }, + "source": [ + "# эту же задачу можно решить через list comprehension\n", + "# по сути мы пишем: \"что сделать, пока есть элемент в списке, при каком условии\"\n", + "a_names = [name for name in names if name.startswith(\"А\")]\n", + "a_names" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "['Артем', 'Антон', 'Александр']" + ] + }, + "metadata": {}, + "execution_count": 48 + } + ] + }, + { + "cell_type": "code", + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "PtAJqkZRsQGM", + "outputId": "57ffe7da-07b4-4106-9226-e26ccf433fb0" + }, + "source": [ + "# переведем все буквы в строчные, условие здесь не нужно\n", + "lower_names = [name.lower() for name in names]\n", + "lower_names" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "['артем', 'антон', 'александр', 'борис', 'виктор', 'геннадий']" + ] + }, + "metadata": {}, + "execution_count": 49 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# схема условия if-else немного отличается\n", + "# оставляем имя, если это не Виктор, если Виктор - заменяем на Вадим\n", + "replace_name = [name if name != \"Виктор\" else \"Вадим\" for name in names]\n", + "replace_name" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "aj8uLZu9clcD", + "outputId": "558587b2-02a1-4339-dc8b-18e38a05d74a" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "['Артем', 'Антон', 'Александр', 'Борис', 'Вадим', 'Геннадий']" + ] + }, + "metadata": {}, + "execution_count": 50 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# на занятии по обработке естественного языка с помощью list comprehension\n", + "# мы применили стеммер Портера к списку слов\n", + "lemmatized = [\n", + " \"paris\",\n", + " \"visited\",\n", + " \"lot\",\n", + " \"museum\",\n", + " \"first\",\n", + " \"went\",\n", + " \"louvre\",\n", + " \"largest\",\n", + " \"art\",\n", + " \"museum\",\n", + " \"world\",\n", + " \"always\",\n", + " \"interested\",\n", + " \"art\",\n", + " \"spent\",\n", + " \"many\",\n", + " \"hour\",\n", + " \"museum\",\n", + " \"enormous\",\n", + " \"week\",\n", + " \"would\",\n", + " \"enough\",\n", + "]\n", + "\n", + "\n", + "porter = PorterStemmer()\n", + "\n", + "# применяем стеммер к элементу s, пока есть элементы s в списке lemmatized\n", + "stemmed_p = [porter.stem(s) for s in lemmatized]\n", + "print(stemmed_p)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "EiKriSA89dJk", + "outputId": "a6964157-1f0e-4cf7-f53f-0cadad414ce5" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "['pari', 'visit', 'lot', 'museum', 'first', 'went', 'louvr', 'largest', 'art', 'museum', 'world', 'alway', 'interest', 'art', 'spent', 'mani', 'hour', 'museum', 'enourm', 'week', 'would', 'enough']\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "kY91ANMfXeRG" + }, + "source": [ + "### Кортежи" + ] + }, + { + "cell_type": "markdown", + "source": [ + "Основы работы с кортежами" + ], + "metadata": { + "id": "aF48XEbsCsV4" + } + }, + { + "cell_type": "code", + "metadata": { + "id": "qVBaa3SrtlYB", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "c561c5ad-c089-450a-9300-7b1d5e2858e5" + }, + "source": [ + "# пустой кортеж можно создать с помощью пустых круглых скобок () или функции tuple()\n", + "tuple_1, tuple_2 = (), tuple()\n", + "print(tuple_1, tuple_2)" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "() ()\n" + ] + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "Vv-okCt8tlau", + "colab": { + "base_uri": "https://localhost:8080/", + "height": 35 + }, + "outputId": "09cb5284-ae26-4057-a206-7b414437d4f3" + }, + "source": [ + "# в кортеже элементы упорядочены, а значит есть индекс\n", + "letters = (\"a\", \"b\", \"c\")\n", + "letters[0]" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "'a'" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "string" + } + }, + "metadata": {}, + "execution_count": 53 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# но изменить элемент, как мы это делали в списке, нельзя\n", + "letters[0] = \"d\"" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 159 + }, + "id": "3MERPn2I_o9D", + "outputId": "353f1a99-0e22-4353-9f24-537d0077cec4" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "error", + "ename": "TypeError", + "evalue": "'tuple' object does not support item assignment", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 1\u001b[0m \u001b[0;31m# но изменить элемент, как мы это делали в списке, нельзя\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 2\u001b[0;31m \u001b[0mletters\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m'd'\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m: 'tuple' object does not support item assignment" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# для изменения элемента кортеж вначале нужно преобразовать в список\n", + "letters = list(letters)\n", + "letters[0] = \"d\"\n", + "letters" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "3AKPc8KEBKDl", + "outputId": "87e678c8-043c-4f31-cef1-75655c3ec8db" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "['d', 'b', 'c']" + ] + }, + "metadata": {}, + "execution_count": 55 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# кортеж из одного элемента можно создать с помощью запятой\n", + "let_a = (\"a\",)\n", + "type(let_a)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "NvRmYNY2C36p", + "outputId": "2c0a674d-e22c-4df9-b7e5-fc6faa7d995f" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "tuple" + ] + }, + "metadata": {}, + "execution_count": 56 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# если запятую не указывать, получится строка\n", + "let_a = \"a\"\n", + "type(let_a)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "D2vQPPY8C_2G", + "outputId": "a10456d8-ae19-4ed5-d5b3-8b44d8b3e29b" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "str" + ] + }, + "metadata": {}, + "execution_count": 57 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Функция enumerate()" + ], + "metadata": { + "id": "4VBqLLmkCyGB" + } + }, + { + "cell_type": "code", + "source": [ + "companies = [\"Microsoft\", \"Apple\", \"Tesla\"]\n", + "\n", + "# если записать результат функции enumerate() в одну переменную,\n", + "for company in enumerate(companies):\n", + "\n", + " # то мы получим кортежи\n", + " print(company, type(company))" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "2Al5QGWAC0sc", + "outputId": "827cc64c-71e4-48f1-cae6-cf6124d5505c" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(0, 'Microsoft') \n", + "(1, 'Apple') \n", + "(2, 'Tesla') \n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Просмотр элементов словаря" + ], + "metadata": { + "id": "OHyjLQYRL-lz" + } + }, + { + "cell_type": "code", + "source": [ + "shopping_dict = {\"огурцы\": 2, \"помидоры\": 3, \"лук\": 1, \"картофель\": 2}" + ], + "metadata": { + "id": "LSkNG2x1MEWX" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# то же самое со словарем и методом .items()\n", + "for item in shopping_dict.items():\n", + " print(item)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "d_s5V8U6NFAL", + "outputId": "9b6ec1e0-25b0-4dce-b3d0-6bd0af6ea425" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "('огурцы', 2)\n", + "('помидоры', 3)\n", + "('лук', 1)\n", + "('картофель', 2)\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Распаковка кортежей" + ], + "metadata": { + "id": "GlSqhwQfJbCN" + } + }, + { + "cell_type": "code", + "source": [ + "# как и список, кортеж можно распаковать в несколько переменных\n", + "a, b, c = (\"a\", \"b\", \"c\")\n", + "print(a)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "h1hVafb_JaUn", + "outputId": "5692e7d9-0089-42d0-987a-b884b8b62c86" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "a\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "companies = [\"Microsoft\", \"Apple\", \"Tesla\"]\n", + "\n", + "# распаковку в две переменные с функцией enumerate() мы делать уже умеем\n", + "for i, company in enumerate(companies):\n", + " print(i, company)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "BFtyYKARKQPT", + "outputId": "bb7ed4cf-d02a-4219-e998-f386324a03f4" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "0 Microsoft\n", + "1 Apple\n", + "2 Tesla\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "shopping_dict = {\"огурцы\": 2, \"помидоры\": 3, \"лук\": 1, \"картофель\": 2}\n", + "\n", + "# то же самое с ключами и значениями словаря\n", + "for k, v in shopping_dict.items():\n", + " print(k, v)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "pO8swT03UAeV", + "outputId": "0b68f3ab-bd57-4526-b439-9c913772ea6d" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "огурцы 2\n", + "помидоры 3\n", + "лук 1\n", + "картофель 2\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Функция zip()" + ], + "metadata": { + "id": "BZRw7ZcPCwGh" + } + }, + { + "cell_type": "code", + "source": [ + "# если есть два и более списка\n", + "names = [\"Артем\", \"Антон\", \"Александр\", \"Борис\", \"Виктор\", \"Геннадий\"]\n", + "income = [97000, 110000, 95000, 84000, 140000, 120000]\n", + "\n", + "# функция zip() соединит первые элементы списков, вторые элементы списков и т.д.\n", + "zip(names, income)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Ti6oDrQjCvhb", + "outputId": "bbb46ac5-a1fa-4925-cced-7e3f2cd4e52e" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ] + }, + "metadata": {}, + "execution_count": 64 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# для вывода результата нужно передать zip-объект в функцию list()\n", + "# на выходе мы получим список из кортежей\n", + "list(zip(names, income))" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "S84QKkqDHztA", + "outputId": "886a7956-4213-4349-fa15-8063782c15b3" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "[('Артем', 97000),\n", + " ('Антон', 110000),\n", + " ('Александр', 95000),\n", + " ('Борис', 84000),\n", + " ('Виктор', 140000),\n", + " ('Геннадий', 120000)]" + ] + }, + "metadata": {}, + "execution_count": 65 + } + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "xLJn10TGXhlq" + }, + "source": [ + "### Множества" + ] + }, + { + "cell_type": "markdown", + "source": [ + "Создание множества" + ], + "metadata": { + "id": "69RH3VDxWu_5" + } + }, + { + "cell_type": "code", + "metadata": { + "id": "7T9QjMN_tn5Q", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "67e65595-422c-408e-ec10-a86901243173" + }, + "source": [ + "# пустое множество задается через функцию set()\n", + "set_1 = set()\n", + "\n", + "# непустое множество задается через функцию set() и список элементов\n", + "set_2 = {\"a\", \"b\", \"c\", \"c\"}\n", + "\n", + "# или путем перечисления элементов в фигурных скобках {}\n", + "set_3 = {\"a\", \"b\", \"c\", \"c\"}\n", + "\n", + "# множество содержит только уникальные элементы, поэтому дубликаты удаляются\n", + "print(set_1, set_2, set_3)" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "set() {'c', 'b', 'a'} {'c', 'b', 'a'}\n" + ] + } + ] + }, + { + "cell_type": "code", + "metadata": { + "id": "k4sVIWhxtn8N", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "0d134a34-16ac-4421-c7fd-13c6492f55bc" + }, + "source": [ + "# создать множество через пустые фигурные скобки нельзя\n", + "not_a_set = {}\n", + "\n", + "# так создается словарь\n", + "type(not_a_set)" + ], + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "dict" + ] + }, + "metadata": {}, + "execution_count": 67 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Добавление и удаление элементов" + ], + "metadata": { + "id": "tHsQ7_dCXQkJ" + } + }, + { + "cell_type": "code", + "source": [ + "# предположим, что мы хотим создать множество гласных букв в русском языке\n", + "vowels = {\"а\", \"о\", \"э\", \"е\", \"у\", \"ё\", \"ю\"}" + ], + "metadata": { + "id": "VMdDL588YmOm" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# добавим одну букву \"я\" методом .add()\n", + "vowels.add(\"я\")\n", + "vowels" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "A3b7LnrTuxu9", + "outputId": "5a6319ac-77ea-435c-884d-b16b4e9f3649" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "{'а', 'е', 'о', 'у', 'э', 'ю', 'я', 'ё'}" + ] + }, + "metadata": {}, + "execution_count": 69 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# добавим две буквы \"и\" и \"ы\" методом .update()\n", + "vowels.update([\"и\", \"ы\"])\n", + "vowels" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "RuCG-RnTk9SZ", + "outputId": "d18e632c-25d8-42a9-e441-084807cbcd20" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "{'а', 'е', 'и', 'о', 'у', 'ы', 'э', 'ю', 'я', 'ё'}" + ] + }, + "metadata": {}, + "execution_count": 70 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# если по ошибке мы добавим согласную букву,\n", + "vowels.add(\"щ\")\n", + "vowels" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "6OJBJ5cYvwrl", + "outputId": "0693321a-76a4-4a8a-deda-d3c8b5abd101" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "{'а', 'е', 'и', 'о', 'у', 'щ', 'ы', 'э', 'ю', 'я', 'ё'}" + ] + }, + "metadata": {}, + "execution_count": 71 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# ее можно удалить методом .remove()\n", + "vowels.remove(\"щ\")\n", + "vowels" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "VTCYCiXZv4Wc", + "outputId": "5698ddec-d2a8-4c89-e9d9-d8fc91fb6b2e" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "{'а', 'е', 'и', 'о', 'у', 'ы', 'э', 'ю', 'я', 'ё'}" + ] + }, + "metadata": {}, + "execution_count": 72 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Теория множеств в Питоне" + ], + "metadata": { + "id": "uB1je436aY19" + } + }, + { + "cell_type": "code", + "source": [ + "# два множества равны, если содержат одинаковые элементы, при этом порядок элементов не важен\n", + "{\"a\", \"b\", \"c\"} == {\"c\", \"b\", \"a\"}" + ], + "metadata": { + "id": "ScRveXFjagly", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "2767f29b-0f54-492d-f9dd-3a0cccbe6048" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "True" + ] + }, + "metadata": {}, + "execution_count": 73 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# выведем мощность множества с помощью функции len()\n", + "len({\"a\", \"b\", \"c\"})" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "O5_E1AS9JOL2", + "outputId": "807df047-e851-4a72-9035-c72316d33b59" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "3" + ] + }, + "metadata": {}, + "execution_count": 74 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# проверим, содержится ли элемент во множестве\n", + "\"a\" in {\"a\", \"b\", \"c\"}" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "tktbnMu4JOOY", + "outputId": "2f201ee0-3b16-4ff6-9121-de1f0155834f" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "True" + ] + }, + "metadata": {}, + "execution_count": 75 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# возможна и обратная операция\n", + "\"a\" not in {\"a\", \"b\", \"c\"}" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "7LjJsYc2JORQ", + "outputId": "3d5cd120-68d9-450c-ba02-c95fb0c3f051" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "False" + ] + }, + "metadata": {}, + "execution_count": 76 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# проверим является ли А подмножеством В\n", + "set_A = {\"a\", \"b\", \"c\"}\n", + "set_B = {\"a\", \"b\", \"c\", \"d\", \"e\", \"f\"}\n", + "\n", + "set_A.issubset(set_B)" + ], + "metadata": { + "id": "MF1nGQvDJOUI", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "95c006ba-48be-4766-fa53-293ecdb1ec27" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "True" + ] + }, + "metadata": {}, + "execution_count": 77 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# проверим является ли B надмножеством А\n", + "set_B.issuperset(set_A)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Ne2zLJy3DMT7", + "outputId": "96bcbed1-0112-40f7-f012-149a229f67af" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "True" + ] + }, + "metadata": {}, + "execution_count": 78 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# даны участники команд по обработке естественного языка (nlp)\n", + "# и компьютерному зрению (cv)\n", + "nlp = {\"Анна\", \"Николай\", \"Павел\", \"Оксана\"}\n", + "cv = {\"Николай\", \"Евгений\", \"Ольга\", \"Оксана\"}" + ], + "metadata": { + "id": "0MxJj85iDc_y" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# найдем тех, кто работает или в nlp, или в cv, или в обеих командах\n", + "\n", + "# можно использовать метод .union()\n", + "print(nlp.union(cv))\n", + "\n", + "# или символ |\n", + "print(nlp | cv)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "ipXl-eO5EFKS", + "outputId": "bc4c9d32-c49f-473e-ff79-5631038a2e61" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "{'Павел', 'Евгений', 'Оксана', 'Николай', 'Анна', 'Ольга'}\n", + "{'Павел', 'Евгений', 'Оксана', 'Николай', 'Анна', 'Ольга'}\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# найдем пересечение множеств, то есть тех, кто работает и в nlp, и в cv\n", + "print(nlp.intersection(cv))\n", + "print(nlp & cv)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "vkUEl3eeEnPn", + "outputId": "3606efdb-d621-4268-b072-7c05e676054b" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "{'Оксана', 'Николай'}\n", + "{'Оксана', 'Николай'}\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# выведем тех, кто работает только в nlp, но не в cv или cv и nlp одновременно\n", + "print(nlp.difference(cv))\n", + "print(nlp - cv)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "mNV8c0hQExzL", + "outputId": "0a71a036-d2a9-4728-9f4a-adff5df74b4b" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "{'Анна', 'Павел'}\n", + "{'Анна', 'Павел'}\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# выведем тех, кто работает только в cv, но не в nlp или nlp и cv одновременно\n", + "print(cv.difference(nlp))\n", + "print(cv - nlp)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "RnawDdtME8T4", + "outputId": "9691b8dd-bc78-428c-ec7f-322a316f33ba" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "{'Евгений', 'Ольга'}\n", + "{'Евгений', 'Ольга'}\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# найдем тех, кто работает или в cv, или в nlp, но не в обеих областях одновременно\n", + "print(nlp.symmetric_difference(cv))\n", + "print(nlp ^ cv)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "sHIWgu4ZFEqv", + "outputId": "8f8c106c-3186-4b23-f95c-5d508a708b65" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "{'Павел', 'Евгений', 'Анна', 'Ольга'}\n", + "{'Павел', 'Евгений', 'Анна', 'Ольга'}\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [], + "metadata": { + "id": "8uLziVR-Z5mU" + }, + "execution_count": null, + "outputs": [] + } + ] +} \ No newline at end of file diff --git a/makarov.lists.tuples.py b/makarov.lists.tuples.py new file mode 100644 index 00000000..85745922 --- /dev/null +++ b/makarov.lists.tuples.py @@ -0,0 +1,480 @@ +# ## Списки, кортежи и множества + +# ### Списки + +# Основы работы со списками + +# + +# пустой список можно создать через [] или функцию list() +# импортируем класс стеммера и создаем объект +from nltk.stem import PorterStemmer + +some_list_1 = [] +some_list_2 = list() + +print(some_list_1, some_list_2) +# - + +# элементами списка могут, в частности, быть числа, строки, другие списки и словари +number_three = [3, "число три", ["число", "три"], {"число": 3}] +number_three + +# длина списка рассчитывается через функцию len() +len(number_three) + +# Индекс и срез списка + +# + +# у списка есть положительный и отрицательный индексы +abc_list = ["a", "b", "c", "d", "e"] + +# воспользуемся ими для вывода первого и последнего элементов +print(abc_list[0], abc_list[-1]) + +# + +# при работе с вложенным списком +salary_list = [["Анна", 90000], ["Игорь", 85000], ["Алексей", 95000]] + +# мы вначале указываем индекс вложенного списка, а затем индекс элемента в нем +salary_list[1][0] +# - + +# индекс можно узнать с помощью метода .index() +abc_list.index("c") + +# метод .index() можно применить и ко вложенному списку +salary_list[0].index(90000) + +# + +# создадим список с днями недели +days_list = ["Пн", "Вт", "Ср", "Чт", "Пт", "Сб", "Вс"] + +# и выведем со второго по пятый элемент включительно +days_list[1:5] +# - + +# выведем каждый второй элемент в срезе с первого по пятый +days_list[:5:2] + +# проверим есть ли "Пн" в списке +"Пн" in days_list + +# если "Вт" есть в списке +if "Вт" in days_list: + + # выведем сообщение + print("Такое слово есть") + +# Добавление, замена и удаление элементов списка + +# создадим список +weekdays = ["Понедельник", "Вторник"] + +# добавим один элемент в конец списка с помощью метода .append() +weekdays.append("Четверг") +weekdays + +# добавим элемент в определенное место в списке через желаемый индекс этого элемента +weekdays.insert(2, "Среда") +weekdays + +# изменим четвертый элемент в списке +weekdays[3] = "Пятница" +weekdays + +# удалим элемент по его значению +weekdays.remove("Пятница") +weekdays + +# удалим элемент по его индексу через ключевое слово del +del weekdays[2] +weekdays + +# сделаем то же самое с помощью метода .pop() +# этот метод выводит удаляемый элемент +weekdays.pop(1) + +# посмотрим, что осталось в нашем списке +weekdays + +# Сложение списков + +# + +# соединить два списка можно с помощью метода .extend() +more_weekdays = ["Вторник", "Среда", "Четверг", "Пятница"] + +weekdays.extend(more_weekdays) +weekdays + +# + +weekend = ["Суббота", "Воскресенье"] + +# или просто сложив два списка +print(weekdays + weekend) +# - + +# иногда бывает полезно "размножить" элементы списка +["Понедельник"] * 2 + +# такие "произведения" также можно складывать +["Понедельник"] * 2 + ["Вторник"] * 2 + +# Распаковка списков + +# дан список +week = [ + "Понедельник", + "Вторник", + "Среда", + "Четверг", + "Пятница", + "Суббота", + "Воскресенье", +] + +# указав индекс элемента, его можно записать в переменную +Mon = week[0] +Mon + +# + +# срез можно поместить в несколько переменных +Mon, Tue, Wed = week[:3] + +# важно, чтобы количество элементов среза было равно количеству переменных +Mon, Tue, Wed +# - + +# можно выделить первый элемент, а остальные поместить в переменную со звездочкой +Mon, *_ = week +Mon + +# также можно поступить, например, с первым и последним элементом +Mon, *days, Sun = week +Mon, Sun + +# посмотрим, какие элементы остались в переменной со звездочкой +days + +# Сортировка списков + +# возьмем список чисел +nums = [25, 10, 30, 20, 5, 15] + +# и отсортируем с помощью функции sorted(), результат выводится сразу +sorted(nums) + +# исходный список при этом не изменился +nums + +# если поместить результат в переменную, изменения сохранятся +sorted_nums = sorted(nums) +sorted_nums + +# метод .sort() сохраняет результат, но не выводит его сразу +# reverse = True задает сортировку по убыванию +nums.sort(reverse=True) + +# выведем результат +nums + +# + +# метод .reverse() задает обратный порядок, сохраняет, но не выводит результат +nums.reverse() + +# его также нужно вывести отдельно +nums +# - + +# функция reversed() возвращает итератор +reversed(nums) + +# вывести результат можно с помощью функции list() +list(reversed(nums)) + +# результат при этом не сохраняется +nums + +# Преобразование списка в строку + +# дан список из строковых элементов +str_list = ["P", "y", "t", "h", "o", "n"] + +# с помощью метода .join() можно соединить все элементы +joined_str = "".join(str_list) +joined_str + +# если в кавычках ничего не указывать, элементы просто соединятся, но можно указать любой другой элемент +joined_str_ = "_".join(str_list) +joined_str_ + +# Арифметика в списках + +# дан список чисел +nums_ = [3, 2, 1, 4, 5, 12, 3, 3, 7, 9, 11, 15] + +# с помощью метода .count() мы можем посчитать частоту вхождения элемента в список +nums_.count(3) + +# кроме того мы можем найти минимальное и максимальное значения и сумму элементов +print(min(nums_), max(nums_), sum(nums_)) + +# List comprehension + +# дан список имен +# оставим имена, начинающиеся с буквы "А" +names = ["Артем", "Антон", "Александр", "Борис", "Виктор", "Геннадий"] + +# + +# вначале решим эту задачу с помощью цикла for + +# создадим пустой список +a_names = [] + +# пройдемся по исходному списку в цикле for +for name in names: + + # с помощью метода .startswith() проверим, начинается ли слово с "А" + if name.startswith("А"): + + # если да, добавим в новый список + a_names.append(name) + +# выведем результат +a_names +# - + +# эту же задачу можно решить через list comprehension +# по сути мы пишем: "что сделать, пока есть элемент в списке, при каком условии" +a_names = [name for name in names if name.startswith("А")] +a_names + +# переведем все буквы в строчные, условие здесь не нужно +lower_names = [name.lower() for name in names] +lower_names + +# схема условия if-else немного отличается +# оставляем имя, если это не Виктор, если Виктор - заменяем на Вадим +replace_name = [name if name != "Виктор" else "Вадим" for name in names] +replace_name + +# + +# на занятии по обработке естественного языка с помощью list comprehension +# мы применили стеммер Портера к списку слов +lemmatized = [ + "paris", + "visited", + "lot", + "museum", + "first", + "went", + "louvre", + "largest", + "art", + "museum", + "world", + "always", + "interested", + "art", + "spent", + "many", + "hour", + "museum", + "enormous", + "week", + "would", + "enough", +] + + +porter = PorterStemmer() + +# применяем стеммер к элементу s, пока есть элементы s в списке lemmatized +stemmed_p = [porter.stem(s) for s in lemmatized] +print(stemmed_p) +# - + +# ### Кортежи + +# Основы работы с кортежами + +# пустой кортеж можно создать с помощью пустых круглых скобок () или функции tuple() +tuple_1, tuple_2 = (), tuple() +print(tuple_1, tuple_2) + +# в кортеже элементы упорядочены, а значит есть индекс +letters = ("a", "b", "c") +letters[0] + +# но изменить элемент, как мы это делали в списке, нельзя +letters[0] = "d" + +# для изменения элемента кортеж вначале нужно преобразовать в список +letters = list(letters) +letters[0] = "d" +letters + +# кортеж из одного элемента можно создать с помощью запятой +let_a = ("a",) +type(let_a) + +# если запятую не указывать, получится строка +let_a = "a" +type(let_a) + +# Функция enumerate() + +# + +companies = ["Microsoft", "Apple", "Tesla"] + +# если записать результат функции enumerate() в одну переменную, +for company in enumerate(companies): + + # то мы получим кортежи + print(company, type(company)) +# - + +# Просмотр элементов словаря + +shopping_dict = {"огурцы": 2, "помидоры": 3, "лук": 1, "картофель": 2} + +# то же самое со словарем и методом .items() +for item in shopping_dict.items(): + print(item) + +# Распаковка кортежей + +# как и список, кортеж можно распаковать в несколько переменных +a, b, c = ("a", "b", "c") +print(a) + +# + +companies = ["Microsoft", "Apple", "Tesla"] + +# распаковку в две переменные с функцией enumerate() мы делать уже умеем +for i, company in enumerate(companies): + print(i, company) + +# + +shopping_dict = {"огурцы": 2, "помидоры": 3, "лук": 1, "картофель": 2} + +# то же самое с ключами и значениями словаря +for k, v in shopping_dict.items(): + print(k, v) +# - + +# Функция zip() + +# + +# если есть два и более списка +names = ["Артем", "Антон", "Александр", "Борис", "Виктор", "Геннадий"] +income = [97000, 110000, 95000, 84000, 140000, 120000] + +# функция zip() соединит первые элементы списков, вторые элементы списков и т.д. +zip(names, income) +# - + +# для вывода результата нужно передать zip-объект в функцию list() +# на выходе мы получим список из кортежей +list(zip(names, income)) + +# ### Множества + +# Создание множества + +# + +# пустое множество задается через функцию set() +set_1 = set() + +# непустое множество задается через функцию set() и список элементов +set_2 = {"a", "b", "c", "c"} + +# или путем перечисления элементов в фигурных скобках {} +set_3 = {"a", "b", "c", "c"} + +# множество содержит только уникальные элементы, поэтому дубликаты удаляются +print(set_1, set_2, set_3) + +# + +# создать множество через пустые фигурные скобки нельзя +not_a_set = {} + +# так создается словарь +type(not_a_set) +# - + +# Добавление и удаление элементов + +# предположим, что мы хотим создать множество гласных букв в русском языке +vowels = {"а", "о", "э", "е", "у", "ё", "ю"} + +# добавим одну букву "я" методом .add() +vowels.add("я") +vowels + +# добавим две буквы "и" и "ы" методом .update() +vowels.update(["и", "ы"]) +vowels + +# если по ошибке мы добавим согласную букву, +vowels.add("щ") +vowels + +# ее можно удалить методом .remove() +vowels.remove("щ") +vowels + +# Теория множеств в Питоне + +# два множества равны, если содержат одинаковые элементы, при этом порядок элементов не важен +{"a", "b", "c"} == {"c", "b", "a"} + +# выведем мощность множества с помощью функции len() +len({"a", "b", "c"}) + +# проверим, содержится ли элемент во множестве +"a" in {"a", "b", "c"} + +# возможна и обратная операция +"a" not in {"a", "b", "c"} + +# + +# проверим является ли А подмножеством В +set_A = {"a", "b", "c"} +set_B = {"a", "b", "c", "d", "e", "f"} + +set_A.issubset(set_B) +# - + +# проверим является ли B надмножеством А +set_B.issuperset(set_A) + +# даны участники команд по обработке естественного языка (nlp) +# и компьютерному зрению (cv) +nlp = {"Анна", "Николай", "Павел", "Оксана"} +cv = {"Николай", "Евгений", "Ольга", "Оксана"} + +# + +# найдем тех, кто работает или в nlp, или в cv, или в обеих командах + +# можно использовать метод .union() +print(nlp.union(cv)) + +# или символ | +print(nlp | cv) +# - + +# найдем пересечение множеств, то есть тех, кто работает и в nlp, и в cv +print(nlp.intersection(cv)) +print(nlp & cv) + +# выведем тех, кто работает только в nlp, но не в cv или cv и nlp одновременно +print(nlp.difference(cv)) +print(nlp - cv) + +# выведем тех, кто работает только в cv, но не в nlp или nlp и cv одновременно +print(cv.difference(nlp)) +print(cv - nlp) + +# найдем тех, кто работает или в cv, или в nlp, но не в обеих областях одновременно +print(nlp.symmetric_difference(cv)) +print(nlp ^ cv) diff --git a/makarov_Decorators.ipynb b/makarov_Decorators.ipynb new file mode 100644 index 00000000..8dcc5a99 --- /dev/null +++ b/makarov_Decorators.ipynb @@ -0,0 +1,1941 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [], + "toc_visible": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "markdown", + "source": [ + "# Декораторы" + ], + "metadata": { + "id": "uj3W4pZ3dgXv" + } + }, + { + "cell_type": "markdown", + "source": [ + "### Объекты первого класса" + ], + "metadata": { + "id": "UWUu0aaT-u4B" + } + }, + { + "cell_type": "markdown", + "source": [ + "Присвоение функции переменной" + ], + "metadata": { + "id": "IXifYlrj_YbX" + } + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "ahhHl0zTdfxX" + }, + "outputs": [], + "source": [ + "# объявим функцию\n", + "import functools\n", + "import time\n", + "\n", + "\n", + "def say_hello(name):\n", + " print(f\"Привет, {name}!\")" + ] + }, + { + "cell_type": "code", + "source": [ + "# присвоим эту функцию переменной (без скобок)\n", + "say_hello_function = say_hello\n", + "# вызовем функцию из новой переменной\n", + "say_hello_function(\"Алексей\")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "VKrmngnh-xqg", + "outputId": "43f26846-32a2-4a7c-ab74-ac3066ddbd57" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Привет, Алексей!\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Передача функции в качестве аргумента другой функции" + ], + "metadata": { + "id": "INxKkQT__c41" + } + }, + { + "cell_type": "code", + "source": [ + "def simple_calculator(operation, a, b):\n", + " return operation(a, b)\n", + "\n", + "\n", + "def add(a, b):\n", + " return a + b\n", + "\n", + "\n", + "def subtract(a, b):\n", + " return a - b\n", + "\n", + "\n", + "def multiply(a, b):\n", + " return a * b\n", + "\n", + "\n", + "def divide(a, b):\n", + " return a / b" + ], + "metadata": { + "id": "YEwkUtPu_Iaf" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "simple_calculator(divide, 1, 3)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "C0tKH9zgACpY", + "outputId": "73672462-f6be-4036-f019-628a3d0e23c0" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "0.3333333333333333" + ] + }, + "metadata": {}, + "execution_count": 49 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "### Внутренние функции" + ], + "metadata": { + "id": "jU0WfJWIN-cs" + } + }, + { + "cell_type": "markdown", + "source": [ + "Вызов внутренней функции" + ], + "metadata": { + "id": "uOl-kzspPzwv" + } + }, + { + "cell_type": "code", + "source": [ + "def outer():\n", + " print(\"Вызов внешней функции.\")\n", + "\n", + " # обратите внимание, мы объявляем, а затем\n", + " def inner():\n", + " print(\"Вызов внутренней функции.\")\n", + "\n", + " # вызываем внутреннюю функцию\n", + " inner()" + ], + "metadata": { + "id": "wom-NUQnOZYs" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "outer()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "EG7HyDpGOpqF", + "outputId": "7afd2d51-8199-4eb9-8a4c-27afe15b655d" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Вызов внешней функции.\n", + "Вызов внутренней функции.\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# inner()" + ], + "metadata": { + "id": "lq8mXyyFPmNi" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "Возвращение функции из функции и замыкание" + ], + "metadata": { + "id": "ggx5eY1BP2E_" + } + }, + { + "cell_type": "code", + "source": [ + "def create_multiplier(factor):\n", + " def multiplier(number):\n", + " return number * factor\n", + "\n", + " return multiplier" + ], + "metadata": { + "id": "f92IsJmiAGEm" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "double = create_multiplier(factor=2)\n", + "triple = create_multiplier(factor=3)" + ], + "metadata": { + "id": "RKJh1YXZPfvy" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "double" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 103 + }, + "id": "n3gfeRpjQJv7", + "outputId": "cf19c87f-2159-40cb-93a8-476f8954e477" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + ".multiplier(number)>" + ], + "text/html": [ + "
\n", + " 
create_multiplier.<locals>.multiplier
def multiplier(number)
/tmp/ipython-input-53-514475797.py<no docstring>
" + ] + }, + "metadata": {}, + "execution_count": 55 + } + ] + }, + { + "cell_type": "code", + "source": [ + "double(number=2), triple(number=2)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "8e_BM_ZbPSrL", + "outputId": "e2e72c8d-1599-4a9b-8c9a-895845021852" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(4, 6)" + ] + }, + "metadata": {}, + "execution_count": 56 + } + ] + }, + { + "cell_type": "code", + "source": [ + "def create_multiplier(factor):\n", + " return lambda number: factor * number" + ], + "metadata": { + "id": "iiyiBcU8dAqM" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "triple = create_multiplier(factor=3)\n", + "triple(number=2)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "VuEd1WLtdMVY", + "outputId": "779967db-9a33-42e6-9f29-1f9b57b098a6" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "6" + ] + }, + "metadata": {}, + "execution_count": 58 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "### Знакомство с декораторами" + ], + "metadata": { + "id": "jOxX3byTQcvZ" + } + }, + { + "cell_type": "markdown", + "source": [ + "Простой декоратор" + ], + "metadata": { + "id": "fl2py8bY_MGw" + } + }, + { + "cell_type": "code", + "source": [ + "def simple_decorator(func):\n", + " def wrapper():\n", + " print(\"Текст до вызова функции func().\")\n", + " func()\n", + " print(\"Текст после вызова функции func().\")\n", + "\n", + " return wrapper\n", + "\n", + "\n", + "def say_hello():\n", + " print(\"Привет!\")" + ], + "metadata": { + "id": "DqWzDydyPdS6" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "say_hello = simple_decorator(say_hello)" + ], + "metadata": { + "id": "YeZqM0Ri-0cE" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "say_hello()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "bRD44QdeTtbL", + "outputId": "26d50e1d-8dac-422f-a4b1-7250cd64f8c3" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Текст до вызова функции func().\n", + "Привет!\n", + "Текст после вызова функции func().\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Конструкция @decorator" + ], + "metadata": { + "id": "3_n1GHNRDn-u" + } + }, + { + "cell_type": "code", + "source": [ + "@simple_decorator\n", + "def say_hi():\n", + " print(\"Снова, привет!\")" + ], + "metadata": { + "id": "aPTsoheWUyqO" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "say_hi()" + ], + "metadata": { + "id": "8FRvX4NEUl6T", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "85a01dca-c68d-41b9-ea86-a489a8d45d50" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Текст до вызова функции func().\n", + "Снова, привет!\n", + "Текст после вызова функции func().\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Функции с аргументами" + ], + "metadata": { + "id": "JaGa8Qwr_N-5" + } + }, + { + "cell_type": "code", + "source": [ + "@simple_decorator\n", + "def say_hello_with_name(name):\n", + " print(f\"Привет, {name}!\")" + ], + "metadata": { + "id": "fKHekNgUHFLo" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# say_hello_with_name('Алексей')" + ], + "metadata": { + "id": "EeW8G0LsHPJu" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "def decorator_with_name_argument(func):\n", + " def wrapper(name):\n", + " print(\"Текст до вызова функции func().\")\n", + " func(name)\n", + " print(\"Текст после вызова функции func().\")\n", + "\n", + " return wrapper" + ], + "metadata": { + "id": "WLoje-LpU_tJ" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "@decorator_with_name_argument\n", + "def say_hello_with_name(name):\n", + " print(f\"Привет, {name}!\")" + ], + "metadata": { + "id": "HcQaW7IAVm5Q" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "say_hello_with_name(\"Алексей\")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Ps96hpvjV9Ra", + "outputId": "95ea1054-a1e0-49ee-cc9b-a93fa8075804" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Текст до вызова функции func().\n", + "Привет, Алексей!\n", + "Текст после вызова функции func().\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "def decorator_with_arguments(func):\n", + " def wrapper(*args, **kwargs):\n", + " print(\"Текст до вызова функции func().\")\n", + " func(*args, **kwargs)\n", + " print(\"Текст после вызова функции func().\")\n", + "\n", + " return wrapper" + ], + "metadata": { + "id": "XLO10uz8jTgf" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "@decorator_with_arguments\n", + "def say_hello_with_argument(name):\n", + " print(f\"Привет, {name}!\")" + ], + "metadata": { + "id": "mmkQw_NeQgDo" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "say_hello_with_argument(\"Алексей\")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "6an3iiFLQjhx", + "outputId": "709e6c14-596e-4feb-ffd3-f8c3d0ef796f" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Текст до вызова функции func().\n", + "Привет, Алексей!\n", + "Текст после вызова функции func().\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Возвращение значения декорируемой функции" + ], + "metadata": { + "id": "nYfQs9qTTvpx" + } + }, + { + "cell_type": "code", + "source": [ + "def another_decorator(func):\n", + " def wrapper(*args, **kwargs):\n", + " print(\"Текст внутренней функции.\")\n", + " func(*args, **kwargs)\n", + "\n", + " return wrapper" + ], + "metadata": { + "id": "n3O_bUeDcd6H" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "@another_decorator\n", + "def return_name(name):\n", + " return name" + ], + "metadata": { + "id": "0QfyEIQ0Tyo1" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "returned_value = return_name(\"Алексей\")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Odulil-rT_6L", + "outputId": "c87fc41e-03c5-4af8-d8eb-4cc98e3a7db3" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Текст внутренней функции.\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "print(returned_value)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Z4mn1aNqUItV", + "outputId": "c86cc40d-161b-4196-8fa5-640d6ad05008" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "None\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "def another_decorator(func):\n", + " def wrapper(*args, **kwargs):\n", + " print(\"Текст внутренней функции.\")\n", + " return func(*args, **kwargs) # внутренняя функция возвращает func()\n", + "\n", + " return wrapper" + ], + "metadata": { + "id": "vY4KoCEpUWPF" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "@another_decorator\n", + "def return_name(name):\n", + " return name" + ], + "metadata": { + "id": "pdBi1JIgUfbA" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "returned_value = return_name(\"Алексей\")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "DgmF5Y80UhxE", + "outputId": "fe7a2730-8dec-4c6e-9cba-3b6e16a71c04" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Текст внутренней функции.\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "print(returned_value)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "C2pBMz0WcDdL", + "outputId": "76d1d18f-d81e-49c9-eecc-9bcfddcf88ff" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Алексей\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Декоратор @functools.wraps" + ], + "metadata": { + "id": "96f9wVE9V9Vr" + } + }, + { + "cell_type": "code", + "source": [ + "def square(x):\n", + " \"\"\"Squares a number\"\"\"\n", + " return x * x" + ], + "metadata": { + "id": "MdPnhLh7UjM8" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "square.__name__, square.__doc__" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "V4UwZvebVvGN", + "outputId": "2fd308ec-95f3-4dad-e197-8c77a432f69c" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "('square', 'Squares a number')" + ] + }, + "metadata": {}, + "execution_count": 81 + } + ] + }, + { + "cell_type": "code", + "source": [ + "def repeat_twice(func):\n", + " def wrapper(*args, **kwargs):\n", + " func(*args, **kwargs)\n", + " func(*args, **kwargs)\n", + "\n", + " return wrapper" + ], + "metadata": { + "id": "0iKP_IpEWNnn" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "@repeat_twice\n", + "def square(x):\n", + " \"\"\"Squares a number\"\"\"\n", + " return x * x" + ], + "metadata": { + "id": "XQPua1yJVwWl" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "square(3)" + ], + "metadata": { + "id": "Xp1b9jLebCpC" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "square.__name__, square.__doc__" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "g5Ijk3fvXDtD", + "outputId": "c0680c69-21fa-47c6-c89d-22c5083f7a2b" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "('wrapper', None)" + ] + }, + "metadata": {}, + "execution_count": 85 + } + ] + }, + { + "cell_type": "code", + "source": [ + "def repeat_twice(func):\n", + " @functools.wraps(func)\n", + " def wrapper(*args, **kwargs):\n", + " func(*args, **kwargs)\n", + " func(*args, **kwargs)\n", + "\n", + " return wrapper" + ], + "metadata": { + "id": "TlJNvigxXMZE" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "@repeat_twice\n", + "def square(x):\n", + " \"\"\"Squares a number\"\"\"\n", + " print(x * x)" + ], + "metadata": { + "id": "DpxKd94oXQlA" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "square.__name__, square.__doc__" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "YsaelJl3YVA0", + "outputId": "9e453de0-6370-41d4-ac20-1d060b0592f3" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "('square', 'Squares a number')" + ] + }, + "metadata": {}, + "execution_count": 88 + } + ] + }, + { + "cell_type": "code", + "source": [ + "square.__wrapped__" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 103 + }, + "id": "Wvl0I71Oh4dc", + "outputId": "3ce27822-0bbe-4008-f36e-3d5a9d9807db" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ], + "text/html": [ + "
\n", + " 
square
def square(x)
/tmp/ipython-input-87-3043693703.pySquares a number
" + ] + }, + "metadata": {}, + "execution_count": 89 + } + ] + }, + { + "cell_type": "code", + "source": [ + "def repeat_twice(func):\n", + " def wrapper(*args, **kwargs):\n", + " func(*args, **kwargs)\n", + " func(*args, **kwargs)\n", + "\n", + " functools.update_wrapper(wrapper, func)\n", + " return wrapper" + ], + "metadata": { + "id": "tNFRtACYf2Ik" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "@repeat_twice\n", + "def power(x, n):\n", + " \"\"\"Raises to a power\"\"\"\n", + " print(x**n)" + ], + "metadata": { + "id": "OqtPbkS0f-Ox" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "power(2, 3)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "cUOkkwwdgFHh", + "outputId": "898e551c-b7bc-4f4f-a647-5342b1d174f5" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "8\n", + "8\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "power.__doc__" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 37 + }, + "id": "HZvDG-hRgHbZ", + "outputId": "258e9681-6bac-4d0f-c4bd-7f639e2ff18b" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "'Raises to a power'" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "string" + } + }, + "metadata": {}, + "execution_count": 93 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "### Примеры декораторов" + ], + "metadata": { + "id": "DRNFII11hPme" + } + }, + { + "cell_type": "markdown", + "source": [ + "Создание логов" + ], + "metadata": { + "id": "90ciKrTXhR4y" + } + }, + { + "cell_type": "code", + "source": [ + "def logging(func):\n", + " def wrapper(*args, **kwargs):\n", + " print(f\"Calling {func.__name__} with args: {args}, kwargs: {kwargs}\")\n", + " result = func(*args, **kwargs)\n", + " print(f\"{func.__name__} returned: {result}\")\n", + " return result\n", + "\n", + " return wrapper" + ], + "metadata": { + "id": "PjrkD7rTgQZh" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "@logging\n", + "def power(x, n):\n", + " return x**n\n", + "\n", + "\n", + "power(5, 3)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "q5a47uz5iDcE", + "outputId": "f98c0fa3-3b97-4247-a5ae-cbc0da48e92a" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Calling power with args: (5, 3), kwargs: {}\n", + "power returned: 125\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "125" + ] + }, + "metadata": {}, + "execution_count": 95 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Время исполнения функции" + ], + "metadata": { + "id": "BATiTOZch5Hd" + } + }, + { + "cell_type": "code", + "source": [ + "def timer(func):\n", + " def wrapper(*args, **kwargs):\n", + " start_time = time.time()\n", + " result = func(*args, **kwargs)\n", + " end_time = time.time()\n", + " print(f\"{func.__name__} executed in {end_time - start_time:.4f} seconds\")\n", + " return result\n", + "\n", + " return wrapper" + ], + "metadata": { + "id": "JzUr3gBrhgsg" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "@timer\n", + "def delayed_function(t):\n", + " time.sleep(t)\n", + " return \"execution completed\"\n", + "\n", + "\n", + "delayed_function(2)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 55 + }, + "id": "MvgB0y7IiKEJ", + "outputId": "35bdcec2-a698-40c0-8357-d49bf741c4fb" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "delayed_function executed in 2.0001 seconds\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "'execution completed'" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "string" + } + }, + "metadata": {}, + "execution_count": 97 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "### Типы методов" + ], + "metadata": { + "id": "Far9nIP_lBcV" + } + }, + { + "cell_type": "markdown", + "source": [ + "Методы экземпляра" + ], + "metadata": { + "id": "yiBHRhX0mr1X" + } + }, + { + "cell_type": "code", + "source": [ + "class CatClass:\n", + "\n", + " def __init__(self, color):\n", + " self.color = color\n", + " self.type_ = \"cat\"\n", + "\n", + " def info(self):\n", + " print(self.color, self.type_, sep=\", \")" + ], + "metadata": { + "id": "uMswH5MoiBQg" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "cat = CatClass(color=\"black\")\n", + "cat.info()" + ], + "metadata": { + "id": "ORHkpRULnV48", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "5fab4183-8729-4a02-8996-a35b50a330fd" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "black, cat\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# CatClass.info()" + ], + "metadata": { + "id": "VUKAK7pIO0OU" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# CatClass.color" + ], + "metadata": { + "id": "mXPMkHLjQn_i" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "Методы класса" + ], + "metadata": { + "id": "Ny5x6rT7o3sN" + } + }, + { + "cell_type": "code", + "source": [ + "class CatClass:\n", + "\n", + " species = \"кошка\" # переменная класса доступна всем экземлярам\n", + "\n", + " def __init__(self, color):\n", + " self.color = color\n", + "\n", + " def info(self):\n", + " print(self.color)\n", + "\n", + " @classmethod\n", + " def get_species(cls):\n", + " print(cls.species)\n", + " # нет доступа к переменным color и type_" + ], + "metadata": { + "id": "CIn4oi0TniKB" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "CatClass.species" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 37 + }, + "id": "OeiyzIrgoJnW", + "outputId": "f7cd1440-f237-4aa4-cff6-e2d35fa3be4d" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "'кошка'" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "string" + } + }, + "metadata": {}, + "execution_count": 103 + } + ] + }, + { + "cell_type": "code", + "source": [ + "CatClass.get_species()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "qq-lk-R1nInf", + "outputId": "764649e5-7dcb-4178-c46c-b11d81724efe" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "кошка\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Статические методы" + ], + "metadata": { + "id": "ksfgajzZo9wu" + } + }, + { + "cell_type": "code", + "source": [ + "class CatClass:\n", + "\n", + " species = \"кошка\"\n", + "\n", + " def __init__(self, color):\n", + " self.color = color\n", + " self.type_ = \"cat\"\n", + "\n", + " def info(self):\n", + " print(self.color, self.type_)\n", + "\n", + " @classmethod\n", + " def get_species(cls):\n", + " print(cls.species)\n", + " # нет доступа к переменным color и type_\n", + "\n", + " @staticmethod\n", + " def convert_to_pounds(x):\n", + " print(f\"{x} kg is approximately {x * 2.205} pounds\")\n", + " # нет доступа к переменным species, color и type_" + ], + "metadata": { + "id": "JuPIH3Z7o0n2" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "CatClass.convert_to_pounds(4)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "bfz6Wubqp-AO", + "outputId": "d42fac14-e6b5-4be2-ab69-66b1e7e7c049" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "4 kg is approximately 8.82 pounds\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "cat = CatClass(\"gray\")\n", + "cat.convert_to_pounds(5)" + ], + "metadata": { + "id": "DaLLVoiEqEQF", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "486cda8c-a04f-4e3c-db24-13281f3cee9e" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "5 kg is approximately 11.025 pounds\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "### Декорирование класса" + ], + "metadata": { + "id": "xy2HkzH6ZrRG" + } + }, + { + "cell_type": "markdown", + "source": [ + "Декорирование методов" + ], + "metadata": { + "id": "zKj05Fh06Sm_" + } + }, + { + "cell_type": "code", + "source": [ + "class CatClass:\n", + "\n", + " @logging\n", + " def __init__(self, color):\n", + " self.color = color\n", + " self.type_ = \"cat\"\n", + "\n", + " @timer\n", + " def info(self):\n", + " time.sleep(2)\n", + " print(self.color, self.type_, sep=\", \")" + ], + "metadata": { + "id": "G9MuM7PCZs8-" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "cat = CatClass(\"black\")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "3fiHjwEJ4cTV", + "outputId": "cd8d8c29-666c-44c3-a103-087093a1db83" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Calling __init__ with args: (<__main__.CatClass object at 0x7fac3c1aa790>, 'black'), kwargs: {}\n", + "__init__ returned: None\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "cat.info()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Kt7-LubB4y6g", + "outputId": "ee6e78e7-6269-4b3d-8a7b-075938562c9d" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "black, cat\n", + "info executed in 2.0003 seconds\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Декорирование всего класса" + ], + "metadata": { + "id": "epmndsSc6Uvh" + } + }, + { + "cell_type": "code", + "source": [ + "@timer\n", + "class CatClass:\n", + "\n", + " def __init__(self, color):\n", + " self.color = color\n", + " self.type_ = \"cat\"\n", + "\n", + " def info(self):\n", + " time.sleep(2)\n", + " print(self.color, self.type_, sep=\", \")" + ], + "metadata": { + "id": "0cXQX0004174" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "cat = CatClass(\"gray\")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "P6aIA7_a6gZh", + "outputId": "c40ae050-d7dc-4488-a3ec-cfdf93be806b" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "CatClass executed in 0.0000 seconds\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "cat.info()" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "-HqSIPFG6jo2", + "outputId": "bc78ba12-4f6c-4a8f-9499-96b6feb5a561" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "gray, cat\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "setattr(cat, \"weight\", 5)" + ], + "metadata": { + "id": "wN17-w_s7WI7" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "cat.weight, getattr(cat, \"weight\")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "w-3c9Vny7d4f", + "outputId": "81981202-4e38-491b-8078-1100747bf04b" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "(5, 5)" + ] + }, + "metadata": {}, + "execution_count": 115 + } + ] + }, + { + "cell_type": "code", + "source": [ + "def add_attribute(attribute_name, attribute_value):\n", + " def wrapper(cls):\n", + " setattr(cls, attribute_name, attribute_value)\n", + " return cls\n", + "\n", + " return wrapper" + ], + "metadata": { + "id": "suehA7UO6ldC" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "@add_attribute(\"species\", \"кошка\")\n", + "class CatClass:\n", + "\n", + " def __init__(self, color):\n", + " self.color = color\n", + " self.type_ = \"cat\"" + ], + "metadata": { + "id": "ra4O3lsm62RO" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "CatClass.species" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 37 + }, + "id": "VRPuN3Wk75y4", + "outputId": "201d5a8f-811b-4812-e834-2874b53ccd8d" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "'кошка'" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "string" + } + }, + "metadata": {}, + "execution_count": 118 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "### Несколько декораторов" + ], + "metadata": { + "id": "D9EuxH7p8Tcz" + } + }, + { + "cell_type": "code", + "source": [ + "@logging\n", + "@timer\n", + "def delayed_function(t):\n", + " time.sleep(t)\n", + " return \"execution completed\"" + ], + "metadata": { + "id": "NqYf_Co077ii" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "delayed_function(2)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 91 + }, + "id": "Px_2Rz_Z8goN", + "outputId": "7f998623-0dd3-4a0f-e8dd-27eab7506d4a" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Calling wrapper with args: (2,), kwargs: {}\n", + "delayed_function executed in 2.0001 seconds\n", + "wrapper returned: execution completed\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "'execution completed'" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "string" + } + }, + "metadata": {}, + "execution_count": 120 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# не забудем заново объявить функцию без декораторов\n", + "\n", + "\n", + "def delayed_function(t):\n", + " time.sleep(t)\n", + " return \"execution completed\"" + ], + "metadata": { + "id": "6vA85Et4Gs4v" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "delayed_function = logging(timer(delayed_function))\n", + "delayed_function(2)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 91 + }, + "id": "oBdmnqV18ifq", + "outputId": "91a5a86a-5090-49ae-8476-8c7c6b4bf981" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Calling wrapper with args: (2,), kwargs: {}\n", + "delayed_function executed in 2.0001 seconds\n", + "wrapper returned: execution completed\n" + ] + }, + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "'execution completed'" + ], + "application/vnd.google.colaboratory.intrinsic+json": { + "type": "string" + } + }, + "metadata": {}, + "execution_count": 122 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "### Декораторы с аргументами" + ], + "metadata": { + "id": "drHaoUEXEPfP" + } + }, + { + "cell_type": "code", + "source": [ + "def repeat(n_times):\n", + " def inner_decorator(func):\n", + " @functools.wraps(func)\n", + " def wrapper(*args, **kwargs):\n", + " for _ in range(n_times):\n", + " func(*args, **kwargs)\n", + "\n", + " return wrapper\n", + "\n", + " return inner_decorator" + ], + "metadata": { + "id": "wrew14E2Fm2L" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "@repeat(n_times=3)\n", + "def say_hello(name):\n", + " print(f\"Привет, {name}!\")" + ], + "metadata": { + "id": "1KdWR3viIeBk" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "say_hello(\"Алексей\")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "N2zEUb1IIiJ6", + "outputId": "542eff2e-1641-421f-a208-12a53e98037e" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Привет, Алексей!\n", + "Привет, Алексей!\n", + "Привет, Алексей!\n" + ] + } + ] + } + ] +} \ No newline at end of file diff --git a/makarov_Decorators.py b/makarov_Decorators.py new file mode 100644 index 00000000..7702e6ce --- /dev/null +++ b/makarov_Decorators.py @@ -0,0 +1,542 @@ +# # Декораторы + +# ### Объекты первого класса + +# Присвоение функции переменной + +# + +# объявим функцию +import functools +import time + + +def say_hello(name): + print(f"Привет, {name}!") + + +# - + +# присвоим эту функцию переменной (без скобок) +say_hello_function = say_hello +# вызовем функцию из новой переменной +say_hello_function("Алексей") + + +# Передача функции в качестве аргумента другой функции + + +# + +def simple_calculator(operation, a, b): + return operation(a, b) + + +def add(a, b): + return a + b + + +def subtract(a, b): + return a - b + + +def multiply(a, b): + return a * b + + +def divide(a, b): + return a / b + + +# - + +simple_calculator(divide, 1, 3) + + +# ### Внутренние функции + +# Вызов внутренней функции + + +def outer(): + print("Вызов внешней функции.") + + # обратите внимание, мы объявляем, а затем + def inner(): + print("Вызов внутренней функции.") + + # вызываем внутреннюю функцию + inner() + + +outer() + + +# + +# inner() +# - + +# Возвращение функции из функции и замыкание + + +def create_multiplier(factor): + def multiplier(number): + return number * factor + + return multiplier + + +double = create_multiplier(factor=2) +triple = create_multiplier(factor=3) + +double + +double(number=2), triple(number=2) + + +def create_multiplier(factor): + return lambda number: factor * number + + +triple = create_multiplier(factor=3) +triple(number=2) + + +# ### Знакомство с декораторами + +# Простой декоратор + + +# + +def simple_decorator(func): + def wrapper(): + print("Текст до вызова функции func().") + func() + print("Текст после вызова функции func().") + + return wrapper + + +def say_hello(): + print("Привет!") + + +# - + +say_hello = simple_decorator(say_hello) + +say_hello() + + +# Конструкция @decorator + + +@simple_decorator +def say_hi(): + print("Снова, привет!") + + +say_hi() + + +# Функции с аргументами + + +@simple_decorator +def say_hello_with_name(name): + print(f"Привет, {name}!") + + +# + +# say_hello_with_name('Алексей') +# - + + +def decorator_with_name_argument(func): + def wrapper(name): + print("Текст до вызова функции func().") + func(name) + print("Текст после вызова функции func().") + + return wrapper + + +@decorator_with_name_argument +def say_hello_with_name(name): + print(f"Привет, {name}!") + + +say_hello_with_name("Алексей") + + +def decorator_with_arguments(func): + def wrapper(*args, **kwargs): + print("Текст до вызова функции func().") + func(*args, **kwargs) + print("Текст после вызова функции func().") + + return wrapper + + +@decorator_with_arguments +def say_hello_with_argument(name): + print(f"Привет, {name}!") + + +say_hello_with_argument("Алексей") + + +# Возвращение значения декорируемой функции + + +def another_decorator(func): + def wrapper(*args, **kwargs): + print("Текст внутренней функции.") + func(*args, **kwargs) + + return wrapper + + +@another_decorator +def return_name(name): + return name + + +returned_value = return_name("Алексей") + +print(returned_value) + + +def another_decorator(func): + def wrapper(*args, **kwargs): + print("Текст внутренней функции.") + return func(*args, **kwargs) # внутренняя функция возвращает func() + + return wrapper + + +@another_decorator +def return_name(name): + return name + + +returned_value = return_name("Алексей") + +print(returned_value) + + +# Декоратор @functools.wraps + + +def square(x): + """Squares a number.""" + return x * x + + +square.__name__, square.__doc__ + + +def repeat_twice(func): + def wrapper(*args, **kwargs): + func(*args, **kwargs) + func(*args, **kwargs) + + return wrapper + + +@repeat_twice +def square(x): + """Squares a number.""" + return x * x + + +square(3) + +square.__name__, square.__doc__ + + +def repeat_twice(func): + @functools.wraps(func) + def wrapper(*args, **kwargs): + func(*args, **kwargs) + func(*args, **kwargs) + + return wrapper + + +@repeat_twice +def square(x): + """Squares a number.""" + print(x * x) + + +square.__name__, square.__doc__ + +square.__wrapped__ + + +def repeat_twice(func): + def wrapper(*args, **kwargs): + func(*args, **kwargs) + func(*args, **kwargs) + + functools.update_wrapper(wrapper, func) + return wrapper + + +@repeat_twice +def power(x, n): + """Raises to a power.""" + print(x**n) + + +power(2, 3) + +power.__doc__ + + +# ### Примеры декораторов + +# Создание логов + + +def logging(func): + def wrapper(*args, **kwargs): + print(f"Calling {func.__name__} with args: {args}, kwargs: {kwargs}") + result = func(*args, **kwargs) + print(f"{func.__name__} returned: {result}") + return result + + return wrapper + + +# + +@logging +def power(x, n): + return x**n + + +power(5, 3) + + +# - + +# Время исполнения функции + + +def timer(func): + def wrapper(*args, **kwargs): + start_time = time.time() + result = func(*args, **kwargs) + end_time = time.time() + print(f"{func.__name__} executed in {end_time - start_time:.4f} seconds") + return result + + return wrapper + + +# + +@timer +def delayed_function(t): + time.sleep(t) + return "execution completed" + + +delayed_function(2) + + +# - + +# ### Типы методов + +# Методы экземпляра + + +class CatClass: + + def __init__(self, color): + self.color = color + self.type_ = "cat" + + def info(self): + print(self.color, self.type_, sep=", ") + + +cat = CatClass(color="black") +cat.info() + + +# + +# CatClass.info() + +# + +# CatClass.color +# - + +# Методы класса + + +class CatClass: + + species = "кошка" # переменная класса доступна всем экземлярам + + def __init__(self, color): + self.color = color + + def info(self): + print(self.color) + + @classmethod + def get_species(cls): + print(cls.species) + # нет доступа к переменным color и type_ + + +CatClass.species + +CatClass.get_species() + + +# Статические методы + + +class CatClass: + + species = "кошка" + + def __init__(self, color): + self.color = color + self.type_ = "cat" + + def info(self): + print(self.color, self.type_) + + @classmethod + def get_species(cls): + print(cls.species) + # нет доступа к переменным color и type_ + + @staticmethod + def convert_to_pounds(x): + print(f"{x} kg is approximately {x * 2.205} pounds") + # нет доступа к переменным species, color и type_ + + +CatClass.convert_to_pounds(4) + +cat = CatClass("gray") +cat.convert_to_pounds(5) + + +# ### Декорирование класса + +# Декорирование методов + + +class CatClass: + + @logging + def __init__(self, color): + self.color = color + self.type_ = "cat" + + @timer + def info(self): + time.sleep(2) + print(self.color, self.type_, sep=", ") + + +cat = CatClass("black") + +cat.info() + + +# Декорирование всего класса + + +@timer +class CatClass: + + def __init__(self, color): + self.color = color + self.type_ = "cat" + + def info(self): + time.sleep(2) + print(self.color, self.type_, sep=", ") + + +cat = CatClass("gray") + +cat.info() + +setattr(cat, "weight", 5) + +cat.weight, getattr(cat, "weight") + + +def add_attribute(attribute_name, attribute_value): + def wrapper(cls): + setattr(cls, attribute_name, attribute_value) + return cls + + return wrapper + + +@add_attribute("species", "кошка") +class CatClass: + + def __init__(self, color): + self.color = color + self.type_ = "cat" + + +CatClass.species + + +# ### Несколько декораторов + + +@logging +@timer +def delayed_function(t): + time.sleep(t) + return "execution completed" + + +delayed_function(2) + +# + +# не забудем заново объявить функцию без декораторов + + +def delayed_function(t): + time.sleep(t) + return "execution completed" + + +# - + +delayed_function = logging(timer(delayed_function)) +delayed_function(2) + + +# ### Декораторы с аргументами + + +def repeat(n_times): + def inner_decorator(func): + @functools.wraps(func) + def wrapper(*args, **kwargs): + for _ in range(n_times): + func(*args, **kwargs) + + return wrapper + + return inner_decorator + + +@repeat(n_times=3) +def say_hello(name): + print(f"Привет, {name}!") + + +say_hello("Алексей") diff --git a/makarov_Iterators.ipynb b/makarov_Iterators.ipynb new file mode 100644 index 00000000..774b2dd5 --- /dev/null +++ b/makarov_Iterators.ipynb @@ -0,0 +1,1372 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [], + "toc_visible": true + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + } + }, + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "0AoPSXyUTTLc" + }, + "source": [ + "## Итераторы и генераторы" + ] + }, + { + "cell_type": "markdown", + "source": [ + "### Итерируемый объект и итератор" + ], + "metadata": { + "id": "5Vlh7nreAD2D" + } + }, + { + "cell_type": "markdown", + "source": [ + "#### Основные определения" + ], + "metadata": { + "id": "kthx3B9dGQY5" + } + }, + { + "cell_type": "code", + "source": [ + "from collections.abc import Iterator\n", + "from itertools import chain, count, cycle\n", + "\n", + "for i in [1, 2, 3]:\n", + " print(i)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "lgrM3Gnp25o-", + "outputId": "916aa0be-5648-4449-8910-127bffe16165" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "1\n", + "2\n", + "3\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# встроенная функция iter() вызывает метод .__iter__(),\n", + "# создающий итератор\n", + "iter([1, 2, 3])" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "YOd5fX1T4VDs", + "outputId": "fda5b2fd-f3ca-40b6-d5e5-782e899731e3" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ] + }, + "metadata": {}, + "execution_count": 2 + } + ] + }, + { + "cell_type": "code", + "source": [ + "iterable_object = [1, 2, 3]\n", + "\n", + "iterator = iter(iterable_object)\n", + "print(iterator)\n", + "print()\n", + "\n", + "print(next(iterator))\n", + "print(next(iterator))\n", + "print(next(iterator))" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "1s_bw0wr6dn_", + "outputId": "85e8b0e2-a4cd-443d-a699-e52cf88dbd66" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "\n", + "\n", + "1\n", + "2\n", + "3\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "for iterator in iterable_object:\n", + " print(iterator)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "tbGGt-NK8Scw", + "outputId": "b51b2e38-fe17-4362-cc76-2a1e5adfb6b9" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "1\n", + "2\n", + "3\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "iterable_object = [1, 2, 3]\n", + "\n", + "iterator_a = iter(iterable_object)\n", + "iterator_b = iter(iterable_object)\n", + "\n", + "print(f\"A: {next(iterator_a)}\")\n", + "print(f\"A: {next(iterator_a)}\")\n", + "print(f\"A: {next(iterator_a)}\")\n", + "print(f\"B: {next(iterator_b)}\")" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "fPbwZ8UO93lC", + "outputId": "bee708e4-d96a-4409-b9d9-4884ecd6851d" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "A: 1\n", + "A: 2\n", + "A: 3\n", + "B: 1\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "iterable_object" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "HkVfe8K3CSD3", + "outputId": "fe0d9740-3d21-43fc-8992-85d88c4f31f3" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "[1, 2, 3]" + ] + }, + "metadata": {}, + "execution_count": 6 + } + ] + }, + { + "cell_type": "code", + "source": [ + "# print(f'A: {next(iterator_a)}')" + ], + "metadata": { + "id": "gPsw6ywr_642" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "list(iterator_a), list(iterator_b)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "PFhBl_4Cx06v", + "outputId": "d30c68e5-c78d-4aed-8c9d-5517438785ce" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "([], [2, 3])" + ] + }, + "metadata": {}, + "execution_count": 8 + } + ] + }, + { + "cell_type": "code", + "source": [ + "for s in {1, 1, 2, 3}:\n", + " print(s)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "ahG3y2qmgY7i", + "outputId": "d6cd205d-d974-4af5-94d4-895e1ece8d57" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "1\n", + "2\n", + "3\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "#### Отсутствие \"обратного хода\"" + ], + "metadata": { + "id": "Sj4h2zyAJTGd" + } + }, + { + "cell_type": "code", + "source": [ + "iterator_c = iter(iterable_object)\n", + "\n", + "for i in iterator_c:\n", + " print(i)\n", + " break\n", + "\n", + "for j in iterator_c:\n", + " print(j)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "0SBq2VSKJQkl", + "outputId": "a3e37ec9-7506-4dbe-e1e5-3ac827ddc2cb" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "1\n", + "2\n", + "3\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "#### Функция `zip()`" + ], + "metadata": { + "id": "KvUcGyCOF2dl" + } + }, + { + "cell_type": "code", + "source": [ + "zip(iterable_object, iterable_object)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "G-Z4ToVzFe0n", + "outputId": "403a9165-5fa7-487e-9b82-6d44fd8b73af" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ] + }, + "metadata": {}, + "execution_count": 11 + } + ] + }, + { + "cell_type": "code", + "source": [ + "iterator_tuple = zip(iterable_object, iterable_object)\n", + "\n", + "print(next(iterator_tuple))\n", + "print(next(iterator_tuple))\n", + "print(next(iterator_tuple))" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "1Zici5FDGpCL", + "outputId": "6be383b2-6215-4b94-93d5-18b2b6faa4f8" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(1, 1)\n", + "(2, 2)\n", + "(3, 3)\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "for i in zip(iterable_object, iterable_object):\n", + " print(i)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Gf2CXrVGFU2I", + "outputId": "c4995972-8e75-4246-b694-9437af79c838" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(1, 1)\n", + "(2, 2)\n", + "(3, 3)\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "#### Примеры итераторов" + ], + "metadata": { + "id": "e9y3-HUEKlXe" + } + }, + { + "cell_type": "markdown", + "source": [ + "Возведение в квадрат" + ], + "metadata": { + "id": "GiQAx3rds0-3" + } + }, + { + "cell_type": "code", + "source": [ + "class Square:\n", + " def __init__(self, seq):\n", + " self._seq = seq\n", + " self._idx = 0\n", + "\n", + " def __iter__(self):\n", + " return self\n", + "\n", + " def __next__(self):\n", + " if self._idx < len(self._seq):\n", + " square = self._seq[self._idx] ** 2\n", + " self._idx += 1\n", + " return square\n", + " else:\n", + " raise StopIteration" + ], + "metadata": { + "id": "Gp1fVFW3qJwE" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "square = Square([1, 2, 3, 4, 5])\n", + "square" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "tO8DeWnSqmSZ", + "outputId": "987af348-d6ab-417d-c4b9-99599e2f87b7" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "<__main__.Square at 0x7ec755cf6450>" + ] + }, + "metadata": {}, + "execution_count": 15 + } + ] + }, + { + "cell_type": "code", + "source": [ + "for s in square:\n", + " print(s)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "o2PxHYNJqt6I", + "outputId": "0e717160-6d5c-4d95-d6dc-d0e3137e4d47" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "1\n", + "4\n", + "9\n", + "16\n", + "25\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Счетчик" + ], + "metadata": { + "id": "oUor5ZgJs3r3" + } + }, + { + "cell_type": "code", + "source": [ + "class Counter:\n", + " def __init__(self, start=3, stop=9):\n", + " self._current = start - 1\n", + " self._stop = stop\n", + "\n", + " def __iter__(self):\n", + " return self\n", + "\n", + " def __next__(self):\n", + " self._current += 1\n", + " if self._current < self._stop:\n", + " return self._current\n", + " else:\n", + " raise StopIteration" + ], + "metadata": { + "id": "k3PWHN0xKoO6" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "counter = Counter()\n", + "counter" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "g-8TFk7MKzjJ", + "outputId": "2cde6f1e-b01c-432c-c90d-354b589a8990" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "<__main__.Counter at 0x7ec755d18490>" + ] + }, + "metadata": {}, + "execution_count": 18 + } + ] + }, + { + "cell_type": "code", + "source": [ + "print(next(counter))\n", + "print(next(counter))" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "B8LRePjDLZA_", + "outputId": "7eb4976f-30f1-4fd4-84dc-3f2d98d4b6d6" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "3\n", + "4\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "for c in counter:\n", + " print(c)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "nWMjrjAzeuOk", + "outputId": "6ed0a768-e606-453e-ff5d-f06c5040b3a6" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "5\n", + "6\n", + "7\n", + "8\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Класс Iterator модуля collections.abc" + ], + "metadata": { + "id": "XQ79dGrps8_v" + } + }, + { + "cell_type": "code", + "source": [ + "class Counter2(Iterator):\n", + " def __init__(self, start=3, stop=9):\n", + " self._current = start - 1\n", + " self._stop = stop\n", + "\n", + " def __next__(self):\n", + " self._current += 1\n", + " if self._current < self._stop:\n", + " return self._current\n", + " else:\n", + " raise StopIteration" + ], + "metadata": { + "id": "10ZltZGVtEFo" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "for c in Counter2():\n", + " print(c)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "zYVob0XttPTm", + "outputId": "9513ea1b-3b75-4f89-eff3-59b0a11e9e10" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "3\n", + "4\n", + "5\n", + "6\n", + "7\n", + "8\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Бесконечный итератор" + ], + "metadata": { + "id": "F5EjaYegFtQf" + } + }, + { + "cell_type": "code", + "source": [ + "class FibIterator:\n", + " def __init__(self):\n", + " self._idx = 0\n", + " self._current = 0\n", + " self._next = 1\n", + "\n", + " def __iter__(self):\n", + " return self\n", + "\n", + " def __next__(self):\n", + " self._idx += 1\n", + " self._current, self._next = (self._next, self._current + self._next)\n", + " return self._current" + ], + "metadata": { + "id": "1K9r-t9jFvZB" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "limit = 10\n", + "\n", + "for f in FibIterator():\n", + " print(f)\n", + " limit -= 1\n", + " if limit == 0:\n", + " break" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "13nuDa2SG2sK", + "outputId": "de87755e-ed16-447f-9a2b-cefc0fc7a12a" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "1\n", + "1\n", + "2\n", + "3\n", + "5\n", + "8\n", + "13\n", + "21\n", + "34\n", + "55\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "### Генератор" + ], + "metadata": { + "id": "i4lNIXO_Edk7" + } + }, + { + "cell_type": "markdown", + "source": [ + "#### Простой пример" + ], + "metadata": { + "id": "CWU2zNr6-1AZ" + } + }, + { + "cell_type": "code", + "source": [ + "def sequence(n):\n", + " res = [x for x in range(1, n + 1)]\n", + " return res" + ], + "metadata": { + "id": "g38UdGuA9TRD" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "sequence(5)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Qk2gw-wH9dUa", + "outputId": "13911636-550d-4ff0-81a6-95a8ee420a52" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "[1, 2, 3, 4, 5]" + ] + }, + "metadata": {}, + "execution_count": 26 + } + ] + }, + { + "cell_type": "code", + "source": [ + "def sequence_gen(n):\n", + " yield from range(1, n + 1)" + ], + "metadata": { + "id": "kX__mcgp8WJm" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "sequence_gen(5)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Cajg_qXU8oPt", + "outputId": "66943925-5e95-42c8-8b93-d5cdd7b53a85" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ] + }, + "metadata": {}, + "execution_count": 28 + } + ] + }, + { + "cell_type": "code", + "source": [ + "seq_5 = sequence_gen(5)\n", + "\n", + "print(next(seq_5))\n", + "print(next(seq_5))" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "rOKU_bf68uP8", + "outputId": "253bc200-2441-4cab-f7a5-b0f0308b13a0" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "1\n", + "2\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "for i in seq_5:\n", + " print(i)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "d573ZcOZ8yty", + "outputId": "2f2cb9ef-7348-44ac-ebb0-fd47642f93e2" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "3\n", + "4\n", + "5\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "# next(seq_5)" + ], + "metadata": { + "id": "9iW5ZNZuORsE" + }, + "execution_count": null, + "outputs": [] + }, + { + "cell_type": "markdown", + "source": [ + "#### Generator comprehension" + ], + "metadata": { + "id": "mFFbJfjvD27P" + } + }, + { + "cell_type": "code", + "source": [ + "(x for x in range(1, 5 + 1))" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "xGCSq8C4BLDQ", + "outputId": "e7c42fd1-39a5-4394-b844-28197b61c6c0" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + " at 0x7ec755ccfe00>" + ] + }, + "metadata": {}, + "execution_count": 32 + } + ] + }, + { + "cell_type": "code", + "source": [ + "list(x for x in range(1, 5 + 1))" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "33g4ikqqFcKJ", + "outputId": "4e36c66e-6fe5-4162-fc81-1acf2c15bc61" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "[1, 2, 3, 4, 5]" + ] + }, + "metadata": {}, + "execution_count": 33 + } + ] + }, + { + "cell_type": "code", + "source": [ + "sum(x for x in range(1, 5 + 1))" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "DyOGWjE2LrWx", + "outputId": "91736c7b-c50a-4990-cbc5-b81593c40586" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "15" + ] + }, + "metadata": {}, + "execution_count": 34 + } + ] + }, + { + "cell_type": "code", + "source": [ + "5 in (x for x in range(1, 5 + 1))" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "nzxrUQmEMR27", + "outputId": "f60aaee5-4be5-4905-f85e-4487d6d683b3" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "True" + ] + }, + "metadata": {}, + "execution_count": 35 + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "### Модуль itertools" + ], + "metadata": { + "id": "dh__pqr-ImTX" + } + }, + { + "cell_type": "markdown", + "source": [ + "#### Функция `count()`" + ], + "metadata": { + "id": "zKzMJtVeLHp0" + } + }, + { + "cell_type": "code", + "source": [ + "natural_numbers = count(start=1, step=0.5)\n", + "\n", + "for num in natural_numbers:\n", + " print(num)\n", + " if num == 2:\n", + " break" + ], + "metadata": { + "id": "MzPekSQWJBPi", + "colab": { + "base_uri": "https://localhost:8080/" + }, + "outputId": "46fd6fd0-3129-4109-dad8-e4939e62bf0c" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "1\n", + "1.5\n", + "2.0\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "list_ = [\"A\", \"B\", \"C\", \"D\"]\n", + "for i in zip(count(), list_):\n", + " print(i)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "DbmVDVFKnTlx", + "outputId": "4d7874e9-96fc-4e36-f445-55f4fc341c79" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "(0, 'A')\n", + "(1, 'B')\n", + "(2, 'C')\n", + "(3, 'D')\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "def f(x):\n", + " return x**2 + x - 2\n", + "\n", + "\n", + "f_x = map(f, count())\n", + "next(f_x)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "nKQCJ_hhoJaH", + "outputId": "a9cdc460-6cd9-4595-de7a-a8525207d65a" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "-2" + ] + }, + "metadata": {}, + "execution_count": 39 + } + ] + }, + { + "cell_type": "code", + "source": [ + "for val in f_x:\n", + " print(val)\n", + " if val > 10:\n", + " break" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "nmLgF8Xio_Kd", + "outputId": "8c8407b8-8043-4ef5-b12c-13402ac22752" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "0\n", + "4\n", + "10\n", + "18\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "#### Функция `cycle()`" + ], + "metadata": { + "id": "_G5eWGYGmYMp" + } + }, + { + "cell_type": "code", + "source": [ + "list_ = [1, 2, 3]\n", + "iterator = cycle(list_)\n", + "\n", + "limit = 5\n", + "for i in iterator:\n", + " print(i)\n", + " limit -= 1\n", + " if limit == 0:\n", + " break" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "_kC3VssumbF5", + "outputId": "7aea461d-18b5-4454-9837-86f65c7280a0" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "1\n", + "2\n", + "3\n", + "1\n", + "2\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "string = \"Python\"\n", + "iterator = cycle(string)\n", + "\n", + "limit = 10\n", + "for i in iterator:\n", + " print(i)\n", + " limit -= 1\n", + " if limit == 0:\n", + " break" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "-IqqesXxrT9M", + "outputId": "8877b29b-24f7-4a4a-eaae-c24bc64786ef" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "P\n", + "y\n", + "t\n", + "h\n", + "o\n", + "n\n", + "P\n", + "y\n", + "t\n", + "h\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "#### Функция `chain()`" + ], + "metadata": { + "id": "ih5bXVq9sGh6" + } + }, + { + "cell_type": "code", + "source": [ + "iterator = chain([\"abc\", \"d\", \"e\", \"f\"], \"abc\", [1, 2, 3])\n", + "iterator" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "EzUlrbwZrmG4", + "outputId": "86f0b35e-e9dc-4749-d987-f02b86d88485" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "" + ] + }, + "metadata": {}, + "execution_count": 43 + } + ] + }, + { + "cell_type": "code", + "source": [ + "list(iterator)" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "Uzij2-C2ttuk", + "outputId": "6895d222-7929-47f6-c8b1-0891648b34ac" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "['abc', 'd', 'e', 'f', 'a', 'b', 'c', 1, 2, 3]" + ] + }, + "metadata": {}, + "execution_count": 44 + } + ] + }, + { + "cell_type": "code", + "source": [ + "list(chain.from_iterable([\"abc\", \"def\"]))" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "exjJKXZjvZJb", + "outputId": "7c677fcf-7cad-45b4-b4c6-6e61ff8d15f2" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "['a', 'b', 'c', 'd', 'e', 'f']" + ] + }, + "metadata": {}, + "execution_count": 45 + } + ] + }, + { + "cell_type": "code", + "source": [ + "sum(chain.from_iterable([[1, 2, 3], [4, 5, 6], [7, 8, 9]]))" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "qE3YDv6SufLi", + "outputId": "9e2037bc-b04e-4cf2-d8ba-9b9d7e045ce7" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "execute_result", + "data": { + "text/plain": [ + "45" + ] + }, + "metadata": {}, + "execution_count": 46 + } + ] + }, + { + "cell_type": "code", + "source": [], + "metadata": { + "id": "HApgWQJPyGPa" + }, + "execution_count": null, + "outputs": [] + } + ] +} \ No newline at end of file diff --git a/makarov_Iterators.py b/makarov_Iterators.py new file mode 100644 index 00000000..07595e22 --- /dev/null +++ b/makarov_Iterators.py @@ -0,0 +1,303 @@ +# ## Итераторы и генераторы + +# ### Итерируемый объект и итератор + +# #### Основные определения + +# + +from collections.abc import Iterator +from itertools import chain, count, cycle + +for i in [1, 2, 3]: + print(i) +# - + +# встроенная функция iter() вызывает метод .__iter__(), +# создающий итератор +iter([1, 2, 3]) + +# + +iterable_object = [1, 2, 3] + +iterator = iter(iterable_object) +print(iterator) +print() + +print(next(iterator)) +print(next(iterator)) +print(next(iterator)) +# - + +for iterator in iterable_object: + print(iterator) + +# + +iterable_object = [1, 2, 3] + +iterator_a = iter(iterable_object) +iterator_b = iter(iterable_object) + +print(f"A: {next(iterator_a)}") +print(f"A: {next(iterator_a)}") +print(f"A: {next(iterator_a)}") +print(f"B: {next(iterator_b)}") +# - + +iterable_object + +# + +# print(f'A: {next(iterator_a)}') +# - + +list(iterator_a), list(iterator_b) + +for s in {1, 1, 2, 3}: + print(s) + +# #### Отсутствие "обратного хода" + +# + +iterator_c = iter(iterable_object) + +for i in iterator_c: + print(i) + break + +for j in iterator_c: + print(j) +# - + +# #### Функция `zip()` + +zip(iterable_object, iterable_object) + +# + +iterator_tuple = zip(iterable_object, iterable_object) + +print(next(iterator_tuple)) +print(next(iterator_tuple)) +print(next(iterator_tuple)) +# - + +for i in zip(iterable_object, iterable_object): + print(i) + + +# #### Примеры итераторов + +# Возведение в квадрат + + +class Square: + def __init__(self, seq): + self._seq = seq + self._idx = 0 + + def __iter__(self): + return self + + def __next__(self): + if self._idx < len(self._seq): + square = self._seq[self._idx] ** 2 + self._idx += 1 + return square + else: + raise StopIteration + + +square = Square([1, 2, 3, 4, 5]) +square + +for s in square: + print(s) + + +# Счетчик + + +class Counter: + def __init__(self, start=3, stop=9): + self._current = start - 1 + self._stop = stop + + def __iter__(self): + return self + + def __next__(self): + self._current += 1 + if self._current < self._stop: + return self._current + else: + raise StopIteration + + +counter = Counter() +counter + +print(next(counter)) +print(next(counter)) + +for c in counter: + print(c) + + +# Класс Iterator модуля collections.abc + + +class Counter2(Iterator): + def __init__(self, start=3, stop=9): + self._current = start - 1 + self._stop = stop + + def __next__(self): + self._current += 1 + if self._current < self._stop: + return self._current + else: + raise StopIteration + + +for c in Counter2(): + print(c) + + +# Бесконечный итератор + + +class FibIterator: + def __init__(self): + self._idx = 0 + self._current = 0 + self._next = 1 + + def __iter__(self): + return self + + def __next__(self): + self._idx += 1 + self._current, self._next = (self._next, self._current + self._next) + return self._current + + +# + +limit = 10 + +for f in FibIterator(): + print(f) + limit -= 1 + if limit == 0: + break + + +# - + +# ### Генератор + +# #### Простой пример + + +def sequence(n): + res = [x for x in range(1, n + 1)] + return res + + +sequence(5) + + +def sequence_gen(n): + yield from range(1, n + 1) + + +sequence_gen(5) + +# + +seq_5 = sequence_gen(5) + +print(next(seq_5)) +print(next(seq_5)) +# - + +for i in seq_5: + print(i) + +# + +# next(seq_5) +# - + +# #### Generator comprehension + +(x for x in range(1, 5 + 1)) + +list(x for x in range(1, 5 + 1)) + +sum(x for x in range(1, 5 + 1)) + +5 in (x for x in range(1, 5 + 1)) + +# ### Модуль itertools + +# #### Функция `count()` + +# + +natural_numbers = count(start=1, step=0.5) + +for num in natural_numbers: + print(num) + if num == 2: + break +# - + +list_ = ["A", "B", "C", "D"] +for i in zip(count(), list_): + print(i) + + +# + +def f(x): + return x**2 + x - 2 + + +f_x = map(f, count()) +next(f_x) +# - + +for val in f_x: + print(val) + if val > 10: + break + +# #### Функция `cycle()` + +# + +list_ = [1, 2, 3] +iterator = cycle(list_) + +limit = 5 +for i in iterator: + print(i) + limit -= 1 + if limit == 0: + break + +# + +string = "Python" +iterator = cycle(string) + +limit = 10 +for i in iterator: + print(i) + limit -= 1 + if limit == 0: + break +# - + +# #### Функция `chain()` + +iterator = chain(["abc", "d", "e", "f"], "abc", [1, 2, 3]) +iterator + +list(iterator) + +list(chain.from_iterable(["abc", "def"])) + +sum(chain.from_iterable([[1, 2, 3], [4, 5, 6], [7, 8, 9]])) diff --git a/mypy.ini b/mypy.ini new file mode 100644 index 00000000..fdd12d14 --- /dev/null +++ b/mypy.ini @@ -0,0 +1,2 @@ +[mypy] +ignore_errors = True diff --git a/oop.ipynb b/oop.ipynb new file mode 100644 index 00000000..c5abd122 --- /dev/null +++ b/oop.ipynb @@ -0,0 +1,125 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "a5fdb13d", + "metadata": {}, + "source": [ + "Этап 1: Объявление класса и интроспекция (Видео №1)\n", + "Класс создается ключевым словом class, а его название пишется в стиле CamelCase. Даже пустой класс является объектом и имеет встроенные атрибуты.\n", + "# 1. Создание простейшего класса\n", + "class Person:\n", + " pass\n", + "\n", + "# 2. Интроспекция класса\n", + "print(Person.__name__) # Имя класса [2]\n", + "print(dir(Person)) # Список всех атрибутов и методов [2]\n", + "\n", + "# 3. Создание экземпляра\n", + "p = Person()\n", + "print(type(p)) # Тип объекта [2]\n", + "print(id(p)) # Адрес объекта в памяти [3]\n", + "\n", + "# 4. Динамическое создание объекта того же типа\n", + "new_p = type(p)()\n", + "print(id(new_p)) # Разные ID подтверждают, что это разные объекты [3]\n", + "Этап 2: Атрибуты класса и функции управления (Видео №2)\n", + "Атрибуты класса задаются через простое присваивание и хранятся в специальном словаре __dict__.\n", + "class Person:\n", + " name = \"Ivan\" # Атрибут класса [4]\n", + "\n", + "# 1. Работа с пространством имен (mappingproxy)\n", + "print(Person.__dict__) [5]\n", + "\n", + "# 2. Динамическое добавление атрибута\n", + "Person.age = 25 [6]\n", + "\n", + "# 3. Встроенные функции для работы с атрибутами\n", + "setattr(Person, \"dob\", \"2000-01-01\") # Установка [7]\n", + "print(getattr(Person, \"name\")) # Чтение [7]\n", + "delattr(Person, \"dob\") # Удаление [7]\n", + "Этап 3: Экземпляры и локальные пространства имен (Видео №3)\n", + "При вызове класса создается экземпляр с собственным пустым словарем __dict__.\n", + "p1 = Person()\n", + "p2 = Person()\n", + "\n", + "# 1. Поиск атрибута (сначала в экземпляре, потом в классе)\n", + "print(p1.name) # Вернет \"Ivan\" из класса, так как в p1.__dict__ пусто [9]\n", + "\n", + "# 2. Создание уникального состояния экземпляра\n", + "p1.name = \"Oleg\"\n", + "p2.name = \"Dima\"\n", + "p2.age = 20\n", + "\n", + "print(p1.__dict__) # {'name': 'Oleg'} [10]\n", + "print(p2.__dict__) # {'name': 'Dima', 'age': 20} [10, 11]\n", + "Этап 4: Методы экземпляра и параметр self (Видео №4)\n", + "Функции внутри класса при вызове через экземпляр становятся «связанными методами» и автоматически получают ссылку на объект в первом аргументе (self).\n", + "class Person:\n", + " def hello(self): # self — обязательный параметр для метода экземпляра [13, 15]\n", + " print(f\"Hello! Я объект {id(self)}\") [14]\n", + "\n", + "p = Person()\n", + "\n", + "# 1. Вызов через точку (синтаксический сахар)\n", + "p.hello() # Ссылка на 'p' передается в 'self' автоматически [14, 16]\n", + "\n", + "# 2. Явный вызов через класс (что происходит под капотом)\n", + "Person.hello(p) [16, 17]\n", + "Этап 5: Инициализация через __init__ (Видео №5)\n", + "Метод __init__ вызывается автоматически сразу после создания объекта для задания его начальных свойств.\n", + "class Person:\n", + " def __init__(self, name, age): # Метод-инициализатор [18, 20]\n", + " self.name = name # Запись данных в локальный словарь объекта [21, 22]\n", + " self.age = age\n", + "\n", + " def display(self):\n", + " print(f\"Имя: {self.name}, Возраст: {self.age}\") [23]\n", + "\n", + "# Создание проинициализированных объектов\n", + "p1 = Person(\"Ivan\", 25) [18]\n", + "p2 = Person(\"Oleg\", 30) [18]\n", + "\n", + "p1.display()\n", + "Этап 6: Статические методы (Видео №6)\n", + "Статические методы не привязаны к конкретному экземпляру и не принимают self. Они определяются декоратором @staticmethod.\n", + "class Person:\n", + " def __init__(self, name):\n", + " self.name = name\n", + "\n", + " @staticmethod\n", + " def generic_info(): # Не принимает self [24, 28]\n", + " print(\"Это вспомогательный метод класса Person.\") [25, 28]\n", + "\n", + "# 1. Вызов статического метода (можно через класс или через объект)\n", + "Person.generic_info() [28]\n", + "p = Person(\"Dima\")\n", + "p.generic_info() [28]\n", + "\n", + "# 2. Проверка: статический метод — это один и тот же объект для всех экземпляров\n", + "print(id(Person.generic_info) == id(p.generic_info)) # True [29]" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "base", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.13.5" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/oop.py b/oop.py new file mode 100644 index 00000000..243c166a --- /dev/null +++ b/oop.py @@ -0,0 +1,93 @@ +# Этап 1: Объявление класса и интроспекция (Видео №1) +# Класс создается ключевым словом class, а его название пишется в стиле CamelCase. Даже пустой класс является объектом и имеет встроенные атрибуты. +# # 1. Создание простейшего класса +# class Person: +# pass +# +# # 2. Интроспекция класса +# print(Person.__name__) # Имя класса [2] +# print(dir(Person)) # Список всех атрибутов и методов [2] +# +# # 3. Создание экземпляра +# p = Person() +# print(type(p)) # Тип объекта [2] +# print(id(p)) # Адрес объекта в памяти [3] +# +# # 4. Динамическое создание объекта того же типа +# new_p = type(p)() +# print(id(new_p)) # Разные ID подтверждают, что это разные объекты [3] +# Этап 2: Атрибуты класса и функции управления (Видео №2) +# Атрибуты класса задаются через простое присваивание и хранятся в специальном словаре __dict__. +# class Person: +# name = "Ivan" # Атрибут класса [4] +# +# # 1. Работа с пространством имен (mappingproxy) +# print(Person.__dict__) [5] +# +# # 2. Динамическое добавление атрибута +# Person.age = 25 [6] +# +# # 3. Встроенные функции для работы с атрибутами +# setattr(Person, "dob", "2000-01-01") # Установка [7] +# print(getattr(Person, "name")) # Чтение [7] +# delattr(Person, "dob") # Удаление [7] +# Этап 3: Экземпляры и локальные пространства имен (Видео №3) +# При вызове класса создается экземпляр с собственным пустым словарем __dict__. +# p1 = Person() +# p2 = Person() +# +# # 1. Поиск атрибута (сначала в экземпляре, потом в классе) +# print(p1.name) # Вернет "Ivan" из класса, так как в p1.__dict__ пусто [9] +# +# # 2. Создание уникального состояния экземпляра +# p1.name = "Oleg" +# p2.name = "Dima" +# p2.age = 20 +# +# print(p1.__dict__) # {'name': 'Oleg'} [10] +# print(p2.__dict__) # {'name': 'Dima', 'age': 20} [10, 11] +# Этап 4: Методы экземпляра и параметр self (Видео №4) +# Функции внутри класса при вызове через экземпляр становятся «связанными методами» и автоматически получают ссылку на объект в первом аргументе (self). +# class Person: +# def hello(self): # self — обязательный параметр для метода экземпляра [13, 15] +# print(f"Hello! Я объект {id(self)}") [14] +# +# p = Person() +# +# # 1. Вызов через точку (синтаксический сахар) +# p.hello() # Ссылка на 'p' передается в 'self' автоматически [14, 16] +# +# # 2. Явный вызов через класс (что происходит под капотом) +# Person.hello(p) [16, 17] +# Этап 5: Инициализация через __init__ (Видео №5) +# Метод __init__ вызывается автоматически сразу после создания объекта для задания его начальных свойств. +# class Person: +# def __init__(self, name, age): # Метод-инициализатор [18, 20] +# self.name = name # Запись данных в локальный словарь объекта [21, 22] +# self.age = age +# +# def display(self): +# print(f"Имя: {self.name}, Возраст: {self.age}") [23] +# +# # Создание проинициализированных объектов +# p1 = Person("Ivan", 25) [18] +# p2 = Person("Oleg", 30) [18] +# +# p1.display() +# Этап 6: Статические методы (Видео №6) +# Статические методы не привязаны к конкретному экземпляру и не принимают self. Они определяются декоратором @staticmethod. +# class Person: +# def __init__(self, name): +# self.name = name +# +# @staticmethod +# def generic_info(): # Не принимает self [24, 28] +# print("Это вспомогательный метод класса Person.") [25, 28] +# +# # 1. Вызов статического метода (можно через класс или через объект) +# Person.generic_info() [28] +# p = Person("Dima") +# p.generic_info() [28] +# +# # 2. Проверка: статический метод — это один и тот же объект для всех экземпляров +# print(id(Person.generic_info) == id(p.generic_info)) # True [29] diff --git a/oop_notebook.ipynb b/oop_notebook.ipynb new file mode 100644 index 00000000..6f618255 --- /dev/null +++ b/oop_notebook.ipynb @@ -0,0 +1,308 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Основы объектно-ориентированного программирования в Python\n", + "\n", + "Этот notebook содержит пошаговое введение в работу с классами в Python." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Этап 1: Объявление класса и интроспекция (Видео №1)\n", + "\n", + "Класс создается ключевым словом `class`, а его название пишется в стиле CamelCase. Даже пустой класс является объектом и имеет встроенные атрибуты." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# 1. Создание простейшего класса\n", + "class Person:\n", + " pass" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# 2. Интроспекция класса\n", + "print(Person.__name__) # Имя класса [2]\n", + "print(dir(Person)) # Список всех атрибутов и методов [2]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# 3. Создание экземпляра\n", + "p = Person()\n", + "print(type(p)) # Тип объекта [2]\n", + "print(id(p)) # Адрес объекта в памяти [3]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# 4. Динамическое создание объекта того же типа\n", + "new_p = type(p)()\n", + "print(id(new_p)) # Разные ID подтверждают, что это разные объекты [3]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Этап 2: Атрибуты класса и функции управления (Видео №2)\n", + "\n", + "Атрибуты класса задаются через простое присваивание и хранятся в специальном словаре `__dict__`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "class Person:\n", + " name = \"Ivan\" # Атрибут класса [4]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# 1. Работа с пространством имен (mappingproxy)\n", + "print(Person.__dict__) # [5]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# 2. Динамическое добавление атрибута\n", + "Person.age = 25 # [6]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# 3. Встроенные функции для работы с атрибутами\n", + "setattr(Person, \"dob\", \"2000-01-01\") # Установка [7]\n", + "print(getattr(Person, \"name\")) # Чтение [7]\n", + "delattr(Person, \"dob\") # Удаление [7]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Этап 3: Экземпляры и локальные пространства имен (Видео №3)\n", + "\n", + "При вызове класса создается экземпляр с собственным пустым словарем `__dict__`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "p1 = Person()\n", + "p2 = Person()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# 1. Поиск атрибута (сначала в экземпляре, потом в классе)\n", + "print(p1.name) # Вернет \"Ivan\" из класса, так как в p1.__dict__ пусто [9]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# 2. Создание уникального состояния экземпляра\n", + "p1.name = \"Oleg\"\n", + "p2.name = \"Dima\"\n", + "p2.age = 20\n", + "\n", + "print(p1.__dict__) # {'name': 'Oleg'} [10]\n", + "print(p2.__dict__) # {'name': 'Dima', 'age': 20} [10, 11]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Этап 4: Методы экземпляра и параметр self (Видео №4)\n", + "\n", + "Функции внутри класса при вызове через экземпляр становятся «связанными методами» и автоматически получают ссылку на объект в первом аргументе (`self`)." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "class Person:\n", + " def hello(self): # self — обязательный параметр для метода экземпляра [13, 15]\n", + " print(f\"Hello! Я объект {id(self)}\") # [14]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "p = Person()\n", + "\n", + "# 1. Вызов через точку (синтаксический сахар)\n", + "p.hello() # Ссылка на 'p' передается в 'self' автоматически [14, 16]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# 2. Явный вызов через класс (что происходит под капотом)\n", + "Person.hello(p) # [16, 17]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Этап 5: Инициализация через __init__ (Видео №5)\n", + "\n", + "Метод `__init__` вызывается автоматически сразу после создания объекта для задания его начальных свойств." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "class Person:\n", + " def __init__(self, name, age): # Метод-инициализатор [18, 20]\n", + " self.name = name # Запись данных в локальный словарь объекта [21, 22]\n", + " self.age = age\n", + "\n", + " def display(self):\n", + " print(f\"Имя: {self.name}, Возраст: {self.age}\") # [23]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# Создание проинициализированных объектов\n", + "p1 = Person(\"Ivan\", 25) # [18]\n", + "p2 = Person(\"Oleg\", 30) # [18]\n", + "\n", + "p1.display()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Этап 6: Статические методы (Видео №6)\n", + "\n", + "Статические методы не привязаны к конкретному экземпляру и не принимают `self`. Они определяются декоратором `@staticmethod`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "class Person:\n", + " def __init__(self, name):\n", + " self.name = name\n", + "\n", + " @staticmethod\n", + " def generic_info(): # Не принимает self [24, 28]\n", + " print(\"Это вспомогательный метод класса Person.\") # [25, 28]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# 1. Вызов статического метода (можно через класс или через объект)\n", + "Person.generic_info() # [28]\n", + "p = Person(\"Dima\")\n", + "p.generic_info() # [28]" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "# 2. Проверка: статический метод — это один и тот же объект для всех экземпляров\n", + "print(id(Person.generic_info) == id(p.generic_info)) # True [29]" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.8.0" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} \ No newline at end of file diff --git a/oop_notebook.py b/oop_notebook.py new file mode 100644 index 00000000..da6f6548 --- /dev/null +++ b/oop_notebook.py @@ -0,0 +1,136 @@ +# # Основы объектно-ориентированного программирования в Python +# +# Этот notebook содержит пошаговое введение в работу с классами в Python. + +# ## Этап 1: Объявление класса и интроспекция (Видео №1) +# +# Класс создается ключевым словом `class`, а его название пишется в стиле CamelCase. Даже пустой класс является объектом и имеет встроенные атрибуты. + + +# 1. Создание простейшего класса +class Person: + pass + + +# 2. Интроспекция класса +print(Person.__name__) # Имя класса [2] +print(dir(Person)) # Список всех атрибутов и методов [2] + +# 3. Создание экземпляра +p = Person() +print(type(p)) # Тип объекта [2] +print(id(p)) # Адрес объекта в памяти [3] + +# 4. Динамическое создание объекта того же типа +new_p = type(p)() +print(id(new_p)) # Разные ID подтверждают, что это разные объекты [3] + + +# ## Этап 2: Атрибуты класса и функции управления (Видео №2) +# +# Атрибуты класса задаются через простое присваивание и хранятся в специальном словаре `__dict__`. + + +class Person: + name = "Ivan" # Атрибут класса [4] + + +# 1. Работа с пространством имен (mappingproxy) +print(Person.__dict__) # [5] + +# 2. Динамическое добавление атрибута +Person.age = 25 # [6] + +# 3. Встроенные функции для работы с атрибутами +setattr(Person, "dob", "2000-01-01") # Установка [7] +print(getattr(Person, "name")) # Чтение [7] +delattr(Person, "dob") # Удаление [7] + +# ## Этап 3: Экземпляры и локальные пространства имен (Видео №3) +# +# При вызове класса создается экземпляр с собственным пустым словарем `__dict__`. + +p1 = Person() +p2 = Person() + +# 1. Поиск атрибута (сначала в экземпляре, потом в классе) +print(p1.name) # Вернет "Ivan" из класса, так как в p1.__dict__ пусто [9] + +# + +# 2. Создание уникального состояния экземпляра +p1.name = "Oleg" +p2.name = "Dima" +p2.age = 20 + +print(p1.__dict__) # {'name': 'Oleg'} [10] +print(p2.__dict__) # {'name': 'Dima', 'age': 20} [10, 11] + + +# - + +# ## Этап 4: Методы экземпляра и параметр self (Видео №4) +# +# Функции внутри класса при вызове через экземпляр становятся «связанными методами» и автоматически получают ссылку на объект в первом аргументе (`self`). + + +class Person: + def hello(self): # self — обязательный параметр для метода экземпляра [13, 15] + print(f"Hello! Я объект {id(self)}") # [14] + + +# + +p = Person() + +# 1. Вызов через точку (синтаксический сахар) +p.hello() # Ссылка на 'p' передается в 'self' автоматически [14, 16] +# - + +# 2. Явный вызов через класс (что происходит под капотом) +Person.hello(p) # [16, 17] + + +# ## Этап 5: Инициализация через __init__ (Видео №5) +# +# Метод `__init__` вызывается автоматически сразу после создания объекта для задания его начальных свойств. + + +class Person: + def __init__(self, name, age): # Метод-инициализатор [18, 20] + self.name = name # Запись данных в локальный словарь объекта [21, 22] + self.age = age + + def display(self): + print(f"Имя: {self.name}, Возраст: {self.age}") # [23] + + +# + +# Создание проинициализированных объектов +p1 = Person("Ivan", 25) # [18] +p2 = Person("Oleg", 30) # [18] + +p1.display() + + +# - + +# ## Этап 6: Статические методы (Видео №6) +# +# Статические методы не привязаны к конкретному экземпляру и не принимают `self`. Они определяются декоратором `@staticmethod`. + + +class Person: + def __init__(self, name): + self.name = name + + @staticmethod + def generic_info(): # Не принимает self [24, 28] + print("Это вспомогательный метод класса Person.") # [25, 28] + + +# 1. Вызов статического метода (можно через класс или через объект) +Person.generic_info() # [28] +p = Person("Dima") +p.generic_info() # [28] + +# 2. Проверка: статический метод — это один и тот же объект для всех экземпляров +print(id(Person.generic_info) == id(p.generic_info)) # True [29] diff --git a/pyproject.toml b/pyproject.toml index 94f5ffc6..3ba44788 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -2,3 +2,6 @@ formats = "ipynb,py:light" cell_metadata_filter = "-all" notebook_metadata_filter = "-all" + +[tool.flake8] +max-line-length = 120 diff --git a/python.makarov.chapter.1.ipynb b/python.makarov.chapter.1.ipynb new file mode 100644 index 00000000..3dd1562c --- /dev/null +++ b/python.makarov.chapter.1.ipynb @@ -0,0 +1,549 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "6b0c731e", + "metadata": {}, + "source": [ + "### Сщздание (обьявление) переменных" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "49daa298", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "15\n" + ] + } + ], + "source": [ + "# можно создать переменную, присвоив ей значение\n", + "x = 15\n", + "print(x) # выводит: 15" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "4cec11cf", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "я програмирую на питоне\n" + ] + } + ], + "source": [ + "# кроме того, переменной можно задать строковое (текстовое) значение\n", + "y = \"я програмирую на питоне\"\n", + "print(y)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "76f73baa", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "питон C++ JavaScript\n" + ] + } + ], + "source": [ + "# в Питоне можно присвоить разные значения сразу нескольким переменным\n", + "(\n", + " a,\n", + " b,\n", + " c,\n", + ") = (\n", + " \"питон\",\n", + " \"C++\",\n", + " \"JavaScript\",\n", + ")\n", + "print(a, b, c) # выводит: питон C++ JavaScript" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "7c3518ba", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "тоже же самое значение, но в других переменных тоже же самое значение, но в других переменных тоже же самое значение, но в других переменных\n" + ] + } + ], + "source": [ + "# a также можно присвоить одно и то же значение нескольким переменим\n", + "x = y = z = \"тоже же самое значение, но в других переменных\"\n", + "print(x, y, z)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "72c7f3bd", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "помидоры огурцы перец\n" + ] + } + ], + "source": [ + "# каждый элемент списка можно \"распоковать\" в переменные\n", + "my_list = [\"помидоры\", \"огурцы\", \"перец\"]\n", + "a, b, c = my_list\n", + "print(a, b, c)" + ] + }, + { + "cell_type": "markdown", + "id": "d44287b9", + "metadata": {}, + "source": [ + "### Автоматическое определение типа данных " + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "939328b2", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n", + "\n" + ] + } + ], + "source": [ + "x = 256 # в этом случае переменной х присвается тип int (целое число)\n", + "y = 0.25 # установится float (деситичное дробью)\n", + "z = \"Привет\" # строка string\n", + "print(type(x)) # выводит: \n", + "print(type(y)) # выводит: \n", + "print(type(z)) # выводит: " + ] + }, + { + "cell_type": "markdown", + "id": "78574ae4", + "metadata": {}, + "source": [ + "### как узнать тип переменой в питоне " + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "460ac1db", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " \n" + ] + } + ], + "source": [ + "# узнаем тип перееменных из передыдущего примера\n", + "print(type(x), type(y), type(z))" + ] + }, + { + "cell_type": "markdown", + "id": "a70bcec9", + "metadata": {}, + "source": [ + "### присвоение и преоброзование типа данных " + ] + }, + { + "cell_type": "markdown", + "id": "d7e3d202", + "metadata": {}, + "source": [ + "Присвоение типа данных " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "07819d2f", + "metadata": {}, + "outputs": [], + "source": [ + "x = str(25) # числа 25 превратится в строку\n", + "y = int(25) # число 25 останется целочисленным значением\n", + "z = float(25) # число 25 превратится в десатичную дробовь" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "8c6c9021", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " \n" + ] + } + ], + "source": [ + "print(type(x), type(y), type(z))" + ] + }, + { + "cell_type": "markdown", + "id": "789ea368", + "metadata": {}, + "source": [ + "**Изменение** типа данных" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "96a37dc4", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "# преобразуем строку, похожую на целое число, в целое число\n", + "print(type(int(\"25\")))" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "aa6955cf", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "# или строку, похожую на дробь, в настоящую десятичную дробь\n", + "print(type(float(\"2.5\")))" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "f0a87b44", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "36\n", + "\n" + ] + } + ], + "source": [ + "# преобразуем дробь в целочисленное значение\n", + "# обратите внимание, что округления в большую сторону не происходит\n", + "print(int(36.6))\n", + "print(type(int(36.6)))" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "id": "4e6cf994", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n" + ] + } + ], + "source": [ + "# конечно, и целое число, и дробь можно преобразовать в строку\n", + "print(type(str(25)))\n", + "print(type(str(36.6)))" + ] + }, + { + "cell_type": "markdown", + "id": "fda10081", + "metadata": {}, + "source": [ + "### Именование переменных" + ] + }, + { + "cell_type": "markdown", + "id": "1f742530", + "metadata": {}, + "source": [ + "\n", + "\n", + "```\n", + "# Выбран кодовый формат\n", + "```\n", + "\n", + "Допустимые имена переменных" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "79caf665", + "metadata": {}, + "outputs": [], + "source": [ + "variable = \"Просто переменная\"\n", + "_variable = \"Просто переменная\"\n", + "variable_ = \"Просто переменная\"\n", + "my_variable = \"Просто переменная\"\n", + "My_variable_123 = \"Просто переменная\"" + ] + }, + { + "cell_type": "markdown", + "id": "9fc8c104", + "metadata": {}, + "source": [ + "Имя переменной состоит из нескольких слов" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4d7000f6", + "metadata": {}, + "outputs": [], + "source": [ + "# можно применить так называемый верблюжий регистр, camelCase\n", + "# все слова кроме первого начинаются с заглавной буквы и пишутся слитно\n", + "camelCaseVariable = \"Верблюжий регистр\"\n", + "\n", + "# нотацию Паскаль, PascalCase (то же самое, только тепер все слова пишутся с заглавной)\n", + "PascalCaseVariable = \"Нотация Паскаль\"\n", + "\n", + "# змеиный стиль, snake_case (с нижними подчеркиваниями)\n", + "snake_case_variable = \"Змеиная нотация\"" + ] + }, + { + "cell_type": "markdown", + "id": "0279ebb8", + "metadata": {}, + "source": [ + "Недопустимые названия переменной" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "id": "bdb453e4", + "metadata": {}, + "outputs": [ + { + "ename": "SyntaxError", + "evalue": "cannot assign to expression here. Maybe you meant '==' instead of '='? (3709343952.py, line 1)", + "output_type": "error", + "traceback": [ + "\u001b[0;36m Cell \u001b[0;32mIn[20], line 1\u001b[0;36m\u001b[0m\n\u001b[0;31m my-variable = 'Так делать нельзя'\u001b[0m\n\u001b[0m ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m cannot assign to expression here. Maybe you meant '==' instead of '='?\n" + ] + } + ], + "source": [ + "# Примеры недопустимых имён (раскомментируйте по очереди, чтобы увидеть ошибки):\n", + "# my-variable = 'Так делать нельзя' # SyntaxError: дефис в имени\n", + "# 123variable = 'Так делать нельзя' # SyntaxError: имя не может начинаться с цифры\n", + "# my variable = 'Так делать нельзя' # SyntaxError: пробел в имени" + ] + }, + { + "cell_type": "markdown", + "id": "c3216f4a", + "metadata": {}, + "source": [ + "### Ответы на вопросы" + ] + }, + { + "cell_type": "markdown", + "id": "434b45a8", + "metadata": {}, + "source": [ + "**Вопрос**. Как можно преобразовать список чисел таким образом, чтобы каждый элемент списка превратился в отдельную строку?" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "id": "5b62ffcc", + "metadata": {}, + "outputs": [], + "source": [ + "# возьмем простой список\n", + "list_ = [1, 2, 3]" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "id": "6c8f414c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'[1, 2, 3]'" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# использовать только функцию str() нельзя\n", + "str(list_)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "id": "21e075bc", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['1', '2', '3']" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# вариант 1: объявить новый список и в цикле for помещать туда строковые значения\n", + "list_str = []\n", + "\n", + "for x in list_:\n", + " list_str.append(str(x))\n", + "\n", + "list_str" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "id": "d41014ad", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['1', '2', '3']" + ] + }, + "execution_count": 25, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# вариант 2: использовать list comprehension\n", + "[str(x) for x in list_]" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "id": "e1e49a8c", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "['1', '2', '3']" + ] + }, + "execution_count": 26, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# вариант 3: функции map() и list()\n", + "list(map(str, list_))" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.10.1" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/python.makarov.chapter.1.py b/python.makarov.chapter.1.py new file mode 100644 index 00000000..4a5cb31b --- /dev/null +++ b/python.makarov.chapter.1.py @@ -0,0 +1,136 @@ +# ### Сщздание (обьявление) переменных + +# можно создать переменную, присвоив ей значение +x = 15 +print(x) # выводит: 15 + +# кроме того, переменной можно задать строковое (текстовое) значение +y = "я програмирую на питоне" +print(y) + +# в Питоне можно присвоить разные значения сразу нескольким переменным +( + a, + b, + c, +) = ( + "питон", + "C++", + "JavaScript", +) +print(a, b, c) # выводит: питон C++ JavaScript + +# a также можно присвоить одно и то же значение нескольким переменим +x = y = z = "тоже же самое значение, но в других переменных" +print(x, y, z) + +# каждый элемент списка можно "распоковать" в переменные +my_list = ["помидоры", "огурцы", "перец"] +a, b, c = my_list +print(a, b, c) + +# ### Автоматическое определение типа данных + +x = 256 # в этом случае переменной х присвается тип int (целое число) +y = 0.25 # установится float (деситичное дробью) +z = "Привет" # строка string +print(type(x)) # выводит: +print(type(y)) # выводит: +print(type(z)) # выводит: + +# ### как узнать тип переменой в питоне + +# узнаем тип перееменных из передыдущего примера +print(type(x), type(y), type(z)) + +# ### присвоение и преоброзование типа данных + +# Присвоение типа данных + +x = str(25) # числа 25 превратится в строку +y = int(25) # число 25 останется целочисленным значением +z = float(25) # число 25 превратится в десатичную дробовь + +print(type(x), type(y), type(z)) + +# **Изменение** типа данных + +# преобразуем строку, похожую на целое число, в целое число +print(type(int("25"))) + +# или строку, похожую на дробь, в настоящую десятичную дробь +print(type(float("2.5"))) + +# преобразуем дробь в целочисленное значение +# обратите внимание, что округления в большую сторону не происходит +print(int(36.6)) +print(type(int(36.6))) + +# конечно, и целое число, и дробь можно преобразовать в строку +print(type(str(25))) +print(type(str(36.6))) + +# ### Именование переменных + +# +# +# ``` +# # Выбран кодовый формат +# ``` +# +# Допустимые имена переменных + +variable = "Просто переменная" +_variable = "Просто переменная" +variable_ = "Просто переменная" +my_variable = "Просто переменная" +My_variable_123 = "Просто переменная" + +# Имя переменной состоит из нескольких слов + +# + +# можно применить так называемый верблюжий регистр, camelCase +# все слова кроме первого начинаются с заглавной буквы и пишутся слитно +camelCaseVariable = "Верблюжий регистр" + +# нотацию Паскаль, PascalCase (то же самое, только тепер все слова пишутся с заглавной) +PascalCaseVariable = "Нотация Паскаль" + +# змеиный стиль, snake_case (с нижними подчеркиваниями) +snake_case_variable = "Змеиная нотация" +# - + +# Недопустимые названия переменной + +# + +# Примеры недопустимых имён (раскомментируйте по очереди, чтобы увидеть ошибки): +# my-variable = 'Так делать нельзя' # SyntaxError: дефис в имени +# 123variable = 'Так делать нельзя' # SyntaxError: имя не может начинаться с цифры +# my variable = 'Так делать нельзя' # SyntaxError: пробел в имени +# - + +# ### Ответы на вопросы + +# **Вопрос**. Как можно преобразовать список чисел таким образом, чтобы каждый элемент списка превратился в отдельную строку? + +# возьмем простой список +list_ = [1, 2, 3] + +# использовать только функцию str() нельзя +str(list_) + +# + +# вариант 1: объявить новый список и в цикле for помещать туда строковые значения +list_str = [] + +for x in list_: + list_str.append(str(x)) + +list_str +# - + +# вариант 2: использовать list comprehension +[str(x) for x in list_] + +# вариант 3: функции map() и list() +list(map(str, list_)) diff --git a/quiz.ipynb b/quiz.ipynb new file mode 100644 index 00000000..ad98c6d7 --- /dev/null +++ b/quiz.ipynb @@ -0,0 +1,136 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "ab862321", + "metadata": {}, + "source": [ + "\n", + "Список вопросов к видео https://youtu.be/hW_7hodGxVU?si=tCEVs00xGt2q61eW (АЛГОРИТМ ПРИНЯТИЯ И ОТДАЧИ ДОМАШКИ):\n", + "\n", + "(По желанию )В ответе подробно всё опишите и обязательно нужно указывать тайм код из видео где я это сказал, по желанию, дополнительно прикладываем скриншот из видео. Если вы знаете ответы на вопросы из Вашего опыта, то таймкоды из видео не надо указывать и т.д.\n", + "\n", + "Как понять, что домашка пришла?\n", + "Как принять домашку?\n", + "Зачем нужна кнопка history и какие функции появляются при нажатии правой кнопки мыши на коммит? 3.1) Где брать ссылку на коммит? куда её отправлять?\n", + "Что такое файл лога? 4.1) Когда нужно его пушить?\n", + "Что такое интерпритатор?\n", + "Где можно выбрать интерпритатор?\n", + "Что такое модуль?\n", + "Как создать и отправить коммит?\n", + "Как посмотреть что коммит точно отправлен и находится в github?\n", + "Какая команда показывает что код не прошёл проверки на ошибки? 10.1) Напишите список линтеров которые используются для проверки кода и дайте их краткую характеристику.\n", + "Как узнать какой именно линтер не прошёл проверку?\n", + "Линтер Pylint видит markdown?\n", + "Номер ячейки в терминале и номер ячейки в vs code может отличаться? в каком случае?\n", + "Где посмотреть номер ячейки в vscode?\n", + "В каком формате ipynb отправляется в гитхаб? причём здесь JSON?\n", + "Где посмотреть в какой ячейке ошибка?\n", + "Как запустить терминал?\n", + "Что такое линтер?\n", + "В какой сайт нужно вставлять код ошибки если ошибка связана с pylint?\n", + "Секция pydocstyle в большинстве случае автоматический закрывается после исправления ошибок в каком линтере?\n", + "Что такое описание модуля? Оно должно отражать информацию о том что находится в модуле? 21.1) С какой git команды начинается утро программиста?\n", + "После внесения изменений в файлах, кнопка open in vs code пропадает в кошке, как по другому открыть vs code из кошки?\n", + "Что такое stash?\n", + "Общее объяснение концепции. 23.1) Как сохранить стэш? git командa(подсказка: https://t.me/c/1937296927/3602/19531):\n", + "Кнопка в vs code:\n", + "\n", + "23.2) Как восстановить стэш(подсказка: https://t.me/c/1937296927/3602/25747)?:\n", + "\n", + " git команда(подсказка: https://t.me/c/1937296927/3602/19531)?:\n", + "23.3) Различие между стэшем и коммитом.\n", + "Когда лучше сохранить изменения в стэше, а когда коммитить. 23.4) Как просмотреть список сохраненных стэшей?\n", + "git команда (подсказка: https://t.me/c/1937296927/3602/19531):\n", + "\n", + "23.5) Как удалить стэш?\n", + "Команды для удаления отдельных стэшей или всех сразу. git команда (подсказка: https://t.me/c/1937296927/3602/19531):\n", + "\n", + "23.6) Практические примеры использования стэша.\n", + "Краткие сценарии, где стэш помогает.\n", + "\n", + "Где посмотреть что есть конфликт в файлах? 24.1) Когда он появляется?\n", + "Как решить конфликт в файлах?\n", + "Напишиие правильное утверждение -Зелёное то что пришло с гитхаба и синее локальные изменения или синее то что пришло с гитхаба и зелёное это локальные изменения\n", + "Если мы работаем в одном файле, можно ли принять pull после того как вы спрячете в стэш свои изменения? 27.1) Что может произойти когда stash восстановите после принятия pull?\n", + "Сколько способов решения конфликтов было показано в видео? Напишите ЧИСЛО и укажите их способы.\n", + "Что делает кнопка complete merge?\n", + "В какой чат нужно писать если остались вопросы?\n", + "Что такое FORK? Зачем его делают?\n", + "Как скачать форкнутый репозиторий на локальный компьютер?\n", + "С какой вероятностью ваши ошибки были уже решены? и кто их решил?\n", + "Как создать файл в vs code?\n", + "Файл лога нужно заполнять в конце каждого урока?\n", + "Дополнительные вопросы: 1)Какая команда конвертирует файл в py из ipynb? подсказка https://t.me/c/1937296927/1/26527 2) Что такое пакетный менеджер? Вы пользуетесь пакетным менеджером conda или pip? Какой лучше использовать для дата сайнс? 3) Почему расширение py лучше чем ipynb? 4) Что такое pep8? подсказка:https://peps.python.org/pep-0008/ 4.1) линтеры проверяют на соблюдение pep8? 4.2) Какая нотация используется для создания переменных? ответ на 85-95 страницы https://t.me/c/1937296927/1/16676 4.3) Может ли переменная состоять из одной буквы например андерскор \"_\" ? 4.4) Зачем и где мы используем андерскор _ 4.5) По PEP8 допустима переменная в одну букву? ответ на 85-95 страницы https://t.me/c/1937296927/1/16676\n", + "\n", + "викторина2\n", + "\n", + "Список вопросов к видео https://youtu.be/Si9MfV8uJ-0?si=JXHe-tsgOEwSTI5E (НАСТРОЙКА VSCODE, перенос строк, линтеры, работа с ячейками):\n", + "\n", + "(По желанию)В ответе подробно всё опишите и обязательно нужно указывать тайм код из видео где я это сказал, по желанию, дополнительно прикладываем скриншот из видео. Если вы знаете ответы на вопросы из Вашего опыта, то таймкоды из видео не надо указывать и т.д.\n", + "\n", + "Как включить автосохранение данных в VSCODE?\n", + "Как настроить перенос строки?\n", + "Сколько символов по pep8 разрешено на строке?\n", + "Какие способы переноса строк показаны в видео:\n", + "4.1 Строки с использованием обратного слэша ()\n", + "\n", + "string_continued = \"This is a long string that we want to \"\n", + "\"split across multiple lines.\" print(string_continued)\n", + "\n", + "4.2 Тройные кавычки (''' или \"\"\")\n", + "\n", + "multi_line_string = \"\"\"This is a string that spans multiple lines. You can write freely and it will keep the line breaks.\"\"\" print(multi_line_string)\n", + "\n", + "4.3 Создание списка строк и объединение с помощью join\n", + "\n", + "strings = [ \"This is the first line.\", \"This is the second line.\", \"This is the third line.\" ] result = \"\\n\".join(strings) # Используем перенос строк '\\n' print(result)\n", + "\n", + "4.4 Использование круглых скобок для продолжения строки long_string = ( \"This is a very long string that I would like to \" \"continue on the next line.\" ) print(long_string)\n", + "\n", + "4.5 Форматированные строки (f-строки) с использованием скобок letter_a = 5 letter_b = 6 product_ab = letter_a * letter_b\n", + "\n", + "message = ( f\"when {letter_a} is multiplied by {letter_b}, \" f\"the result is {product_ab}\" ) print(message)\n", + "\n", + "4.6 Сложение строк с помощью +\n", + "\n", + "string_part1 = \"This is the first part, \" string_part2 = \"and this is the second part.\" full_string = string_part1 + string_part2 print(full_string)\n", + "\n", + "Проверка на ошибки c помощью кнопки problems, где она находится?\n", + "Где в vscode находится клиент гита? как в нём отправить коммит? как принять домашку?\n", + "Что такое GIT? он локальный? В нём можно посмотреть историю изменений файлов и вернуться к любому коммиту?\n", + "Как вставить картинку в маркдаун?\n", + "Где посмотреть длину строки в vs code?\n", + "Как поменять тип ячейки с питона на маркдаун?\n", + "Как запустить сразу все ячейки в юпитере?\n", + "Как изменить размер картинки в юпитере? Нужно для этого знать HTML?\n", + "Какой хоткей чтобы запустить ячейку с смещением на следующую?\n", + "Как включить отображение номеров строк в юпитере(Cell line numbers)?\n", + "Что такое \"Go To\" чем это полезно? Как перейти сразу на ошибочную ячейку?\n", + "Как очистить вывод ячеек которые уже запущены?\n", + "Как работать одновременно в нескольких файлах в VSCODE? Что такое SPLIT?\n", + "Каким сочетанием убирается левый сайдбар?\n", + "Кнопка два листочка это наши локальные файлы?\n", + "Какая ошибка появилась в трассировке при запуске всех ячеек DICT или LIST?\n", + "Вы ознакомились с https://t.me/c/1937296927/832/19307? и https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet?\n", + "Что такое валидация?\n", + "Что такое трассировка ошибки?\n", + "Что значит отвалился интерпритатор?\n", + "Отвечаете на вопросы в вашем редакторе кода." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "name": "python", + "version": "3.10.1" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/quiz.py b/quiz.py new file mode 100644 index 00000000..d9ad9076 --- /dev/null +++ b/quiz.py @@ -0,0 +1,112 @@ +# +# Список вопросов к видео https://youtu.be/hW_7hodGxVU?si=tCEVs00xGt2q61eW (АЛГОРИТМ ПРИНЯТИЯ И ОТДАЧИ ДОМАШКИ): +# +# (По желанию )В ответе подробно всё опишите и обязательно нужно указывать тайм код из видео где я это сказал, по желанию, дополнительно прикладываем скриншот из видео. Если вы знаете ответы на вопросы из Вашего опыта, то таймкоды из видео не надо указывать и т.д. +# +# Как понять, что домашка пришла? +# Как принять домашку? +# Зачем нужна кнопка history и какие функции появляются при нажатии правой кнопки мыши на коммит? 3.1) Где брать ссылку на коммит? куда её отправлять? +# Что такое файл лога? 4.1) Когда нужно его пушить? +# Что такое интерпритатор? +# Где можно выбрать интерпритатор? +# Что такое модуль? +# Как создать и отправить коммит? +# Как посмотреть что коммит точно отправлен и находится в github? +# Какая команда показывает что код не прошёл проверки на ошибки? 10.1) Напишите список линтеров которые используются для проверки кода и дайте их краткую характеристику. +# Как узнать какой именно линтер не прошёл проверку? +# Линтер Pylint видит markdown? +# Номер ячейки в терминале и номер ячейки в vs code может отличаться? в каком случае? +# Где посмотреть номер ячейки в vscode? +# В каком формате ipynb отправляется в гитхаб? причём здесь JSON? +# Где посмотреть в какой ячейке ошибка? +# Как запустить терминал? +# Что такое линтер? +# В какой сайт нужно вставлять код ошибки если ошибка связана с pylint? +# Секция pydocstyle в большинстве случае автоматический закрывается после исправления ошибок в каком линтере? +# Что такое описание модуля? Оно должно отражать информацию о том что находится в модуле? 21.1) С какой git команды начинается утро программиста? +# После внесения изменений в файлах, кнопка open in vs code пропадает в кошке, как по другому открыть vs code из кошки? +# Что такое stash? +# Общее объяснение концепции. 23.1) Как сохранить стэш? git командa(подсказка: https://t.me/c/1937296927/3602/19531): +# Кнопка в vs code: +# +# 23.2) Как восстановить стэш(подсказка: https://t.me/c/1937296927/3602/25747)?: +# +# git команда(подсказка: https://t.me/c/1937296927/3602/19531)?: +# 23.3) Различие между стэшем и коммитом. +# Когда лучше сохранить изменения в стэше, а когда коммитить. 23.4) Как просмотреть список сохраненных стэшей? +# git команда (подсказка: https://t.me/c/1937296927/3602/19531): +# +# 23.5) Как удалить стэш? +# Команды для удаления отдельных стэшей или всех сразу. git команда (подсказка: https://t.me/c/1937296927/3602/19531): +# +# 23.6) Практические примеры использования стэша. +# Краткие сценарии, где стэш помогает. +# +# Где посмотреть что есть конфликт в файлах? 24.1) Когда он появляется? +# Как решить конфликт в файлах? +# Напишиие правильное утверждение -Зелёное то что пришло с гитхаба и синее локальные изменения или синее то что пришло с гитхаба и зелёное это локальные изменения +# Если мы работаем в одном файле, можно ли принять pull после того как вы спрячете в стэш свои изменения? 27.1) Что может произойти когда stash восстановите после принятия pull? +# Сколько способов решения конфликтов было показано в видео? Напишите ЧИСЛО и укажите их способы. +# Что делает кнопка complete merge? +# В какой чат нужно писать если остались вопросы? +# Что такое FORK? Зачем его делают? +# Как скачать форкнутый репозиторий на локальный компьютер? +# С какой вероятностью ваши ошибки были уже решены? и кто их решил? +# Как создать файл в vs code? +# Файл лога нужно заполнять в конце каждого урока? +# Дополнительные вопросы: 1)Какая команда конвертирует файл в py из ipynb? подсказка https://t.me/c/1937296927/1/26527 2) Что такое пакетный менеджер? Вы пользуетесь пакетным менеджером conda или pip? Какой лучше использовать для дата сайнс? 3) Почему расширение py лучше чем ipynb? 4) Что такое pep8? подсказка:https://peps.python.org/pep-0008/ 4.1) линтеры проверяют на соблюдение pep8? 4.2) Какая нотация используется для создания переменных? ответ на 85-95 страницы https://t.me/c/1937296927/1/16676 4.3) Может ли переменная состоять из одной буквы например андерскор "_" ? 4.4) Зачем и где мы используем андерскор _ 4.5) По PEP8 допустима переменная в одну букву? ответ на 85-95 страницы https://t.me/c/1937296927/1/16676 +# +# викторина2 +# +# Список вопросов к видео https://youtu.be/Si9MfV8uJ-0?si=JXHe-tsgOEwSTI5E (НАСТРОЙКА VSCODE, перенос строк, линтеры, работа с ячейками): +# +# (По желанию)В ответе подробно всё опишите и обязательно нужно указывать тайм код из видео где я это сказал, по желанию, дополнительно прикладываем скриншот из видео. Если вы знаете ответы на вопросы из Вашего опыта, то таймкоды из видео не надо указывать и т.д. +# +# Как включить автосохранение данных в VSCODE? +# Как настроить перенос строки? +# Сколько символов по pep8 разрешено на строке? +# Какие способы переноса строк показаны в видео: +# 4.1 Строки с использованием обратного слэша () +# +# string_continued = "This is a long string that we want to " +# "split across multiple lines." print(string_continued) +# +# 4.2 Тройные кавычки (''' или """) +# +# multi_line_string = """This is a string that spans multiple lines. You can write freely and it will keep the line breaks.""" print(multi_line_string) +# +# 4.3 Создание списка строк и объединение с помощью join +# +# strings = [ "This is the first line.", "This is the second line.", "This is the third line." ] result = "\n".join(strings) # Используем перенос строк '\n' print(result) +# +# 4.4 Использование круглых скобок для продолжения строки long_string = ( "This is a very long string that I would like to " "continue on the next line." ) print(long_string) +# +# 4.5 Форматированные строки (f-строки) с использованием скобок letter_a = 5 letter_b = 6 product_ab = letter_a * letter_b +# +# message = ( f"when {letter_a} is multiplied by {letter_b}, " f"the result is {product_ab}" ) print(message) +# +# 4.6 Сложение строк с помощью + +# +# string_part1 = "This is the first part, " string_part2 = "and this is the second part." full_string = string_part1 + string_part2 print(full_string) +# +# Проверка на ошибки c помощью кнопки problems, где она находится? +# Где в vscode находится клиент гита? как в нём отправить коммит? как принять домашку? +# Что такое GIT? он локальный? В нём можно посмотреть историю изменений файлов и вернуться к любому коммиту? +# Как вставить картинку в маркдаун? +# Где посмотреть длину строки в vs code? +# Как поменять тип ячейки с питона на маркдаун? +# Как запустить сразу все ячейки в юпитере? +# Как изменить размер картинки в юпитере? Нужно для этого знать HTML? +# Какой хоткей чтобы запустить ячейку с смещением на следующую? +# Как включить отображение номеров строк в юпитере(Cell line numbers)? +# Что такое "Go To" чем это полезно? Как перейти сразу на ошибочную ячейку? +# Как очистить вывод ячеек которые уже запущены? +# Как работать одновременно в нескольких файлах в VSCODE? Что такое SPLIT? +# Каким сочетанием убирается левый сайдбар? +# Кнопка два листочка это наши локальные файлы? +# Какая ошибка появилась в трассировке при запуске всех ячеек DICT или LIST? +# Вы ознакомились с https://t.me/c/1937296927/832/19307? и https://github.com/adam-p/markdown-here/wiki/Markdown-Cheatsheet? +# Что такое валидация? +# Что такое трассировка ошибки? +# Что значит отвалился интерпритатор? +# Отвечаете на вопросы в вашем редакторе кода. diff --git a/venv.py b/venv.py new file mode 100644 index 00000000..74e32898 --- /dev/null +++ b/venv.py @@ -0,0 +1,92 @@ +# %% [markdown] +# ![](111.jpg) +# + +# %% [markdown] +# 1. Что делает команду Python -m venv venv? +# создаёт виртуальное окружение Python. +# +# 1,1. Что делают команды в списке? +# pip list: Выводит список всех пакетов, установленных в текущем окружении, и их версии +# +# pip freeze > requirements.txt: Сохраняет список всех установленных библиотек и их +# точных версий в файл requirements.txt. Это нужно, чтобы другие могли воссоздать ваш проект. +# +# pip install -r requirements.txt: Читает файл requirements.txt и автоматически устанавливает все перечисленные в нем пакеты. +# +# 2. Что делают команды Conda в списке? +# conda env list: Показывает список всех созданных окружений Conda. +# +# 3. conda create -n env_name python=3.5: +# Создает новое окружение с именем "env_name" и устанавливает в него Python версии 3.5. +# +# 4. conda env update -n env_name -f file.yml: +# Обновляет пакеты в окружении "env_name", используя настройки из файла конфигурации .yml. +# +# 5. source activate env_name +# Активирует указанное окружение (в новых версиях чаще используется conda activate). +# +# 6. source deactivate +# Деактивирует текущее окружение и возвращает вас в системную среду. +# +# 7. conda clean -a +# Очищает кэш и удаляет неиспользуемые пакеты, чтобы освободить место на диске. +# +# 8. Как установить необходимые пакеты виртуального окружения для conda/venv? +# Для venv: Используйте команду pip install имя_пакета. +# Для Conda: Используйте команду conda install имя_пакета (или pip +# install, если пакета нет в репозиториях conda). + +# %% [markdown] +# ![/Users/apple/Без.png](/Users/apple/Без.png) + +# %% [markdown] +# + +# %% [markdown] +# Что делают эти команды? +# pip freeze > requirements.txt +# создаёт файл requirements.txt со списком библиотек и их версий +# Используется, чтобы передать окружение другому человеку или серверу +# +# conda env export > environment.yml +# создаёт файл environment.yml для conda +# +# +# + +# %% [markdown] +# ![](/Users//python/Без названия.png) + +# %% [markdown] +# 1. Что делают эти команды? +# pip install -r requirements.txt +# клонировали репозиторий +# нужно восстановить окружение +# +# 2. conda env create -f environment.yml . +# создаёт новое conda-окружение +# полностью по файлу environment.yml +# +# 3. Что делают эти команды? +# pip list +# показывает установленные pip-пакеты в текущем окружении +# +# pip show +# показывает информацию о конкретном пакете: +# +# conda list +# показывает все пакеты в conda-окружении +# +# Где по умолчанию больше пакетов: venv/pip или conda? +# В conda — больше +# +# Зачем нужно виртуальное окружение? +# изоляция проектов +# разные версии библиотек +# воспроизводимость +# +# С этого момента надо работать в виртуальных средах с помощью conda , ты научился(-ась) выгружать независимо и работать с окружением? да +# +# !!К СОЖИЛЕНИЕ НЕ СМОГ ПОСТАВИТЬ КАРТИНКУ СЮДА КАК ПРОСИЛИ!! ПОСТАВЛЬЮ В СЛЕДУЩИЙ ИШЬЮСЬ!! +#