{"cells":[{"cell_type":"markdown","metadata":{"id":"yOTXeTwHw_jB"},"source":["# Занятие  1"]},{"cell_type":"markdown","metadata":{"id":"vTldGT0QtFvS"},"source":["## Аннотация\n","Занятие посвящено переменным, базовым типам данных и основным арифметическим и логическим операторам.\n"]},{"cell_type":"markdown","metadata":{"id":"GIUAD8o7wvNw"},"source":["## 1. Принцип работы переменных в Python"]},{"cell_type":"markdown","source":["### Имя переменной"],"metadata":{"id":"fO0r-k8Hj5h4"}},{"cell_type":"markdown","source":["Переменные предназначены для хранения данных в памяти компьютера и проведения с этими данными различных операций. Они являются основой для всего программирования, поэтому давайте подробно рассмотрим механизы работы с переменными.\n","\n","Вспомним пример с прошлого занятия:"],"metadata":{"id":"KcEchR_eef6U"}},{"cell_type":"code","execution_count":null,"metadata":{"id":"dy9dPPO2wvNv","outputId":"41a07e2b-1fe9-4561-b1ef-0324fafed196","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1759853681752,"user_tz":-300,"elapsed":4217,"user":{"displayName":"Evgeniy K.","userId":"01881409169257461735"}}},"outputs":[{"output_type":"stream","name":"stdout","text":["Как тебя зовут? Паша\n","Привет, Паша\n"]}],"source":["name = input('Как тебя зовут? ')\n","print('Привет,', name)"]},{"cell_type":"markdown","metadata":{"id":"wUTTJ-dEwvNx"},"source":["Здесь **name** — это **имя переменной**, в которую мы записываем данные, полученные из командной строки. Согласно правилам Python, имя переменной может состоять из латинских букв, цифр и символа подчеркивания и не может начинаться с цифры. Для именования переменных в стандарте PEP8 принято использовать стиль lower_case_with_underscores (слова из маленьких букв с подчеркиваниями). Когда программист придумывает имя переменной, он должен помнить, что имя должно иметь осмысленный вид и отражать назначение переменной:"]},{"cell_type":"code","source":["coin_flipping_result = ['орёл', 'решка', 'решка', 'орёл']"],"metadata":{"id":"N-9ZiTfBhZN9"},"execution_count":null,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"S0lmjbZmwvN1"},"source":["В каждом языке есть **зарезервированные слова**. Такие слова имеют специальное значение, и поэтому запрещены для использования в качестве имён переменных. Вот список зарезервированных слов для языка Python:"]},{"cell_type":"code","source":["False      await      else       import     pass\n","None       break      except     in         raise\n","True       class      finally    is         return\n","and        continue   for        lambda     try\n","as         def        from       nonlocal   while\n","assert     del        global     not        with\n","async      elif       if         or         yield"],"metadata":{"id":"uQIHAa8zizAn"},"execution_count":null,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"8wPyPHfrwvN1"},"source":["### Значение переменной"]},{"cell_type":"markdown","metadata":{"id":"zSa5R_p6wvN2"},"source":["**Значение переменной** — информация, которая хранится в памяти компьютера и с которой работают программы.\n","\n","Знак «=» обозначает команду под названием «оператор присваивания». Оператор присваивания приписывает значение, которое находится справа от знака равно, переменной, которая находится слева от знака равно. Стандарт PEP8 рекомендует окружать оператор присваивания одним пробелом с каждой стороны.\n","\n","Значение всегда принадлежит к какому-либо типу данных. Например, `['орёл', 'решка', 'решка', 'орёл']` — это тип данных \"список\". Тип переменной можно узнать функцией **type()**.\n","\n"]},{"cell_type":"code","source":["print(type(coin_flipping_result))"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"zK2ygtgJfnPV","executionInfo":{"status":"ok","timestamp":1759853884299,"user_tz":-300,"elapsed":22,"user":{"displayName":"Evgeniy K.","userId":"01881409169257461735"}},"outputId":"3de04c70-3399-493c-92c9-ce7a7ddac392"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["<class 'list'>\n"]}]},{"cell_type":"markdown","source":["Подробнее о том, что такое класс — в следующем модуле."],"metadata":{"id":"4Fe0j_QU82b-"}},{"cell_type":"markdown","metadata":{"id":"RnvdBnGiwvN3"},"source":["### Адрес переменной"]},{"cell_type":"markdown","metadata":{"id":"RDHr9AoewvN4"},"source":["**Адрес** — это номер ячейки памяти, в которой хранится значение переменной. Его можно посмотреть функцией **id()**. Например:"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"T3ERlJWOwvN4","outputId":"812ca0e1-ec4b-4bcd-d736-7217d3163864","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1759853927124,"user_tz":-300,"elapsed":4,"user":{"displayName":"Evgeniy K.","userId":"01881409169257461735"}}},"outputs":[{"output_type":"stream","name":"stdout","text":["<class 'str'>\n","138945339706144\n","<class 'int'>\n","11645992\n"]}],"source":["name = 'Анна'\n","print(type(name))   # тип — строковая переменная\n","print(id(name))     # адрес объекта\n","\n","a = 123\n","print(type(a))      # тип — целочисленная переменная\n","print(id(a))        # адрес объекта"]},{"cell_type":"markdown","metadata":{"id":"JVYKlyAOwvN5"},"source":["Когда в процессе выполнения программного кода появляется новое значение, интерпретатор выделяет для него область памяти – то есть создаёт **объект** определенного типа (число, строка и т.д.). После этого Python записывает в свой внутренний список адрес этого объекта.\n","\n","Но как теперь получить доступ к созданному объекту?\n","Для этого и существуют переменные – они дают возможность удобно работать с объектами используя понятные имена вместо адресов из чисел.\n","Т.е. переменная в Python – это просто *имя, прикрепленное к определенному объекту*.\n","\n","Таким образом, у нас одновременно существуют пространство объектов с адресами и пространство имён (переменных)."]},{"cell_type":"markdown","source":["![изображение.png](data:image/png;base64,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)"],"metadata":{"id":"KAF3s_6T-uEv"}},{"cell_type":"markdown","metadata":{"id":"q2ps5UXfwvN6"},"source":["### Принцип работы переменных"]},{"cell_type":"markdown","metadata":{"id":"YkZweqm_wvN7"},"source":["Для понимания работы переменных разберемся, что происходит, когда мы создаем новую переменную и присваиваем ей значение."]},{"cell_type":"code","execution_count":null,"metadata":{"id":"FFeD07MtwvN7"},"outputs":[],"source":["a = 10"]},{"cell_type":"markdown","metadata":{"id":"6J10HsG1wvN8"},"source":["В данном примере происходит следующее:\n","\n","* создается объект типа int со значение 10;\n","* создается переменная `a`;\n","* в переменной `a` сохраняется адрес (ссылка) на объект.\n","\n","Теперь посмотрим, что произойдет, если одной переменой присвоить другую переменную:"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"0t62wKiswvN9","outputId":"0bed7172-8d55-412b-8cd5-73081c483a1b","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1759854094620,"user_tz":-300,"elapsed":4,"user":{"displayName":"Evgeniy K.","userId":"01881409169257461735"}}},"outputs":[{"output_type":"stream","name":"stdout","text":["11642376\n","11642376\n"]}],"source":["b = a\n","\n","print(id(a))\n","print(id(b))"]},{"cell_type":"markdown","metadata":{"id":"wGclWDkbwvN-"},"source":["В данном примере Python не создает новый объект — он просто создает переменную, которая ссылается на тот же объект, что и переменная a.\n","\n","Предположим, что в какой-то момент мы захотели поменять значение переменной b:"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"TGiNcI8zwvN_","outputId":"1e092cc6-6e77-4799-9c45-38edc2752d37","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1759854139444,"user_tz":-300,"elapsed":42,"user":{"displayName":"Evgeniy K.","userId":"01881409169257461735"}}},"outputs":[{"output_type":"stream","name":"stdout","text":["11642376\n","138945342619792\n"]}],"source":["b = 1000\n","\n","print(id(a))\n","print(id(b))"]},{"cell_type":"markdown","metadata":{"id":"YLGUQTz8wvN_"},"source":["Теперь уже Python создал новый объект типа int, и теперь переменная b ссылается на новый объект."]},{"cell_type":"markdown","metadata":{"id":"A7FznOzzwvOA"},"source":["Рассмотрим еще один пример:"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"rUJHDNUKwvOA","outputId":"1a4ba6ee-502c-40ea-9b0c-4d4cf714b735","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1759854157488,"user_tz":-300,"elapsed":5,"user":{"displayName":"Evgeniy K.","userId":"01881409169257461735"}}},"outputs":[{"output_type":"stream","name":"stdout","text":["138946291437312\n"]}],"source":["b = \"sun\"\n","\n","print(id(b))"]},{"cell_type":"markdown","metadata":{"id":"SsKXPblAwvOB"},"source":["В этом примере создается новый объект типа str, и переменная b ссылается на новый объект. На объект типа int со значением 1000 больше никто не ссылается, т.е. количество ссылок на него равно нулю. Следовательно, он больше не доступен и будет удален сборщиком мусора (Garbage Collector), тем самым освободив немного памяти."]},{"cell_type":"markdown","metadata":{"id":"2xqm0vS8wvOC"},"source":["### Идентификатор объекта (Object Identity)"]},{"cell_type":"markdown","metadata":{"id":"HbqGoPKjwvOC"},"source":["В примерах выше мы вызывали функцию id(). Эта функция возвращает число, которое является неизменным и уникальным для каждого объекта на протяжении его жизненного периода:"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"O4MICeaEwvOC","outputId":"b2509f47-15d3-49da-afa0-af8d3352a222","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1759854221789,"user_tz":-300,"elapsed":21,"user":{"displayName":"Evgeniy K.","userId":"01881409169257461735"}}},"outputs":[{"output_type":"stream","name":"stdout","text":["11642088\n","11642088\n","11642088\n"]}],"source":["a = b = 1\n","\n","print(id(a))\n","\n","print(id(b))\n","\n","print(id(1))"]},{"cell_type":"markdown","metadata":{"id":"uclFw7xLwvOD"},"source":["Видно, что объект здесь всего один. При этом **a** и **b** – по-разному названные переменные, которые на него ссылаются. Проверить равенство идентификаторов можно с помощью оператора **is**:"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"FgLTbaHXwvOD","outputId":"7b116beb-6f20-4ad4-93f7-e49ce80751df","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1759854229838,"user_tz":-300,"elapsed":17,"user":{"displayName":"Evgeniy K.","userId":"01881409169257461735"}}},"outputs":[{"output_type":"stream","name":"stdout","text":["True\n"]}],"source":["print(a is b)"]},{"cell_type":"markdown","source":["Подведем **итог**:\n","\n","Переменная — это область памяти компьютера, которая структурно состоит из трёх частей:\n","* Имя (идентификатор) — придумывается программистом и подчиняется стилю именования lower_case_with_underscores. В примерах выше это a, b, name и coin_flipping_result.\n","* Значение — информация, которая хранится в памяти компьютера и с которой работают программы. Значение всегда принадлежит к какому-либо типу данных. Например, 154 — это целое число, ['орёл', 'решка', 'решка', 'орёл'] — это список строк.\n","* Адрес — это номер ячейки памяти, в которой хранится значение переменной."],"metadata":{"id":"sJO4r3ZxmVoO"}},{"cell_type":"markdown","source":["**Внимание.** В Jupyter Notebook есть возможность выводить значение переменной, не прибегая к функции print(). Для этого **в конце** блока с кодом можно просто указать её название:"],"metadata":{"id":"iXKZl0EOJflv"}},{"cell_type":"code","source":["counter = 24\n","counter"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"BIEwp_JWKOTy","executionInfo":{"status":"ok","timestamp":1759854280179,"user_tz":-300,"elapsed":42,"user":{"displayName":"Evgeniy K.","userId":"01881409169257461735"}},"outputId":"476c5d13-0afe-4e85-d68c-72728a5cd987"},"execution_count":null,"outputs":[{"output_type":"execute_result","data":{"text/plain":["24"]},"metadata":{},"execution_count":24}]},{"cell_type":"markdown","metadata":{"id":"qsNM1pnuNz1N"},"source":["### Множественное присваивание и обмен переменных"]},{"cell_type":"markdown","source":["Мы уже видели, что Python позволяет присваивать одно значение нескольким переменным одновременно. Таким образом, вы можете инициализировать несколько переменных, а позже переназначить их:"],"metadata":{"id":"Z9tVS7_QK1nr"}},{"cell_type":"code","source":["x = y = z = 0"],"metadata":{"id":"iIoTDShULCgq"},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":["Ещё можно присваивать несколько значений нескольким переменным в рамках одной строки. Например:"],"metadata":{"id":"b1YPKs8ALNrJ"}},{"cell_type":"code","source":["x, y, z = \"hello\", 1.05, 16\n","print(x, y, z)"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"xgunutIhLVuz","executionInfo":{"status":"ok","timestamp":1695122598619,"user_tz":-300,"elapsed":319,"user":{"displayName":"Evgeniy K.","userId":"01881409169257461735"}},"outputId":"d6962f00-9596-4f24-c0ef-a3a3d327bf3c"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["hello 1.05 16\n"]}]},{"cell_type":"markdown","source":["Python также позволяет поменять значения у двух переменных без использования временной переменной:"],"metadata":{"id":"xUJm6OhFOJYS"}},{"cell_type":"code","execution_count":null,"metadata":{"outputId":"72abb820-98ca-44f0-8e93-ca7e1aebe251","id":"AMBKBAUXNz1S"},"outputs":[{"name":"stdout","output_type":"stream","text":["100 200\n","200 100\n"]}],"source":["a = 100\n","b = 200\n","print(a, b)\n","\n","a, b = b, a\n","print(a, b)"]},{"cell_type":"markdown","source":["# 2. Базовые типы данных"],"metadata":{"id":"NzZ8RVejojo-"}},{"cell_type":"markdown","source":["Python работает с двумя категориями данных: стандартными типами (они поддерживаются по умолчанию) и специализированными (для операций с ними нужно подключение определенного модуля). К специализированным типам данных относится, например, тип datetime (дата и время)."],"metadata":{"id":"7MzKKTSSq9At"}},{"cell_type":"markdown","source":["В Python есть несколько стандартных типов данных:\n","* Numbers (числа).\n","* Strings (строки).\n","* Lists (списки).\n","* Dictionaries (словари).\n","* Tuples (кортежи).\n","* Sets (множества).\n","* Boolean (логический тип данных).\n","\n","Эти типы данных можно, в свою очередь, классифицировать по нескольким признакам:\n","* изменяемые (списки, словари и множества),\n","* неизменяемые (числа, строки и кортежи),\n","* упорядоченные (списки, кортежи, строки и словари),\n","* неупорядоченные (множества).\n","\n","Далее рассмотрим некоторые из этих типов данных."],"metadata":{"id":"n4hH0LEJr50N"}},{"cell_type":"markdown","source":["### Строки: str\n","\n","С таким типом данных мы уже немного знакомы — он хранит строку текста:"],"metadata":{"id":"PQPk2UpS49AL"}},{"cell_type":"code","source":["my_name = \"Марианна\""],"metadata":{"id":"Bk9YeaP_5Oe1"},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":["Для объявления строки значения переменной обязательно нужно поместить в кавычки. Более подробно с методами работы со строками мы познакомимся в следующих занятиях."],"metadata":{"id":"5JhUdSrS7XtQ"}},{"cell_type":"markdown","metadata":{"id":"N6qxKbB8w_jK"},"source":["### Целые числа: int"]},{"cell_type":"markdown","metadata":{"id":"Rf_QljOIw_jN"},"source":["Чтобы в Python создать переменную целого типа данных, нужно убрать кавычки при объявлении переменной. Рассмотрим следующий код, создающий переменные целого типа:"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"A87C-Dc3w_jO","outputId":"42ce66bb-428b-4f61-ef4d-c9ccd8a3351d","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1690305180418,"user_tz":-300,"elapsed":357,"user":{"displayName":"Evgeniy K.","userId":"01881409169257461735"}}},"outputs":[{"output_type":"stream","name":"stdout","text":["12\n","0\n","-10\n"]}],"source":["num = 12\n","print(num)\n","\n","num = 0\n","print(num)\n","\n","num = -10\n","print(num)"]},{"cell_type":"markdown","metadata":{"id":"EbrL_ac8w_jS"},"source":["Начиная с Python 3.6 появилась возможность разделять порядки символом нижнего подчеркивания в длинных числах, тем самым мы можем улучшить читаемость этих чисел в исходном коде."]},{"cell_type":"code","execution_count":null,"metadata":{"id":"6fSS7HE1w_jU","outputId":"a69f3a55-48c0-43ca-a10e-45adea35066a","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1759854563779,"user_tz":-300,"elapsed":5,"user":{"displayName":"Evgeniy K.","userId":"01881409169257461735"}}},"outputs":[{"output_type":"stream","name":"stdout","text":["10000000\n"]}],"source":["num = 10_000_000\n","print(num)"]},{"cell_type":"markdown","metadata":{"id":"n_xeKVHIw_jU"},"source":["Python поддерживает длинную арифметику при работе с целыми числами, то есть поддерживаются числа неограниченной длины."]},{"cell_type":"markdown","metadata":{"id":"nCyLaLaRw_jW"},"source":["Посмотрим тип объекта с помощью **type()**:"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"Wg5rgKghw_jX","outputId":"f57687c2-cf5a-4c81-a53b-7e30bbc9626c","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1759854582967,"user_tz":-300,"elapsed":22,"user":{"displayName":"Evgeniy K.","userId":"01881409169257461735"}}},"outputs":[{"output_type":"stream","name":"stdout","text":["<class 'int'>\n"]}],"source":["num = 22\n","print(type(num))"]},{"cell_type":"markdown","metadata":{"id":"0Ciy_wVYw_jY"},"source":["### Вещественные числа: float"]},{"cell_type":"markdown","metadata":{"id":"Mmt7qxJFw_jY"},"source":["Python умеет работать с вещественными числами, то есть с числами с плавающей точкой. Точка используется для того чтобы разделить целую и дробную часть вещественного числа:"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"JnePDQnOw_jZ","outputId":"5a5d23ca-af4e-47a8-ed49-552dab388d98","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1690305404681,"user_tz":-300,"elapsed":366,"user":{"displayName":"Evgeniy K.","userId":"01881409169257461735"}}},"outputs":[{"output_type":"stream","name":"stdout","text":["3.14\n","0.0\n","-11.7\n"]}],"source":["num = 3.14\n","print(num)\n","\n","num = 0.0\n","print(num)\n","\n","num = -11.7\n","print(num)"]},{"cell_type":"markdown","metadata":{"id":"HhcODnEuw_ja"},"source":["По аналогии с типом int мы можем использовать символ нижнего подчёркивания, для того чтобы разделять порядки в длинном вещественном числе:"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"TDgK4RMfw_jb","outputId":"f62aa93c-4148-4e96-b96c-245ce9ce0a90"},"outputs":[{"name":"stdout","output_type":"stream","text":["100000.000001\n"]}],"source":["num = 100_000.000_001\n","print(num)"]},{"cell_type":"markdown","metadata":{"id":"dcycrQ_aw_jc"},"source":["Также Python поддерживает экспоненциальную нотацию записи вещественного числа:"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"HYTpcZK6w_jc","outputId":"083dcfca-a8c4-4bc4-f2d2-10258ae57f9c","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1690305478526,"user_tz":-300,"elapsed":382,"user":{"displayName":"Evgeniy K.","userId":"01881409169257461735"}}},"outputs":[{"output_type":"stream","name":"stdout","text":["150.0\n"]}],"source":["num = 1.5e2    # 1.5 умножить на 10 в степени 2\n","print(num)"]},{"cell_type":"markdown","source":["Мы можем округлить до нужного числа знаков после запятой с помощью функции **round()**:"],"metadata":{"id":"e5pHpbAdjuRT"}},{"cell_type":"code","source":["x = 3.1415\n","print(round(x, 3))"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"i_DWL7sPj9_d","executionInfo":{"status":"ok","timestamp":1695140182183,"user_tz":-300,"elapsed":349,"user":{"displayName":"Evgeniy K.","userId":"01881409169257461735"}},"outputId":"9dd4d369-6aa9-41af-bd23-c47705f0e77b"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["3.142\n"]}]},{"cell_type":"markdown","source":["**Внимание.** Из-за внутренних особенностей устройства языка Python округление пятёрки идёт в **большую** сторону."],"metadata":{"id":"FsGT3DPWkQz0"}},{"cell_type":"markdown","source":["### Логический тип bool"],"metadata":{"id":"Fr1qk4GAN93J"}},{"cell_type":"markdown","source":["Логический тип данных **bool** (или булевый тип) — это примитивный тип данных, который принимает 2 значения: истина или ложь. В Python имеется самостоятельный логический тип bool, с двумя предопределенными значениями:\n","*   **True** — истина;\n","*   **False** — ложь.\n","\n","True и False пишутся с большой буквы. Если написать с маленькой буквы, интерпретатор выдаст ошибку: NameError: name 'true' is not defined."],"metadata":{"id":"0cQaUzrcl647"}},{"cell_type":"code","execution_count":null,"metadata":{"outputId":"6c59b7af-748e-4f00-91d1-99b511f6d1bb","id":"A4d3cgMCl65D"},"outputs":[{"data":{"text/plain":["True"]},"execution_count":1,"metadata":{},"output_type":"execute_result"}],"source":["True"]},{"cell_type":"code","execution_count":null,"metadata":{"outputId":"333f4955-937d-40b5-e73f-5fbe03773d87","id":"ORDNHV9gl65G"},"outputs":[{"name":"stdout","output_type":"stream","text":["<class 'bool'>\n"]}],"source":["result = False\n","print(type(result))"]},{"cell_type":"code","execution_count":null,"metadata":{"outputId":"4c75f3a0-60fe-4a98-c754-afb9c78a613e","colab":{"base_uri":"https://localhost:8080/","height":169},"executionInfo":{"status":"error","timestamp":1690307576709,"user_tz":-300,"elapsed":359,"user":{"displayName":"Evgeniy K.","userId":"01881409169257461735"}},"id":"BjzozfEcl65I"},"outputs":[{"output_type":"error","ename":"NameError","evalue":"ignored","traceback":["\u001b[0;31m---------------------------------------------------------------------------\u001b[0m","\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)","\u001b[0;32m<ipython-input-28-724ba28f4a9a>\u001b[0m in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mtrue\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m","\u001b[0;31mNameError\u001b[0m: name 'true' is not defined"]}],"source":["true"]},{"cell_type":"markdown","metadata":{"id":"7dTvADflw_jd"},"source":["### Конвертация типов"]},{"cell_type":"markdown","source":["Команда input() всегда считывает строку текста. Однако во многих случаях нам нужно работать именно с числами. Чтобы преобразовать строку в число, воспользуемся функцией **int()**:"],"metadata":{"id":"yBYuzDfnIBzC"}},{"cell_type":"code","source":["x = input()\n","print(type(x))\n","x = int(x)  # применяем функцию конвертации и сразу же присваиваем той же переменной\n","print(type(x))"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"4wm8CpDRIT7e","executionInfo":{"status":"ok","timestamp":1695140212882,"user_tz":-300,"elapsed":4078,"user":{"displayName":"Evgeniy K.","userId":"01881409169257461735"}},"outputId":"1f4176b2-3bc6-43e8-df95-6ac9bf05e537"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["48576\n","<class 'str'>\n","<class 'int'>\n"]}]},{"cell_type":"markdown","metadata":{"id":"9FHntv5pw_jd"},"source":["Теперь возьмем переменную num, которая связана с вещественным объектом со значением 210,3 и имеет тип float. В любой момент мы можем воспользоваться функцией int, чтобы переменную, которая связана с типом float, перевести в объект типа integer и затем преобразовать integer обратно к вещественному типу, используя функцию float. Таким способом в процессе работы программы мы можем из одного типа конвертировать переменные в другой тип."]},{"cell_type":"code","execution_count":null,"metadata":{"id":"Y_RTDJzuw_jd","outputId":"761f6ff2-180f-44dc-bcaf-c051e38fa910","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1690305700158,"user_tz":-300,"elapsed":369,"user":{"displayName":"Evgeniy K.","userId":"01881409169257461735"}}},"outputs":[{"output_type":"stream","name":"stdout","text":["<class 'float'>\n"]}],"source":["num = 210.3\n","print(type(num))"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"Z4xFe7gMw_je","outputId":"ba6de426-54f0-4e72-a6f3-f3f17a637864","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1690305702486,"user_tz":-300,"elapsed":375,"user":{"displayName":"Evgeniy K.","userId":"01881409169257461735"}}},"outputs":[{"output_type":"stream","name":"stdout","text":["210 <class 'int'>\n","210.0 <class 'float'>\n"]}],"source":["num = int(num)\n","print(num, type(num))\n","\n","num = float(num)\n","print(num, type(num))"]},{"cell_type":"markdown","metadata":{"id":"_ok0i_7Cw_je"},"source":["Обратите внимание, что в процессе конвертации мы теряем дробную часть вещественного числа."]},{"cell_type":"markdown","metadata":{"id":"LI2j0wuPw_jg"},"source":["# 3. Основные арифметические операции с числами"]},{"cell_type":"markdown","source":["А теперь повторим основные арифметические операции."],"metadata":{"id":"yucQaw2YodE2"}},{"cell_type":"markdown","metadata":{"id":"eEITpon5w_jg"},"source":["#### Сложение"]},{"cell_type":"markdown","metadata":{"id":"Eak3jDxbw_jh"},"source":["Cумма двух целых чисел дает нам целое число; если мы складываем целое число и вещественное число, то результат получается вещественный:"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"pt-wmyM5w_jh","outputId":"e0308f4e-16a9-4368-f3fc-ecef208ac294","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1690306127875,"user_tz":-300,"elapsed":397,"user":{"displayName":"Evgeniy K.","userId":"01881409169257461735"}}},"outputs":[{"output_type":"execute_result","data":{"text/plain":["2"]},"metadata":{},"execution_count":13}],"source":["1 + 1"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"xs_jCd9vw_jh","outputId":"560d5c17-9583-462c-cf26-c4bb99796e91","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1695140598763,"user_tz":-300,"elapsed":315,"user":{"displayName":"Evgeniy K.","userId":"01881409169257461735"}}},"outputs":[{"output_type":"execute_result","data":{"text/plain":["3.0"]},"metadata":{},"execution_count":16}],"source":["1 + 2.0"]},{"cell_type":"markdown","metadata":{"id":"NY5X00msw_jj"},"source":["#### Вычитание"]},{"cell_type":"markdown","metadata":{"id":"bnNpVVMhw_jj"},"source":["То же самое с вычитанием, если мы вычитаем из целого целое, получается целое число, если мы вычитаем из вещественного целое, то результат вещественный:"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"1SBLczMZw_jk","outputId":"0f60fde0-b747-4c6a-e3b8-e2f484196fd1","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1690306176435,"user_tz":-300,"elapsed":13,"user":{"displayName":"Evgeniy K.","userId":"01881409169257461735"}}},"outputs":[{"output_type":"execute_result","data":{"text/plain":["8"]},"metadata":{},"execution_count":15}],"source":["9 - 1"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"adaY85cTw_jk","outputId":"8ee5bf0a-e5c6-4892-f641-6eb7acf64db4","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1695140612308,"user_tz":-300,"elapsed":314,"user":{"displayName":"Evgeniy K.","userId":"01881409169257461735"}}},"outputs":[{"output_type":"execute_result","data":{"text/plain":["4.3"]},"metadata":{},"execution_count":17}],"source":["5.3 - 1"]},{"cell_type":"markdown","metadata":{"id":"EinHKFIPw_jk"},"source":["#### Деление"]},{"cell_type":"markdown","metadata":{"id":"WNQm1YHnw_jk"},"source":["Для того, чтобы разделить числа, мы можем воспользоваться символом прямого слэша, и результат деления всегда **вещественный**."]},{"cell_type":"code","execution_count":null,"metadata":{"id":"Hevjg7ovw_jl","outputId":"5f09dcf8-d584-4e62-bfde-a029b3b0b556","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1690306235714,"user_tz":-300,"elapsed":399,"user":{"displayName":"Evgeniy K.","userId":"01881409169257461735"}}},"outputs":[{"output_type":"execute_result","data":{"text/plain":["4.0"]},"metadata":{},"execution_count":17}],"source":["12 / 3"]},{"cell_type":"markdown","metadata":{"id":"vOkmYH7Bw_jl"},"source":["Делить на 0 нельзя:"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"Iguo9GNrw_jm","outputId":"55a4bd3f-a725-454d-8387-7c78c8a55b8d","colab":{"base_uri":"https://localhost:8080/","height":169},"executionInfo":{"status":"error","timestamp":1690306242290,"user_tz":-300,"elapsed":368,"user":{"displayName":"Evgeniy K.","userId":"01881409169257461735"}}},"outputs":[{"output_type":"error","ename":"ZeroDivisionError","evalue":"ignored","traceback":["\u001b[0;31m---------------------------------------------------------------------------\u001b[0m","\u001b[0;31mZeroDivisionError\u001b[0m                         Traceback (most recent call last)","\u001b[0;32m<ipython-input-18-e1965806ec03>\u001b[0m in \u001b[0;36m<cell line: 1>\u001b[0;34m()\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0;36m3\u001b[0m \u001b[0;34m/\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m","\u001b[0;31mZeroDivisionError\u001b[0m: division by zero"]}],"source":["3 / 0"]},{"cell_type":"markdown","metadata":{"id":"Q1h2PDZjw_jm"},"source":["Если мы попытаемся разделить на 0, то мы получим исключение ZeroDivisionError."]},{"cell_type":"markdown","metadata":{"id":"71KSYniBw_jm"},"source":["#### Умножение"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"nbtAqCg8w_jo","outputId":"f45439e6-e69f-4fc3-d5ba-b82c62c0f65c","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1690306340121,"user_tz":-300,"elapsed":364,"user":{"displayName":"Evgeniy K.","userId":"01881409169257461735"}}},"outputs":[{"output_type":"execute_result","data":{"text/plain":["18.75"]},"metadata":{},"execution_count":19}],"source":["3 * 6.25"]},{"cell_type":"markdown","metadata":{"id":"oxlHuzXzw_jp"},"source":["#### Возведение в степень"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"fQBKDGHhw_jp","outputId":"3fac02a5-6c90-457a-b78e-dea301b492b4","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1690306347266,"user_tz":-300,"elapsed":373,"user":{"displayName":"Evgeniy K.","userId":"01881409169257461735"}}},"outputs":[{"output_type":"execute_result","data":{"text/plain":["16"]},"metadata":{},"execution_count":20}],"source":["2 ** 4"]},{"cell_type":"markdown","metadata":{"id":"p-UJ2ktvw_jq"},"source":["#### Целочисленное деление"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"1S8V2M2Cw_jr","outputId":"be5298c8-65bc-4120-b1da-6dd8d81669be"},"outputs":[{"data":{"text/plain":["3"]},"execution_count":18,"metadata":{},"output_type":"execute_result"}],"source":["10 // 3"]},{"cell_type":"markdown","metadata":{"id":"JjuAkqDpw_js"},"source":["#### Остаток от деления"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"B6KOMA-1w_js","outputId":"f61a24a2-d5ab-4ac5-c7f3-8d5f3294920a"},"outputs":[{"data":{"text/plain":["1"]},"execution_count":19,"metadata":{},"output_type":"execute_result"}],"source":["10 % 3"]},{"cell_type":"markdown","source":["**Внимание**. В Python операции деления с остатком ведут себя не так, как в математике. Главное отличие — остаток в Python всегда имеет тот же знак, что и делитель, а не делимое. Рассмотрим примеры."],"metadata":{"id":"NHLDucfuPwKe"}},{"cell_type":"markdown","source":["Пример 1. Положительное делимое и отрицательный делитель:"],"metadata":{"id":"8DO-gWagQM8_"}},{"cell_type":"code","source":["print(7 // -3)  # Результат: -3\n","print(7 % -3)   # Результат: -2"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"jmSnhQZ6QOcH","executionInfo":{"status":"ok","timestamp":1760185883982,"user_tz":-300,"elapsed":9,"user":{"displayName":"Evgeniy K.","userId":"01881409169257461735"}},"outputId":"e2b82800-6396-471b-93e7-d9536b8ba710"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["-3\n","-2\n"]}]},{"cell_type":"markdown","source":["Пример 2. Отрицательное делимое и положительный делитель:"],"metadata":{"id":"qghDrIBiQZqW"}},{"cell_type":"code","source":["print(-7 // 3)  # Результат: -3\n","print(-7 % 3)   # Результат: 2"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"XXOW4-zvQZ0n","executionInfo":{"status":"ok","timestamp":1760185960009,"user_tz":-300,"elapsed":5,"user":{"displayName":"Evgeniy K.","userId":"01881409169257461735"}},"outputId":"a6343685-87fb-479c-c2bd-378ed27b56ce"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["-3\n","2\n"]}]},{"cell_type":"markdown","source":["Пример 3. Оба числа отрицательные:"],"metadata":{"id":"8zoEiFBtQaBz"}},{"cell_type":"code","source":["print(-7 // -3)  # Результат: 2\n","print(-7 % -3)   # Результат: -1"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"kVMgu13gQaIP","executionInfo":{"status":"ok","timestamp":1760185985100,"user_tz":-300,"elapsed":12,"user":{"displayName":"Evgeniy K.","userId":"01881409169257461735"}},"outputId":"85e2914c-12f1-4eff-bb29-9b10fec672cd"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["2\n","-1\n"]}]},{"cell_type":"markdown","source":["Если вам нужен математически правильный результат, воспользуйтесь функцией модуля abs(): ```a % abs(b)```"],"metadata":{"id":"zo5j2LQ0Q4-I"}},{"cell_type":"markdown","metadata":{"id":"coGIr6hew_jt"},"source":["#### Порядок операций в выражениях с числами\n","Операции с числами имеют разный приоритет. Подробнее на этом остановимся на следующем занятии. Ниже показан пример того, как скобки меняют приоритет выполнения операций и влияют на конечный результат."]},{"cell_type":"code","execution_count":null,"metadata":{"id":"5oVamwMSw_jt","outputId":"83695e94-81fe-4ebf-f0e3-4b3075bbf3fd","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1695140695408,"user_tz":-300,"elapsed":5,"user":{"displayName":"Evgeniy K.","userId":"01881409169257461735"}}},"outputs":[{"output_type":"stream","name":"stdout","text":["22\n","40\n"]}],"source":["print(10 * 2 + 2)\n","print(10 * (2 + 2))"]},{"cell_type":"markdown","metadata":{"id":"IqcxPO3Fw_ju"},"source":["## * Бинарное представление числа\n","[продвинутая тема]"]},{"cell_type":"markdown","source":["Двоичное число — это число, состоящее из двоичных цифр. В отличии от привычной десятеричной системы, где мы записываем все числа десятью цифрами от 0 до 9, в двоичной системе исчисления их всего две. Их принято обозначать 0 и 1. Компьютеры работают именно в двоичной системе, поскольку им гораздо проще различать всего два числа, например как \"нет тока\" и \"есть электрический ток\".\n","\n","Работать в двоичной системе так же просто, как и в десятичной. Когда у нас заканчиваются цифры, мы возвращаемся к 0, переходим на следующий разряд и дописываем одну цифру:  \n","0, 1, 2, 3, 4, 5, 6, 7, 8, 9, **10**  \n","И дальше начинаем по новой, пока разряд снова не закончится:  \n","10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, ... 98, 99, **100**, 101, 102 ...\n","\n","В двоичной системе происходит то же самое, только цифр там гораздо меньше:  \n","0, 1, 10, 11, 100, 101, 110, 111, 1000 ...  \n","Мы получили строку с числами от 0 до 8. Отсюда можно видеть, что новый разряд добавляется при очередном умножении на два (в десятичной системе это будет соответственно умножение на 10).\n","\n","Несмотря на то, что Python не считается подходящим языком для низкоуровневого программирования, инструменты для работы с двоичным представлением данных у него всё же есть. Начнем с простого. Чтобы вывести число в бинарном виде, воспользуемся функцией **bin()**:"],"metadata":{"id":"3HsnJxGmRcY8"}},{"cell_type":"code","source":["bin(5)"],"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":35},"id":"snzsKxjDQtK7","executionInfo":{"status":"ok","timestamp":1695107216166,"user_tz":-300,"elapsed":331,"user":{"displayName":"Evgeniy K.","userId":"01881409169257461735"}},"outputId":"5ee2d469-3087-4b21-9247-3e5f1b298627"},"execution_count":null,"outputs":[{"output_type":"execute_result","data":{"text/plain":["'0b101'"],"application/vnd.google.colaboratory.intrinsic+json":{"type":"string"}},"metadata":{},"execution_count":1}]},{"cell_type":"markdown","source":["Мы получили бинарное представление числа 5. Правда отображенное здесь число не совсем бинарное, на самом деле 5 здесь — это последние три цифры (101), а код 0b используется в Python для вывода чисел в бинарном виде (есть и -0b для отрицательных значений). Теперь мы можем вывести любое число в двоичном коде."],"metadata":{"id":"GG_-YMaBQ3wM"}},{"cell_type":"markdown","metadata":{"id":"Q5orHDJExAOl"},"source":["# 4. Логические операторы и выражения\n","\n","В естественном языке (например, русском), чтобы сравнивать одно с другим, мы используем слова \"равно\", \"больше\", \"меньше\". В языках программирования для этого есть специальные знаки, подобные тем, которые используются в математике.\n","Поэтому, чтобы составлять логические условия, в Python существует несколько стандартных логических операторов."]},{"cell_type":"markdown","metadata":{"id":"CWwIfZFPxAOu"},"source":["### Оператор \"равно\""]},{"cell_type":"markdown","source":["Используется для проверки двух чисел на равность. Результатом является истина или ложь:"],"metadata":{"id":"L8qhKmmz1YAk"}},{"cell_type":"code","execution_count":null,"metadata":{"id":"h1rmmxdFxAOu","outputId":"8389b28c-c703-448f-8fbd-9aa673602d2a","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1695140372322,"user_tz":-300,"elapsed":356,"user":{"displayName":"Evgeniy K.","userId":"01881409169257461735"}}},"outputs":[{"output_type":"execute_result","data":{"text/plain":["True"]},"metadata":{},"execution_count":9}],"source":["10 == 10"]},{"cell_type":"markdown","source":["Допустимо прямое сравнение целых и вещественных чисел:"],"metadata":{"id":"8WBHpVj3s_6x"}},{"cell_type":"code","source":["10 == 10.0"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"NusjUqPlJdML","executionInfo":{"status":"ok","timestamp":1760457952575,"user_tz":-300,"elapsed":7,"user":{"displayName":"Evgeniy K.","userId":"01881409169257461735"}},"outputId":"90315a9e-3101-4456-f5a6-2fda5660ab6a"},"execution_count":null,"outputs":[{"output_type":"execute_result","data":{"text/plain":["True"]},"metadata":{},"execution_count":1}]},{"cell_type":"markdown","source":["**Внимание.** Строковые данные нельзя сравнивать с числовыми напрямую без конвертации типов:"],"metadata":{"id":"XMSL8-poJZks"}},{"cell_type":"code","source":["10 == \"10\""],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"JoB17O_cJPfZ","executionInfo":{"status":"ok","timestamp":1760457969609,"user_tz":-300,"elapsed":14,"user":{"displayName":"Evgeniy K.","userId":"01881409169257461735"}},"outputId":"0f378291-fe67-4681-fffa-71b23046eb05"},"execution_count":null,"outputs":[{"output_type":"execute_result","data":{"text/plain":["False"]},"metadata":{},"execution_count":2}]},{"cell_type":"markdown","source":["**Ещё раз внимание.** Не путайте операцию сравнения **==** и операцию присваивания **=** . Это разные операции!"],"metadata":{"id":"gpDirbjj8Z_l"}},{"cell_type":"markdown","metadata":{"id":"3JjV6kBxxAOv"},"source":["### Оператор \"не равно\""]},{"cell_type":"code","execution_count":null,"metadata":{"id":"CrxQg3aExAOv","outputId":"5735341f-8203-4523-d816-9ebf014e2392"},"outputs":[{"data":{"text/plain":["True"]},"execution_count":5,"metadata":{},"output_type":"execute_result"}],"source":["2 != 3"]},{"cell_type":"markdown","metadata":{"id":"23gdMHaOxAOw"},"source":["### Операторы сравнения:"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"TiJKwxd2xAOw","outputId":"6d0dffde-169a-4afe-ffbe-d0b1476abd9b","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1760454053470,"user_tz":-300,"elapsed":10,"user":{"displayName":"Evgeniy K.","userId":"01881409169257461735"}}},"outputs":[{"output_type":"stream","name":"stdout","text":["False\n","True\n","False\n","True\n"]}],"source":["print(2 > 5)\n","print(7 >= 7)\n","print(8 < 3)\n","print(3 <= 3)"]},{"cell_type":"markdown","source":["Позволительны и более сложные конструкции в виде двойных неравенств, как мы привыкли в математике:"],"metadata":{"id":"gMG3_qeFJ6yg"}},{"cell_type":"code","execution_count":null,"metadata":{"id":"MjdR6jrXxAOx","outputId":"a8826132-61ce-4f3b-b3bf-41bcd8108ce3","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1695140430182,"user_tz":-300,"elapsed":488,"user":{"displayName":"Evgeniy K.","userId":"01881409169257461735"}}},"outputs":[{"output_type":"stream","name":"stdout","text":["True\n"]}],"source":["x = 3\n","print(2 < x < 4)"]},{"cell_type":"markdown","source":["### Сравнение float\n","**Внимание**. Будьте осторожны при сравнении вещественных чисел. Из-за внутреннего устройства языка float имеют ограниченную точность. Посмотрите на следующий пример:"],"metadata":{"id":"ZWZwAeDcbOYz"}},{"cell_type":"code","source":["0.1 + 1.1 == 1.2  # сравнение даёт неверный результат"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"5dO_-I0xbuy9","executionInfo":{"status":"ok","timestamp":1760458072104,"user_tz":-300,"elapsed":7,"user":{"displayName":"Evgeniy K.","userId":"01881409169257461735"}},"outputId":"5f50c786-85e4-4b6b-f6d3-e0c77f43a9de"},"execution_count":null,"outputs":[{"output_type":"execute_result","data":{"text/plain":["False"]},"metadata":{},"execution_count":3}]},{"cell_type":"code","source":["0.1 + 1.1  # при выполнении такой операции подсчет недостаточно точен"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"pjRu_1vXb4yB","executionInfo":{"status":"ok","timestamp":1760458078921,"user_tz":-300,"elapsed":17,"user":{"displayName":"Evgeniy K.","userId":"01881409169257461735"}},"outputId":"997d012a-c70f-42a2-b4cd-9508ceb8f039"},"execution_count":null,"outputs":[{"output_type":"execute_result","data":{"text/plain":["1.2000000000000002"]},"metadata":{},"execution_count":4}]},{"cell_type":"markdown","source":["Поэтому при сравнении пользуйтесь округлением, например так:"],"metadata":{"id":"DYMQ-b7mcrgL"}},{"cell_type":"code","source":["round(0.1 + 1.1, 1) == round(1.2, 1)"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"rdzF7pW3cyHD","executionInfo":{"status":"ok","timestamp":1698398685590,"user_tz":-300,"elapsed":256,"user":{"displayName":"Evgeniy K.","userId":"01881409169257461735"}},"outputId":"ab272a83-dd85-438b-9742-7d862e6b3097"},"execution_count":null,"outputs":[{"output_type":"execute_result","data":{"text/plain":["True"]},"metadata":{},"execution_count":3}]},{"cell_type":"markdown","metadata":{"id":"Zrqq7x9ExAOz"},"source":["### Логический оператор \"И\""]},{"cell_type":"code","execution_count":null,"metadata":{"id":"9wUPD1qkxAO0","outputId":"6420eda5-bf37-4f96-ca47-2a0204fe650a"},"outputs":[{"name":"stdout","output_type":"stream","text":["False\n"]}],"source":["x, y = True, False\n","print(x and y)"]},{"cell_type":"markdown","source":["Таблица истинности для and:"],"metadata":{"id":"kp_6aCARBdlg"}},{"cell_type":"markdown","source":["![изображение.png](data:image/png;base64,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)"],"metadata":{"id":"gDNbppWJBP6w"}},{"cell_type":"markdown","metadata":{"id":"FODsFFHGxAO0"},"source":["### Логический оператор \"ИЛИ\""]},{"cell_type":"code","execution_count":null,"metadata":{"id":"kUcHd8i9xAO0","outputId":"d17ae2aa-6a42-4138-8471-70d579418558"},"outputs":[{"name":"stdout","output_type":"stream","text":["True\n"]}],"source":["x, y = True, False\n","print(x or y)"]},{"cell_type":"markdown","source":["Таблица истинности для or:"],"metadata":{"id":"76CFp8-gBiTz"}},{"cell_type":"markdown","source":["![изображение.png](data:image/png;base64,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)"],"metadata":{"id":"gnz3PH43Bm7q"}},{"cell_type":"markdown","metadata":{"id":"ZDLOlwH6xAO1"},"source":["### Логический оператор отрицания"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"s_utSPSkxAO1","outputId":"ca295eb3-030b-4c47-e1f1-dc69a87ee215"},"outputs":[{"name":"stdout","output_type":"stream","text":["True\n"]}],"source":["y = False\n","print(not y)"]},{"cell_type":"markdown","metadata":{"id":"4TS39B6yxAO2"},"source":["### Составные логические выражения"]},{"cell_type":"markdown","source":["Допустимо комбинировать логические операторы между собой:"],"metadata":{"id":"I4n1LUgcRl4G"}},{"cell_type":"code","execution_count":null,"metadata":{"id":"KFnQk2XhxAO2","outputId":"a81024e6-b898-459d-f974-c04fca472bc5","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1760454750202,"user_tz":-300,"elapsed":7,"user":{"displayName":"Evgeniy K.","userId":"01881409169257461735"}}},"outputs":[{"output_type":"stream","name":"stdout","text":["True\n"]}],"source":["x, y, z = True, False, True\n","result = x and y or z\n","print(result)"]},{"cell_type":"markdown","source":["Важно помнить о приоритете логических операторов. В этом примере оператор and имеет бОльший приоритет, чем or. Подробнее о приоритете операций ниже."],"metadata":{"id":"nlthUu5YRbNs"}},{"cell_type":"markdown","metadata":{"id":"t-lThrz8xAO2"},"source":["Особенность Python — так называемая \"ленивая\" обработка логических выражений and и or. Пример:"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"J85-6PwFxAO2","outputId":"531d7f6f-14dd-44ae-a15c-428a8a9b12a3","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1760458264119,"user_tz":-300,"elapsed":7,"user":{"displayName":"Evgeniy K.","userId":"01881409169257461735"}}},"outputs":[{"output_type":"stream","name":"stdout","text":["13\n"]}],"source":["x = 13\n","y = False\n","\n","print(x or y)"]},{"cell_type":"markdown","metadata":{"id":"RqtSzHjJxAO3"},"source":["В результате работы этого выражения мы видим, что на экране не True, как мы могли бы ожидать, а число 13.\n","\n","Python, начиная интерпретировать логическое выражение, видит, что \"x\" является истинным, и понимает, что ему не нужно выполнять оставшуюся часть логического выражения. Поэтому раз \"x\" — это истина, затем стоит оператор or - логическое сложение, значит нас устраивает то, что мы можем остановиться в этот момент и результатом выполнения выражения будет как раз значение \"x\", без проверки переменной \"y\"."]},{"cell_type":"code","execution_count":null,"metadata":{"id":"aGQbsIOrxAO3","outputId":"37135092-2e2f-4d98-a9dc-d8041c3ba2ae","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1760458295771,"user_tz":-300,"elapsed":53,"user":{"displayName":"Evgeniy K.","userId":"01881409169257461735"}}},"outputs":[{"output_type":"stream","name":"stdout","text":["boom\n"]}],"source":["x = 321\n","y = \"boom\"\n","\n","print(x and y)"]},{"cell_type":"markdown","metadata":{"id":"G7I4tGmOxAO3"},"source":["В результате работы логического выражения \"x and y\" мы получаем как результат работы логического выражения строку \"boom\". Python выполняет логическое выражение, до тех пор, пока оно имеет смысл, и результатом является последнее значение.\n","\n","Логические выражения пригодятся пригодятся нам в следующем занятии, когда мы будем составлять логические условия для условного оператора."]},{"cell_type":"markdown","source":["### * Битовые операторы\n","\n","[продвинутая тема]"],"metadata":{"id":"mE_v4R4ZiQRW"}},{"cell_type":"markdown","source":["Для различных манипуляций с двоичными данными в Python существуют побитовые (или битовые) операторы. Такое название здесь не случайно, ведь 1 бит информации — это как раз тот символ или сигнал, который может принимать два значения: 1 (включено) или 0 (выключено).\n","\n","Побитовые операторы предназначены для изменения строк с двоичным кодом, что может понадобиться для работы с криптографическими алгоритмами, драйверами различных устройств или, например, с сетевой инфраструктурой.\n","\n","Результатом действия побитовых операторов в Python является изменение объекта на уровне битов путем нескольких типов логических операций с двоичным кодом.\n","\n","Рассмотрим **пример**.  \n","Возьмем числа 4 = 100 и 3 = 011.\n","Побитовое «ИЛИ» — это операция по применению логического «ИЛИ» к каждой паре битов, которые стоят на одинаковых позициях. Если записать наши числа друг над другом и применить логическую операцию «ИЛИ», мы получим\n","```\n","100\n","или\n","011\n","---\n","111\n","```\n","Результатом такой операции будет число 111 (семь в десятичном виде). То есть, 4 | 3 = 7\n","\n","Подробнее о логических операторах — на следующем занятии."],"metadata":{"id":"ielwl-fnQAoX"}},{"cell_type":"markdown","source":["Следующий код демонстрирует все доступные битовые операторы:"],"metadata":{"id":"eTvgws85Woal"}},{"cell_type":"code","execution_count":null,"metadata":{"id":"9KytALcjw_ju","outputId":"ccde3c6f-7ecf-4d76-b13e-d4e9311d122d","colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"status":"ok","timestamp":1759851425329,"user_tz":-300,"elapsed":26,"user":{"displayName":"Evgeniy K.","userId":"01881409169257461735"}}},"outputs":[{"output_type":"stream","name":"stdout","text":["4  =  0b100\n","3  =  0b11\n","Побитовое или: 7  =  0b111\n","Побитовое исключающее или: 7  =  0b111\n","Побитовое и: 0  =  0b0\n","Битовый сдвиг влево на 3: 32  =  0b100000\n","Битовый сдвиг вправо на 1: 2  =  0b10\n","Инверсия битов: -5  =  -0b101\n"]}],"source":["x = 4\n","y = 3\n","print(x, \" = \", bin(x))\n","print(y, \" = \", bin(y))\n","\n","print(\"Побитовое или:\", x | y, \" = \", bin(x | y))\n","print(\"Побитовое исключающее или:\", x ^ y, \" = \", bin(x ^ y))\n","print(\"Побитовое и:\", x & y, \" = \", bin(x & y))\n","print(\"Битовый сдвиг влево на 3:\", x << 3, \" = \", bin(x << 3))\n","print(\"Битовый сдвиг вправо на 1:\", x >> 1, \" = \", bin(x >> 1))\n","print(\"Инверсия битов:\", ~x, \" = \", bin(~x))"]},{"cell_type":"markdown","source":["**Пример**\n","\n","Разберем пример использования битовых операций.  \n","Пусть у нас есть пользователь операционной системы, и у него есть права на пользование некоторым каталогом.  \n","Зададим права на каталог в виде битовых значений:\n"],"metadata":{"id":"yilR_t3StECX"}},{"cell_type":"code","source":["# Права (битовые флаги)\n","ADMIN   = 1  # 0001 - является ли пользователь администратором\n","READ    = 2  # 0010\n","WRITE   = 4  # 0100\n","DELETE  = 8  # 1000\n","\n","# Начальные права пользователя\n","user_rights = 0  # 0000\n","\n","# Добавим пользователю право читать и удалять каталог: READ и DELETE\n","user_rights = READ | DELETE  # 0010 | 1000 = 1010 (то есть 10 в десятичной)\n","print(\"Наши права:\", bin(user_rights))\n","\n","# Проверим, есть ли право на запись:\n","has_write = bool(user_rights & WRITE)\n","print(\"Умеет записывать?\", has_write)  # False\n","\n","# Добавим право на запись:\n","user_rights = user_rights | WRITE\n","print(\"Добавили право записи:\", bin(user_rights))  # 1110\n","\n","# Удалим право на чтение:\n","user_rights = user_rights & ~READ  # зануляем нужный бит с помощью инверсии\n","print(\"Удалили право на чтение:\", bin(user_rights))  # 1100\n","\n","# Проверим, является ли пользователь администратором:\n","is_admin = bool(user_rights & ADMIN)\n","print(\"Администратор?\", is_admin)  # False\n","\n","print(\"Наши права в десятичном виде:\", user_rights)"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"6FzLEiDWtyf_","executionInfo":{"status":"ok","timestamp":1760195143551,"user_tz":-300,"elapsed":8,"user":{"displayName":"Evgeniy K.","userId":"01881409169257461735"}},"outputId":"3be22305-6280-4dc8-bf73-e4f840b63dee"},"execution_count":null,"outputs":[{"output_type":"stream","name":"stdout","text":["Наши права: 0b1010\n","Умеет записывать? False\n","Добавили право записи: 0b1110\n","Удалили право на чтение: 0b1100\n","Администратор? False\n","Наши права в десятичном виде: 12\n"]}]},{"cell_type":"markdown","source":["Как мы видим, чтобы держать целый набор прав, нам нужна всего одна небольшая переменная целого типа, например, user_rights = 12. Однако внутри этого маленького числа мы закодировали сразу несколько различных полей с данными (поля называются флагами) с помощью двоичного представления числа. А с помощью битовых операций над переменной мы можем изменять лежащие внутри флаги, тем самым управляя доступом нужных пользователей к нужным файлам."],"metadata":{"id":"RvPAMka2w8r5"}},{"cell_type":"markdown","source":["С точки зрения анализа данных, битовые операции, хотя и не являются типичными инструментами для этой области, всё же могут использоваться для определенных задач. Это может быть анализ сетевого трафика с помощью битовых масок или бинарная обработка файлов, которая выполняется напрямую без декодирования информации в текст.\n","\n","Важно помнить, что битовые операции могут усложнить понимание кода и сделать его менее читаемым. Их следует использовать осторожно и только тогда, когда они действительно необходимы для решения конкретных задач."],"metadata":{"id":"IQ37foKz3wyF"}},{"cell_type":"markdown","source":["## Итоги"],"metadata":{"id":"UYIuPw3PHoBe"}},{"cell_type":"markdown","source":["Подведем итоги занятия:\n","* Переменная — это область памяти компьютера, которая состоит из имени, значения и адреса.\n","* Базовые типы данных для Python — это строки, целые числа, вещественные числа и логический тип данных bool.\n","* Python поддерживает все основные арифметические операции, включая вычисление остатка от деления.\n","* Для сравнения чисел и составления логических выражений используются базовые математические и логические операторы типа."],"metadata":{"id":"5KYHAa8d4dC1"}}],"metadata":{"kernelspec":{"display_name":"Python 3","language":"python","name":"python3"},"language_info":{"codemirror_mode":{"name":"ipython","version":3},"file_extension":".py","mimetype":"text/x-python","name":"python","nbconvert_exporter":"python","pygments_lexer":"ipython3","version":"3.7.6"},"colab":{"provenance":[]}},"nbformat":4,"nbformat_minor":0}