Операторы Python: арифметика, деление // и %, сравнение, and/or/not и python round

Операторы Python — это знаки, которые превращают значения в новые значения: + складывает, // делит нацело, and объединяет условия. Ниже — полный список операторов с примерами, разница между / и //, логика and, or, not, а также функции округления: python round, math.ceil, math.floor и abs. Все примеры можно вставить в REPL и проверить.

Список операторов Python

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

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

Сложение, вычитание и умножение работают как в школе. Если в выражении участвует хотя бы один float, результат тоже будет float: 2 + 1.0 даёт 3.0. Целые числа в Python не переполняются — 2 ** 100 посчитается точно, сколько бы цифр ни получилось.

>>> 250 + 120
370
>>> 12.5 * 3
37.5
>>> 2 ** 10
1024
>>> 2 ** 0.5
1.4142135623730951

Степень в Python: оператор **

Возведение в степень — две звёздочки, а не ^: знак ^ в Python означает побитовое «исключающее ИЛИ», и 2 ^ 3 вернёт 1, а не 8. Дробная степень даёт корень: 9 ** 0.5 равно 3.0. Есть и функция pow(x, y) — то же самое, плюс третий аргумент для остатка: pow(2, 10, 1000) вернёт 24.

Учтите приоритет: ** выполняется раньше унарного минуса, поэтому -2 ** 2 равно -4. Если нужен квадрат отрицательного числа, пишите скобки: (-2) ** 2.

Деление в Python: /, // и %

В Python два вида деления, и это главный источник сюрпризов у новичков. Обычное деление / всегда возвращает float, даже если делится нацело. Целочисленное деление // отбрасывает дробную часть, а % возвращает остаток.

>>> 7 / 2
3.5
>>> 8 / 2
4.0
>>> 7 // 2
3
>>> 7 % 2
1

Целочисленное деление // и остаток %: практика

Пара // и % решает задачи «сколько целых и сколько осталось». В курсе трекер расходов хранит деньги в копейках, чтобы не терять точность, и раскладывает сумму на рубли и копейки:

kopecks = 125050          # храним деньги в копейках
rub = kopecks // 100      # 1250 — целые рубли
kop = kopecks % 100       # 50 — остаток
print(rub, kop)           # 1250 50

print(40 // 7, "недель и", 40 % 7, "дней")   # 5 недель и 5 дней

Обе операции сразу возвращает встроенная функция divmod: divmod(125050, 100) даёт кортеж (1250, 50). Остаток удобен и для проверки чётности: n % 2 == 0 истинно для чётных чисел.

Отрицательные числа: // округляет вниз

Оператор // не просто отбрасывает дробь, а округляет вниз, к минус бесконечности. Для положительных чисел разницы нет, для отрицательных — есть. Знак остатка % в Python совпадает со знаком делителя, так что всегда выполняется равенство a == (a // b) * b + a % b.

>>> -7 // 2
-4
>>> -7 % 2
1
>>> int(-7 / 2)     # отбросить дробь, а не округлить вниз
-3

Деление на ноль: какая ошибка

Деление на ноль любым из трёх операторов вызывает исключение ZeroDivisionError. Это касается и целых, и дробных чисел. Его можно перехватить через try/except или заранее проверить делитель.

>>> 10 / 0
Traceback (most recent call last):
  ...
ZeroDivisionError: division by zero
>>> count = 0
>>> avg = 1500 / count if count else 0
>>> avg
0

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

Сравнения возвращают True или False. Равенство проверяется двумя знаками ==, одиночный = — это присваивание. Строки сравниваются посимвольно по кодам символов, поэтому "Б" < "а" истинно: заглавные буквы идут раньше строчных.

>>> 250 == 250.0
True
>>> 3 != 4
True
>>> 1 < 5 <= 10     # цепочка: 1 < 5 and 5 <= 10
True
>>> 0.1 + 0.2 == 0.3
False

Цепочки сравнений вроде 0 <= x < 100 — удобная особенность Python: не нужно писать and. А последняя строка напоминает о погрешности дробных чисел: 0.1 + 0.2 даёт 0.30000000000000004. Дробные числа сравнивайте через math.isclose(a, b), а деньги храните в копейках или в Decimal.

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

Логические операторы в Python пишутся словами, а не символами && и ||, как в других языках. and истинно, когда истинны обе части, or — когда истинна хотя бы одна, not переворачивает значение.

Приоритет: сначала not, затем and, затем or. Выражение True or False and False равно True, потому что and считается первым. В сложных условиях ставьте скобки — так понятнее и вам, и коллегам.

Что на самом деле возвращают and и or

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

>>> name = ""
>>> name or "Гость"
'Гость'
>>> 5 and 0
0
>>> not ""
True

Вычисление ленивое: если результат ясен по левой части, правая не вычисляется. Поэтому count and total / count не упадёт с делением на ноль при count == 0. Оператор not, в отличие от двух других, всегда возвращает bool.

Операторы is и in

== сравнивает значения, а is проверяет, что два имени указывают на один и тот же объект. Две разные пустые корзины равны, но это не один объект. Единственное место, где is нужен постоянно, — проверка на None: if x is None.

>>> a = [250, 120]
>>> b = [250, 120]
>>> a == b, a is b
(True, False)
>>> c = a
>>> c is a
True

Не сравнивайте через is числа и строки: иногда это «работает» из-за внутреннего кэширования объектов, но результат зависит от реализации, и Python выдаёт SyntaxWarning на конструкции вроде x is 5.

Оператор in проверяет вхождение: подстроку в строке, элемент в списке, ключ в словаре. not in — обратная проверка.

>>> "кофе" in "кофе с собой"
True
>>> "еда" in {"еда": 450, "такси": 300}
True
>>> 5 not in [1, 2, 3]
True

Операторы присваивания и моржовый оператор :=

Составные операторы +=, -=, *=, //= и другие — сокращение: total += 250 означает total = total + 250. Операторов ++ и -- в Python нет: x++ вызовет синтаксическую ошибку.

Моржовый оператор := (назван так за сходство с глазами и бивнями моржа) присваивает значение прямо внутри выражения. Он полезен, когда значение нужно и проверить, и использовать дальше:

items = ["кофе", "такси", "обед", "кино"]
if (n := len(items)) > 3:
    print(f"Слишком много трат: {n}")

while (line := input("Сумма: ")) != "":
    print(int(line) * 2)

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

Округление в Python: round, ceil, floor

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

Функция round в Python и банковское округление

Функция round(x, n) округляет до n знаков после запятой; без второго аргумента возвращает целое int. Главные грабли: python round округляет «по-банковски» — половину к ближайшему чётному. Поэтому round(2.5) даёт 2, а round(3.5) — 4. Так ошибки округления не накапливаются в одну сторону при больших расчётах.

>>> round(2.5), round(3.5)
(2, 4)
>>> round(3.14159, 2)
3.14
>>> round(1250, -2)     # до сотен
1200
>>> round(2.675, 2)     # не 2.68: в двоичном виде это 2.67499...
2.67

Если нужно привычное школьное округление «половина вверх», например в чеке, используйте Decimal с режимом ROUND_HALF_UP. Число передавайте строкой, чтобы не унаследовать погрешность float:

>>> from decimal import Decimal, ROUND_HALF_UP
>>> Decimal("2.5").quantize(Decimal("1"), ROUND_HALF_UP)
Decimal('3')
>>> Decimal("2.675").quantize(Decimal("0.01"), ROUND_HALF_UP)
Decimal('2.68')

И ещё одно правило из курса: округляйте только при выводе. Для красивой печати не нужен round — достаточно f-строки: f"{amount:.2f}" покажет два знака, а само число останется точным.

math.ceil и math.floor: округление вверх и вниз

math.ceil нужен, когда «не хватает» недопустимо: сколько автобусов заказать, сколько страниц в выдаче. math.floor — когда считаются только полные единицы. Обе функции возвращают int.

import math

guests = 47
seats = 20
print(math.ceil(guests / seats))   # 3 автобуса
print(math.floor(9.99))            # 9
print(-(-guests // seats))         # 3 — ceil без math, приём через //

В модуле math есть и другие полезные функции: math.sqrt (корень), math.isclose (сравнение дробей), math.pi, math.gcd. В Python 3.15 появился подмодуль math.integer (PEP 791) для целочисленной математики: в нём comb, factorial, gcd, isqrt, lcm, perm, а старые math.gcd и другие продолжают работать.

Функция abs: модуль числа

abs(x) возвращает модуль — расстояние от нуля без знака. Импорт не нужен, функция встроенная. Работает с целыми, дробными и даже комплексными числами: для 3+4j вернёт длину вектора, 5.0.

>>> abs(-250)
250
>>> abs(-12.5)
12.5
>>> budget, spent = 5000, 5320
>>> abs(budget - spent)    # на сколько отклонились
320

Типичное применение — разница без учёта направления и сравнение с допуском: abs(a - b) < 0.001. Для дробей надёжнее math.isclose, потому что он учитывает масштаб чисел.

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

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

1. **
2. унарные -x, +x, ~x
3. * / // %
4. + -
5. побитовые сдвиги и операции
6. сравнения, in, is
7. not
8. and
9. or
10. :=

Так, 2 + 3 * 4 равно 14, а (2 + 3) * 4 — 20. Если сомневаетесь, ставьте скобки: лишние скобки ничего не стоят, а ошибка приоритета находится долго.

Частые ошибки с операторами

Итог

Запомните главное: / всегда даёт float, // округляет вниз, % возвращает остаток со знаком делителя, а степень — это **. Логические and, or, not пишутся словами и вычисляются лениво, is нужен для проверки на None. Функция python round округляет к чётному, для округления вверх и вниз есть math.ceil и math.floor, модуль числа даёт abs. В курсе эти операторы разбираются на практике — в трекере расходов, где деньги хранятся в копейках.