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

В этой статье разберём числовые типы данных в Python 3: int, float и complex. Научимся пользоваться арифметическими операциями, узнаем порядок их выполнения, как округлять числа и какие ошибки могут возникнуть при работе с ними.

Числовые типы данных

Python 3 позволяет создавать три разных типа числовых объектов:

  • int — целое, положительное или отрицательное число. В Python нет ограничений на размер целых чисел, то есть они могут быть очень большими (ограничена только память компьютера). Пример целого числа — 5.
  • float — число с плавающей точкой (дробное число). Оно занимает в памяти фиксированный размер, поэтому у него есть ограничения: по максимальному значению и по точности. Пример такого числа — 1.5.
  • complex — комплексное число. Про них можете почитать отдельно, например в этой статье . Пример комплексного числа — 2 + 2j.

Чтобы узнать тип объекта, используется функция type():

a = 5
b = 1.5
c = 2 + 2j
print(type(a))
print(type(b))
print(type(c))

Исполнение:

<class 'int'>
<class 'float'>
<class 'complex'>

Для удобства чтения большие числа можно записывать с символом подчёркивания. Python его просто игнорирует:

print(1_000_000)
print(1e3)

Исполнение:

1000000
1000.0

Запись 1e3 — это экспоненциальная форма, она означает 1 умножить на 10 в степени 3. Такое число всегда будет типа float.

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

Python 3 поддерживает следующие арифметические операции:

ОперацияНазваниеПример
+сложение5 + 2
-вычитание7 - 3
*умножение3 * 4
/деление10 / 2
//целочисленное деление14 // 4
%остаток от деления14 % 4
**возведение в степень5 ** 3

Посмотрим на них в действии:

print(5 + 2)
print(7 - 3)
print(3 * 4)
print(10 / 2)
print(10 / 3)
print(5 ** 3)
print(14 // 4)
print(14 % 4)

Исполнение:

7
4
12
5.0
3.3333333333333335
125
3
2

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

Если нужно получить целую часть от деления, то используют целочисленное деление //. А если нужен остаток — операцию %. Они хорошо дополняют друг друга: 14 разделить на 4 — это 3 и 2 в остатке. Оба результата сразу можно получить функцией divmod():

print(divmod(14, 4))

Исполнение:

(3, 2)

Операция % часто используется, чтобы проверить чётность числа. Остаток от деления на 2 у чётных чисел равен 0, у нечётных — 1.

Типы результата

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

print(5 + 2.0)
print(type(5 + 2.0))
print(10 // 2)
print(10.0 // 3)

Исполнение:

7.0
<class 'float'>
5
3.0

Преобразование типов

Результат деления мы можем преобразовать в целое число с помощью функции int():

print(int(10 / 2))
print(int(7.9))
print(int(-7.9))

Исполнение:

5
7
-7

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

Точно так же мы можем превратить целое число в число с плавающей точкой:

print(float(2))

Исполнение:

2.0

Также int() и float() умеют превращать в числа строки, например, когда вы получаете число от пользователя:

print(int("42"))
print(float("3.5"))

Исполнение:

42
3.5

Отрицательные числа и целочисленное деление

Здесь есть один момент, на котором часто спотыкаются. Операция // округляет результат вниз (в сторону меньшего числа), а не отбрасывает дробную часть. С положительными числами разницы не видно, а вот с отрицательными она есть:

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

Исполнение:

-4
-3
1
2
  • -7 / 2 это -3.5. Функция int() отбросила дробную часть и получилось -3, а // округлил вниз до -4.
  • Остаток от деления при этом считается так, чтобы выполнялось равенство: a == (a // b) * b + (a % b).
    • Случай 7 % 3. 7 // 3
    • 7 / 3 ≈ 2,33. Округление вниз даёт 2. 2 * 3 = 6.Остаток: 7 - 6 = 1.
    • Случай -7 % 3
    • -7 / 3 ≈ -2,33. Округление вниз даёт -3. -3 * 3 = -9. Остаток: -7 - (-9) = 2.

Составные операторы присваивания

Часто нужно изменить значение переменной на основе её же текущего значения. Для этого есть сокращённая запись:

x = 10
x += 5
print(x)
x -= 3
print(x)
x *= 2
print(x)
x /= 4
print(x)

Исполнение:

15
12
24
6.0

Запись x += 5 — это то же самое, что x = x + 5. Такие операторы есть для всех арифметических операций: +=, -=, *=, /=, //=, %=, **=.

Порядок выполнения операций

Арифметические операции в Python имеют свои приоритеты (как и в математике):

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

Операции с одинаковым приоритетом выполняются слева направо. Единственное исключение — возведение в степень, оно выполняется справа налево.

print(2 + 3 * 4)
print((2 + 3) * 4)
print(10 - 2 - 3)
print(100 / 10 * 2)
print(2 ** 3 ** 2)
print(-2 ** 2)
print((-2) ** 2)
print(2 ** -1)

Исполнение:

14
20
5
20.0
512
-4
4
0.5

Разберём некоторые примеры:

  • 2 ** 3 ** 2 — сначала считается 3 ** 2 (это 9), затем 2 ** 9 (это 512);
  • -2 ** 2 — сначала возводим в степень 2 ** 2, и только потом применяем минус, поэтому получаем -4. Чтобы возвести в степень именно отрицательное число, его нужно взять в скобки;
  • 2 ** -1 — отрицательная степень даёт дробное число, это 1 / 2.

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

Полезные встроенные функции

Для работы с числами в Python есть несколько встроенных функций:

print(abs(-5))
print(pow(2, 10))
print(round(3.14159, 2))

Исполнение:

5
1024
3.14
  • abs() — возвращает модуль числа (число без знака);
  • pow(a, b) — возводит a в степень b, то же самое, что a ** b;
  • round(число, знаков) — округляет число до указанного количества знаков после запятой. Если количество знаков не указывать, то получим целое число.

У функции round() есть особенность: она использует так называемое банковское округление. Если число находится ровно посередине, то оно округляется до ближайшего чётного целого:

print(round(2.5))
print(round(3.5))

Исполнение:

2
4

Точность чисел с плавающей точкой

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

print(0.1 + 0.2)
print(0.1 + 0.2 == 0.3)

Исполнение:

0.30000000000000004
False

Это не ошибка Python, так работают числа с плавающей точкой во всех языках программирования. Что с этим делать:

  • для вывода на экран — округлить число функцией round();
  • для сравнения — не использовать ==, а использовать функцию isclose() из модуля math;
  • для денег и других расчётов, где важна точность — использовать модуль decimal.
import math
from decimal import Decimal

print(round(0.1 + 0.2, 2))
print(math.isclose(0.1 + 0.2, 0.3))
print(Decimal("0.1") + Decimal("0.2"))

Исполнение:

0.3
True
0.3

Обратите внимание, что в Decimal числа передаются строкой. Если передать обычное число с плавающей точкой, то неточность уже будет внесена.

Комплексные числа

Комплексные числа используются редко, но в Python они поддерживаются «из коробки». У комплексного числа есть действительная и мнимая части, которые можно получить через атрибуты real и imag. С такими числами можно выполнять те же арифметические операции:

z = 2 + 2j
print(z.real)
print(z.imag)
print(z * (1 + 1j))

Исполнение:

2.0
2.0
4j

Некоторые ошибки при работе с числами

Слишком большое число float

К целому числу (int) Python не предъявляет ограничений по размеру, а вот число с плавающей точкой (float) не может быть больше, чем примерно 1,8 × 10308. Это значение чуть меньше, чем 2 в степени 1024. Узнать точный предел можно через модуль sys:

import sys

print(sys.float_info.max)

Исполнение:

1.7976931348623157e+308

Если при возведении в степень мы выйдем за этот предел, то получим ошибку:

print(2.5 ** 1024)

Исполнение:

OverflowError: (34, 'Result too large')

А вот при умножении Python ошибку не вызовет, а вернёт специальное значение inf (бесконечность):

print(1e308 * 10)

Исполнение:

inf

С целыми числами таких проблем нет, например:

print(2 ** 100)

Исполнение:

1267650600228229401496703205376

Начиная с Python 3.11 есть одно ограничение: целое число нельзя превратить в строку, если в нём больше 4300 цифр. Это защита от атак, которые перегружают процессор. Само вычисление при этом работает, но вывод через print() или str() вызовет ошибку:

print(len(str(2 ** 1000)))
print(len(str(10 ** 5000)))

Исполнение:

302
ValueError: Exceeds the limit (4300 digits) for integer string conversion; use sys.set_int_max_str_digits() to increase the limit

В первой строке мы получили количество цифр в числе 2 в степени 1000, их 302. Во второй строке число уже слишком большое. Предел можно изменить функцией sys.set_int_max_str_digits(), но делать это стоит осознанно.

Деление на ноль

Ещё одной довольно известной ошибкой считается деление на ноль:

print(3 / 0)

Исполнение (последняя строка трейсбека):

ZeroDivisionError: division by zero

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

Чтобы программа не падала из-за такой ошибки, её можно перехватить:

try:
    print(3 / 0)
except ZeroDivisionError:
    print("На ноль делить нельзя")

Исполнение:

На ноль делить нельзя

Как работает конструкция try и except, я расскажу в отдельной статье.

Про другие типы данных можете почитать:


Если понравилась статья, подпишись на мой канал в VK или Telegram .