Операторы в Python

Оператор в Python — символ или ключевое слово, которое выполняет действие над значениями (операндами): складывает числа, сравнивает их, проверяет вхождение в коллекцию или присваивает результат переменной. Операторы делятся на группы: арифметические, сравнения, логические, побитовые, присваивания (включая моржовый :=), принадлежности in, тождественности is и тернарный if … else. Порядок их выполнения задаёт приоритет: в 7 + 3 * 2 сначала выполняется умножение.

total = 7 + 3 * 2
print(total)                               # → 13
print(total > 10 and total % 2 == 1)       # → True
print("py" in "python")                    # → True

Ниже каждая группа разобрана с примерами, а в конце — полная таблица приоритета и перегрузка операторов в своих классах. Все примеры проверены на Python 3.12; вывод показан комментарием # →. Краткий обзор остального синтаксиса языка — в шпаргалке по синтаксису Python.

Какие операторы есть в Python

Группа	Операторы	Пример	Результат
Арифметические	+, -, *, /, //, %, **, @	17 // 5	3
Сравнения	==, !=, <, >, <=, >=	3 != 4	True
Логические	and, or, not	not 0	True
Побитовые	&, |, ^, ~, <<, >>	12 & 10	8
Присваивания	=, +=, -=, *=, /=, //=, %=, **= и другие	x += 1	—
Присваивающее выражение	:= (моржовый)	(n := 5) > 3	True
Принадлежности	in, not in	3 in [1, 2, 3]	True
Тождественности	is, is not	x is None	True
Условное выражение	a if условие else b	1 if 0 else 2	2

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

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

Оператор	Действие	Пример	Результат
+	сложение	17 + 5	22
-	вычитание	17 - 5	12
*	умножение	17 * 5	85
/	деление, результат всегда float	17 / 5	3.4
//	целочисленное деление	17 // 5	3
%	остаток от деления	17 % 5	2
**	возведение в степень	17 ** 2	289
-x, +x	унарный минус и плюс	-(-5)	5

Деление // и % с отрицательными числами

Оператор // округляет результат вниз, к минус бесконечности, а не к нулю, как в C или Java. Остаток % получает знак делителя. Эти два оператора всегда согласованы: a == (a // b) * b + a % b.

print(-17 // 5, -17 % 5)  # → -4 3
print(17 // -5, 17 % -5)  # → -4 -3
print(7.5 // 2, 7.5 % 2)  # → 3.0 1.5   с float результат тоже float
print(divmod(-17, 5))     # → (-4, 3)   частное и остаток за один вызов

На практике % чаще всего проверяет чётность (n % 2 == 0) и делимость, а // с % вместе переводят единицы: секунды в минуты и секунды, копейки в рубли. Деление на ноль любым из операторов /, //, % выбрасывает ZeroDivisionError. Подробнее о числах, округлении и погрешности float — в статье про числа в Python: int и float.

Степень ** и унарный минус

Возведение в степень выполняется раньше унарного минуса слева от него, поэтому -2 ** 2 равно -4. Цепочка степеней вычисляется справа налево.

print(-2 ** 2, (-2) ** 2)  # → -4 4
print(2 ** 3 ** 2)         # → 512   то есть 2 ** 9
print(2 ** -1)             # → 0.5

+ и * для строк и списков

Для последовательностей + означает склеивание, а * — повторение. Складывать строку с числом нельзя: Python не преобразует типы сам.

print("ab" + "cd", "-" * 10)     # → abcd ----------
print([1, 2] + [3], [0] * 3)     # → [1, 2, 3] [0, 0, 0]
print("5" + 5)
# → TypeError: can only concatenate str (not "int") to str

Нужное преобразование делают явно: int("5") + 5 или "5" + str(5).

Оператор @ (матричное умножение, Python 3.5+) встроенные типы не поддерживают — он нужен библиотекам вроде NumPy: a @ b перемножает матрицы.

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

Сравнение возвращает True или False.

Оператор	Значение	Пример	Результат при x = 15
==	равно	x == 15	True
!=	не равно	x != 15	False
>	больше	x > 10	True
<	меньше	x < 10	False
>=	больше или равно	x >= 15	True
<=	меньше или равно	x <= 10	False

Сравнения объединяются в цепочку, как в математике: a < b < c означает a < b and b < c, причём b вычисляется один раз.

x = 15
print(10 < x < 20)  # → True
print(1 < 3 > 2)    # → True   то есть 1 < 3 and 3 > 2

Строки сравниваются посимвольно по кодам Unicode, списки и кортежи — поэлементно слева направо:

print("apple" < "banana")   # → True
print("Z" < "a")            # → True   заглавные буквы идут раньше строчных
print("10" < "9")           # → True   сравниваются символы "1" и "9", а не числа
print([1, 2, 3] < [1, 3])   # → True   решает второй элемент: 2 < 3

Числа разных типов сравниваются по значению, а число со строкой — нет: == вернёт False, а < и > выбросят ошибку.

print(1 == 1.0, 1 == "1")  # → True False
print(True == 1)           # → True   bool — подкласс int
print("10" > 9)
# → TypeError: '>' not supported between instances of 'str' and 'int'

Такая ошибка обычно возникает со значением из input(): функция всегда возвращает строку, и перед сравнением её переводят в число через int(). Дробные числа не сравнивайте через ==: 0.1 + 0.2 == 0.3 даёт False из-за двоичного представления, правильная проверка — math.isclose(0.1 + 0.2, 0.3).

Логические операторы and, or, not

Оператор	Результат	Пример	Результат
and	истина, если истинны оба операнда	True and False	False
or	истина, если истинен хотя бы один	True or False	True
not	отрицание	not True	False

Операндами могут быть любые значения, не только True и False. Ложью считаются 0, 0.0, пустая строка, пустые коллекции и None, всё остальное — истина.

and и or возвращают операнд

and и or возвращают не True/False, а один из операндов: and — первый ложный или последний, or — первый истинный или последний. Только not всегда возвращает bool.

print(0 and 5, 3 and 5)         # → 0 5
print(0 or 5, 3 or 5)           # → 5 3
print(not 0, not "текст")       # → True False

name = ""
print(name or "Гость")          # → Гость   значение по умолчанию

Приём value or default удобен для пустых строк и None, но подставит значение по умолчанию и вместо законного 0. Если ноль допустим, пишите явно: value if value is not None else default.

Короткое замыкание

Python вычисляет правый операнд, только если результат ещё не ясен. Если левая часть and ложна, правая не выполняется — это защищает от ошибок:

user = None
if user is not None and user.startswith("a"):
    print("ok")
else:
    print("нет пользователя")  # → нет пользователя

Без проверки user is not None вызов user.startswith() выбросил бы AttributeError.

Ошибка: x == “да” or “ок”

Частая ошибка — сравнить переменную с несколькими вариантами через or:

answer = "нет"
print(answer == "да" or "ок")   # → ок   непустая строка истинна, условие сработает всегда
print(answer in ("да", "ок"))   # → False

Python читает первую строку как (answer == "да") or "ок". Для проверки «равно одному из» используйте in. Как условия работают в if, elif и else, разобрано в статье условия if, elif, else в Python.

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

Побитовые операторы работают с целыми числами как с последовательностью двоичных разрядов. Двоичную запись показывает функция bin().

Оператор	Действие	Пример (a = 12, b = 10)	Результат
&	И: бит равен 1, если он 1 в обоих числах	a & b	8
|	ИЛИ: бит равен 1 хотя бы в одном числе	a | b	14
^	исключающее ИЛИ: бит равен 1 ровно в одном	a ^ b	6
~	инверсия всех битов, равна -x - 1	~a	-13
<<	сдвиг влево, умножение на 2 в степени n	a << 2	48
>>	сдвиг вправо, деление нацело на 2 в степени n	a >> 2	3

a, b = 12, 10
print(bin(a), bin(b))                       # → 0b1100 0b1010
print(bin(a & b), bin(a | b), bin(a ^ b))   # → 0b1000 0b1110 0b110
print(~a, a << 2, a >> 2)                   # → -13 48 3
print(-12 >> 1)                             # → -6

Типичное применение — набор флагов в одном числе:

READ, WRITE, EXEC = 1, 2, 4
perms = READ | WRITE                         # включить два флага
print(perms, bool(perms & WRITE), bool(perms & EXEC))  # → 3 True False
perms |= EXEC                                # добавить флаг
perms &= ~WRITE                              # снять флаг
print(perms, bin(perms))                     # → 5 0b101

Проверка n & 1 возвращает 1 для нечётных чисел и 0 для чётных.

Те же знаки для множеств и словарей

У множеств &, |, - и ^ дают пересечение, объединение, разность и симметричную разность. Словари с Python 3.9 объединяются через |.

s1, s2 = {1, 2, 3}, {2, 3, 4}
print(s1 & s2, s1 | s2, s1 - s2, s1 ^ s2)  # → {2, 3} {1, 2, 3, 4} {1} {1, 4}
print({"a": 1} | {"b": 2})                 # → {'a': 1, 'b': 2}

Больше операций с множествами — в статье про множества set, со словарями — в статье про словари dict.

Когда нужен &, а когда and

& — побитовое И с высоким приоритетом, and — логическое И с низким. Если перепутать их в условии, результат будет неверным без всякой ошибки:

x = 15
print(x > 0 & x < 10)        # → True    неверно
print(x > 0 and x < 10)      # → False
print((x > 0) & (x < 10))    # → False

Первая строка вычисляется как x > (0 & x) < 10: сначала 0 & 15 даёт 0, затем цепочка 15 > 0 < 10 оказывается истинной. В обычных условиях пишите and. В pandas и NumPy, где and с массивами не работает, используют & и обязательно берут каждое сравнение в скобки.

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

Обычное присваивание = связывает имя со значением. Python поддерживает множественное присваивание и обмен значений без временной переменной:

a, b = 1, 2
a, b = b, a
print(a, b)                    # → 2 1

first, *rest = [1, 2, 3, 4]
print(first, rest)             # → 1 [2, 3, 4]

Запись x = y = 0 присваивает одно значение двум именам. С числами это безопасно, а со списком оба имени будут указывать на один объект: после row = col = [] и row.append(1) список col тоже станет [1].

Составное присваивание

Составной оператор объединяет действие и присваивание: x += 5 — то же, что x = x + 5.

Оператор	Аналог	Оператор	Аналог
x += y	x = x + y	x &= y	x = x & y
x -= y	x = x - y	x |= y	x = x | y
x *= y	x = x * y	x ^= y	x = x ^ y
x /= y	x = x / y	x <<= y	x = x << y
x //= y	x = x // y	x >>= y	x = x >> y
x %= y	x = x % y	x **= y	x = x ** y

count = 10
count += 5;  print(count)   # → 15
count -= 3;  print(count)   # → 12
count *= 2;  print(count)   # → 24
count /= 4;  print(count)   # → 6.0   после / число стало float
count //= 2; print(count)   # → 3.0
count **= 3; print(count)   # → 27.0
count %= 5;  print(count)   # → 2.0

text = "ab"
text += "c"
text *= 2
print(text)                 # → abcabc

Для изменяемых объектов += меняет сам объект, а не создаёт новый. Это видно, если на список ссылаются два имени:

lst = [1]
alias = lst
lst += [2]
print(lst, alias)       # → [1, 2] [1, 2]   изменился общий список

t = (1,)
alias_t = t
t += (2,)
print(t, alias_t)       # → (1, 2) (1,)     кортеж неизменяем, создан новый

Запись lst = lst + [2] создаёт новый список и не трогает alias. Операторов ++ и -- в Python нет — используйте x += 1 и x -= 1.

Моржовый оператор :=

Оператор := (присваивающее выражение, Python 3.8+) присваивает значение переменной и сразу возвращает его. Название «моржовый» — из-за сходства := с глазами и бивнями моржа. Он нужен, когда значение требуется и в условии, и в теле блока:

data = [3, 8, 1, 9, 4, 7, 2, 6, 5, 10, 11]
if (n := len(data)) > 10:
    print(f"Слишком длинный список: {n} элементов")
# → Слишком длинный список: 11 элементов

Без := пришлось бы вычислить len(data) дважды или завести переменную отдельной строкой. Ещё три типичных сценария — результат поиска по регулярному выражению, цикл чтения ввода и генератор списка, где вычисленное значение нужно и в фильтре, и в результате:

import re

if m := re.search(r"\d+", "Заказ №123 оплачен"):
    print(m.group())                      # → 123

while (command := input("> ")) != "выход":
    print(f"Команда: {command}")

prices = [120, 80, 300, 45]
with_tax = [t for p in prices if (t := round(p * 1.2)) > 100]
print(with_tax)                           # → [144, 360]

Правила и подводные камни:

• Скобки. У := самый низкий приоритет. if (n := len(data)) > 10 сохраняет длину, а if n := len(data) > 10 сохранит в n результат сравнения — True или False. Без скобок := допустим, только если он — всё выражение условия, как в примере с re.search.
• Отдельной строкой не работает. n := 10 на верхнем уровне даёт SyntaxError: invalid syntax; для простого присваивания есть =.
• Переменная из генератора остаётся снаружи. После примера с prices переменная t существует и равна 54 — последнему вычисленному значению. Она может перезаписать одноимённую переменную функции.
• Короткое замыкание. В if (a := f()) and (b := g()) при ложном a переменная b не создаётся, и обращение к ней дальше выбросит NameError.

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

in проверяет, содержится ли значение в строке, списке, кортеже, множестве, словаре или диапазоне. not in — обратная проверка.

print("py" in "python", "Py" in "python")    # → True False   с учётом регистра
print(3 in [1, 2, 3], 5 not in [1, 2, 3])    # → True True
print(2 in range(0, 10, 2))                  # → True

ages = {"Анна": 30, "Олег": 25}
print("Анна" in ages, 30 in ages)            # → True False   ищет среди ключей
print(30 in ages.values())                   # → True
print(("Анна", 30) in ages.items())          # → True

Для строки in ищет подстроку, для списка — отдельный элемент: [1, 2] in [1, 2, 3] вернёт False, потому что списка [1, 2] среди элементов нет.

Скорость зависит от коллекции. В списке и кортеже in перебирает элементы по очереди, а в множестве и словаре находит значение по хешу почти мгновенно. Если проверок много, превратите список в множество: allowed = set(ids). Свой класс поддержит in через метод __contains__.

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

is проверяет, что обе переменные указывают на один и тот же объект в памяти, а == — что значения равны.

a = [1, 2, 3]
b = [1, 2, 3]
c = a
print(a == b, a is b, a is c)   # → True False True
c.append(4)
print(a)                        # → [1, 2, 3, 4]   a и c — один объект

Технически a is c равно id(a) == id(c). Где что применять:

• is — для сравнения с None: if value is None, if value is not None. Так советует руководство по стилю PEP 8. Реже is сравнивает с True, False и типами: type(x) is int.
• == — для всех остальных сравнений: чисел, строк, списков.

Сравнение чисел и строк через is даёт непредсказуемый результат. CPython (основная реализация Python) хранит в кэше небольшие целые числа от -5 до 256, поэтому для них is иногда «работает», а для больших чисел — нет:

x = 1000
y = int("1000")
print(x == y, x is y)   # → True False

Если сравнить через is с литералом, Python выдаст предупреждение SyntaxWarning: "is" with 'int' literal. Did you mean "=="?.

Тернарный оператор

Условное выражение выбирает одно из двух значений в одну строку: значение_если_истина if условие else значение_если_ложь. Сначала вычисляется условие, затем только одна из ветвей.

age = 17
status = "взрослый" if age >= 18 else "несовершеннолетний"
print(status)   # → несовершеннолетний

items = []
print(f"Товаров: {len(items) if items else 'нет'}")   # → Товаров: нет

Тернарные выражения можно вкладывать, но больше одного уровня читается тяжело:

n = 0
print("плюс" if n > 0 else "минус" if n < 0 else "ноль")   # → ноль

Ветка else обязательна. У тернарного оператора низкий приоритет, поэтому price * 0.9 if price > 50 else price означает (price * 0.9) if … else price. Если условие должно влиять только на множитель, возьмите его в скобки: price * (0.9 if price > 50 else 1).

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

Приоритет определяет, какие операторы выполняются первыми. Операторы одной строки таблицы равноправны и выполняются слева направо; исключения — ** и тернарный оператор, они группируются справа налево.

Приоритет	Операторы	Описание
Высший	(...), [...], x[i], x.attr, f(...)	скобки, индексы, атрибуты, вызовы
	await x	ожидание в асинхронном коде
	**	степень
	+x, -x, ~x	унарные плюс, минус, инверсия
	*, @, /, //, %	умножение и деление
	+, -	сложение и вычитание
	<<, >>	сдвиги
	&	побитовое И
	^	исключающее ИЛИ
	|	побитовое ИЛИ
	in, not in, is, is not, <, <=, >, >=, !=, ==	сравнения, принадлежность, тождественность
	not	логическое НЕ
	and	логическое И
	or	логическое ИЛИ
	if … else	тернарный оператор
	lambda	лямбда-выражение
Низший	:=	моржовый оператор

Таблица соответствует разделу «Operator precedence» справочника языка Python. Примеры, на которых чаще всего ошибаются:

print(2 + 3 * 4, (2 + 3) * 4)      # → 14 20
print(-3 ** 2, (-3) ** 2)          # → -9 9
print(2 ** 3 ** 2, (2 ** 3) ** 2)  # → 512 64
print(10 - 4 - 3, 100 / 10 / 5)    # → 3 2.0    слева направо
print(1 + 2 << 1)                  # → 6        (1 + 2) << 1
print(True or False and False)     # → True     and выполняется раньше or
print(not 1 == 2)                  # → True     not (1 == 2)
print(5 > 3 == True)               # → False    цепочка: 5 > 3 and 3 == True

Две особенности Python, непривычные после других языков:

• Побитовые операторы стоят выше сравнений. В C выражение x & 1 == 0 читается как x & (1 == 0), а в Python — как (x & 1) == 0.
• Все сравнения, включая in и is, имеют один приоритет и образуют цепочки. Поэтому 5 > 3 == True превращается в 5 > 3 and 3 == True.

Если порядок неочевиден, ставьте скобки: лишние скобки ничего не стоят и избавляют читателя кода от необходимости помнить таблицу.

Перегрузка операторов: магические методы

Каждый оператор вызывает специальный («магический») метод левого операнда: a + b превращается в a.__add__(b), a == b — в a.__eq__(b). Определив такие методы в своём классе, вы заставите операторы работать с его объектами.

Оператор	Метод	Оператор	Метод
+, -	__add__, __sub__	==, !=	__eq__, __ne__
*, @	__mul__, __matmul__	<, <=	__lt__, __le__
/, //	__truediv__, __floordiv__	>, >=	__gt__, __ge__
%, **	__mod__, __pow__	in	__contains__
&, |, ^	__and__, __or__, __xor__	-x, ~x	__neg__, __invert__
<<, >>	__lshift__, __rshift__	+=	__iadd__

class Vector:
    def __init__(self, x, y):
        self.x, self.y = x, y

    def __repr__(self):
        return f"Vector({self.x}, {self.y})"

    def __add__(self, other):
        if not isinstance(other, Vector):
            return NotImplemented
        return Vector(self.x + other.x, self.y + other.y)

    def __mul__(self, k):
        if not isinstance(k, (int, float)):
            return NotImplemented
        return Vector(self.x * k, self.y * k)

    __rmul__ = __mul__  # чтобы работало и 2 * v

    def __eq__(self, other):
        if not isinstance(other, Vector):
            return NotImplemented
        return (self.x, self.y) == (other.x, other.y)


v = Vector(1, 2) + Vector(3, 4)
print(v)                     # → Vector(4, 6)
print(v * 2, 2 * v)          # → Vector(8, 12) Vector(8, 12)
print(v == Vector(4, 6))     # → True
v += Vector(1, 1)
print(v)                     # → Vector(5, 7)
Vector(1, 2) + 5
# → TypeError: unsupported operand type(s) for +: 'Vector' and 'int'

Что стоит знать о перегрузке:

• Если метод возвращает NotImplemented, Python пробует «отражённый» метод правого операнда (__radd__, __rmul__), а если и он не подходит — выбрасывает TypeError. Поэтому 2 * v работает благодаря __rmul__.
• Без __iadd__ оператор += использует __add__ и создаёт новый объект.
• != по умолчанию возвращает противоположность __eq__, отдельный __ne__ обычно не нужен. Для всех сравнений <, <=, >, >= достаточно __eq__, __lt__ и декоратора functools.total_ordering.
• and, or, not и is перегрузить нельзя. На результат not и логических операторов влияет только истинность объекта — метод __bool__ (или __len__).

Как устроены классы и методы, рассказано в статье про классы и ООП в Python.

Операторы как функции: модуль operator

Модуль operator из стандартной библиотеки содержит операторы в виде функций. Они пригодятся, когда оператор нужно передать как аргумент — например, в sorted() или functools.reduce() вместо lambda-функции:

import operator
from functools import reduce

print(operator.add(2, 3))                    # → 5
print(reduce(operator.mul, [1, 2, 3, 4, 5]))  # → 120

users = [("Олег", 25), ("Анна", 30), ("Иван", 19)]
print(sorted(users, key=operator.itemgetter(1)))
# → [('Иван', 19), ('Олег', 25), ('Анна', 30)]

Частые вопросы

Есть ли в Python операторы ++ и —?

Нет. Запись x++ вызывает SyntaxError, а ++x ошибки не даёт: это два унарных плюса подряд, значение x не меняется. Для увеличения и уменьшения на единицу пишут x += 1 и x -= 1.

Как в Python написать «не равно»?

Оператором !=: if answer != "да":. Старая запись <> из Python 2 в Python 3 удалена и вызывает SyntaxError. Для проверки «не является None» используют is not None, для «не содержится» — not in.

Что означает оператор % у строк?

У строк % — старый способ форматирования: "%s — %d лет" % ("Анна", 30) вернёт Анна — 30 лет. Приоритет у него такой же, как у арифметического %. В новом коде вместо него используют f-строки: f"{name} — {age} лет".

Что делают * и ** перед аргументом функции?

В вызове функции это распаковка, а не умножение: f(*nums) передаёт элементы списка как позиционные аргументы, f(**opts) — пары словаря как именованные. В определении функции *args и **kwargs собирают лишние аргументы. Подробнее — в статье про функции в Python.

Чем = отличается от == и :=?

= — инструкция присваивания, она ничего не возвращает и не может стоять внутри условия. == сравнивает значения и возвращает True или False. := присваивает и возвращает значение, поэтому его можно использовать внутри if, while и генераторов. Если написать if x = 5:, Python подскажет: Maybe you meant '==' or ':=' instead of '='?.

Почему 5 > 3 == True возвращает False?

Сравнения в Python образуют цепочку, поэтому выражение читается как 5 > 3 and 3 == True, а 3 не равно True. Сравнивать результат с True вообще не нужно: условие if 5 > 3: уже даёт логическое значение.

Итог

• Арифметика: / всегда возвращает float, // округляет вниз, % берёт знак делителя, ** выполняется раньше унарного минуса.
• Сравнения объединяются в цепочки a < b < c; число со строкой сравнивать нельзя, float проверяют через math.isclose().
• and и or вычисляются по короткой схеме и возвращают один из операндов; «равно одному из» записывают через in.
• Побитовые &, |, ^, ~, <<, >> работают с битами целых чисел, а для множеств и словарей означают операции над коллекциями.
• += меняет изменяемый объект на месте; ++ в Python нет; моржовый := присваивает внутри выражения и почти всегда требует скобок.
• is сравнивает объекты, а не значения: используйте его для None, остальное сравнивайте через ==.
• При сомнениях в приоритете ставьте скобки, а для своих классов задавайте поведение операторов магическими методами.