Переменные и типы данных из прошлого урока уже умеют хранить числа, и настал момент заставить эти числа работать. Операторами в Python называют специальные знаки, которые соединяют значения в выражения, а интерпретатор вычисляет такое выражение и отдаёт готовый результат. Запись 2 + 3 выглядит тривиально, однако за ней стоит целый конвейер: разбор символов, учёт приоритетов, приведение типов. Этот урок разбирает все арифметические операторы, порядок их вычисления, короткие формы записи и сравнения, без которых не напишется ни одно условие. Каждый пример готов к запуску: его можно скопировать в редактор или интерактивный режим целиком и сразу увидеть ответ.

Сложение вычитание умножение и деление в Python

Четыре базовых знака работают так, как подсказывает школьная математика, и удивляют разве что одним нюансом. Плюс складывает, минус вычитает, звёздочка умножает, а слэш делит. Проверить всё это можно одним блоком:

print(17 + 5)   # 22
print(17 - 5)   # 12
print(17 * 5)   # 85
print(17 / 5)   # 3.4

Нюанс прячется в делении. Оператор / в Python всегда возвращает число с плавающей точкой, даже если исходные значения были целыми и делились нацело. 10 / 2 выдаёт 5.0, а не 5. Проверка через функцию type подтверждает:

print(type(10 / 2))   # <class 'float'>
print(type(10 + 2))   # <class 'int'>

Правило простое: целые числа при сложении, вычитании и умножении остаются целыми, а деление переводит результат в float без вариантов. Если в одном выражении встретились целое и дробное значения, итог тоже станет float. Это поведение полезно запомнить заранее, потому что оно регулярно всплывает в проверках вида result == 5, которые внезапно не срабатывают, поскольку в переменной лежит 5.0. Отсюда практический вывод: тип результата зависит не только от чисел, но и от самого оператора.

Оператор минус работает в двух ролях. В выражении 17 - 5 он бинарный, то есть соединяет два значения, а в записи -5 становится унарным и просто меняет знак числа. Плюс тоже умеет притворяться унарным, хотя +5 не меняет число никак и на практике почти не встречается. В настоящем коде числа редко пишут руками, обычно трудятся переменные:

price = 249
count = 3
total = price * count
print(total)         # 747
print(total / 100)   # 7.47, цена в рублях из копеек

Здесь видна удобная особенность языка: типы не нужно объявлять заранее, Python сам разбирается, что в price лежит целое число, и подбирает правила вычисления на ходу.

Целочисленное деление и остаток от деления

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

print(7 // 2)   # 3
print(7 % 2)    # 1
print(17 // 5)  # 3
print(17 % 5)   # 2

Логика прозрачна: семь делится на два три раза, и единица остаётся в остатке. Классическая пара задач, где эти операторы незаменимы.

Первая задача - проверить чётность. Число чётное, когда остаток от деления на два равен нулю:

number = 42
print(number % 2 == 0)   # True
print(number % 2)        # 0

Вторая задача - разложить общее количество секунд на часы, минуты и секунды. Такой приём живёт в таймерах, плеерах и журналах событий:

total = 9375
hours = total // 3600
minutes = (total % 3600) // 60
seconds = total % 60
print(hours, minutes, seconds)   # 2 36 15

Ещё один житейский пример: сорок семь конфет раскладывают по коробкам по шесть штук. Выражение sweets // capacity ответит, сколько коробок заполнится полностью, а sweets % capacity покажет, сколько конфет останется без места:

sweets = 47
capacity = 6
print(sweets // capacity)   # 7, полные коробки
print(sweets % capacity)    # 5, конфеты в остатке

Здесь же прячутся трюки с разрядами. Выражение n % 10 достаёт последнюю цифру числа, а деление на степени десятки в паре с процентом вытаскивает любую нужную позицию:

n = 1234
print(n % 10)          # 4, единицы
print(n // 10 % 10)    # 3, десятки
print(n // 100 % 10)   # 2, сотни
print(n // 1000)       # 1, тысячи

Отрицательные значения ведут себя коварно: -7 // 2 даёт -4, а не -3, потому что целочисленное деление округляет вниз, к меньшему значению, а не к нулю. Остаток при этом наследует знак делителя, поэтому -7 % 2 возвращает 1. Достаточно запомнить сам факт такого поведения и в спорных случаях сверяться с интерпретатором.

Возведение в степень и оператор две звёздочки

Оператор ** возводит левое число в степень правого:

print(2 ** 10)    # 1024
print(5 ** 3)     # 125
print(9 ** 0.5)   # 3.0
print(2 ** -2)    # 0.25

Дробная степень честно извлекает корень: 9 0.5 возвращает квадратный корень из девяти. Отрицательная степень даёт дробь. Оба факта пригодятся в расчётах, где раньше понадобилась бы отдельная функция из библиотеки. Целая степень к тому же не знает предела разрядности: Python перемножает огромные числа без потерь, и запись 2 100 печатает весь ответ из 31 цифры целиком. В финансовых прикидках ** заменяет формулу сложного дохода: вклад в тысячу под десять процентов на три года считается одним выражением 1000 1.1 * 3, правда, результат получит дробный хвост, и к этой особенности раздел ещё вернётся.

У есть две ловушки. Первая: этот оператор вычисляется справа налево, в отличие от всех остальных. Выражение 2 3 2 означает 2 9, то есть 512, а вовсе не 64:

print(2 ** 3 ** 2)    # 512, степень применяется справа налево
print((2 ** 3) ** 2)  # 64

Вторая ловушка касается унарного минуса. Запись -3 2 читается как -(3 2) и даёт -9. Чтобы возвести в квадрат именно минус три, нужны скобки: (-3) ** 2 вернёт 9. Оба правила одинаково важны в формулах, где степени комбинируются с отрицательными коэффициентами.

Приоритет операторов и роль скобок

Калькулятор из магазина вычисляет выражения слева направо и легко обманывается, а Python следует математическим правилам. Выражение 2 + 3 * 4 равно 14, а не 20, потому что умножение выполняется раньше сложения:

print(2 + 3 * 4)    # 14
print((2 + 3) * 4)  # 20

Полный порядок вычислений в выражении без скобок такой:

  1. Сначала считается всё, что стоит в скобках;
  2. Затем выполняется возведение в степень;
  3. После него работают унарный минус, умножение и все виды деления, включая // и %;
  4. В самом конце считаются сложение и вычитание.

Операторы одного уровня выполняются слева направо, поэтому цепочка 10 - 4 - 3 даёт 3, а не 9. Разобрать настоящее выражение по шагам несложно. В записи 20 - 2 3 * 2 / 6 сначала считается степень, дающая девять, затем умножение на два, затем деление на шесть и лишь в самом конце вычитание:

print(20 - 2 * 3 ** 2 / 6)   # 17.0

Дробный хвост здесь не случаен: деление в середине цепочки превратило итог в float, хотя на глаз ответ выглядел целым. Одна скобка меняет и наглядность, и порядок действий: выражение (7 + 3) % 4 сначала находит сумму, а уже потом остаток от деления. Скобки в Python разрешено ставить свободно и даже там, где приоритет и так очевиден: запись (a + b) * (a - b) читается легче, чем длинная строка без них. Хороший стиль - расставлять скобки ради человека, который будет читать код через полгода, ведь компьютеру они добавляют лишь однозначность, а человеку заметно упрощают жизнь.

Составные операторы для короткой записи действий

Частая операция в программировании - изменить переменную на основе её же значения: счётчик растёт на единицу, баланс уменьшается на стоимость покупки, множитель удваивается. Писать имя переменной дважды утомительно, поэтому в Python существуют составные операторы: +=, -=, =, /=, //=, %=, *=.

score = 0
score += 10   # 10, прибавили десять
score *= 2    # 20, удвоили
score -= 5    # 15, отняли пять
print(score)  # 15

Строка score += 10 делает ровно то же самое, что и score = score + 10, только короче и без риска опечататься в имени переменной. Привычка к короткой записи вырабатывается за пару дней и остаётся навсегда. Отдельный сюрприз ждёт тех, кто пришёл из других языков: в Python нет операторов ++ и --. Увеличение счётчика записывается как x += 1, и никакого другого способа язык не предоставляет. Составные формы честно сохраняют приоритет обычных операций, так что a = b + 2 означает a = a (b + 2), а не a = a * b + 2. Деление в составной форме ведёт себя так же разборчиво, как и обычное: x /= 2 даст float, а x //= 2 останется целым:

x = 9
x /= 2
print(x)   # 4.5
y = 9
y //= 2
print(y)   # 4

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

Сравнение значений и логический тип bool

Шесть операторов сравнения проверяют отношения между числами: == равно, != не равно, > больше, < меньше, >= больше или равно, <= меньше или равно. Результатом всегда служит логическое значение типа bool, то есть True или False:

age = 20
print(age >= 18)   # True
print(age == 20)   # True
print(age != 20)   # False
print(age < 18)    # False

Главный источник ошибок новичка - путаница между = и ==. Один знак присваивает значение переменной, два знака сравнивают значения. Python в большинстве случаев отреагирует ошибкой синтаксиса, но привычка перепроверять этот символ сбережёт нервы и время. Приятная особенность языка - цепочки сравнений: запись 0 <= x <= 100 проверяет попадание в диапазон одним выражением, как в школьной математике:

x = 50
print(0 <= x <= 100)          # True
print(0 <= x and x <= 100)    # True, то же самое в развёрнутом виде

Булевы значения из сравнений станут фундаментом условных операторов, о которых разговор пойдёт в ближайших уроках, а пока достаточно понять: любое сравнение в Python вычисляется как обычное выражение, и его результат можно положить в переменную. Сравнение к тому же спокойно переживает смесь типов: целое пять равно дробному 5.0, потому что Python сравнивает значения, а не внутреннее устройство чисел. Проверка 7 / 2 == 3.5 честно возвращает True:

print(5 == 5.0)      # True
print(7 / 2 == 3.5)  # True

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

Типичные ловушки при работе с числами

Первая ловушка - деление на ноль. Попытка разделить число на ноль обрывает программу исключением ZeroDivisionError:

print(10 / 0)   # ZeroDivisionError: division by zero

То же самое произойдёт при 10 // 0 и при 10 % 0, ведь остаток от деления на ноль тоже не имеет смысла. Ошибка не приговор, а подсказка: делитель приходит из данных или из вычислений, и его стоит проверять заранее:

a = 10
b = 0
if b != 0:
    print(a / b)
else:
    print("Делитель равен нулю, считаем иначе")

Вторая ловушка тоньше и коварнее:

print(0.1 + 0.2)          # 0.30000000000000004
print(0.1 + 0.2 == 0.3)   # False

Компьютер хранит дробные числа в двоичной системе, а дробь одна десятая в двоичной записи не имеет конца, поэтому хранится приближённо. Погрешность копится с каждым действием и однажды всплывает в виде хвоста из цифр. Это не баг Python, так устроены float во всех популярных языках, от JavaScript до C.

Средства защиты просты. Функция round округляет результат до нужного знака:

print(round(0.1 + 0.2, 2))   # 0.3

Для денег работает другое правило: хранить суммы в копейках целыми числами и делить на сто лишь при выводе на экран. Для точных научных расчётов стандартная библиотека предлагает модуль decimal с честной десятичной арифметикой, но на старте достаточно помнить сам факт неточности и не сравнивать float через == без округления.

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

total = 0.0
for i in range(10):
    total += 0.1
print(total)                    # 0.9999999999999999
print(total == 1.0)             # False
print(round(total, 10) == 1.0)  # True после округления

Именно поэтому в деньгах, счётчиках и длинах лучше держаться целых чисел там, где это возможно, а float оставлять для измерений, где погрешность в четырнадцатом знаке никого не волнует.

Арифметика в Python оказалась набором из десятка знаков и пары правил: деление всегда даёт float, двойной слэш и процент делят нацело и берут остаток, две звёздочки возводят в степень, скобки рулят порядком, а сравнения возвращают True и False. Следующий урок посвящён строкам, и там знакомый плюс предстанет в неожиданной роли: вместо сложения чисел он начнёт склеивать текст.