Целые числа int и вещественные float – Учебник

1.6

О чём этот урок

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

Разминка. У вас 7 конфет и 2 друга, конфеты делятся только целиком. Сколько конфет достанется каждому и сколько останется лишних?

Ответ «по 3 каждому, 1 в остатке» вы наверняка посчитали мгновенно: деление с остатком проходят ещё в начальной школе. Сейчас увидим, как этот бытовой навык записывается на Python.

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

Целые и вещественные числа

int (integer) – тип данных для целых чисел, без дробной части: 5, -12, 0.

float (floating point number) – тип данных для чисел с дробной частью: 3.14, -0.5, 2.0.

Python различает эти типы по одному признаку – наличию точки в записи числа. 5 – это int, а 5.0 – уже float, хотя математически это одно и то же число. Точка здесь не украшение, а сигнал типа.

Разделитель дробной части в Python – точка, а не запятая, как принято в русской математической традиции: запись 3,14 Python поймёт не как одно дробное число, а как два значения через запятую.

print(type(5))      # <class 'int'>
print(type(5.0))    # <class 'float'>
print(type(-3))     # <class 'int'>
print(type(0.5))    # <class 'float'>

Что будет, если смешать int и float в одной операции

Если в арифметическом выражении встречаются оба типа, Python не ошибается и не отбрасывает дробную часть – он «повышает» результат до float, чтобы не потерять точность:

print(3 + 2.0)    # 5.0 – результат float, хотя одно из чисел было int

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

Семь арифметических операций

Оператор	Название	Пример	Результат
`+`	Сложение	`5 + 2`	`7`
`-`	Вычитание	`5 - 2`	`3`
`*`	Умножение	`5 * 2`	`10`
`**`	Возведение в степень	`5 ** 2`	`25`
`/`	Деление	`5 / 2`	`2.5`
`//`	Целочисленное деление (деление нацело)	`5 // 2`	`2`
`%`	Остаток от деления	`5 % 2`	`1`

Отдельно стоит запомнить: оператор / в Python всегда возвращает float, даже если числа делятся друг на друга без остатка – 10 / 2 даст 5.0, а не 5. Это принципиальное отличие от //, которая всегда «отбрасывает» дробную часть и возвращает int, если оба операнда были int.

Возвращаемся к разминке: 7 // 2 – это «по сколько досталось каждому» (3), а 7 % 2 – это «сколько осталось лишних» (1).

candies = 7
friends = 2

each = candies // friends      # 3 – досталось каждому
leftover = candies % friends   # 1 – осталось лишних

print(each, leftover)          # 3 1

Приоритет операций

Порядок вычисления в Python совпадает со школьной математикой:

Скобки () – вычисляются первыми, как и в математике.
** – возведение в степень.
*, /, //, % – умножение и все виды деления, слева направо.
+, - – сложение и вычитание.

Если сомневаетесь, как Python посчитает конкретное выражение – не гадайте, а расставьте скобки явно. Это всегда безопаснее и понятнее для человека, который потом будет читать ваш код.

print(2 + 3 * 4)     # 14 – сначала умножение, потом сложение
print((2 + 3) * 4)   # 20 – скобки меняют порядок
print(2 ** 3 ** 2)   # 512 – возведение в степень – справа налево

Почему 0.1 + 0.2 не равно 0.3

Особенность float, о которую спотыкаются все новички:

print(0.1 + 0.2)     # 0.30000000000000004

Это не ошибка Python и не поломка компьютера – так ведут себя дробные числа в любом языке программирования. Причина в том, что процессор хранит числа в двоичной системе, а привычная нам десятичная дробь 0.1 в двоичной записывается бесконечной последовательностью – примерно как 1/3 = 0,333… в десятичной. Бесконечное число в память не помещается, поэтому оно сохраняется приближённо, и при вычислениях крошечная погрешность вылезает наружу.

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

print(round(0.1 + 0.2, 2))   # 0.3
print(round(3.7))            # 4 – без второго аргумента до целого

У целых чисел этой проблемы нет: int хранится точно, и в Python его размер ограничен только объёмом памяти – даже число из тысячи цифр посчитается без потери точности.

Целые числа – отдельные точки на числовой прямой с шагом 1; вещественные числа заполняют прямую непрерывно.

Коротко

Разминка в начале урока – это ровно то, что делают операторы // и %: «по сколько досталось каждому» и «сколько осталось лишних».