Числа и арифметические операции

В прошлом уроке у чисел появились имена, теперь займёмся самими вычислениями. Сложение, вычитание и умножение в Python такие же, как на уроке математики, а с делением интереснее. Сколько полных пятёрок помещается в 23 и сколько остаётся? Для таких вопросов в Python есть две отдельные операции — целое деление // и остаток %. На них держатся проверка делимости, цифры числа и перевод секунд в часы и минуты.

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

В Python семь основных арифметических операций. Вот они все на числах 23 и 5, у каждой строки — комментарий с названием:

print(23 + 5)   # сложениеprint(23 - 5)   # вычитаниеprint(23 * 5)   # умножениеprint(23 / 5)   # делениеprint(23 // 5)  # целое делениеprint(23 % 5)   # остатокprint(23 ** 5)  # степень

Первые три работают как в математике. ** — степень: 23 ** 5 — это 23⁵, а 2 ** 5 — 2⁵ = 32. Обычное деление / всегда даёт дробное число float, даже если делится нацело: 8 / 2 — это 4.0, а не 4.

Умножение пишут явно: 2 * x, а не 2x. Степень — **, а не ^: знак ^ в Python означает другую операцию.

Целое деление и остаток. 23 // 5 — сколько полных пятёрок помещается в 23: четыре. 23 % 5 — сколько осталось сверх них: 3. Разложи клетки на порции сам:

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

print(23 // 5 * 5 + 23 % 5)

Делить на ноль нельзя и здесь: 23 // 0 и 23 % 0 остановят программу с ZeroDivisionError, как деление на ноль в первом уроке.

// округляет частное вниз — к меньшему целому. Для положительных чисел это то же, что отбросить дробную часть: 23 / 5 — 4.6, а 23 // 5 — 4. У отрицательных чисел разница видна:

print(-7 / 3)print(-7 // 3)print(int(-7 / 3))

int(x) превращает дробное число в целое, отбрасывая дробную часть; подробнее о нём — в уроке «Ввод, преобразование и вывод». Отбросить дробную часть у −2.33… — значит получить −2, то есть сдвинуться к нулю. А округлить вниз — значит взять меньшее целое: −3.

Поэтому заменять a // b на int(a / b) нельзя: для отрицательных чисел ответы разойдутся.

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

print(2 + 3 * 4)print((2 + 3) * 4)print(472 // 10 % 10)print(2 ** 3 ** 2)print(-3 ** 2)print((-3) ** 2)

472 // 10 % 10 читается слева направо: сначала 472 // 10 = 47, затем 47 % 10 = 7. Этот приём понадобится в разделе о цифрах числа.

Степень — исключение: цепочку ** Python считает справа налево. 2 ** 3 ** 2 — это 2 ** (3 ** 2), то есть 2⁹ = 512. И степень выполняется раньше минуса перед числом: -3 ** 2 — это -(3 ** 2), то есть −9.

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

Если сомневаешься в порядке, ставь скобки: (-3) ** 2 или 2 + (3 * 4) читаются сразу, без знания правил.

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

print(2 ** 100)

С дробными иначе. float хранит число с ограниченным количеством знаков, поэтому некоторые простые дроби записываются чуть неточно — так же, как 1/3 не записать конечной десятичной дробью 0.333…:

print(0.1 + 0.2)

Это не ошибка Python, а свойство дробных чисел в компьютере. Отсюда правило: если задача о целых — количестве, цифрах, делимости, — считай в целых: // и % вместо /.

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

print(abs(-12))print(min(5, 2, 9))print(max(5, 2, 9))print(round(2.5))print(round(3.5))

abs даёт модуль числа, min и max — наименьшее и наибольшее из значений в скобках. round округляет до ближайшего целого. Но при ровной половине — 2.5 или 3.5 — Python выбирает ближайшее чётное: 2.5 превратилось в 2, а 3.5 — в 4. Это правило Python, а не ошибка.

Делимость и цифры числа — это остатки. «n делится на d» значит, что остаток n % d равен нулю. Чётность — остаток от деления на 2: у чётного числа он 0, у нечётного 1.

print(91 % 7)print(18 % 2)print(17 % 2)

91 делится на 7, 18 — чётное, 17 — нечётное. Последняя цифра — тоже остаток. Если n — неотрицательное целое, то n % 10 — его последняя цифра, а n // 10 — число без неё. Почему? Любое такое число записывается как 10 * q + r, где r — от 0 до 9, и эти q и r как раз вычисляют две операции. Например, 472 = 10 · 47 + 2:

n = 472print(n % 10)print(n // 10)print(n // 10 % 10)

Третья строка сначала отбрасывает последнюю цифру, а затем берёт последнюю цифру того, что осталось, — получается вторая цифра справа. Для цифр отрицательного числа сначала берут abs(n): знак — не цифра.

Те же две операции раскладывают время. В 3671 секунде 1 полный час (3600 секунд), в остатке 71 секунда: из них 1 полная минута и 11 секунд. print с несколькими значениями через запятую печатает их в одну строку через пробел; подробнее — в следующем уроке:

seconds = 3671hours = seconds // 3600minutes = seconds % 3600 // 60remaining_seconds = seconds % 60print(hours, minutes, remaining_seconds)