Операторы Python: для чего они нужны и какими бывают

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

Содержание

• Арифметические операторы
• Операторы сравнения
• Операторы присваивания
• Логические операторы
• Операторы принадлежности
• Операторы тождественности
• Битовые операторы

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

Выполняют арифметические операции над числами: складывают, вычитают, умножают, делят и так далее.

Операции можно производить непосредственно над числами или переменными, которым присвоено числовое значение. Полученный результат можно вывести на экран или присвоить переменной.

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

+ (сложение)

Складывает два числа:

x = 5
y = 7
print(x + y)  # Возвращает: 12
x = 5.2
print(x + y)  # Возвращает: 12.2
y = 7.8
print(x + y)  # Возвращает: 13.0

- (вычитание)

Вычитает одно число из другого:

x = 10
y = 3
print(x - y)  # Возвращает: 7
x = 10.0
print(x - y)  # Возвращает: 7.0

* (умножение)

Используется для умножения двух чисел:

x = 4
y = 2
print(x * y)  # Возвращает: 8
x = 4.15
print(x * y)  # Возвращает: 8.3

/ (деление)

Делит одно число на другое и возвращает результат в виде числа с плавающей точкой:

x = 15
y = 5
print(x / y)  # Возвращает: 3.0

// (целочисленное деление)

Делит первое число на второе и возвращает только целую часть результата:

x = 17
y = 4
print(x // y)  # Возвращает: 4

% (остаток от деления)

Возвращает остаток от деления одного числа на другое:

x = 18
y = 7
print(x % y)  # Возвращает: 4

** (возведение в степень)

Используется для возведения числа в степень:

x = 2
y = 3
print(x ** y)  # Возвращает: 8

Операторы + и * также могут работать со строками. + можно использовать для склеивания (конкатенации) строк, а * — для повторения строки заданное количество раз:

print('Привет, ' + 'мир!')  # Возвращает: 'Привет, мир!'
print('Привет! ' * 3)  # Возвращает: 'Привет! Привет! Привет! '

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

С помощью сравнения в Python можно выяснить, равны ли два объекта или один из них больше/меньше другого. При этом сравниваемые объекты должны быть одного типа, иначе в программе возникнет ошибка TypeError.

Операторы сравнения используются в условных выражениях для принятия решений и управления ходом программы.

Далее перечислим их все.

== (равенство)

Проверяет, равны ли два значения. Если да, то оператор возвращает True, в противном случае — False.

x = 5
y = 3
print(x == y)  # Вернёт: False

! = (неравенство)

Также проверяет равенство двух значений, но возвращает True, если значения не равны, и False — в противном случае.

x = 5
y = 3
print(x != y)  # Вернёт: True

> (больше)

Если левое значение больше правого, то оператор возвращает True, иначе — False.

x = 5
y = 3
print(x > y)  # Вернёт: True

< (меньше)

Если левое значение меньше правого, то оператор возвращает True, иначе — False.

x = 5
y = 3
print(x < y)  # Вернёт: False

>= (больше или равно)

Если левое значение больше или равно правому, то оператор возвращает True, иначе — False.

x = 5
y = 5
print(x >= y)  # Вернёт: True

<= (меньше или равно)

Если левое значение меньше или равно правому, то оператор возвращает True, иначе — False.

x = 5
y = 7
print(x <= y)  # Вернёт: True

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

Например:

x = 5
y = 10
z = 15

# Проверяем, меньше ли x и y, чем z
print(x < y < z)  # Вернёт: True

# Проверяем, равны ли все значения
print(x == y == z)  # Вернёт: False

# Проверяем, больше ли y, чем z и x
print(x < y > z)  # Вернёт: False

Выражение x < y > z возвращает False, так как хоть y больше x, но y не больше z, поэтому второе сравнение возвращает False. В итоге всё выражение возвращает False.

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

Чаще всего для присваивания мы используем стандартный оператор =, но есть и другие варианты, которые упрощают и даже ускоряют код.

= (обычное присваивание)

Присваивает значение справа переменной слева:

x = 5
print(x)  # Вернёт: 5

+= (плюс равно)

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

x = 5
x += 3  # Эквивалентно x = x + 3
print(x)  # Вернёт: 8

-= (минус равно)

Вычитает значение, расположенное справа, из переменной слева, а затем присваивает результат переменной:

x = 5
x -= 3  # Эквивалентно x = x - 3
print(x)  # Вернёт: 2

*= (умножить равно)

Оператор умножает значение слева на значение справа, а потом присваивает результат переменной:

x = 5
x *= 3  # Это эквивалентно x = x * 3
print(x)  # Вернёт: 15

/= (делить равно)

Оператор делит значение слева на значение справа, а затем присваивает результат переменной:

x = 10
x /= 2  # Это эквивалентно x = x / 2
print(x)  # Вернёт: 5.0

Аналогично работают операторы //=, **=, %= для целочисленного деления, возведения в степень и построения остатка соответственно.

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

Используются для выполнения логических операций (часто вместе с операторами сравнения), возвращающих True или False.

and — логическое И

Если оба условия истинны, то оператор возвращает True, в противном случае — False:

x = 5
print(x > 1 and x < 10) # Вернёт: True, потому что 5 больше 1 и меньше 10

or — логическое ИЛИ

Если хотя бы одно из условий истинно, оператор возвращает True. Если оба условия ложные — False:

x = 5
print(x < 1 or x > 10) # Вернёт: False, потому что 5 не меньше 1 и не больше 10

not — логическое НЕ

not меняет логическое значение условия, перед которым он стоит, на противоположное (инвертирует). Другими словами, если значение выражения равно True, то оператор вернёт False и наоборот.

x = 5
print(not(x > 1 and x < 10)) # Вернёт: False, потому что 5 больше 1 и меньше 10, но оператор not инвертировал значение.

Эти операторы часто используются в условиях и циклах, которые выполняют код при выполнении определённого условия.

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

Операторы принадлежности в Python используются для проверки присутствия элемента в коллекции (списках, кортежах, множествах, словарях) или в строке. Эти операторы возвращают True или False в зависимости от результата. В Python существуют два оператора принадлежности: in и not in.

Оператор in

Проверяет, присутствует ли элемент в коллекции. Если присутствует, оператор возвращает True, в противном случае — False.

my_list = [1, 2, 3, 4, 5]
print(3 in my_list)  # Вернёт: True
   
my_string = 'Hello, world!'
print('planet' in my_string)  # Вернёт: False

Оператор not in

Оператор, обратный in. Проверяет, отсутствует ли элемент в коллекции. Если отсутствует, возвращает True, иначе — False:

my_list = [1, 2, 3, 4, 5]
print(6 not in my_list)  # Вернёт: True
   
my_string = 'Hello, world!'
print('world' not in my_string)  # Вернёт: False

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

Если операторы сравнения позволяют выяснить, равны ли значения двух переменных, то с помощью операторов тождественности можно проверить, ссылаются ли они на один и тот же объект.

В отличие от операторов равенства операторы тождественности можно использовать для сравнения разнотипных объектов — это не вызовет ошибку typeError.

Оператор is 

Возвращает True, если оба операнда указывают на один и тот же объект в памяти, иначе возвращает False:

a = [1, 2, 3]
b = a  # 'b' теперь ссылается на тот же объект, что и 'a'
c = [1, 2, 3]

print(a is b)  # Вернёт: True
print(a is c)  # Вернёт: False, хотя 'a' и 'c' имеют одно и то же значение

В этом примере выражение a is c возвращает False. Несмотря на то что переменные имеют одинаковое значение, они ссылаются на разные объекты в памяти.

Оператор is not

Возвращает True, если оба операнда указывают на разные объекты, иначе возвращает False:

a = [1, 2, 3]
b = a  # 'b' теперь ссылается на тот же объект, что и 'a'
c = [1, 2, 3]

print(a is not b)  # Вернёт: False
print(a is not c)  # Вернёт: True

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

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

Главное при работе с битовыми операциями — помнить, что они сравнивают попарно каждые биты двух чисел. Рассмотрим битовые операции на примере чисел 10 и 4. Их двоичные представления — 1010 и 0100 соответственно.

& — оператор AND

В битовом И, если оба бита равны 1, итоговый бит тоже будет 1. В противном случае — 0.

В случае с 10 & 4 (1010 & 0100 в двоичном представлении), результат будет 0, так ни одна пара битов этих чисел не даёт 1 при логическом умножении:

print(10 & 4)  # Результат будет 0

| — оператор OR

Если хотя бы один из битов в двух числах равен 1, результат будет равен 1, иначе — 0.

Выражение 10 | 4 вернёт 14 (1110 в двоичном представлении), так как только два последних бита в обоих числах равны 0:

print(10 | 4)  # Результат равен 14
print(bin(0b1010 | 0b0100)) # Результат равен 0b1110

^ — оператор XOR

Операция «исключающее ИЛИ» возвращает 1, если только один из битов в двух числах равен 1, иначе — 0.

Выражение 10 ^ 4 вернёт 14 (1110), так как в первом и втором числах только последние биты имеют значения 0:

print(10 ^ 4)  # Результат равен 14
print(bin(0b1010 ^ 0b0100)) # Результат равен 0b1110

~ — оператор NOT

Оператор НЕ инвертирует все биты. Например, ~10 (~1010 в двоичном представлении) будет равно 0101:

print(~10)  # Результат равен 11
print(bin(~0b1010)) # Результат равен 0b101

<< — Left Shift

Сдвигает биты числа на указанное количество позиций влево. Например, если сдвинуть число 1010 (10 в десятичном представлении) на две позиции влево (1010 << 2), это даст 101000 (40), так как два наименьших бита обнулятся:

print(10 << 2) # Результат равен 40
print(bin(0b1010 << 2)) # Результат равен 0b101000

>> — Right Shift

Сдвигает биты числа на указанное количество позиций вправо. Например, если сдвинуть число 1010 (10 в десятичном представлении) на две позиции вправо (1010 >> 2), то получится 0010 (2 в десятичном представлении), потому что два крайних правых бита обнулятся:

print(10 >> 2) # Результат равен 2
print(bin(0b1010 >> 2)) # Результат равен 0b10

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

В заключение

Мы рассмотрели основные группы операторов в Python: арифметические, сравнения, присваивания, битовые, логические, принадлежности и тождественности.

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