Python 3. Арифметические операции
Числовые типы данных
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.
Логические значения True и False в Python тоже являются числами (тип bool — это подвид int). True равно 1, а False равно 0. Поэтому True + True вернёт 2. Но на практике так лучше не писать.
Арифметические операции
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 имеют свои приоритеты (как и в математике):
- Сначала выполняются выражения в скобках;
- Затем возведение в степень;
- Затем умножение и деление (
*,/,//,%); - И в самом конце сложение и вычитание.
Операции с одинаковым приоритетом выполняются слева направо. Единственное исключение — возведение в степень, оно выполняется справа налево.
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 .