- Работа с числами в Python
- Целые и числа с плавающей точкой в Python
- Создание int и float чисел
- Арифметические операции над целыми и числами с плавающей точкой
- Сложение
- Вычитание
- Умножение
- Деление
- Деление без остатка
- Остаток от деления
- Возведение в степень
- Комплексные числа
- Операторы Python
- Введение в операторы Python
- Арифметические операторы Python
- Сложение (+)
- Вычитание (-)
- Умножение (*)
- Деление (/)
- Возведение в степень (**)
- Деление без остатка (//)
- Деление по модулю (остаток от деления) (%)
- Операторы сравнения
- Меньше (<)
- Больше (>)
- Меньше или равно (<=)
- Больше или равно (>=)
- Равно (==)
- Не равно (!=)
- Операторы присваивания
- Присваивание (=)
- Сложение и присваивание (+=)
- Вычитание и присваивание (-=)
- Деление и присваивание (/=)
- Умножение и присваивание (*=)
- Деление по модулю и присваивание (%=)
- Возведение в степень и присваивание (**=)
- Деление с остатком и присваивание (//=)
- Логические операторы Python
- И (and)
- Или (or)
- Не (not)
- Операторы принадлежности
- В (in)
- Нет в (not in)
- Операторы тождественности
- Это (is)
- Это не (is not)
- Битовые операторы Python
- Бинарное И (&)
- Бинарное ИЛИ (|)
- Бинарное ИЛИ НЕТ (^)
- Инвертирующий оператор (~)
- Бинарный сдвиг влево (<<)
- Бинарный сдвиг вправо (>>)
- Выводы
Работа с числами в Python
В этом материале рассмотрим работу с числами в Python. Установите последнюю версию этого языка программирования и используйте IDE для работы с кодом, например, Visual Studio Code.
В Python достаточно просто работать с числами, ведь сам язык является простым и одновременно мощным. Он поддерживает всего три числовых типа:
Хотя int и float присутствуют в большинстве других языков программирования, наличие типа комплексных чисел — уникальная особенность Python. Теперь рассмотрим в деталях каждый из типов.
Целые и числа с плавающей точкой в Python
В программирование целые числа — это те, что лишены плавающей точкой, например, 1, 10, -1, 0 и так далее. Числа с плавающей точкой — это, например, 1.0, 6.1 и так далее.
Создание int и float чисел
Для создания целого числа нужно присвоить соответствующее значение переменной. Возьмем в качестве примера следующий код:
Здесь мы присваиваем значение 25 переменной var1 . Важно не использовать одинарные или двойные кавычки при создании чисел, поскольку они отвечают за представление строк. Рассмотрим следующий код.
В этих случаях данные представлены как строки, поэтому не могут быть обработаны так, как требуется. Для создания числа с плавающей точкой, типа float , нужно аналогичным образом присвоить значение переменной.
Здесь также не стоит использовать кавычки.
Проверить тип данных переменной можно с помощью встроенной функции type() . Можете проверить результат выполнения, скопировав этот код в свою IDE.
var1 = 1 # создание int
var2 = 1.10 # создание float
var3 = "1.10" # создание строки
print(type(var1))
print(type(var2))
print(type(var3))В Python также можно создавать крупные числа, но в таком случае нельзя использовать запятые.
# создание 1,000,000
var1 = 1,000,000 # неправильноЕсли попытаться запустить этот код, то интерпретатор Python вернет ошибку. Для разделения значений целого числа используется нижнее подчеркивание. Вот пример корректного объявления.
# создание 1,000,000
var1 = 1_000_000 # правильно
print(var1)Значение выведем с помощью функции print :
Арифметические операции над целыми и числами с плавающей точкой
Используем такие арифметические операции, как сложение и вычитание, на числах. Для запуска этого кода откройте оболочку Python, введите python или python3 . Терминал должен выглядеть следующим образом:
Сложение
В Python сложение выполняется с помощью оператора + . В терминале Python выполните следующее.
Результатом будет сумма двух чисел, которая выведется в терминале.
Теперь запустим такой код.
В нем было выполнено сложение целого и числа с плавающей точкой. Можно обратить внимание на то, что результатом также является число с плавающей точкой. Таким образом сложение двух целых чисел дает целое число, но если хотя бы один из операндов является числом с плавающей точкой, то и результат станет такого же типа.
Вычитание
В Python для операции вычитания используется оператор -. Рассмотрим примеры.
>>> 3 - 1 2 >>> 1 - 5 -4 >>> 3.0 - 4.0 -1.0 >>> 3 - 1.0 2.0
Положительные числа получаются в случае вычитания маленького числа из более крупного. Если же из маленького наоборот вычесть большое, то результатом будет отрицательно число. По аналогии с операцией сложения при вычитании если один из операндов является числом с плавающей точкой, то и весь результат будет такого типа.
Умножение
Для умножения в Python применяется оператор * .
>>> 8 * 2 16 >>> 8.0 * 2 16.0 >>> 8.0 * 2.0 16.0
Если перемножить два целых числа, то результатом будет целое число. Если же использовать число с плавающей точкой, то результатом будет также число с плавающей точкой.
Деление
В Python деление выполняется с помощью оператора / .
>>> 3 / 1 3.0 >>> 4 / 2 2.0 >>> 3 / 2 1.5
В отличие от трех предыдущих операций при делении результатом всегда будет число с плавающей точкой. Также нужно помнить о том, что на 0 делить нельзя, иначе Python вернет ошибку ZeroDivisionError . Вот пример такого поведения.
>>> 1 / 0 Traceback (most recent call last): File "", line 1, in ZeroDivisionError: division by zero
Деление без остатка
При обычном делении с использованием оператора / результатом будет точное число с плавающей точкой. Но иногда достаточно получить лишь целую часть операции. Для этого есть операции интегрального деления. Стоит рассмотреть ее на примере.
Результатом такой операции становится частное. Остаток же можно получить с помощью модуля, о котором речь пойдет дальше.
Остаток от деления
Для получения остатка деления двух чисел используется оператор деления по модулю % .
>>> 5 % 2 1 >>> 4 % 2 0 >>> 3 % 2 1 >>> 5 % 3 2
На этих примерах видно, как это работает.
Возведение в степень
Число можно возвести в степень с помощью оператора ** .
Комплексные числа
Комплексные числа — это числа, которые включают мнимую часть. Python поддерживает их «из коробки». Их можно запросто создавать и использовать. Пример:
Операторы Python
В этом руководстве речь пойдет об операторах языка программирования Python. Вы узнаете об арифметических, логических и битовых операторах, а также операторах сравнения, присваивания, принадлежности, тождественности и их синтаксисе. Все это будет проиллюстрировано примерами.
Оператор в Python — это символ, который выполняет операцию над одним или несколькими операндами.
Операндом выступает переменная или значение, над которыми проводится операция.Введение в операторы Python
Операторы Python бывают 7 типов:
- Арифметические операторы
- Операторы сравнения
- Операторы присваивания
- Логические операторы
- Операторы принадлежности
- Операторы тождественности
- Битовые операторы
Арифметические операторы Python
Этот тип включает операторы для проведения базовых арифметических операций.
Сложение (+)
Складывает значение по обе стороны оператора.
Пример:
Вычитание (-)
Вычитает значение правой стороны из значения в левой.
Пример:
Умножение (*)
Перемножает значения с обеих сторон оператора.
Пример:
Деление (/)
Делит значение левой стороны на значение правой. Тип данных результата деления — число с плавающей точкой.
Пример:
Возведение в степень (**)
Возводит первое число в степень второго.
Пример:
Деление без остатка (//)
Выполняет деление и возвращает целочисленное значение частного, убирая цифры после десятичной точки.
Пример:
Деление по модулю (остаток от деления) (%)
Выполняет деление и возвращает значение остатка.
Пример:
Операторы сравнения
Операторы сравнения в Python проводят сравнение операндов. Они сообщают, является ли один из них больше второго, меньше, равным или и то и то.
Меньше (<)
Этот оператор проверяет, является ли значение слева меньше, чем правое.
Пример:
Больше (>)
Проверяет, является ли значение слева больше правого.
Меньше или равно (<=)
Проверяет, является ли левая часть меньше или равной правой.
Пример:
Больше или равно (>=)
Проверяет, является ли левая часть больше или равной правой.
Пример:
Равно (==)
Этот оператор проверяет, равно ли значение слева правому. 1 равна булевому True , а 2 (двойка) — нет. 0 равен False .
Пример:
Не равно (!=)
Проверяет, не равно ли значение слева правому. Оператор <> выполняет ту же задачу, но его убрали в Python 3.
Когда условие выполнено, возвращается True . В противном случае — False . Это возвращаемое значение можно использовать в последующих инструкциях и выражениях.
Пример:
>>> 1==True # Это вызывает SyntaxError
Операторы присваивания
Оператор присваивания присваивает значение переменной. Он может манипулировать значением до присваивания. Есть 8 операторов присваивания: 1 простой и 7 с использованием арифметических операторов.
Присваивание (=)
Присваивает значение справа левой части. Стоит обратить внимание, что == используется для сравнения, а = — для присваивания.
Пример:
Сложение и присваивание (+=)
Суммирует значение обеих сторон и присваивает его выражению слева. a += 10 — это то же самое, что и a = a + 10 .
То же касается и все остальных операторов присваивания.
Пример:
Вычитание и присваивание (-=)
Вычитает значение справа из левого и присваивает его выражению слева.
Пример:
Деление и присваивание (/=)
Делит значение слева на правое. Затем присваивает его выражению слева.
Пример:
Умножение и присваивание (*=)
Перемножает значения обеих сторон. Затем присваивает правое левому.
Пример:
Деление по модулю и присваивание (%=)
Выполняет деление по модулю для обеих частей. Результат присваивает левой части.
Пример:
Возведение в степень и присваивание (**=)
Выполняет возведение левой части в степень значения правой части. Затем присваивает значение левой части.
Пример:
Деление с остатком и присваивание (//=)
Выполняет деление с остатком и присваивает результат левой части.
Пример:
Это один из важных операторов Python
Логические операторы Python
Это союзы, которые позволяют объединять по несколько условий. В Python есть всего три оператора: and (и), or (или) и not (не).
И (and)
Если условия с двух сторон оператора and истинны, тогда все выражение целиком считается истинным.
Пример:
Или (or)
Выражение ложно, если оба операнда с двух сторон ложные. Если хотя бы одно из них истинное, то и все выражение истинно.
Пример:
Не (not)
Этот оператор инвертирует булевые значения выражения. True превращается в False и наоборот. В примере внизу булево значение 0 — False . Поэтому оно превращается в True .
Пример:
Операторы принадлежности
Эти операторы проверяют, является ли значение частью последовательности. Последовательность может быть списком, строкой или кортежем. Есть всего два таких оператора: in и not in .
В (in)
Проверяет, является ли значение членом последовательности. В этом примере видно, что строки fox нет в списке питомцев. Но cat — есть, поэтому она возвращает True . Также строка me является подстрокой disappointment . Поэтому она вернет True .
Пример:
>>> pets=['dog','cat', 'ferret'] >>> 'fox' in pets
Нет в (not in)
Этот оператор проверяет, НЕ является ли значение членом последовательности.
Пример:
>>> 'pot' not in 'disappointment'
Операторы тождественности
Эти операторы проверяют, являются ли операнды одинаковыми (занимают ли они одну и ту же позицию в памяти).
Это (is)
Если операнды тождественны, то вернется True . В противном случае — False . Здесь 2 не является 20 , поэтому вернется False . Но '2' — это то же самое, что и "2" . Разные кавычки не меняют сами объекты, поэтому вернется True .
Пример:
Это не (is not)
2 — это число, а '2' — строка. Поэтому вернется True .
Пример:
Битовые операторы Python
Эти операторы работают над операндами бит за битом.
Бинарное И (&)
Проводит побитовую операцию and над двумя значением. Здесь бинарная 2 — это 10 , а 3 — 11 . Результатом побитового and является 10 — бинарная 2 . Побитовое and над 011 (3) и 100 (4) выдает результат 000 (0).
Пример:
Бинарное ИЛИ (|)
Проводит побитовую операцию or на двух значениях. Здесь or для 10 (2) и 11 (3) возвращает 11 (3).
Пример:
Бинарное ИЛИ НЕТ (^)
Проводит побитовую операцию xor (исключающее или) на двух значениях. Здесь результатом ИЛИ НЕ для 10 (2) и 11 (3) будет 01 (1).
Пример:
Инвертирующий оператор (~)
Он возвращает инвертированные двоичные числа. Другими словами, переворачивает биты. Битовая 2 — это 00000010 . Ее инвертированная версия — 11111101 . Это бинарная -3 . Поэтому результат -3 . Похожим образом ~1 равняется -2 .
Пример:
Еще раз, инвертированная -3 — это 2 .
Бинарный сдвиг влево (<<)
Он сдвигает значение левого операнда на позицию, которая указана справа. Так, бинарная 2 — это 10 . 2 сдвинет значение на две позиции влево и выйдет 1000 — это бинарная 8 .
Пример:
Бинарный сдвиг вправо (>>)
Сдвигает значение левого оператора на позицию, указанную справа. Так, бинарная 3 — это 11 . 3 >> 2 сдвинет значение на два положение вправо. Результат — 00 , то есть 0 . 3 >> 1 сдвинет на одну позицию вправо, а результатом будет 01 — бинарная 1 .
Пример:
Выводы
В этом уроке были рассмотрены все 7 типов операторов Python. Для каждого был предложен пример в IDE. Для понимания особенностей работы операторов нужно продолжать с ними работать, использовать в условных конструкциях и объединять.