diff --git a/Data_types.ipynb b/Data_types.ipynb new file mode 100644 index 0000000..c6c8b4e --- /dev/null +++ b/Data_types.ipynb @@ -0,0 +1,1117 @@ +{ + "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": 6, + "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": [ + "veillez saisir un nombre entier179\n", + "17\n" + ] + } + ], + "source": [ + "# 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)" + ] + }, + { + "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": "code", + "execution_count": 9, + "metadata": { + "id": "B_KtSqfJacTp", + "outputId": "f3583dfe-7332-4e0c-b4e7-3baf66874671" + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "в этот момент:150\n", + "2 ч 30 мин\n" + ] + } + ], + "source": [ + "# 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, \"мин\" )" + ] + } + ], + "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/HW_0.ipynb b/HW_0.ipynb new file mode 100644 index 0000000..0b7dee5 --- /dev/null +++ b/HW_0.ipynb @@ -0,0 +1,596 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "4aae3dfe", + "metadata": {}, + "source": [ + "## Вывод (std out)" + ] + }, + { + "cell_type": "code", + "execution_count": 97, + "id": "19d51336", + "metadata": {}, + "outputs": [], + "source": [ + "## Напишите программу, которая вводит строки без newline или space (не забудьте что print принимает сколько угодно аргументов)\n", + "\n", + "# Тестовые данные\n", + "\n", + "# 1, 5, 8, 3 -> 1583\n", + "# 1, \"new\", 8, \"old\" -> 1new8old" + ] + }, + { + "cell_type": "code", + "execution_count": 245, + "id": "d20d52c5", + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1583\n", + "1new8old" + ] + } + ], + "source": [ + "numbers = [1,5,8,3]\n", + "print(*numbers, end=\"\" , sep=\"\") \n", + "print()\n", + "info = [1, \"new\", 8, \"old\"]\n", + "print(*info, end=\"\", sep=\"\")" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4add0113", + "metadata": {}, + "outputs": [], + "source": [ + "#Арифметика" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "a7a1bfa0", + "metadata": {}, + "outputs": [], + "source": [ + "## Расчитайте расстояние между двумя заданными точками (math.sqrt) заданными в двумерном пространстве\n", + "\n", + "# Тестовые данные\n", + "\n", + "# [0, 0], [1, 1] -> 1.4142135623730951\n", + "# [0, 1], [1, 5] -> 4.123105625617661\n", + "# [4, 1], [12, 5] -> 8.94427190999916\n" + ] + }, + { + "cell_type": "code", + "execution_count": 258, + "id": "d66833ba", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Введите координат x первой точки: 0\n", + "Введите координат y первой точки: 1\n", + "Введите координат x второй точки: 0\n", + "Введите координат y второй точки: 1\n", + "1.4142135623730951\n", + "8.94427190999916\n" + ] + } + ], + "source": [ + "#первый вармант \n", + "from math import sqrt\n", + "# [0, 0], [1, 1] -> 1.4142135623730951\n", + "#x: list = [0,0]\n", + "# y: list = [1,1]\n", + "x1 = int(input(\"Введите координат x первой точки: \"))\n", + "y1 = int(input(\"Введите координат y первой точки: \"))\n", + "\n", + "x2 = int(input(\"Введите координат x второй точки: \"))\n", + "y2 = int(input(\"Введите координат y второй точки: \"))\n", + "\n", + "def distance_between_2points(y1,x1,y2,x2) -> float: \n", + " return sqrt((y1-x1)**2 + (y2-x2)**2)\n", + "print (distance_between_2points(y1,x1,y2,x2)) \n", + "\n", + "# второй вариант \n", + "from math import sqrt\n", + "x = [4,1]\n", + "y = [12,5]\n", + "Deltax = y[0]-x[0]\n", + "Deltay = y[1]- x[1]\n", + "Distance = 0 \n", + "Distance = sqrt(Deltax**2 + Deltay**2)\n", + "print(Distance)" + ] + }, + { + "cell_type": "markdown", + "id": "6c5d4192", + "metadata": {}, + "source": [ + "## Списки" + ] + }, + { + "cell_type": "code", + "execution_count": 219, + "id": "ace65e2e", + "metadata": {}, + "outputs": [], + "source": [ + "## Посчитайте сумму элементов в списке (только тех, что чей тип float)\n", + "\n", + "# Тестовые данные\n", + "\n", + "color_list = [0.1,\"зеленый\", 1.6, \"белый\", 0.3, \"черный\", 7, \"2.0\"]\n", + "\n", + "# ответ: 2" + ] + }, + { + "cell_type": "code", + "execution_count": 263, + "id": "d8db5eef", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2\n", + "2\n" + ] + } + ], + "source": [ + "#первый вариант \n", + "color_list = [0.1,\"зеленый\", 1.6, \"белый\", 0.3, \"черный\", 7, \"2.0\"]\n", + "i = 0 \n", + "\n", + "len_list = 8 \n", + "\n", + "total=0 \n", + "\n", + "while i < len_list: \n", + " \n", + " element_list = color_list[i] \n", + " \n", + " if type(element_list) == float: \n", + " total = total + element_list\n", + " i = i + 1 \n", + "print (int(total))\n", + "\n", + "#второй вариант \n", + "color_list = [0.1,\"зеленый\", 1.6, \"белый\", 0.3, \"черный\", 7, \"2.0\"]\n", + "total = 0\n", + "for element in color_list:\n", + " if type (element) == float:\n", + " total += element \n", + "print(int(total))" + ] + }, + { + "cell_type": "code", + "execution_count": 206, + "id": "f5efd6f8", + "metadata": {}, + "outputs": [], + "source": [ + "## Отобразите с помощью print только первый и последний элемент списка (цикл while)\n", + "\n", + "# Тестовые данные\n", + "\n", + "color_list = [\"красный\",\"зеленый\",\"белый\" ,\"черный\"]" + ] + }, + { + "cell_type": "code", + "execution_count": 301, + "id": "e1904dcc", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "красный, черный\n" + ] + } + ], + "source": [ + "color_list: list = [\"красный\",\"зеленый\",\"белый\" ,\"черный\"]\n", + "\n", + "i: int = 0\n", + "while i < len(color_list):\n", + " if i == 0:\n", + " print(color_list[i], end=\", \")\n", + " if i == len(color_list) - 1:\n", + " print(color_list[i])\n", + " i += 1\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "0120e466", + "metadata": {}, + "outputs": [], + "source": [ + "## Проверьте есть ли в данный элемент в списке, если есть выведите с помощью print \"Element такой то was found\", \n", + "# если элемента не нашлось выведите \"Clear\" (цикл while) \n", + "\n", + "# Тестовые данные\n", + "\n", + "# 3 -> [1, 5, 8, 3] -> \"Element 3 was found\"\n", + "# -1 -> [1, 5, 8, 3] -> \"Clear\"\n", + "# \"color\" -> [1, \"color\", 1.3, 3] -> \"Element color was found\"\n" + ] + }, + { + "cell_type": "code", + "execution_count": 269, + "id": "c7f44ae6", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "element 3 was found\n", + "clear\n", + "element color was found\n" + ] + } + ], + "source": [ + "# 3 -> [1, 5, 8, 3] -> \"Element 3 was found\"\n", + "i = 0 \n", + "lst = [ 1, 5, 8, 3]\n", + "element1 = 3 \n", + "\n", + "while i < len(lst):\n", + " if element1 == lst[i]:\n", + " print (\"element 3 was found\")\n", + " break\n", + " i = i + 1\n", + "else:\n", + " print (\"clear\")\n", + " \n", + "# -1 -> [1, 5, 8, 3] -> \"Clear\" \n", + "\n", + "i = 0 \n", + "lst1 = [1, 5, 8, 3] \n", + "element2 = -1 \n", + "\n", + "while i < len(lst1):\n", + " if element2 == lst1[i]:\n", + " print (\"element -1 was found\")\n", + " break\n", + " i = i + 1\n", + "else:\n", + " print (\"clear\") \n", + " \n", + "# \"color\" -> [1, \"color\", 1.3, 3] -> \"Element color was found\" \n", + "i = 0 \n", + "lst2 = [1, \"color\", 1.3, 3] \n", + "element3 = \"color\"\n", + "\n", + "while i < len(lst2):\n", + " if element3 == lst2[i]:\n", + " print (\"element color was found\")\n", + " break\n", + " i = i + 1\n", + "else:\n", + " print (\"clear\") " + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "824424aa", + "metadata": {}, + "outputs": [], + "source": [ + "## Пройдите по списку и объедините все элементы из списка в одну строку через пробел (цикл while)\n", + "\n", + "# Тестовые данные\n", + "\n", + "# [\"9\", \"caMii\", \" /\\y4LLIii\", \"proger\", \"v\", \"2022\", \"roDy\"] -> 9 caMii /\\y4LLIii proger v 2022 roDy" + ] + }, + { + "cell_type": "code", + "execution_count": 224, + "id": "87baf550", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "9 caMii /\\y4LLIii proger v 2022 roDy jjj " + ] + } + ], + "source": [ + "info_list = [\"9\", \"caMii\", \" /\\y4LLIii\", \"proger\", \"v\", \"2022\", \"roDy\"]\n", + "\n", + "i = 0 \n", + "sentence = []\n", + "while i < len(info_list):\n", + " sentence = info_list[i] \n", + " print (sentence, end=\" \")\n", + " i = i + 1\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 231, + "id": "1c52c4b8", + "metadata": {}, + "outputs": [], + "source": [ + "## Пройдите по двум списка сразу и выведите сразу по два элемента - один из одного списка, другой из другого \n", + "## (подсказка - обращайтесь по индексу к элементам обоих списков)\n", + "\n", + "# Тестовые данные\n", + "\n", + "color_list_1 = [\"White\", \"Black\", \"Red\" ]\n", + "color_list_2 = [\"Red\", \"Green\", \"White\" ]\n", + "\n", + "# White Red\n", + "# Black Green\n", + "# Red White" + ] + }, + { + "cell_type": "code", + "execution_count": 232, + "id": "a55ba8ec", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "White Red\n", + "Black Green\n", + "Red White\n" + ] + } + ], + "source": [ + "# with while \n", + "color_list_1 = [\"White\", \"Black\", \"Red\"]\n", + "color_list_2 = [\"Red\", \"Green\", \"White\"]\n", + "\n", + "i = 0\n", + "while i < len(color_list_1) and i \"aaabbbbbbcccccccccdddddddddddd\"" + ] + }, + { + "cell_type": "code", + "execution_count": 271, + "id": "c3ede4b9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "aaabbbbbbcccccccccdddddddddddd\n" + ] + } + ], + "source": [ + "a = [\"a\", \"b\", \"c\", \"d\"] \n", + "\n", + "resultat = \"\"\n", + "\n", + "i = 0\n", + "\n", + "while i < len(a):\n", + " number = (i + 1) * 3\n", + " lettre = a[i] * number\n", + " resultat += lettre\n", + " i += 1\n", + "\n", + "print(resultat)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fee59929", + "metadata": {}, + "outputs": [], + "source": [ + "a = [\"a\", \"b\", \"c\", \"d\"] \n", + "i = 0 \n", + "while i < len(a):\n", + " if i == 0:\n", + " a = \n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "bfd569fd", + "metadata": {}, + "outputs": [], + "source": [ + "## Зайдите в каждый масив внутри (если это списко) и рассортируйте мне элементы по соответствующим спискам (не забудьте про append)\n", + "\n", + "sample = [[\"a\", \"b\", 1, 2.4], \"string\", [\"new\", 11111, 1000.0, \"old\"]]\n", + "\n", + "\n", + "integers = []\n", + "floats = []\n", + "strings = []\n", + "\n", + "# ответ\n", + "# integers -> [1, 11111]\n", + "# floats -> [2.4, 1000.0]\n", + "# strings -> [\"a\", \"b\", \"string\", \"new\", \"old\"]" + ] + }, + { + "cell_type": "code", + "execution_count": 203, + "id": "46a4b291", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "integers: [1, 11111]\n", + "floats: [2.4, 1000.0]\n", + "strings: ['a', 'b', 'string', 'new', 'old']\n" + ] + } + ], + "source": [ + "sample: list = [[\"a\", \"b\", 1, 2.4], \"string\", [\"new\", 11111, 1000.0, \"old\"]] \n", + "integers = []\n", + "floats = []\n", + "strings = []\n", + "\n", + "i = 0 \n", + "while i < len(sample):\n", + " if type(sample[i]) == str:\n", + " strings.append(sample[i])\n", + " if type(sample[i]) == int:\n", + " integers.append(sample[i])\n", + " if type(sample[i]) == float:\n", + " floats.append(sample[i])\n", + " j: int = 0\n", + " while (j < len(sample[i]) and type(sample[i]) != str):\n", + " if type(sample[i][j]) == int:\n", + " integers.append(sample[i][j])\n", + " if type(sample[i][j]) == float:\n", + " floats.append(sample[i][j])\n", + " if type(sample[i][j]) == str:\n", + " strings.append(sample[i][j])\n", + " j += 1\n", + " i += 1\n", + "print(\"integers: \"+str(integers))\n", + "print (\"floats: \"+ str(floats))\n", + "print (\"strings: \"+ str(strings))" + ] + }, + { + "cell_type": "markdown", + "id": "4d785ec2", + "metadata": {}, + "source": [ + "## Библиотеки " + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "0937e5e0", + "metadata": {}, + "outputs": [], + "source": [ + "## Напишите программу, которая выводит настоящее время ( то есть в ремя в которую программа запущена, используйте либу - time) \n", + "\n", + "# Тестовые данные (например)\n", + "\n", + "# 'Sat Oct 1 00:34:36 2022'" + ] + }, + { + "cell_type": "code", + "execution_count": 279, + "id": "3c10eb55", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mon Oct 17 00:01:21 2022\n" + ] + } + ], + "source": [ + "import time\n", + "\n", + "now = time.strftime(\"%a %b %d %H:%M:%S %Y\")\n", + "\n", + "print(now)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "45605a20", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "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": 5 +} diff --git a/HW_0/HW_0.ipynb b/HW_0/HW_0.ipynb index ca21c39..61f2071 100644 --- a/HW_0/HW_0.ipynb +++ b/HW_0/HW_0.ipynb @@ -10,7 +10,7 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 97, "id": "19d51336", "metadata": {}, "outputs": [], @@ -24,17 +24,59 @@ ] }, { - "cell_type": "markdown", - "id": "c6a2735e", + "cell_type": "code", + "execution_count": 28, + "id": "d20d52c5", + "metadata": { + "scrolled": false + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "1583\n", + "1new8old\n", + "1new8old\n", + "1new8old" + ] + } + ], + "source": [ + "# первый вариант \n", + "numbers = [1,5,8,3]\n", + "print(*numbers, end=\"\" , sep=\"\") \n", + "print()\n", + "info = [1, \"new\", 8, \"old\"]\n", + "print(*info, end=\"\", sep=\"\")\n", + "print()\n", + "\n", + "#второй вариант\n", + "line_info = 1, \"new\", 8, \"old\"\n", + "for i in (line_info):\n", + " print (*line_info, sep = \"\")\n", + " break\n", + " \n", + "#третий вариант\n", + "line_info = 1, \"new\", 8, \"old\"\n", + "for i in range(len(line_info)):\n", + " print(line_info[i], end='')" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "4add0113", "metadata": {}, + "outputs": [], "source": [ - "## Арифметика " + "#Арифметика" ] }, { "cell_type": "code", - "execution_count": 2, - "id": "bc23a479", + "execution_count": null, + "id": "a7a1bfa0", "metadata": {}, "outputs": [], "source": [ @@ -47,6 +89,51 @@ "# [4, 1], [12, 5] -> 8.94427190999916\n" ] }, + { + "cell_type": "code", + "execution_count": 29, + "id": "d66833ba", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Введите координат x первой точки: 0\n", + "Введите координат y первой точки: 1\n", + "Введите координат x второй точки: 0\n", + "Введите координат y второй точки: 1\n", + "1.4142135623730951\n", + "8.94427190999916\n" + ] + } + ], + "source": [ + "#первый вармант \n", + "from math import sqrt\n", + "# [0, 0], [1, 1] -> 1.4142135623730951\n", + "#x: list = [0,0]\n", + "# y: list = [1,1]\n", + "x1 = int(input(\"Введите координат x первой точки: \"))\n", + "y1 = int(input(\"Введите координат y первой точки: \"))\n", + "x2 = int(input(\"Введите координат x второй точки: \"))\n", + "y2 = int(input(\"Введите координат y второй точки: \"))\n", + "\n", + "def distance_between_2points(y1,x1,y2,x2) -> float: \n", + " return sqrt((y1-x1)**2 + (y2-x2)**2)\n", + "print (distance_between_2points(y1,x1,y2,x2)) \n", + "\n", + "# второй вариант \n", + "from math import sqrt\n", + "x = [4,1]\n", + "y = [12,5]\n", + "Deltax = y[0]-x[0]\n", + "Deltay = y[1]- x[1]\n", + "Distance = 0 \n", + "Distance = sqrt(Deltax**2 + Deltay**2)\n", + "print(Distance)" + ] + }, { "cell_type": "markdown", "id": "6c5d4192", @@ -57,7 +144,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 219, "id": "ace65e2e", "metadata": {}, "outputs": [], @@ -73,7 +160,49 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 263, + "id": "d8db5eef", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "2\n", + "2\n" + ] + } + ], + "source": [ + "#первый вариант \n", + "color_list = [0.1,\"зеленый\", 1.6, \"белый\", 0.3, \"черный\", 7, \"2.0\"]\n", + "i = 0 \n", + "\n", + "len_list = 8 \n", + "\n", + "total=0 \n", + "\n", + "while i < len_list: \n", + " \n", + " element_list = color_list[i] \n", + " \n", + " if type(element_list) == float: \n", + " total = total + element_list\n", + " i = i + 1 \n", + "print (int(total))\n", + "\n", + "#второй вариант \n", + "color_list = [0.1,\"зеленый\", 1.6, \"белый\", 0.3, \"черный\", 7, \"2.0\"]\n", + "total = 0\n", + "for element in color_list:\n", + " if type (element) == float:\n", + " total += element \n", + "print(int(total))" + ] + }, + { + "cell_type": "code", + "execution_count": 206, "id": "f5efd6f8", "metadata": {}, "outputs": [], @@ -85,6 +214,33 @@ "color_list = [\"красный\",\"зеленый\",\"белый\" ,\"черный\"]" ] }, + { + "cell_type": "code", + "execution_count": 301, + "id": "e1904dcc", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "красный, черный\n" + ] + } + ], + "source": [ + "color_list: list = [\"красный\",\"зеленый\",\"белый\" ,\"черный\"]\n", + "\n", + "i: int = 0\n", + "while i < len(color_list):\n", + " if i == 0:\n", + " print(color_list[i], end=\", \")\n", + " if i == len(color_list) - 1:\n", + " print(color_list[i])\n", + " i += 1\n", + " " + ] + }, { "cell_type": "code", "execution_count": 5, @@ -92,7 +248,8 @@ "metadata": {}, "outputs": [], "source": [ - "## Проверьте есть ли в данный элемент в списке, если есть выведите с помощью print \"Element такой то was found\", если элемента не нашлось выведите \"Clear\" (цикл while) \n", + "## Проверьте есть ли в данный элемент в списке, если есть выведите с помощью print \"Element такой то was found\", \n", + "# если элемента не нашлось выведите \"Clear\" (цикл while) \n", "\n", "# Тестовые данные\n", "\n", @@ -101,6 +258,66 @@ "# \"color\" -> [1, \"color\", 1.3, 3] -> \"Element color was found\"\n" ] }, + { + "cell_type": "code", + "execution_count": 269, + "id": "c7f44ae6", + "metadata": { + "scrolled": true + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "element 3 was found\n", + "clear\n", + "element color was found\n" + ] + } + ], + "source": [ + "# 3 -> [1, 5, 8, 3] -> \"Element 3 was found\"\n", + "i = 0 \n", + "lst = [ 1, 5, 8, 3]\n", + "element1 = 3 \n", + "\n", + "while i < len(lst):\n", + " if element1 == lst[i]:\n", + " print (\"element 3 was found\")\n", + " break\n", + " i = i + 1\n", + "else:\n", + " print (\"clear\")\n", + " \n", + "# -1 -> [1, 5, 8, 3] -> \"Clear\" \n", + "\n", + "i = 0 \n", + "lst1 = [1, 5, 8, 3] \n", + "element2 = -1 \n", + "\n", + "while i < len(lst1):\n", + " if element2 == lst1[i]:\n", + " print (\"element -1 was found\")\n", + " break\n", + " i = i + 1\n", + "else:\n", + " print (\"clear\") \n", + " \n", + "# \"color\" -> [1, \"color\", 1.3, 3] -> \"Element color was found\" \n", + "i = 0 \n", + "lst2 = [1, \"color\", 1.3, 3] \n", + "element3 = \"color\"\n", + "\n", + "while i < len(lst2):\n", + " if element3 == lst2[i]:\n", + " print (\"element color was found\")\n", + " break\n", + " i = i + 1\n", + "else:\n", + " print (\"clear\") " + ] + }, { "cell_type": "code", "execution_count": 6, @@ -117,7 +334,33 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 224, + "id": "87baf550", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "9 caMii /\\y4LLIii proger v 2022 roDy jjj " + ] + } + ], + "source": [ + "info_list = [\"9\", \"caMii\", \" /\\y4LLIii\", \"proger\", \"v\", \"2022\", \"roDy\"]\n", + "\n", + "i = 0 \n", + "sentence = []\n", + "while i < len(info_list):\n", + " sentence = info_list[i] \n", + " print (sentence, end=\" \")\n", + " i = i + 1\n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": 231, "id": "1c52c4b8", "metadata": {}, "outputs": [], @@ -127,8 +370,8 @@ "\n", "# Тестовые данные\n", "\n", - "color_list_1 = [\"White\", \"Black\", \"Red\"]\n", - "color_list_2 = [\"Red\", \"Green\", \"White\"]\n", + "color_list_1 = [\"White\", \"Black\", \"Red\" ]\n", + "color_list_2 = [\"Red\", \"Green\", \"White\" ]\n", "\n", "# White Red\n", "# Black Green\n", @@ -137,7 +380,34 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 232, + "id": "a55ba8ec", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "White Red\n", + "Black Green\n", + "Red White\n" + ] + } + ], + "source": [ + "# with while \n", + "color_list_1 = [\"White\", \"Black\", \"Red\"]\n", + "color_list_2 = [\"Red\", \"Green\", \"White\"]\n", + "\n", + "i = 0\n", + "while i < len(color_list_1) and i \"aaabbbbbbcccccccccdddddddddddd\"" ] }, + { + "cell_type": "code", + "execution_count": 271, + "id": "c3ede4b9", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "aaabbbbbbcccccccccdddddddddddd\n" + ] + } + ], + "source": [ + "a = [\"a\", \"b\", \"c\", \"d\"] \n", + "\n", + "resultat = \"\"\n", + "\n", + "i = 0\n", + "\n", + "while i < len(a):\n", + " number = (i + 1) * 3\n", + " lettre = a[i] * number\n", + " resultat += lettre\n", + " i += 1\n", + "\n", + "print(resultat)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "fee59929", + "metadata": {}, + "outputs": [], + "source": [ + "a = [\"a\", \"b\", \"c\", \"d\"] \n", + "i = 0 \n", + "while i < len(a):\n", + " if i == 0:\n", + " a = \n", + " " + ] + }, { "cell_type": "code", "execution_count": 9, @@ -173,6 +488,51 @@ "# strings -> [\"a\", \"b\", \"string\", \"new\", \"old\"]" ] }, + { + "cell_type": "code", + "execution_count": 203, + "id": "46a4b291", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "integers: [1, 11111]\n", + "floats: [2.4, 1000.0]\n", + "strings: ['a', 'b', 'string', 'new', 'old']\n" + ] + } + ], + "source": [ + "sample: list = [[\"a\", \"b\", 1, 2.4], \"string\", [\"new\", 11111, 1000.0, \"old\"]] \n", + "integers = []\n", + "floats = []\n", + "strings = []\n", + "\n", + "i = 0 \n", + "while i < len(sample):\n", + " if type(sample[i]) == str:\n", + " strings.append(sample[i])\n", + " if type(sample[i]) == int:\n", + " integers.append(sample[i])\n", + " if type(sample[i]) == float:\n", + " floats.append(sample[i])\n", + " j: int = 0\n", + " while (j < len(sample[i]) and type(sample[i]) != str):\n", + " if type(sample[i][j]) == int:\n", + " integers.append(sample[i][j])\n", + " if type(sample[i][j]) == float:\n", + " floats.append(sample[i][j])\n", + " if type(sample[i][j]) == str:\n", + " strings.append(sample[i][j])\n", + " j += 1\n", + " i += 1\n", + "print(\"integers: \"+str(integers))\n", + "print (\"floats: \"+ str(floats))\n", + "print (\"strings: \"+ str(strings))" + ] + }, { "cell_type": "markdown", "id": "4d785ec2", @@ -194,6 +554,36 @@ "\n", "# 'Sat Oct 1 00:34:36 2022'" ] + }, + { + "cell_type": "code", + "execution_count": 279, + "id": "3c10eb55", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mon Oct 17 00:01:21 2022\n" + ] + } + ], + "source": [ + "import time\n", + "\n", + "now = time.strftime(\"%a %b %d %H:%M:%S %Y\")\n", + "\n", + "print(now)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "45605a20", + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { @@ -212,7 +602,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.9" + "version": "3.9.12" } }, "nbformat": 4, 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, diff --git a/week_4/Set_Dict.ipynb b/week_4/Set_Dict.ipynb index 26021b7..18afbbc 100644 --- a/week_4/Set_Dict.ipynb +++ b/week_4/Set_Dict.ipynb @@ -365,7 +365,9 @@ "execution_count": null, "metadata": {}, "outputs": [], - "source": [] + "source": [ + ",,,,," + ] }, { "cell_type": "markdown", @@ -2320,7 +2322,7 @@ ], "metadata": { "kernelspec": { - "display_name": "Python 3", + "display_name": "Python 3 (ipykernel)", "language": "python", "name": "python3" }, @@ -2334,7 +2336,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.8.8" + "version": "3.9.12" } }, "nbformat": 4,