В этой статье мы поговорим про различные операторы в Python. Мы на примерах разберем арифметические, битовые и логические операторы, а также операторы присваивания и сравнения. Кроме того, мы рассмотрим операторы принадлежности и идентичности, такие как is, is not и in, not in.

Арифметические операторы

Python реализует семь основных бинарных арифметических операторов, два из которых могут использоваться как унарные операторы. Они приведены в следующей таблице:

Оператор	Название	Описание
a + b	Сложение	Сумма a и b
a — b	Вычитание	Разность a и b
a * b	Умножение	Произведение a и b
a / b	Деление	Частное a и b
a // b	Целочисленное деление	Деление a на b без остатка (дробная часть отбрасывается)
a % b	Взятие модуля	Целый остаток от деления a на b
a ** b	Возведение в степень	a, возведенное в степень b
-a	Отрицание	Отрицательное значение a
+a	Унарный плюс	а без изменений (используется редко)

Эти операторы можно использовать и комбинировать интуитивно понятным образом, используя стандартные круглые скобки для группировки операций. К примеру, это может выглядеть так:

# сложение, вычитание, умножение (4 + 8) * (6.5 - 3) # 42.0

Целочисленное деление — это обычное деление, только с усечённой дробной частью:

# Деление print(11 / 2) # 5.5 # Целочисленное деление print(11 // 2) # 5

Оператор целочисленного деления был добавлен в Python 3. Если вы работаете в Python 2, вы должны знать, что стандартный оператор деления (/) действует как оператор целочисленного деления для целых чисел и как обычный оператор деления для чисел с плавающей запятой.

Наконец, упомянем ещё один арифметический оператор, который был добавлен в Python 3.5. Это оператор a @ b, предназначенный для указания матричного произведения a и b для использования в различных пакетах линейной алгебры.

Марк Лутц «Изучаем Python»

Скачивайте книгу у нас в телеграм

Скачать ×

Битовые операторы

В дополнение к стандартным числовым операциям в Python есть операторы для выполнения побитовых логических операций над целыми числами. Они используются гораздо реже стандартных арифметических операций, но знать их полезно. Шесть побитовых операторов сведены в следующую таблицу:

Оператор	Название	Описание
a & b	Логическое И	Биты, определенные как в a, так и в b
a | b	Логическое ИЛИ	Биты, определенные в a или b или в обоих
a ^ b	Исключающее ИЛИ	Равен 1, если только a или только b равно 1
a << b	Побитовый сдвиг влево	Сдвинуть биты a влево на b единиц
a >> b	Побитовый сдвиг вправо	Сдвинуть биты a вправо на b единиц
~a	Логическое НЕ	Отрицание a

Эти побитовые операторы имеют смысл только с точки зрения двоичного представления чисел. Это можно увидеть, используя встроенную функцию bin:

bin(10) # '0b1010'

Результат имеет префикс 0b, что указывает на двоичное представление. Остальные цифры означают, что число 10 выражается как сумма 1⋅23+0⋅22+1⋅21+0⋅20. Точно так же мы можем написать:

bin(4) # '0b100'

Теперь, используя логическое ИЛИ, мы можем найти число, которое объединяет биты 4 и 10:

4 | 10 # 14 bin(4 | 10) # '0b1110'

Эти побитовые операторы не так полезны, как стандартные арифметические операторы, но стоит увидеть их хотя бы раз, чтобы понять, какой класс операций они выполняют. В частности, у пользователей других языков иногда возникает соблазн использовать исключающее ИЛИ (т. е. a ^ b), на самом деле имея в виду возведение в степень (т. е. a ** b).

Операторы присваивания

Мы видели, что переменным можно присваивать значение с помощью оператора =. Например, следующим образом:

a = 24 print(a) # 24

Мы можем использовать эти переменные в выражениях с любым из упомянутых ранее операторов. Например, чтобы добавить 2 к a, мы пишем:

a + 2 # 26

Мы можем захотеть обновить переменную a новым значением. В этом случае мы могли бы объединить сложение и присваивание и написать a = a + 2. Поскольку этот тип комбинированной операции и присваивания очень распространен, Python включает встроенные операторы обновления для всех арифметических операций:

a += 2  # эквивалентно a = a + 2 print(a) # 26

Расширенный оператор присваивания есть для каждого из бинарных операторов, перечисленных ранее. Они выглядят следующим образом:

a += b    a -= b    a *= b    a /= b  a //= b    a %= b    a **= b    a &= b  a |= b    a ^= b    a <<= b    a >>= b

Каждый из этих операторов эквивалентен применению соответствующего оператора с последующим присваиванием. То есть для любого оператора ■ выражение a ■= b эквивалентно a = a ■ b с небольшой оговоркой.

Для изменяемых объектов, таких как списки, массивы или датафреймы, эти расширенные операции присваивания на самом деле немного отличаются от своих более подробных аналогов. Они изменяют содержимое исходного объекта, а не создают новый объект для хранения результата. Но это тонкости, в целом же укороченная версия работает так же, как и полная, но экономит кучу вашего времени.

Операторы сравнения

Другой тип операций, который может быть очень полезным, — это сравнение различных переменных. Для этого в Python реализованы стандартные операторы сравнения, которые возвращают логические значения True или False. Операции сравнения представлены в следующей таблице:

Оператор	Описание
a == b	a равняется b
a < b	a строго меньше чем b
a <= b	a меньше либо равно b
a != b	a не равняется b
a > b	a строго больше чем b
a >= b	a больше либо равно b

Эти операторы сравнения можно комбинировать с арифметическими и побитовыми операторами, чтобы осуществлять самые разнообразные операции над числами. Например, мы можем проверить, является ли число нечетным, проверив, что остаток от деления на 2 возвращает 1:

# 25 - нечетное число 25 % 2 == 1 # True # 66 - нечетное число 66 % 2 == 1 # False

Мы можем объединить несколько сравнений, чтобы проверить более сложные отношения:

# проверяем, находится ли a между 15 и 30 a = 25 15 < a < 30 # True

И, чтобы у вас немного закружилась голова, взгляните на это сравнение:

-1 == ~0 # True

Напомним, что ~ — это оператор инвертирования битов, и, очевидно, когда вы инвертируете все биты нуля, вы получите -1. Если вам интересно, почему это так, посмотрите схему кодирования целых чисел с дополнением до двух, которую Python использует для кодирования целых чисел со знаком, и подумайте, что происходит, когда вы начинаете переворачивать все биты целых чисел, закодированных таким образом.

От редакции Pythonist: об операторе != можно почитать в статье «Оператор неравенства != в Python».

Логические операторы

При работе с логическими значениями Python предоставляет операторы для объединения значений с использованием стандартных понятий «и», «или» и «не». Эти операторы ожидаемо представлены словами and, or и not:

x = 4 (x < 6) and (x > 2) # True (x > 10) or (x % 2 == 0) # True not (x < 6) # False

Поклонники булевой алгебры могут заметить, что оператор исключающего ИЛИ не включен. Он, конечно, может быть построен несколькими способами путем составления других операторов. Или же вы можете использовать хитрый трюк:

# (x > 1) xor (x < 10) (x > 1) != (x < 10) # False

Иногда в языке возникает путаница: когда использовать логические операторы (and, or, not), а когда побитовые (&, |, ~). Ответ кроется в их названиях: логические операторы следует использовать, когда вы хотите вычислить логические значения (т.е. истинность или ложность) утверждений. Побитовые операции следует использовать, когда вы хотите работать с отдельными битами или компонентами рассматриваемых объектов.

Операторы принадлежности и идентичности

Помимо and, or и not, Python также имеет операторы для проверки принадлежности и идентичности. Они следующие:

Оператор	Описание
a is b	Возвращает True, если a и b — идентичные объекты
a is not b	Возвращает True, если a и b — не идентичные объекты
a in b	Возвращает True, если a содержится в b
a not in b	Возвращает True, если a не содержится в b

Операторы is и is not проверяют идентичность объекта. Идентичность объекта отличается от равенства, как мы видим здесь:

a = [1, 2, 3] b = [1, 2, 3] a == b # True a is b # False a is not b # True

Как выглядят одинаковые объекты? Вот пример:

a = [1, 2, 3] b = a a is b # True

Разница между этими двумя случаями в том, что в первом a и b указывают на разные объекты, а во втором они указывают на один и тот же объект. Оператор is проверяет, указывают ли две переменные на один и тот же контейнер (объект), а не на то, что содержит контейнер.

Новички часто испытывают искушение использовать is, хотя на самом деле имеют в виду ==. Подробнее о разнице между == и is можно почитать в статье «Чем == отличается от is?«.

Операторы принадлежности проверяют принадлежность к составным объектам. Так, например, мы можем написать:

1 in [1, 2, 3] # True 2 not in [1, 2, 3] # False

Эти операции членства являются примером простоты Python по сравнению с языками более низкого уровня, такими как C. В языке C членство обычно определяется путем ручного построения цикла по списку и проверки равенства каждого значения. В Python вы просто печатаете то, что хотите узнать, в манере, напоминающей простой текст.

Заключение

Итак, сегодня мы разобрали на примерах различные операторы в Python. Надеемся вам было полезно! Успехов в написании кода!

Перевод статьи «Basic Python Semantics: Operators».