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

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

Каждый арифметический оператор имеет свой приоритет, который определяет порядок выполнения операций в сложных выражениях.

Арифметические операции выполняются, как в математике, по порядку приоритетов: от высшего к низшему. Сначала выполняется возведение в степень, затем – умножение и деление, и в последнюю очередь – сложение и вычитание.

При этом операторы, имеющие одинаковый приоритет, выполняются слева направо.

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

print(2 + 2 * 2)  
# Вывод: 6

print((2 + 2) * 2) 
# Вывод: 8

Рассмотренные арифметические операции называются бинарными, так как принимают два операнда. Однако существуют унарные операции, принимающие один операнд. Большинство унарных операторов имеют более высокий приоритет, чем бинарные операторы. Например, изменение знака числа на противоположный с помощью унарного минуса (-10 или -3.5) будет выполнено перед любыми бинарными операторами. Так, если мы вычисляем выражение -2 * 3, то сначала будет изменён знак числа 2, и только потом выполнится умножение.

Особенности операции деления

При обычном делении / результатом всегда является число с плавающей точкой (тип float), даже если деление происходит нацело:

print(6 / 3) 
# Вывод: 2.0

Но при целочисленном делении // результатом будет целое число (тип int), так как возвращается целая часть от деления без дробного остатка:

print(7 // 2)  
# Вывод: 3

Здесь результат деления 7 на 2 равен 3.5, однако целочисленное деление отбрасывает дробную часть .5 числа без учёта правил округления. Это равносильно использованию обычного оператора деления / и функции int():

print(int(7 / 2))  
# Вывод: 3

Также в Python существует возможность получения остатка от деления:

print(7 % 2)
# Вывод: 1

Мы уже знаем, что результат целочисленного деления 7 на 2 равен 3 (его ещё называют неполным частным), тогда остаток равен 7 - 3 * 2 = 1.

Оператор остатка от деления часто используется для проверки кратности числа или определения четности/нечетности:

print(21 % 2)  # Число нечётное, так как остаток не равен 0
# Вывод: 1 

print(40 % 2)  # Число чётное, так как остаток равен 0
# Вывод: 0

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

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

counter = 10
counter += 1  # Эквивалентно n = n + 1
print(counter)
# Вывод: 10

Для каждого стандартного арифметического оператора существует соответствующий расширенный оператор присваивания:

Рассмотрим несколько примеров использования расширенных операторов:

number1 = 10
number1 += 5
print(n1) 
# Вывод: 15

number2 = 15
number2 //= 2
print(n2) 
# Вывод: 7

Расширенные операторы присваивания могут использоваться только с переменными, которые уже были определены ранее. Попытка использовать их с необъявленной переменной приведет к ошибке NameError (с англ. – Ошибка имени):

age += 1 
# NameError: name 'age' is not defined

Арифметические операции с вещественными числами

При операциях над вещественными числами (тип float) в Python, как и в большинстве современных языков программирования, могут возникать некоторые погрешности. Причина кроется в ограниченности представления вещественных чисел внутри компьютера.

Компьютеры хранят вещественные числа в двоичном представлении, используя стандарт IEEE 754. Из-за особенностей перевода некоторых десятичных дробей в двоичную систему возникает небольшая потеря точности. Это значит, что многие привычные нам числа, такие как 0.1 или 0.2, хранятся в памяти компьютера лишь приближенно, поэтому операции над ними могут привести к неожиданному результату:

print(0.1 + 0.2)
# Вывод: 0.30000000000000004

Несмотря на то, что мы ожидали увидеть на экране число 0.3, компьютер выводит нечто близкое, но немного отличающееся от правильного ответа. Такое поведение связано с внутренним устройством хранения чисел с плавающей точкой и особенностями преобразования между десятичной и двоичной системами счисления.

Округление чисел

Помимо стандартных арифметических операций, Python также предоставляет возможность округления чисел. Чаще всего для этого используется встроенная функция round(), которая позволяет округлить число до указанного количества десятичных знаков или до ближайшего целого.

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

result = 10 / 3
print(round(result, 2))
# Вывод: 3.33

Без использования параметра ndigits функция round() округляет число до ближайшего целого:

print(10.156)
# Вывод: 10

Для случаев, когда число ровно посередине между двумя ближайшими значениями (например, 3.5 или 2.5), в Python действует банковское округление. То есть значение округляются в сторону ближайшего чётного числа:

print(round(2.5))
# Вывод: 2

print(round(3.5))
# Вывод: 4

Такой метод округления может показаться странным, ведь в математике мы округляем число в меньшую сторону, если после запятой присутствуют цифры от 1 до 4, а в большую – цифры от 5 до 9. Однако банковское округление позволяет бороться с накоплением ошибки при совершении операций с округлёнными числами:

# Запишем исходное выражение:
expression = 1.5 + 2.5 + 3.5 + 4.5
print(expression)
# Вывод: 12

# Используем математическое округление:
math_round = 2 + 3 + 4 + 5 
print(math_round)
# Вывод: 14

# Используем банковское округление:
bank_round = 2 + 2 + 4 + 4
print(bank_round)
# Вывод: 12

Здесь математическое округление дало погрешность 2, в то время как банковское округление позволило её избежать.

1. Опишите приоритет выполнения арифметических операций.

2. Как происходит целочисленное деление в Python?

3. Что будет выведено на экран в результате выполнения данного кода?

print(13 % 2 + 1)
print(2 ** 3 // 3)
print(10 / 2 ** 2)
print(-25 * 4 / 5)
print((2 + 3) ** 2)
print(2 + 3 ** 2)

2
2
2.5
-20.0
25
11

4. Что будет выведено на экран в результате выполнения данного кода?

n_1 = 10 % 3 + 2
n_1 /= 3
print(n_1)

n_2 = 3 ** 2
n_2 -= 1
print(n_2)

n_3 = 21 // 4
n_3 += 2
print(n_3)

n_4 = 12 - 4 ** 2
n_4 *= 3
print(n_4)

n_5 = 30 / 2
n_5 %= 2
print(n_5)

1.0
8
7
-12
1.0

5. Округлите числа 0.15865 и 32.23124 до трёх знаков после запятой, а числа -8.87231 и 14.5 – до ближайшего целого числа.

print(round(0.15865, 3))
# Вывод: 0.159
print(round(32.23124, 3))
# Вывод: 32.231 
print(round(-8.87231))
# Вывод: -9
print(round(14.5))
# Вывод: 14