Числа и арифметика

В прошлом уроке мы научились создавать переменные и сохранять в них значения. Сейчас пришло время разобраться, с какими именно числами Python умеет работать — и чем они отличаются друг от друга.

Числовые типы: int и float

В Python числа бывают двух основных видов: целые и дробные. Для целых чисел используется тип int, для чисел с дробной частью — float.

int — это любое целое число: положительное, отрицательное или ноль. Python не ограничивает его размер, поэтому int может быть сколь угодно большим.

x = 42
y = -7
z = 0

float — число с точкой. Точка здесь обязательна: именно она отличает 2.0 от 2. Даже если дробная часть равна нулю, Python будет хранить значение как float.

price = 3.14
temperature = -0.5
whole_as_float = 2.0

Определить тип значения можно по записи: целое число без точки — это int, число с точкой — float.

Основные арифметические операторы: +, -, *, /

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

print(10 + 3)   # 13
print(10 - 3)   # 7
print(10 * 3)   # 30
print(10 / 3)   # 3.3333333333333335
print(10 / 2)   # 5.0, не 5

С +, - и * всё предсказуемо: если оба операнда int, результат тоже int. Если хотя бы один из них float — результат станет float. То же правило работает в смешанном выражении: 3 + 1.5 даёт 4.5.

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

Операнды могут быть не только литералами, но и переменными — результат от этого не меняется:

a = 8
b = 4
print(a + b)   # 12
print(a - b)   # 4
print(a * b)   # 32
print(a / b)   # 2.0

Выражения можно комбинировать в одной строке. Python вычислит их слева направо (при одинаковом приоритете), но подробнее о приоритетах — в разделе про скобки.

Специальные операторы: //, % и **

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

Целочисленное деление //

Оператор // делит два числа и отбрасывает дробную часть — не округляет, а именно отбрасывает. Результат всегда «обрезается» в сторону отрицательной бесконечности.

print(17 // 5)    # 3  (17 / 5 = 3.4, дробь отброшена)
print(20 // 4)    # 5
print(-17 // 5)   # -4 (не -3, а именно -4)

Тип результата зависит от операндов: если оба int — получишь int; если хотя бы один float — получишь float, но всё равно без дробной части:

print(17 // 5)      # 3   → int
print(17.0 // 5)    # 3.0 → float

Целочисленное деление удобно, когда нужно знать, сколько раз одно число вмещается в другое. Классический пример: сколько полных часов в N минутах.

minutes = 150
hours = minutes // 60
print(hours)   # 2

Остаток от деления %

% возвращает то, что «не вошло» при целочисленном делении. Если // даёт частное, то % даёт остаток.

print(17 % 5)    # 2  (17 = 5 * 3 + 2)
print(20 % 4)    # 0  (делится нацело)
print(150 % 60)  # 30

В паре с // он закрывает картину полностью: // говорит сколько полных единиц, % — сколько осталось. Из тех же 150 минут:

minutes = 150
hours = minutes // 60
remaining = minutes % 60
print(hours, remaining)   # 2 30

Ещё одна распространённая задача — проверка чётности. Если n % 2 == 0, число чётное; если n % 2 == 1 — нечётное. Это стандартный приём, который встречается повсюду.

Возведение в степень **

** возводит левый операнд в степень правого. Никаких дополнительных функций импортировать не нужно.

print(2 ** 10)    # 1024
print(3 ** 3)     # 27
print(9 ** 0.5)   # 3.0  (квадратный корень)

Да, ** работает и с дробными степенями: 9 0.5 — это корень квадратный из 9. Результат в таком случае будет float.

Приоритет у ** выше, чем у умножения и деления — это важно, но подробнее об этом в следующем разделе.

Приоритет операций, скобки и программа вычисления площади

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

Порядок убывает так:

• ** — самый высокий приоритет
• унарный минус (например, -x)
• *, /, //, %
• +, - — самый низкий среди арифметических

Операторы с одинаковым приоритетом выполняются слева направо. Исключение — **: он выполняется справа налево, то есть 2 3 2 читается как 2 (3 2) = 2 9 = 512.

Скобки меняют правила

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

print(2 + 3 * 4)     # 14 — сначала умножение: 3 * 4 = 12, потом 2 + 12
print((2 + 3) * 4)   # 20 — скобки заставляют сложить сначала: 2 + 3 = 5, потом 5 * 4

Без скобок второй пример дал бы 14, а не 20. Это не тонкость — это принципиальная разница в результате.

Ещё пример с **:

print(2 + 3 ** 2)     # 11 — сначала 3 ** 2 = 9, потом 2 + 9
print((2 + 3) ** 2)   # 25 — сначала 2 + 3 = 5, потом 5 ** 2

Правило простое: если не уверен в порядке — ставь скобки. Они не только меняют результат, но и делают код читаемее.

Программа вычисления площади прямоугольника

Теперь соберём всё вместе. Задача: вычислить площадь прямоугольника со сторонами 7 и 4. Нам нужны переменные (из прошлого урока) и оператор умножения.

width = 7
height = 4
area = width * height
print(area)   # 28

Здесь нет скобок, потому что в выражении width * height только один оператор. Но чуть усложним: добавим периметр.

width = 7
height = 4
area = width * height
perimeter = 2 * (width + height)
print(area)        # 28
print(perimeter)   # 22

Без скобок в perimeter выражение 2 * width + height дало бы 2 * 7 + 4 = 18 — неправильно. Скобки здесь не декоративны, они меняют результат.

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