Операторы в Python

В этой статье мы поговорим про различные операторы в 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 logo

Английский для программистов

Наш телеграм канал с тестами по английскому языку для программистов. Английский это часть карьеры программиста. Поэтому полезно заняться им уже сейчас

×

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

В дополнение к стандартным числовым операциям в 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 == ba равняется b
a < ba строго меньше чем b
a <= ba меньше либо равно b
a != ba не равняется b
a > ba строго больше чем b
a >= ba больше либо равно 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».