Операторы в Python: виды и примеры

Оператор в Python — это символ или ключевое слово, которое выполняет действие над одним или несколькими значениями: складывает числа, сравнивает объекты, проверяет условие. Значения, с которыми работает оператор, называют операндами. В 2 + 3 число 2 и число 3 — операнды, + — оператор.

Операторы делятся на семь групп по типу действия: арифметические, сравнения, логические, присваивания, битовые, принадлежности и тождественности. Ниже — каждая группа с таблицей и рабочим кодом.

Группы операторов Python

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

Работают с числами, а + и * дополнительно определены для строк и списков (конкатенация и повтор).

a, b = 17, 5
print(a + b)    # 22
print(a - b)    # 12
print(a * b)    # 85
print(a / b)    # 3.4
print(a // b)   # 3
print(a % b)    # 2
print(a ** b)   # 1419857

/ и // для отрицательных чисел ведут себя не так, как в C или Java: // округляет результат к минус бесконечности, а не к нулю.

print(-7 / 2)    # -3.5
print(-7 // 2)   # -4, а не -3

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

Результат сравнения — всегда True или False.

x, y = 10, 20
print(x == y)               # False
print(x != y)                # True
print(x < y)                 # True
print("apple" < "banana")    # True, сравнение строк идет лексикографически

В Python можно записать цепочку сравнений подряд, и она читается как последовательность условий, соединенных через and:

n = 7
print(1 < n < 10)   # True, эквивалентно (1 < n) and (n < 10)

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

Всего три: and, or, not. Работают со значениями, которые Python приводит к истине или лжи, а не только с явными True/False.

and и or работают по короткому замыканию: and останавливается на первом ложном операнде, or — на первом истинном, и правая часть выражения может вообще не выполниться.

def check(name):
    print(f"проверяю {name}")
    return False

result = check("a") and check("b")

В консоли появится только одна строка:

проверяю a

Вызов check("b") не произойдет: and уже получил False от первого операнда и вернул его без дальнейших вычислений.

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

Простое присваивание = записывает значение в переменную. Составные операторы (+=, -= и другие) сокращают запись «переменная = переменная действие значение».

counter = 10
counter += 5     # 15
counter *= 2     # 30
counter //= 4    # 7, потому что 30 // 4 = 7
print(counter)   # 7

Отдельно стоит оператор := (walrus, «морж») — он появился в Python 3.8 и делает не то же самое, что =. Это не оператор-инструкция, а выражение: он присваивает значение и одновременно возвращает его, поэтому его можно использовать внутри условия:

data = [1, 2, 3, 4, 5]
if (n := len(data)) > 3:
    print(f"элементов: {n}")   # элементов: 5

Без := пришлось бы сначала посчитать len(data) отдельной строкой, а потом использовать переменную в if.

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

Работают только с целыми числами: переводят их во внутреннее двоичное представление и обрабатывают побитово.

a, b = 12, 10   # 1100 и 1010 в двоичном виде
print(a & b)    # 8   (1000)
print(a | b)    # 14  (1110)
print(a ^ b)    # 6   (0110)
print(~a)       # -13, дополнение до двух: ~x равно -x-1
print(a << 2)   # 48, сдвиг влево на 2 равен умножению на 4
print(a >> 2)   # 3,  сдвиг вправо на 2 равен целочисленному делению на 4

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

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

Проверяют, есть ли значение в последовательности — списке, кортеже, строке, множестве или словаре (по ключам).

fruits = ["apple", "banana", "cherry"]
print("banana" in fruits)       # True
print("mango" in fruits)        # False
print("mango" not in fruits)    # True
print("an" in "banana")         # True, in работает и как проверка подстроки

Тождественность: is — и чем это отличается от ==

Здесь легко перепутать два разных вопроса. == спрашивает «одинаковые ли значения», is спрашивает «один ли это объект в памяти». Для изменяемых объектов разница видна сразу:

a = [1, 2, 3]
b = [1, 2, 3]
c = a

print(a == b)   # True: значения списков совпадают
print(a is b)   # False: это два разных объекта
print(a is c)   # True: c ссылается на тот же объект, что и a

Частая ошибка новичков — сравнивать числа через is вместо ==, потому что на маленьких значениях это иногда «работает». CPython кеширует некоторые небольшие целые числа, и для них is может случайно вернуть True, но это деталь конкретной реализации интерпретатора, а не гарантия языка. Она зависит от версии и точного места в коде, поэтому в фактчек этой статьи вынесены только общие рамки поведения, а не конкретные числа для каждой версии. Практический вывод один: для сравнения значений всегда используйте ==, а is — только там, где действительно нужно проверить тождество объекта, например if value is None.

is not работает симметрично: возвращает True, если это разные объекты.

Приоритет операторов

Когда в выражении несколько операторов, Python выполняет их не слева направо вслепую, а по приоритету — как в математике со скобками.

result = 2 + 3 * 4 ** 2
print(result)   # 50: сначала 4**2=16, потом 3*16=48, потом 2+48=50

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

Выводы

• Оператор — символ или слово, выполняющее действие над операндами; в Python семь групп операторов.
• / всегда дает float, // — целочисленное деление к минус бесконечности, а не к нулю.
• and/or работают по короткому замыканию и могут не вычислить правый операнд.
• == сравнивает значения, is — тождество объекта в памяти; для чисел и строк по умолчанию используйте ==.
• := (Python 3.8+) — это выражение присваивания, а не замена обычному =.

Где применяется / связь с практикой

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

FAQ

Чем / отличается от // для отрицательных чисел?
/ всегда возвращает точное значение с плавающей точкой: -7 / 2 равно -3.5. // округляет результат вниз, к минус бесконечности, а не к нулю: -7 // 2 равно -4, а не -3.

Можно ли добавить в Python свой оператор или изменить поведение существующего?
Новый символ-оператор добавить нельзя, но можно переопределить поведение существующих операторов для своего класса через специальные методы, например __add__ для + или __eq__ для ==. Это отдельная тема (перегрузка операторов), выходящая за рамки базового синтаксиса.

Работают ли операторы сравнения со списками и кортежами?
Да. Python сравнивает последовательности поэлементно слева направо, как строки: [1, 2, 3] < [1, 2, 4] дает True, потому что сравнение доходит до третьего элемента, и там 3 меньше 4.