Операторы Python: для чего они нужны и какими бывают
2026-02-21 06:01 Diff
https://skillbox.ru/media/code/operatory-python-dlya-chego-oni-nuzhny-i-kakimi-byvayut/

#статьи

  • 2 апр 2024
  • 0

Всё, что может когда-либо пригодиться питонисту при работе с числами, строками и логическими значениями, — в одной статье.

Иллюстрация: Оля Ежак для Skillbox Media

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

В 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.

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

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

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

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

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

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

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

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

Оператор, обратный 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.

Возвращает 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. Несмотря на то что переменные имеют одинаковое значение, они ссылаются на разные объекты в памяти.

Возвращает 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 соответственно.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Python для всех

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

Пройти бесплатно

Бесплатный курс по разработке на Python ➞
Пройдите бесплатный курс по Python и создайте с нуля телеграм-бот, веб-парсер и сайт. Спикер — руководитель отдела разработки в «Сбере». Пройти курс