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

URL: https://skillaria.top/ru/guides/python/operatory-python

Оператор / в Python всегда даёт float, // — целую часть с округлением вниз, % — остаток, ** — степень. Функция round(x, n) округляет до n знаков по-банковски: round(2.5) равно 2, а round(3.5) — 4; вверх и вниз до целого округляют math.ceil и math.floor, модуль числа даёт abs.

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

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

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

| Группа | Операторы | Пример |
| --- | --- | --- |

| Арифметические | `+ - * / // % **` | `7 // 2` → 3 |

| Сравнения | `== != < > <= >=` | `3 < 5` → True |

| Логические | `and or not` | `not True` → False |

| Тождества | `is`, `is not` | `x is None` |

| Принадлежности | `in`, `not in` | `"ф" in "кофе"` → True |

| Присваивания | `= += -= *= /= //= %= **=` | `total += 250` |

| Моржовый | `:=` | `if (n := len(s)) > 10:` |

| Побитовые | `& | ^ ~ << >>` | `5 & 3` → 1 |

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

Сложение, вычитание и умножение работают как в школе. Если в выражении участвует хотя бы один `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 > 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` переворачивает значение.

| a | b | a and b | a or b | not a |
| --- | --- | --- | --- | --- |

| True | True | True | True | False |

| True | False | False | True | False |

| False | True | False | True | True |

| False | False | False | False | True |

Приоритет: сначала `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`. Они решают разные задачи, и путать их — частая ошибка.

| Функция | Что делает | 2.5 | -2.5 | 2.7 |
| --- | --- | --- | --- | --- |

| `round(x)` | к ближайшему, половина — к чётному | 2 | -2 | 3 |

| `math.floor(x)` | вниз, к минус бесконечности | 2 | -3 | 2 |

| `math.ceil(x)` | вверх, к плюс бесконечности | 3 | -2 | 3 |

| `math.trunc(x)`, `int(x)` | отбросить дробь, к нулю | 2 | -2 | 2 |

### Функция 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. Если сомневаетесь, ставьте скобки: лишние скобки ничего не стоят, а ошибка приоритета находится долго.

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

| Ошибка | Что происходит | Как правильно |
| --- | --- | --- |

| `if x = 5:` | SyntaxError: это присваивание | `if x == 5:` |

| `2 ^ 3` вместо степени | побитовое XOR, результат 1 | `2 ** 3` |

| ждут целое от `8 / 2` | получают `4.0` | `8 // 2` |

| `x == 1 or 2` | всегда истинно: `or 2` | `x in (1, 2)` |

| ждут 3 от `round(2.5)` | банковское округление даёт 2 | `Decimal` с `ROUND_HALF_UP` |

| `"5" + 5` | TypeError | `int("5") + 5` |

## Итог

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

## FAQ

**Как в Python округлить число до двух знаков после запятой?**

Используйте round(x, 2), а если нужно только красиво вывести число — f-строку f"{x:.2f}", которая не меняет само значение.

**Почему round(0.5) в Python возвращает 0?**

Потому что round округляет половину к ближайшему чётному числу, а 0 — чётное; так же round(1.5) и round(2.5) дают 2.

**Как получить целую часть от деления в Python?**

Оператором //: 17 // 5 вернёт 3. Для отрицательных чисел он округляет вниз, поэтому -17 // 5 даст -4; если нужно отбросить дробь к нулю, используйте int(-17 / 5).

**Есть ли в Python тернарный оператор?**

Да, это условное выражение: значение_если_да if условие else значение_если_нет, например "чётное" if n % 2 == 0 else "нечётное".

**Чем отличаются & и and в Python?**

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


---
Source: Skillaria.Top (https://skillaria.top)