diff --git a/Data_types.ipynb b/Data_types.ipynb new file mode 100644 index 0000000..c26f5ed --- /dev/null +++ b/Data_types.ipynb @@ -0,0 +1,1134 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": { + "id": "n-ykzW59acTY" + }, + "source": [ + "## Введение в Python. Целые и вещественные числа. Логические переменные." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "Nifq5zd_acTa" + }, + "source": [ + "# Функция `print()`" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "m_Ame35uacTa" + }, + "source": [ + "С помощью Python можно решать огромное количество задач. Мы начнем с очень простых и постепенно будем их усложнять, закончив наш курс небольшим проектом. Если вы уже сталкивались с программированием, то вы помните, что обычно самой первой программой становится вывод \"Hello, world\". Попробуем сделать это в Python." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "executionInfo": { + "elapsed": 271, + "status": "ok", + "timestamp": 1629267401477, + "user": { + "displayName": "Ian Pile", + "photoUrl": "", + "userId": "15446314713627471182" + }, + "user_tz": -180 + }, + "id": "Js941SVBacTb", + "outputId": "1c968456-a700-4465-a3ad-6ded90d72a8b" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hello, world!\n" + ] + } + ], + "source": [ + "print('Hello, world!')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "-lk86t_WacTc" + }, + "source": [ + "Обратите внимание, что `\"Hello, world!\"` мы написали в кавычках, а единицу - нет. Это связанно с тем,\n", + "что в программировании мы имеем дело с разными типами данных. И `Python` будет воспринимать текст как текст (строковую переменную), только в том случае, если мы его возьмем в кавычки (неважно, одинарные или двойные). А при выводе эти кавычки отображаться уже не будут (они служат знаком для `Python`, что внутри них - текст).\n", + "\n", + "`print()` - это функция, которая выводит то, что мы ей передадим. В других IDE это был бы вывод в терминал, а в `Jupyter` вывод напечатается под запускаемой ячейкой. Распознать функцию в питоне можно по скобкам после слова, внутри которых мы передаем аргумент, к которому эту функцию нужно применить (текст `\"Hello, world\"` или `1` в нашем случае). " + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 164 + }, + "executionInfo": { + "elapsed": 317, + "status": "error", + "timestamp": 1629267361980, + "user": { + "displayName": "Ian Pile", + "photoUrl": "", + "userId": "15446314713627471182" + }, + "user_tz": -180 + }, + "id": "L4BerLhMacTc", + "outputId": "2a09c5dc-c73a-4a90-e272-d80ff76f713e" + }, + "outputs": [ + { + "ename": "NameError", + "evalue": "name 'Hello' is not defined", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mNameError\u001b[0m Traceback (most recent call last)", + "Input \u001b[0;32mIn [2]\u001b[0m, in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[43mHello\u001b[49m, world)\n", + "\u001b[0;31mNameError\u001b[0m: name 'Hello' is not defined" + ] + } + ], + "source": [ + "print(Hello, world)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "ML16MrgVacTd" + }, + "source": [ + "Написали без кавычек - получили ошибку. Кстати, обратите внимание, что очень часто в тексте ошибки есть указание на то, что именно произошло, и можно попробовать догадаться, что же нужно исправить. Текст без кавычек `Python` воспринимает как название переменной, которую еще не задали. Кстати, если забыть закрыть или открыть кавычку (или поставить разные), то тоже поймаем ошибку." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "LogQJv1vacTd" + }, + "source": [ + "\n", + "Иногда мы хотим комментировать наш код, чтобы я-будущий или наши коллеги поменьше задавались вопросами, а что вообще имелось ввиду. Комментарии можно писать прямо в коде, они не повлияют на работу программы, если их правильно оформить." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "executionInfo": { + "elapsed": 262, + "status": "ok", + "timestamp": 1629267522823, + "user": { + "displayName": "Ian Pile", + "photoUrl": "", + "userId": "15446314713627471182" + }, + "user_tz": -180 + }, + "id": "3sY5r2soacTe", + "outputId": "fa52d131-ac17-4492-fddc-0fa0b6fdc62a" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hello, world\n" + ] + } + ], + "source": [ + "# Обратите внимание: так выглядит комментарий - часть скрипта, которая не будет исполнена \n", + "# при запуске программы.\n", + "# Каждую строку комментария мы начинаем со знака хэштега.\n", + "\n", + "'''\n", + "Это тоже комментарий - обычно выделение тремя апострофами мы используем для тех случаев, \n", + "когда хотим написать длинный, развернутый текст.\n", + "'''\n", + "\n", + "print('Hello, world')" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "cmWwH05JacTe" + }, + "source": [ + "Обратите внимание, что в отличие от других `IDE` (например, `PyCharm`) в `Jupyter Notebook` не всегда обязательно использовать `print()`, чтобы что-то вывести. Но не относитесь к этому как к стандарту для любых `IDE`." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 37 + }, + "executionInfo": { + "elapsed": 264, + "status": "ok", + "timestamp": 1629267562088, + "user": { + "displayName": "Ian Pile", + "photoUrl": "", + "userId": "15446314713627471182" + }, + "user_tz": -180 + }, + "id": "FF-_6r0facTf", + "outputId": "f10910d6-509a-4a34-c66b-cf65d4d5816b" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hello, world\n", + "hi\n" + ] + } + ], + "source": [ + "print(\"Hello, world\")\n", + "print(\"hi\")" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "g_wkrnwGacTf" + }, + "source": [ + "Выше рядом с выводом появилась подпись `Out[]`. В данном случае `Jupyter` показывает нам последнее значение, лежащее в буфере ячейки. Например, в PyCharm такой вывод всегда будет скрыт, пока мы его не \"напечатаем\" с помощью `print()`. Но эта особенность `Jupyter` помогает нам быстро проверить, что, например, находится внутри переменной, когда мы отлаживаем наш код." + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "hHerJopIacTg" + }, + "source": [ + "Следующая вещь, которую нужно знать про язык программирования - как в нем задаются переменные. Переменные - это \n", + "контейнеры, которые хранят в себе информацию (текстовую, числовую, какие-то более сложные виды данных). В `Python`\n", + "знаком присвоения является знак `=`. " + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "executionInfo": { + "elapsed": 285, + "status": "ok", + "timestamp": 1629267857141, + "user": { + "displayName": "Ian Pile", + "photoUrl": "", + "userId": "15446314713627471182" + }, + "user_tz": -180 + }, + "id": "KbkPrvAeacTg", + "outputId": "208f20ff-d5ba-44ae-b300-eb43dfec10f3" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hello, world!\n" + ] + } + ], + "source": [ + "x = 'Hello, world!'\n", + "print(x) # Обратите внимание, что результат вызова этой функции такой же, как выше, \n", + " # только текст теперь хранится внутри переменной." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "str" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "type(x)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "gO9IjMSDacTg" + }, + "source": [ + "`Python` - язык чувствительный к регистру. Поэтому, когда создаете/вызываете переменные или функции, обязательно используйте правильный регистр. Так, следующая строка выдаст ошибку." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 164 + }, + "executionInfo": { + "elapsed": 8, + "status": "error", + "timestamp": 1629267859317, + "user": { + "displayName": "Ian Pile", + "photoUrl": "", + "userId": "15446314713627471182" + }, + "user_tz": -180 + }, + "id": "49A60ptqacTh", + "outputId": "a8024aaf-de50-44e5-8e26-b11f8f8ff267" + }, + "outputs": [ + { + "ename": "NameError", + "evalue": "ignored", + "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[0;32m----> 1\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mX\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;31m# мы создали переменную x, а X не существует\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m", + "\u001b[0;31mNameError\u001b[0m: name 'X' is not defined" + ] + } + ], + "source": [ + "print(X) # мы создали переменную x, а X не существует" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "BxkFuAy5acTh" + }, + "source": [ + "Еще раз обратим внимание на ошибку. *NameError: name 'X' is not defined* означает, что переменная с таким названием не была создана в этой программе. Кстати, обратите внимание, что переменные в Jupyter хранятся на протяжении всей сессии (пока вы работаете с блокнотом и не закрыли его), и могут быть созданы в одной ячейке, а вызваны в другой. Давайте опять попробуем обратиться к `x`." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "executionInfo": { + "elapsed": 273, + "status": "ok", + "timestamp": 1629267896433, + "user": { + "displayName": "Ian Pile", + "photoUrl": "", + "userId": "15446314713627471182" + }, + "user_tz": -180 + }, + "id": "23dmeQRTacTh", + "outputId": "f697917f-3e1d-4d5b-95f2-6fb7f376435f" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Hello, world!\n" + ] + } + ], + "source": [ + "print(x) # работает!" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "JjhLJimpacTi" + }, + "source": [ + "# Типы данных: целочисленные переменные (integer)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "yYmNEKLcacTi" + }, + "source": [ + "Знакомство с типа данных мы начнем с целых чисел. Если вы вдруг знакомы с другими языками программирования, то стоит отметить, что типизация в `Python` - динамическая. Это значит, что вам не нужно говорить какой тип данных вы хотите положить в переменную - `Python` сам все определит. Проверить тип данных можно с помощью функции `type()`, передав ей в качестве аргумента сами данные или переменную.\n", + "\n", + "**ЦЕЛЫЕ ЧИСЛА (INT, INTEGER):** 1, 2, 592, 1030523235 - любое целое число без дробной части. " + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "int" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "type(22345678946375892347)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "executionInfo": { + "elapsed": 292, + "status": "ok", + "timestamp": 1629267958034, + "user": { + "displayName": "Ian Pile", + "photoUrl": "", + "userId": "15446314713627471182" + }, + "user_tz": -180 + }, + "id": "8XktENAAacTi", + "outputId": "dc3dc259-a5bc-4922-c339-d046fc7d9821" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "\n" + ] + } + ], + "source": [ + "y = 22345678946375892347\n", + "print(type(2))\n", + "print(type(y))" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "joJtxkkVacTj" + }, + "source": [ + "Обратите внимание - выше мы вызвали функцию внутри функции. \n", + "`type(2)` возвращает скрытое значение типа переменной (`int` для `integer`). \n", + "Чтобы вывести это скрытое значение - мы должны его \"напечатать\".\n", + "\n", + "Самое элементарное, что можно делать в `Python` - использовать его как калькулятор. Давайте посмотрим, как\n", + "он вычитает, складывает и умножает." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "executionInfo": { + "elapsed": 291, + "status": "ok", + "timestamp": 1629268004910, + "user": { + "displayName": "Ian Pile", + "photoUrl": "", + "userId": "15446314713627471182" + }, + "user_tz": -180 + }, + "id": "5rzOEfXnacTj", + "outputId": "ae8c1859-2f76-42f6-c26c-894d9dadbd43" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "4\n", + "9\n", + "12\n" + ] + } + ], + "source": [ + "print(2 + 2)\n", + "print(18 - 9)\n", + "print(4 * 3)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "tDqVQwHUacTk" + }, + "source": [ + "С делением нужно быть немного осторожней. Существует два типа деления - привычное нам, которое даст в ответе дробь при делении 5 на 2, и целочисленное деление, в результате которого мы получим только целую часть частного." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2.5\n" + ] + } + ], + "source": [ + "print(5 / 2) # в результате такого деления получается другой тип данных (float), подробнее о нем поговорим позже." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "executionInfo": { + "elapsed": 283, + "status": "ok", + "timestamp": 1629268199672, + "user": { + "displayName": "Ian Pile", + "photoUrl": "", + "userId": "15446314713627471182" + }, + "user_tz": -180 + }, + "id": "gTDe3h2wacTk", + "outputId": "16139deb-6b90-4a9c-af9d-08dca43aeb63" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2\n" + ] + } + ], + "source": [ + "print(5 // 2)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "FMuliui-acTk" + }, + "source": [ + "А если нам надо как раз найти остаток от деления, то мы можем воспользоваться оператором модуло %\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "executionInfo": { + "elapsed": 309, + "status": "ok", + "timestamp": 1629268242569, + "user": { + "displayName": "Ian Pile", + "photoUrl": "", + "userId": "15446314713627471182" + }, + "user_tz": -180 + }, + "id": "EXhUVBw-acTl", + "outputId": "79537975-9994-4309-bf64-1ce016428971" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1\n" + ] + } + ], + "source": [ + "print(5 % 2)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "WnYIxtdxacTl" + }, + "source": [ + "Еще одна математическая операция, которую мы можем выполнять без загрузки специальных математических библиотек - это\n", + "возведение в степень." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "executionInfo": { + "elapsed": 278, + "status": "ok", + "timestamp": 1629268255372, + "user": { + "displayName": "Ian Pile", + "photoUrl": "", + "userId": "15446314713627471182" + }, + "user_tz": -180 + }, + "id": "uja1KaZcacTl", + "outputId": "2e4feb72-cd70-4d76-94bd-645f925cc628" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "25\n" + ] + } + ], + "source": [ + "print(5 ** 2)" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "sOBb_YAbacTm" + }, + "source": [ + "Все то же самое работает и с переменными, содержащими числа." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": { + "id": "Nahua0_yacTm", + "outputId": "cb94c497-aa2e-4b12-a457-42e53d2c979c" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "8\n", + "125\n" + ] + } + ], + "source": [ + "a = 2\n", + "b = 3\n", + "print(a ** b)\n", + "# изменится ли результат, если мы перезапишем переменную a?\n", + "a = 5\n", + "print(a ** b)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "4.166666666666667" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "a = 5\n", + "b = 1.2\n", + "\n", + "a / b" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "518" + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "6 + (4 * 2) ** 3" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "8" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "2 ** 3" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "32" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "4 * 8" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "e8aidkBzacTm" + }, + "source": [ + "Часто возникает ситуация, что мы считали какие-то данные в формате текста, и у нас не работают арифметические операции. Тогда мы можем с помощью функции `int()` преобразовать строковую переменную (о них ниже) в число, если эта строка может быть переведена в число в десятичной системе." + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 164 + }, + "executionInfo": { + "elapsed": 313, + "status": "error", + "timestamp": 1629268492531, + "user": { + "displayName": "Ian Pile", + "photoUrl": "", + "userId": "15446314713627471182" + }, + "user_tz": -180 + }, + "id": "RmOMP4oqacTn", + "outputId": "2293c563-a939-403f-ff95-69a2bbf828fe" + }, + "outputs": [ + { + "ename": "TypeError", + "evalue": "unsupported operand type(s) for +: 'int' and 'str'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)", + "Input \u001b[0;32mIn [12]\u001b[0m, in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[38;5;28mprint\u001b[39m(\u001b[38;5;241;43m2\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;241;43m+\u001b[39;49m\u001b[43m \u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43m5\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m)\n", + "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for +: 'int' and 'str'" + ] + } + ], + "source": [ + "print(2 + '5') # ошибка, не сможем сложить целое число и строку" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "5.0" + ] + }, + "execution_count": 21, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "float('5')" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "'5.0'" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "str(5.)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "executionInfo": { + "elapsed": 287, + "status": "ok", + "timestamp": 1629268585048, + "user": { + "displayName": "Ian Pile", + "photoUrl": "", + "userId": "15446314713627471182" + }, + "user_tz": -180 + }, + "id": "2y3q7p4aacTn", + "outputId": "7b715b58-983e-4440-87af-62a32c4fbe5f" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "7\n" + ] + } + ], + "source": [ + "print(2 + int('5')) # преобразовали строку в число и все заработало" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 164 + }, + "executionInfo": { + "elapsed": 328, + "status": "error", + "timestamp": 1629268590174, + "user": { + "displayName": "Ian Pile", + "photoUrl": "", + "userId": "15446314713627471182" + }, + "user_tz": -180 + }, + "id": "GVxQkEbtacTn", + "outputId": "15d0d60f-e374-44fd-9191-f6d21baa0316" + }, + "outputs": [ + { + "ename": "ValueError", + "evalue": "invalid literal for int() with base 10: 'текст'", + "output_type": "error", + "traceback": [ + "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[0;31mValueError\u001b[0m Traceback (most recent call last)", + "Input \u001b[0;32mIn [20]\u001b[0m, in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[38;5;28;43mint\u001b[39;49m\u001b[43m(\u001b[49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[38;5;124;43mтекст\u001b[39;49m\u001b[38;5;124;43m'\u001b[39;49m\u001b[43m)\u001b[49m\n", + "\u001b[0;31mValueError\u001b[0m: invalid literal for int() with base 10: 'текст'" + ] + } + ], + "source": [ + "int('текст') # здесь тоже поймаем ошибку, потому что строка не представляет собой число" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Home tasks" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "J89oTkOKacTo" + }, + "source": [ + "## Task #1\n", + "\n", + "### Сумма цифр трехзначного числа\n", + "\n", + "Дано трехзначное число 179. Найдите сумму его цифр.\n", + "\n", + "**Формат вывода** \n", + "Выведите ответ на задачу.\n", + "\n", + "**Ответ** \n", + "Вывод программы: \n", + "17" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "executionInfo": { + "elapsed": 306, + "status": "ok", + "timestamp": 1629268642164, + "user": { + "displayName": "Ian Pile", + "photoUrl": "", + "userId": "15446314713627471182" + }, + "user_tz": -180 + }, + "id": "XYI5AwfuacTo", + "outputId": "04ecfc14-e257-4538-d588-134533d49c03" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "n=179\n", + "17\n" + ] + } + ], + "source": [ + "# code\n", + "n = int (input ('n='))\n", + "# давайте назовем три цифры a ,b ,c\n", + "# n = ( a+b+c) \n", + "# ищем a, b,c \n", + "a = n % 10 \n", + "n = n // 10 \n", + "b = n % 10 \n", + "n = n// 10 \n", + "c = n % 10 \n", + "c = n \n", + " \n", + "\n", + "print ( a + b + c) " + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "P7tD_YjJacTo" + }, + "source": [ + "# Task #2\n", + "\n", + "### Электронные часы\n", + "\n", + "Дано число N. С начала суток прошло N минут. Определите, сколько часов и минут будут показывать электронные часы в этот момент.\n", + "\n", + "**Формат ввода** \n", + "\n", + "Вводится число N — целое, положительное, не превышает 10⁷.\n", + "\n", + "**Формат вывода**\n", + "\n", + "Программа должна вывести два числа: количество часов (от 0 до 23) и количество минут (от 0 до 59).\n", + "\n", + "Учтите, что число N может быть больше, чем количество минут в сутках.\n", + "\n", + "#### Примеры\n", + "\n", + "Тест 1 \n", + "**Входные данные:** \n", + "150\n", + "\n", + "**Вывод программы:** \n", + "2 30" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "B_KtSqfJacTp", + "outputId": "f3583dfe-7332-4e0c-b4e7-3baf66874671" + }, + "source": [ + "# Your code" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "n1400\n", + "23 20\n" + ] + } + ], + "source": [ + "n = int ( input ('n')) \n", + "n = n % 1440 \n", + "print (n // 60 , n % 60) \n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "colab": { + "collapsed_sections": [ + "JjhLJimpacTi", + "J89oTkOKacTo", + "P7tD_YjJacTo", + "--uh0bMFacTp", + "i2Au_ny0acTr", + "Dbv-iio7acTs", + "V3sjcVMKacTt", + "uMugd4w4acTx", + "OgGnW4_kacTz", + "qyb47c62acTz" + ], + "name": "Data_types.ipynb", + "provenance": [] + }, + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.9.12" + } + }, + "nbformat": 4, + "nbformat_minor": 1 +} diff --git a/week_1/Data_types.ipynb b/week_1/Data_types.ipynb index b65e591..c6c8b4e 100644 --- a/week_1/Data_types.ipynb +++ b/week_1/Data_types.ipynb @@ -971,7 +971,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 6, "metadata": { "colab": { "base_uri": "https://localhost:8080/" @@ -990,9 +990,31 @@ "id": "XYI5AwfuacTo", "outputId": "04ecfc14-e257-4538-d588-134533d49c03" }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "veillez saisir un nombre entier179\n", + "17\n" + ] + } + ], "source": [ - "# Your code" + "# Your code\n", + "# la somme d'un nombre \n", + "# n est le nombre ()\n", + "# demander a la console de saisir un nombre entier \n", + "\n", + "n = int(input(\"veillez saisir un nombre entier\")) \n", + "# creer une variable s = la somme des chiffres \n", + "somme = 0 \n", + "\n", + "while n > 0: \n", + " somme = somme + n % 10\n", + " n = n // 10\n", + " \n", + "print (somme)" ] }, { @@ -1029,14 +1051,29 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 9, "metadata": { "id": "B_KtSqfJacTp", "outputId": "f3583dfe-7332-4e0c-b4e7-3baf66874671" }, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "в этот момент:150\n", + "2 ч 30 мин\n" + ] + } + ], "source": [ - "# Your code" + "# considerons N le nombre de minutes \n", + "# dans 24 h il y a 1440 minutes, количество минут в 24 ч \n", + "\n", + "N = int (input( \"в этот момент:\"))\n", + "N = N % 1440 \n", + "\n", + "print (N//60, \"ч\", N % 60, \"мин\" )" ] } ], @@ -1072,7 +1109,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.9" + "version": "3.9.12" } }, "nbformat": 4, diff --git a/week_2/If_Else_While.ipynb b/week_2/If_Else_While.ipynb index 5bb9d83..e966a21 100644 --- a/week_2/If_Else_While.ipynb +++ b/week_2/If_Else_While.ipynb @@ -883,10 +883,22 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 21, "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1505, 1540, 1575, 1610, 1645, 1680, 1715, 1750, 1785, 1820, 1855, 1890, 1925, 1960, 1995, 2030, 2065, 2100, 2135, 2170, 2205, 2240, 2275, 2310, 2345, 2380, 2415, 2450, 2485, 2520, 2555, 2590, 2625, 2660, 2695, " + ] + } + ], + "source": [ + "for nombre in range(1500,2700): \n", + " if (nombre % 7 == 0) and (nombre % 5 == 0): \n", + " print (nombre , end = \", \")" + ] }, { "cell_type": "markdown", @@ -915,10 +927,40 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 18, "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "enter the number of lines: 5\n", + "* \n", + "* * \n", + "* * * \n", + "* * * * \n", + "* * * * * \n", + "* * * * \n", + "* * * \n", + "* * \n", + "* \n", + "\n" + ] + } + ], + "source": [ + "# the left pascal's pattern\n", + "# n = number of lines \n", + "n = int(input(\"enter the number of lines: \"))\n", + "for i in range(n): \n", + " for j in range(i+1): \n", + " print(\"*\", end= \" \")\n", + " print()\n", + "for i in range(n):\n", + " for j in range(i+1,n):\n", + " print(\"*\", end= \" \")\n", + " print ()" + ] }, { "cell_type": "markdown", @@ -938,10 +980,33 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 41, "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "0\n", + "1\n", + "2\n", + "4\n", + "5\n" + ] + } + ], + "source": [ + "# make a variable blacklist for 3 and 6\n", + "# x is a number between (0,7) \n", + "\n", + "x = 0 \n", + "blacklist = [3,6]\n", + "\n", + "for x in range(0,7):\n", + " if x in blacklist:\n", + " continue\n", + " print (x)\n" + ] }, { "cell_type": "markdown", @@ -967,10 +1032,34 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 35, "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "enter the value of the first side of the triangle:6\n", + "enter the value of the seconde side of the triangle:8\n", + "enter the value of the third side of the triangle:12\n", + "Scalene triangle\n" + ] + } + ], + "source": [ + "x = int(input(\"enter the value of the first side of the triangle:\"))\n", + "y = int(input(\"enter the value of the seconde side of the triangle:\"))\n", + "z = int(input(\"enter the value of the third side of the triangle:\"))\n", + "\n", + "if x == y == z and z==x: \n", + " print(\"Equilateral triangle\")\n", + " \n", + "elif x != y != z: \n", + " print(\"Scalene triangle\")\n", + "else: \n", + " x == y or y ==z or x ==z \n", + " print(\"Isosceles triangle\")" + ] }, { "cell_type": "markdown", @@ -993,6 +1082,42 @@ "`The next date is [yyyy-mm-dd] 2016-8-24` " ] }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Enter a year:2016\n", + "Enter a month:08\n", + "Enter a day:23\n", + "The next date is 2016 8 24\n" + ] + } + ], + "source": [ + "y = int(input(\"Enter a year:\"))\n", + "m = int(input(\"Enter a month:\"))\n", + "d = int(input(\"Enter a day:\"))\n", + "\n", + "if (y %4 == 0) and ( m == 2):\n", + " print (\"The next date is\", y, m, d+1)\n", + "elif (y %4 != 0) and (m==2):\n", + " print (\"The next date is\", y, m+1, d//d)\n", + "elif m!= 2 and d==30: \n", + " print (\"The next date is\", y, m+1, d//d)\n", + "elif d == 31 and d!=31: \n", + " print (\"The next date is\", y, m+1,d//d)\n", + "elif m != 2 and d<31:\n", + " print (\"The next date is\", y, m, d+1)\n", + "else: \n", + " (m==12) and (d==31)\n", + " print (\"The next date is\", y+1, m//m, d//d)" + ] + }, { "cell_type": "code", "execution_count": null, @@ -1008,7 +1133,7 @@ "provenance": [] }, "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -1022,7 +1147,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.8" + "version": "3.9.12" } }, "nbformat": 4, diff --git a/week_2/Strings_Input.ipynb b/week_2/Strings_Input.ipynb index c74bfc3..f3b5d7a 100644 --- a/week_2/Strings_Input.ipynb +++ b/week_2/Strings_Input.ipynb @@ -2969,11 +2969,25 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 7, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "What is your name:Ludventz \n", + "How old are you:24\n", + "Ludventz will be 100 years old in the year 2098\n" + ] + } + ], "source": [ - "# Your code" + "# Your code\n", + "name = input( \"What is your name:\")\n", + "age = int(input(\"How old are you:\"))\n", + "\n", + "print (name, \"will be 100 years old in the year\",(100 + 2022)-age )\n" ] }, { @@ -2994,7 +3008,7 @@ "provenance": [] }, "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -3008,7 +3022,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.8" + "version": "3.9.12" } }, "nbformat": 4, diff --git a/week_3/0.List_Tuple.ipynb b/week_3/0.List_Tuple.ipynb index a303086..f440c7a 100644 --- a/week_3/0.List_Tuple.ipynb +++ b/week_3/0.List_Tuple.ipynb @@ -207,7 +207,8 @@ "execution_count": null, "metadata": { "id": "8k2Zys5-Be0G", - "outputId": "4260b4a8-c60e-4590-8b0b-4fd013d95915" + "outputId": "4260b4a8-c60e-4590-8b0b-4fd013d95915", + "scrolled": true }, "outputs": [ { @@ -2315,10 +2316,41 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": {}, - "outputs": [], - "source": [] + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[1]\n", + "Elements with index 0 are different\n" + ] + } + ], + "source": [ + "# какие елементы не в (b)\n", + "a = [1,2,3]\n", + "b = [2,2,3] \n", + "c = [] \n", + "\n", + "for number in a:\n", + " if number not in b:\n", + " c.append(number)\n", + "print (c)\n", + "\n", + "# давайте сравним показатели\n", + "a = [1,2,3]\n", + "b = [2,2,3] \n", + "\n", + "if (a[0])!= (b[0]):\n", + " print (\"Elements with index 0 are different\")\n", + "elif (a[1]) != (b[1]):\n", + " print (\"Elements with index 1 are different\")\n", + "else: \n", + " (a[2]) != (b[2])\n", + " print (\"Elements with index 2 are different\")" + ] }, { "cell_type": "code", @@ -2335,7 +2367,7 @@ "provenance": [] }, "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -2349,7 +2381,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.8" + "version": "3.9.12" } }, "nbformat": 4,