Операторы – это важное понятие в программировании. Они используются для выполнения базовых математических операций, операций сравнения, вычисления логических выражений и много другого. В этой статье мы рассмотрим, какие есть операторы в Python.
Скачивайте книги ТОЛЬКО на русском языке у нас в телеграм канале: PythonBooksRU
Арифметические операторы в Python
Для выполнения основных математических операций в языке Python используются арифметические операторы. Некоторые из них, вероятно, знакомы вам из курса математики начальной школы. А те, которые вдруг не знакомы, интуитивно понятны и просты для восприятия.
Вот краткая шпаргалка по арифметическим операторам в Python:
| Оператор | Пример использования | Название | Описание |
|---|---|---|---|
| + | a + b | Сложение | Складывает переменные а и b |
| – | a – b | Вычитание | Вычитает переменную b из переменной a |
| * | a * b | Умножение | Умножает переменную a на переменную b |
| / | a / b | Деление | Делит переменную a на переменную b |
| % | a % b | Деление по модулю | Дает остаток от деления переменной а на переменную b |
| // | a // b | Целочисленное деление | Делит переменную а на переменную b и округляет результат до целочисленного значения (в меньшую сторону) |
| ** | a ** b | Возведение в степень | Возводит переменную а в степень b |
Теперь давайте подробнее разберем, как использовать каждый из этих операторов.
Оператор сложения (+)
Оператор сложения (+) суммирует два числовых значения. Это бинарный оператор, поскольку он принимает два значения. Например:
sum = 1 + 2 print(sum)
Результат: 3
Унарный оператор +
Как и в математике, + можно использовать как унарный оператор. Это означает, что его можно поместить перед числом, чтобы подчеркнуть его положительность. Например:
temperature = +30 print(temperature) # Результат: # 30
Однако на практике он практически не применяется, так как никакого действия не производит.
Оператор вычитания (-)
Оператор вычитания производит вычитание одного числа из другого. Например:
diff = 1 - 2 print(sum) # Результат: # -1
Унарный оператор –
Оператор - можно использовать и как унарный оператор, просто поместив его перед числовым значением. Тогда он будет менять знак числа на противоположенный. То есть положительное число станет отрицательным, а отрицательное – положительным.
Например:
n = -10 p = -n print(p) # Результат: # 10
Оператор умножения (*)
Оператор умножения умножает два числовых значения. Например:
prod = 10 * 3 print(prod) # Результат: # 30
Оператор деления (/)
Оператор деления делит одно число на другое. Например:
fraction = 10.0 / 4.0 print(fraction) # Результат: # 2.5
Оператор деления по модулю (%)
В математике деление по модулю возвращает остаток от деления. Для примера рассмотрим выражение 7 mod 2 = 1. Число 7 нацело разделить на 2 невозможно, в остатке остается 1. В Python оператор деления по модулю обозначается знаком процента (%).
Давайте подсчитаем, сколько кусочков пиццы останется, если их было 15, а едоков четверо.
pizzaSlices = 15 eaters = 4 leftoverSlices = 15 % 4 print(leftoverSlices) # Результат: # 3
Результат равен трем, потому что нет возможности поровну разделить 15 ломтиков пиццы на 4 человек. По справедливости каждый получает по 3 ломтика, то есть всего будет съедено 12. Тогда остается 3 ломтика.
Оператор целочисленного деления (//)
Данный оператор делит одно числовое значение на другое и округляет результат в меньшую сторону до ближайшего целого числа. Например:
result = 10 // 3 print(result) # Результат: # 3
Результат равен 3, потому что 10/3 = 3,333…., а ближайшее целое число ниже этого значения равно 3. Заметьте, что данный оператор всегда округляет в меньшую сторону.
Давайте рассмотрим другой пример:
result = 10 // 6 print(result) # Результат: # 1
Результат деления 10 на 6 равен 1,6667, а следующее целое число ниже полученного значения равно 1. Таким образом, несмотря на то, что по правилам обычного округления результат был бы равен 2, оператор целочисленного деления дает в результате 1.
Оператор возведения в степень (**)
Как легко догадаться, этот оператор возводит число в определенную степень. В языке Python он обозначается двойной звездочкой – **.
Возведение в степень означает умножение числа само на себя столько раз, сколько указано в показателе степени. Например, 2³ = 2 * 2 * 2 = 8.
Рассмотрим возведение в степень в коде:
result = 4 ** 3 print(result) # Результат: # 64
Это эквивалентно 4 * 4 * 4.
Сокращенные формы операторов присваивания
В языке Python в порядке вещей обновлять существующие значения. Например, давайте создадим переменную counter (счетчик) и начнем ее увеличивать:
counter = 0 counter = counter + 1 counter = counter + 1 counter = counter + 1 print(counter) # Результат: # 3
Поскольку подобное обновление существующего значения является очень распространенной операцией, для нее есть сокращение. В Python это называется сокращенным присваиванием.
Чтобы обновить значение, мы объединяем оператор присваивания (=) с любым из арифметических операторов (+, -, *, /, **, %, //).
Например, давайте повторим предыдущий пример, но при добавлении значений к счетчику будем использовать сокращенное присваивание:
counter = 0 counter += 1 counter += 1 counter += 1 print(counter)
Здесь выражение counter += 1 эквивалентно counter = counter + 1.
Вот примеры сокращенного присваивания с другими арифметическими операторами:
s = 0 s += 1 print(s) # s is now 1 d = 10 d -= 5 print(d) # d is now 5 m = 5 m *= 10 print(m) # m is now 50 n = 10 n /= 2 print(n) # n is now 5.0 x = 16 x %= 6 print(x) # x is now 4 y = 10 y //= 4 print(y) #y is now 2 z = 4 z **= 3 print(z) #z is now 64
Операторы сравнения в Python
В Python мы постоянно имеем дело с данными. Эти данные необходимо время от времени сравнивать друг с другом. Для этого в языке Python есть шесть операторов сравнения.
Вот краткая шпаргалка по этим операторам:
| Оператор | Пример использования | Имя | Описание |
|---|---|---|---|
| == | a == b | Проверка на равенство | Если значение а равно значению b, то возвращается True. В противном случае возвращается False |
| != | a != b | Проверка на неравенство | Если значение а не равно значению b, то возвращается True. В противном случае возвращается False |
| < | a < b | Меньше | Если значение a меньше b, то возвращается True. В противном случаев возвращается False |
| <= | a <= b | Меньше либо равно | Если значение a меньше либо равно b, то возвращается True. В противном случаев возвращается False |
| > | a > b | Больше | Если значение a больше b, то возвращается True. В противном случаев возвращается False |
| >= | a >= b | Больше либо равно | Если значение a больше либо равно b, то возвращается True. В противном случаев возвращается False |
Теперь давайте рассмотрим каждый из этих операторов отдельно.
Оператор проверки на равенство (==)
Оператор проверки на равенство проверяет, равны ли два значения друг другу. Он обозначается двойным знаком равенства ==.
Возникает вопрос, а почему знак равенства двойной, а не одинарный? Это связано с тем, что одиночный знак равенства зарезервирован за оператором присваивания.
Например, давайте сравним два числа:
a = 10 b = 10 print(a == b) # Результат: # True
Заметим также, что производить аналогичное сравнение можно и между строками:
name1 = "Alice" name2 = "Alice" print(name1 == name2) # Результат: # True
Оператор проверки на неравенство (!=)
Для этого оператора используется обозначение !=. Если два сравниваемых значения не равны друг другу, данный оператор возвращает True, в противном случае возвращает False. Например:
a = 10 b = 10 print(a != b) # Результат: # False
Оператор меньше ( < )
Чтобы проверить, меньше ли одно значение, чем другое, используется оператор меньше <. Он ставится между двумя сравниваемыми значениями. Например:
result = 1 < 2 print(result) # Результат: # True
Оператор меньше либо равно (<=)
Иногда интересно знать не превышает ли одно значение другое. Для такой проверки используется оператор меньше либо равно <=. Он получается посредством объединения знака меньше и знака равенства. Например:
print(2 <= 2) # Результат: # True
Оператор больше (>)
Для проверки, больше ли одно значение, чем другое, используется оператор больше >. Он также помещается между сравниваемыми значениями. Например:
print(20 > 2) # Результат: # True
Оператор больше либо равно (>=)
Иногда бывает необходимо убедиться, что одно значение равно другому либо превышает его. Для этого существует оператор больше либо равно >=. Например:
result = 8 >= 3 print(result) # Результат: # True
Изучив основы операторов сравнения, давайте теперь поговорим об их запутанном и неправильном поведении при сравнении чисел с плавающей запятой.
Погрешность при сравнении чисел типа float
Взглянем на следующий фрагмент кода, в котором мы сравниваем два числа с плавающей запятой (типа float):
print(3.6 == 1.3 + 2.3) # Результат: # False
Очевидно, что результат должен быть True. Но в языке Python оно вычисляется как False. Это происходит из-за погрешности при операциях с числами с плавающей запятой.
В памяти компьютера недостаточно места для точного представления конкретных чисел с плавающей запятой.
Например, рассмотрим число 1/3. Его десятичное представление равно 0.3333333….. , где цифра 3 повторяется. Чтобы точно записать это число, цифру 3 после точки нужно будет повторять бесконечно, что очевидно невозможно.
Похожая логика применима к операциям с плавающей запятой в Python.
Для представления чисел в компьютере используется двоичная система счисления. Подобно нашей десятеричной системе, в двоичной системе есть числа, цифры в которых повторяются бесконечно. И для их хранения потребовалась бы бесконечная память. Поэтому некоторые числа в десятичном выражении обрезаются, что приводит к небольшой погрешности.
Итак, некоторые числа типа float (с плавающей запятой) немного не точны. И из-за этой неточности сравнение чисел с плавающей запятой теряет смысл.
Чтобы проверить равенство двух чисел с плавающей запятой, вместо этого нужно проверить близость числа к некоторому значению. При небольших неточностях в числах a и b их разность близка к нулю. Например:
tolerance = 0.000001 areEqual = abs((1.3 + 2.3) - 3.6) < tolerance print(areEqual) # Результат: # True
Поскольку абсолютное значение разности между 1.3 + 2.3 и 3.6 меньше, чем 0.000001, числа должны быть очень близки друг к другу. Другими словами, они равны.
Также надо заметить, что неточность при вычислении чисел с плавающей запятой не является характерной именно для Python. Такие ошибки присущи абсолютно всем языкам программирования.
Логические операторы в Python
В языке Python можно комбинировать логические выражения с логическими операторами.
Логические операторы используются в повседневной жизни. Пример: «Если жарко и солнечно, пойдем на пляж». Хотя вы можете этого не замечать, но в этом самом предложении используется логический оператор «и» для объединения двух логических выражений.
Давайте перефразируем предложение, чтобы лучше понять, что оно означает: «Если это солнечный день и если это жаркий день, пойдем на пляж».
Теперь разобьем это предложение на три части:
- Это солнечный день.
- И
- Это жаркий день.
Первая часть – “Это солнечный день” – является логическим выражением. Его результатом может быть либо True, либо False. Вторая часть – “И” – это логический оператор. Он связывает первую и третью части выражения. И наконец третья часть – “Это жаркий день”. Она тоже является логическим выражением с двумя результатами, True либо False.
Если эти два логических выражения верны одновременно, мы идем на пляж. А в противном случае мы этого делать не будем.
Если вкратце, то в этом и есть вся суть логических выражений и логических операторов. Теперь давайте посмотрим на логические операторы в Python.
Логические выражения и логические операторы в Python
В языке Python есть три логических оператора:
- not
- or
- and
Вот шпаргалка, которая поможет вам быстро понять, как они работают:
| Оператор | Пример использования | Описание |
|---|---|---|
| not | not x | Меняет значение на противоположенное. Если x True, то результат – False. И наоборот. |
| or | a or b | True, если a или b равны True. В противном случае False. |
| and | a and b | True, если a и b равны True. В противном случае False. |
Теперь, когда вы понимаете, как работают логические операторы в Python, превратим приведенный выше пример из реальной жизни в код:
isSunny = True isHot = False beachTime = isSunny and isHot print(beachTime) # Результат: # False
Давайте рассмотрим другой пример. В этом примере человек занят, если он работает или учится:
isStudying = False isWorking = True isBusy = isStudying or isWorking print(isBusy) # Результат: # True
Как можно заметить, несмотря на то, что переменная isStudying имеет значение False, человек все равно занят, потому что переменная isWorking имеет значение True.
Теперь давайте посмотрим на пример работы оператора not. Оператор not инвертирует логическое значение, так что True становится False и наоборот. Например:
isRainy = True isSunny = not isRainy print(isSunny) # Результат: # False
То есть сейчас не солнечно, потому что дождливо. Переменная isSunny имеет значение, обратное значению переменной isRainy.
Обратите внимание, что логические операторы в Python можно использовать для объединения любых логических выражений. Например, можно объединить результаты двух (или более) сравнений:
print(1 == 2 or 10 < 20) # Результат: # True
Логический контекст
В Python объекты и выражения обычно не являются логическими (True или False). Но их можно считать истинными или ложными в логическом смысле.
Иными словами, любое значение в Python в логическом смысле становится либо истинным (True), либо ложным (False). Например, 0 в логическом контексте False, а 1 – True. По сути любое ненулевое значение считается истинным.
Ниже приведены все значения, которые в логическом смысле можно считать ложными (False):
- собственно False
- 0 и 0.0
- пустая строка
- пустые составные объекты данных, например пустой список или кортеж
- None. Это специальный тип данных, который обозначает отсутствие значения
Все остальные значения в логическом контексте имеют значение True.
Для преобразования значений в логические величины используется встроенная функция bool(). Например, давайте превратим число 0 в логическую величину:
booleanZero = bool(0) print(booleanZero) # Результат: # False
Логические выражения с нелогическими значениями
В предыдущем разделе мы узнали, что все значения в Python являются в некотором смысле «истинными» или «ложными». Это позволяет применять к ним логические операторы.
Лучше всего это продемонстрировать на примерах с использованием различных логических операторов.
Оператор or с нелогическими значениями
Как вы узнали ранее, оператор or возвращает значение False только в том случае, если оба сравниваемых значения равны False. В противном случае он всегда возвращает True. Например:
result = True or False print(result) # Результат: # True
Теперь давайте отвлечемся от логических значений и применим оператор or к двум целым числам:
result = 0 or 1 print(result) # Результат: # 1
Результат равен 1, потому что в логическом контексте 0 — это False, а 1 — True. Как мы выяснили ранее, результат оператора or может быть False, только если все сравниваемые величины имеют значение False. В данном примере значение 1 в логическом контексте истинно (True), соответственно результат такой же – “истинный” – в логическом смысле.
Рассмотрим теперь другой пример. Давайте применим оператор or к двум «истинным» значениям и посмотрим, что мы получим:
result = 10 or 5 print(result) # Результат: # 10
В качестве результата выведено значение первой величины. Но почему? Это происходит из-за того, что в Python называется сокращенными вычислениями.
Если вкратце, у нас первое значение равно как бы True или “истинно”, а это значит, что результат работы оператора or также будет “True” или то, что считается True. Поэтому значение второй величины даже не рассматривается. И в качестве результата представлено значение первой величины.
Чуть позже мы более подробно рассмотрим сокращенные вычисления.
Оператор and с нелогическими значениями
Давайте повторим приведенные выше примеры, заменив оператор or на оператор and.
Как мы узнали ранее, оператор and возвращает значение True, только если оба сравниваемых значения равны True. В противном случае всегда возвращается значение False. Например:
result = True and False print(result) # Результат: # False
Теперь давайте используем оператор and c целочисленными значениями:
result = 1 and 0 print(result) # Результат: # 0
Результат 0, потому что в логическом контексте 0 — это False, а 1 — True. А результат оператора and может быть True, только если значение всех величин True. Здесь второе значение 0 является False, поэтому и результат False, то есть 0.
Давайте посмотрим на другой пример:
result = 10 and 5 print(result) # Результат: # 5
На этот раз результат равен 5. Но почему не 10?
Первая цифра 10 в логическом контексте означает True. Но для определения результат работы оператора and этого недостаточно. Если следующее значение будет True, то результат тоже True, а если False, то и результат False. Поэтому второе значение также будет проверяться.
Итак, второе значение в данном случае это решающий фактор. Поэтому оно и выведено в качестве результата.
Не пугайтесь, если все это выглядит несколько запутанно: мы вернемся к этому чуть позже. Но прежде давайте рассмотрим пример с оператором not.
Оператор not с нелогическими значениями
Оператор not непосредственно преобразует значения True в False и наоборот. Например:
result = not 10 print(result) # Результат: # False
Результат False, потому что число 10 в логическом смысле это True. А оператор not меняет это значение на противоположенное, то есть на False.
Давайте рассмотрим еще один похожий пример:
result = not 0.0 print(result) # Результат: # True
В логическом смысле 0.0 это False, поэтому оператор not преобразует результат в True.
Теперь давайте поговорим подробней о сокращенных вычислениях.
Сокращенные вычисления и цепочки операторов
В предыдущих примерах мы узнали, как создавать простые логические выражения, объединяя два выражения с логическим оператором. Например:
truth = False or True # Результат: # True
Но в случае необходимости можно создавать более длинные цепочки операторов. Взгляните на следующую цепочку:
v1 or v2 or v2 or ... vN
По определению все это выражение истинно, только если все элементы vn имеют значение True.
Когда Python сталкивается с цепочкой такого типа, значения вычисляются слева направо. Как только одно из значений определяется как False, другие значения не проверяются, поскольку результат автоматически становится False.
Та же логика применима к цепочкам нелогических значений. Результатом является значение, на котором закончилась проверка.
Чтобы это понять, давайте посмотрим несколько примеров:
result = True and True and False and True print(result) # Результат: # False
В этом выражении:
- Python вычисляет первое значение
- То же самое касается второго значения. Так как оно равно True, вычисления продолжаются
- Третье значение — False. Таким образом, все выражение равно False, независимо от того, каковы остальные значения.
Давайте теперь посмотрим на аналогичный пример с нелогическими значениями:
result = 45 and 0 and 322 and 98 print(result) # Результат: # 0
Вычисление данного выражение завершается на числе 0, потому что 0 соответствует значению False. А если в цепочке операторов and есть хоть одно значение False, то все выражение будет равно False. Соответственно, значение, на котором завершится вычисление, и будет результатом. В данном случае это число 0.
Как использовать сокращенные вычисления в Python
Реализация сокращенных вычислений в Python имеет несколько практических применений.
Вот два наиболее распространенных варианта использования:
- изолирование ошибок
- выбор значений по умолчанию
Давайте кратко разберем оба.
Изолирование ошибок при помощи сокращенных вычислений
Давайте поделим одно число на другое:
x = 10 y = 5 result = x / y print(result) # Результат: # 2.0
С этим кодом нет никаких проблем. Это неудивительно, потому что деление чисел — вполне допустимая операция. Но мы знаем из элементарной математики, что на 0 делить нельзя. Если в Python делить на 0, то будет выдана ошибка. Например:
x = 10 y = 0 result = x / y print(result) # Результат: # ZeroDivisionError: division by zero
Подобной ошибки можно избежать при помощи сокращенных вычислений. Из предыдущей секции мы узнали, что вычисление цепочки операторов and прекращается после получения значения False. Давайте используем эту идею, чтобы защититься от деления на 0:
x = 10 y = 0 result = y != 0 and x / y print(result) # Результат: # False
Как можно заметить, хоть в программе и есть деление на 0, но она не рушится. Вместо этого она выдает результат False.
Чтобы это понять, давайте разберем следующее выражение:
y != 0 and x / y
Благодаря сокращенным вычислениям, если y != 0 имеет значение False, результат всего выражения равен False. Смысл в том, что в таком случае выражение справа не вычисляется и деление на ноль никогда не произойдет.
Но в случае, когда y не равен нулю, значение первого выражения равно True, и результатом всего выражения будет результат деления справа.
Например:
x = 10 y = 5 result = y != 0 and x / y print(result) # Результат: # 2.0
Так как y != 0 дает True, вычисления продолжаются, и деление x на y определяет результат всего выражения. Это один из примеров полезного применения сокращенных вычислений в Python.
Прежде чем пойти дальше, давайте взглянем на еще один пример.
Выбор значения по умолчанию при помощи сокращенных вычислений
Еще одно полезное применение сокращенных вычислений – это выбор значений по умолчанию. Рассмотрим следующий пример:
name = "" or "there"
print("Hello", name)
# Результат:
# Hello there
Здесь левая часть выражения является пустой строкой, поэтому по умолчанию выбирается ‘there’. Но почему?
Обратите внимание на это выражение:
"" or "there"
Как мы уже узнали ранее, в логическом контексте пустая строка эквивалентна значению False. В данном случае первая строка дает False, и вычисление переходит на вторую строку, которая и дает результат.
Если первая строка непустая, она в логическом контексте истинна и вычисления останавливаются. В качестве результата возвращается первая строка:
name = "Alice" or "there"
print("Hello", name)
# Результат:
# Hello Alice
Цепочки сравнений
Теперь, когда мы познакомились с операторами сравнения и логическими операторами, можно изучить красивый синтаксис для цепочек сравнений.
Например, давайте проверим, что наше значение меньше 1000 и больше 0:
value = 10 isInRange = value < 1000 and value > 0 print(isInRange) # Результат: # True
Этот код прекрасно работает. Однако его можно сделать более читаемым, объединив оба сравнения в цепочку. Вот как это будет выглядеть:
value = 10 isInRange = 0 < value < 1000 print(isInRange) # Результат: # True
Это выражение легче читать. Кроме того, это похоже на то, как мы определяем диапазоны в математике.
Битовые операторы в Python
В дополнение к основным числовым операторам, о которых мы говорили ранее, в Python есть операторы для выполнения побитовых операций с целыми числами.
Битовые операторы используются гораздо реже, чем основные математические операторы, поэтому мы не особо будем углубляться в детали. Однако полезно знать, что такие операторы существуют.
Вот краткая шпаргалка по битовым операторам в Python:
| Оператор | Пример использования | Имя | Описание |
|---|---|---|---|
| & | a & b | битовое AND (И) | Логическая операция AND между битовыми последовательностями. Производится с каждым битом в соответствующей позиции. |
| | | a | b | битовое OR (ИЛИ) | Логическая операция OR между битовыми последовательностями. Производится с каждым битом в соответствующей позиции. |
| ~ | ~a | битовое NOT (НЕТ) | Логическое отрицание каждого бита в соответствующей позиции в битовой последовательности. |
| ^ | a ^ b | битовое XOR (исключающее OR) | Логическая операция XOR между битовыми последовательностями. Производится с каждым битом в соответствующей позиции. |
| >> | a >> n | сдвиг вправо на n позиций | Каждый бит сдвигается вправо на n позиций. |
| << | a << n | сдвиг влево на n позиций | Каждый бит сдвигается влево на n позиций. |
Операторы тождественности
В языке Python вы можете проверить уникальный идентификатор объекта с помощью функции id(). Например, чтобы проверить, ссылаются ли две переменные на один и тот же объект, проверьте, совпадают ли их идентификаторы.
Наприемер:
x = 10 y = x print(id(x) == id(y)) # Результат: # True
Это показывает, что переменные x и y указывают на один и тот же объект в памяти.
Но вместо функции id() можно использовать два специальных оператора: is и is not. При помощи оператора is можно убедиться, что два объекта имеют одинаковый идентификатор. Оператор is not поможет удостовериться, что два объекта имеют разные идентификаторы.
Давайте перепишем приведенный выше пример, используя оператор is:
x = 10 y = x print(x is y) # Результат: # True
Этот подход чище и легче читается по сравнению с использованием функции id().
Предупреждение: не используйте оператор is для проверки равенства. Используйте его только для того, чтобы узнать, ссылаются ли две переменные на один и тот же объект в памяти!
Теперь, когда вы познакомились со всеми основными операторами Python, давайте обсудим порядок их вычисления или, иными словами, приоритет этих операторов.
Приоритет операторов
Как вы узнали в начальной школе, не все математические операторы одинаковы. Операторы + и – применяются после * или / (то есть сначала производится умножение или деление, а затем сложение или вычитание).
Понятие, определяющее порядок вычисления операторов, называется приоритетом. Приоритет показывает, какой оператор выполняется вначале. Та же логика используется и в языке Python. Например:
result = 1 + 10 * 3 - 8 / 2 print(result) # Результат: # 27.0
Давайте визуализируем приоритет этих операций при помощи скобок:
result = 1 + (10 * 3) - (8 / 2)
= 1 + 30 - 4
= 27
Важно понимать приоритет арифметических операций. Также полезно знать приоритет логических операторов (OR, AND, NOT). Приоритет остальных операторов не так важен.
Ниже представлен список всех операторов в порядке убывания приоритетности (чем ниже оператор в списке, тем ниже у него приоритет):
**+x, -x, ~x*, /, //, %+, -<<, >>&^|is, is not, <, <=, >, >=, !=, ==notandor
Заключение
В этом руководстве мы разобрали все операторы в Python. Арифметические операторы позволяют выполнять базовые математические операции. Операторы сравнения – сравнивать данные. Логические операторы – подключать логические выражения, например сравнения. Битовые операторы дают возможность работать с целыми числами на битовом уровне. Операторы тождественности позволяют проверить, являются ли два объекта одним и тем же объектом в памяти.
Все операторы в Python имеют определенный приоритет. Он определяет, какие операции выполняются первыми, если используется несколько операторов.
Спасибо за внимание!
Перевод статьи Artturri Jalli “Operators in Python: Arithmetic, Logical, Comparison [2022]”.
Пингбэк: Конкатенация строк в Python
Пингбэк: Инкремент и декремент значений в Python
Пингбэк: Операторы in и not in в Python
Пингбэк: Как проверить, содержит ли строка подстроку