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

Python поддерживает все распространенные арифметические операции:

• +

  Сложение двух чисел:

  print(6 + 2)  # 8

• -

  Вычитание двух чисел:

  print(6 - 2)  # 4

• *

  Умножение двух чисел:

  print(6 * 2)  # 12

• /

  Деление двух чисел:

  print(6 / 2)  # 3.0

• //

  Целочисленное деление двух чисел:

  print(7 / 2)  # 3.5
  print(7 // 2)  # 3
  

  Данная операция возвращает целочисленный результат деления, отбрасывая дробную часть

• **

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

  print(6 ** 2)  # Возводим число 6 в степень 2. Результат - 36
  

• %

  Получение остатка от деления:

  print(7 % 2)  # Получение остатка от деления числа 7 на 2. Результат - 1
  

  В данном случае ближайшее число к 7, которое делится на 2 без остатка, это 6. Поэтому остаток от деления равен 7 - 6 = 1

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

Операции	Направление
**	Справо налево
* / // %	Слева направо
+ -	Слева направо

Пусть у нас выполняется следующее выражение:

number = 3 + 4 * 5 ** 2 + 7
print(number)  # 110

Здесь начале выполняется возведение в степень (5 ** 2) как операция с большим приоритетом, далее результат умножается на 4 (25 * 4), затем происходит сложение (3 + 100) и далее опять идет сложение (103 + 7).

Чтобы переопределить порядок операций, можно использовать скобки:

number = (3 + 4) * (5 ** 2 + 7)
print(number)  # 224

Следует отметить, что в арифметических операциях могут принимать участие как целые, так и дробные числа. Если в одной операции участвует целое число (int) и число с плавающей точкой (float), то целое число приводится к типу float.

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

Ряд специальных операций позволяют использовать присвоить результат операции первому операнду:

• +=

  Присвоение результата сложения

• -=

  Присвоение результата вычитания

• *=

  Присвоение результата умножения

• /=

  Присвоение результата от деления

• //=

  Присвоение результата целочисленного деления

• **=

  Присвоение степени числа

• %=

  Присвоение остатка от деления

Примеры операций:

number = 10
number += 5
print(number)  # 15

number -= 3
print(number)  # 12

number *= 4
print(number)  # 48

Округление и функция round

При операциях с числами типа float надо учитывать, что результат операций с ними может быть не совсем точным. Например:

first_number = 2.0001
second_number = 5
third_number = first_number / second_number
print(third_number)	# 0.40002000000000004

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

print(2.0001 + 0.1)  # 2.1001000000000003

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

first_number = 2.0001
second_number = 0.1
third_number = first_number + second_number
print(round(third_number))  # 2

В функцию round() передается число, которое надо округлить. Если в функцию передается одно число, как в примере выше, то оно округляется до целого.

Функция round() также может принимать второе число, которое указывает, сколько знаков после запятой должно содержать получаемое число:

first_number = 2.0001
second_number = 0.1
third_number = first_number + second_number
print(round(third_number, 4))  # 2.1001

В данном случае число third_number округляется до 4 знаков после запятой.

Если в функцию передается только одно значение - только округляемое число, оно округляется то ближайшего целого

Примеры округлений:

# округление до целого числа
print(round(2.49))  # 2 - округление до ближайшего целого 2
print(round(2.51))  # 3

Однако если округляемая часть равна одинаково удалена от двух целых чисел, то округление идет к ближайшему четному:

print(round(2.5))   # 2 - ближайшее четное
print(round(3.5))   # 4 - ближайшее четное

Округление производится до ближайшего кратного 10 в степени минус округляемая часть:

# округление до двух знаков после запятой
print(round(2.554, 2))      # 2.55
print(round(2.5551, 2))      # 2.56
print(round(2.554999, 2))   # 2.55
print(round(2.499, 2))      # 2.5

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

# округление до двух знаков после запятой
print(round(2.545, 2))   # 2.54
print(round(2.555, 2))   # 2.56 - округление до четного
print(round(2.565, 2))   # 2.56
print(round(2.575, 2))   # 2.58

print(round(2.655, 2))   # 2.65 - округление не до четного
print(round(2.665, 2))   # 2.67
print(round(2.675, 2))   # 2.67

Подобно о проблеме можно почитать к документации.