Числа и булевы в Python: int, float, bool и арифметика

Два вида чисел и один вид истины

Числовые типы, которые ты будешь использовать каждый день, - int и float, плюс bool для истина/ложь. Этого достаточно почти для всей арифметики и логики, нужной обычной Python-программе.

count = 42
ratio = 0.25
is_ready = True

print(type(count), type(ratio), type(is_ready))

Python иногда называет булевы подтипом целых - True буквально равен 1, а False - 0, - что открывает пару полезных трюков дальше.

Целочисленная арифметика

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

print(2 ** 100)
print(1000 * 1000 * 1000 * 1000)

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

Арифметические операторы - те, что ожидаешь, плюс пара бонусных:

print(10 + 3)   # 13   addition
print(10 - 3)   # 7    subtraction
print(10 * 3)   # 30   multiplication
print(10 / 3)   # 3.3333... true division (returns a float)
print(10 // 3)  # 3    floor division (drops the remainder)
print(10 % 3)   # 1    modulo (the remainder)
print(10 ** 3)  # 1000 exponent

Три вещи из этого списка стоит запомнить:

• / всегда возвращает float в Python 3, даже когда обе стороны - целые. 10 / 2 даст тебе 5.0, а не 5. Нужно целое - используй //.
• // округляет в сторону минус бесконечности, так что -7 // 2 - это -4, а не -3. Необычно, но последовательно.
• % даёт остаток, и он удобен для «чётно ли это число?» (n % 2 == 0) и для обвёртывания в фиксированный диапазон.

Float и его знаменитая ловушка

Float-ы несовершенны по задумке. Они хранятся в двоичной форме, которая не может точно представить большинство десятичных дробей. Учебниковый пример:

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

Первая строка печатает 0.30000000000000004. Вторая - False. В любом языке, следующем стандарту IEEE 754 - Python, JavaScript, Java, C - поведение такое же. Это не баг Python.

На практике это означает две вещи:

1. Не сравнивай float через ==. Если нужно «достаточно близко» - используй math.isclose(a, b) или проверь abs(a - b) < some_tolerance.
2. Для денег используй decimal.Decimal. Модуль decimal из стандартной библиотеки даёт точную десятичную арифметику - никаких сюрпризов вроде 0.1 + 0.2. Он медленнее float, поэтому и не используется по умолчанию, но для валюты - правильный выбор.

from decimal import Decimal

total = Decimal("0.1") + Decimal("0.2")
print(total)

Преобразования между числовыми типами

Python не будет молча превращать целое в строку или строку в число. Ты просишь об этом явно:

age_text = "30"
age = int(age_text)
print(age + 5)

price = float("19.99")
print(price)

count = 7
label = "Count: " + str(count)
print(label)

Недопустимые преобразования поднимают ValueError:

>>> int("hello")
ValueError: invalid literal for int() with base 10: 'hello'

Сообщение об ошибке прямолинейно и его легко отработать. Почисти ввод или перехвати исключение.

Булевы чуть подробнее

True и False - два булевых значения, написанные ровно так, с заглавной буквы в начале. Большинство сравнений дают одно из них:

print(5 > 3)
print("abc" == "abc")
print([1] != [1])

Булевы операторы - and, or и not, записанные английскими словами, а не символами:

can_drive = True
has_car = False

print(can_drive and has_car)   # False - needs both
print(can_drive or has_car)    # True - needs one
print(not can_drive)           # False

Одна полезная тонкость: and и or не обязательно возвращают True или False - они возвращают значение, которое решило выражение. 0 or "fallback" даёт "fallback"; 5 and 10 даёт 10. Это позволяет писать короткие дефолты вроде name = user_input or "anonymous", но этот факт полезно помнить и тогда, когда булева проверка неожиданно возвращает не тот тип.

Truthy и falsy

Python считает многие значения «истинными» или «ложными», когда ты используешь их в булевом контексте вроде if или while. Falsy-значения такие:

• False
• 0, 0.0
• None
• Пустые контейнеры: "", [], {}, set(), ()

Всё остальное - truthy. Это позволяет писать более естественно выглядящие проверки:

name = ""

if name:
    print(f"Hello, {name}")
else:
    print("No name provided")

Читай if name: как «если в name что-то есть». Гораздо чище, чем if name != "":. Только с числами осторожнее - if count: воспримет 0 как «пропустить», и это обычно, но не всегда, то, чего ты хочешь. Если ноль - легитимное значение, лучше if count is not None:.

Булева арифметика

Поскольку булевы и есть целые, над ними можно делать арифметику:

checks = [True, False, True, True, False]
print(sum(checks))   # 3 - counts how many are True

Этот трюк всплывает достаточно часто, чтобы отложить в копилку. Если хочешь посчитать, сколько элементов списка проходят некоторый тест - суммируй генератор булевых:

scores = [52, 78, 91, 45, 88, 63]
above_60 = sum(score >= 60 for score in scores)
print(above_60)

Практические выводы

• Целые не переполняются. Пользуйся свободно.
• / возвращает float; для целочисленного деления - //.
• Не сравнивай float через ==; сравнивай с допуском или используй Decimal для денег.
• Truthy-проверки делают условия читабельнее - но помни, что 0 и пустые строки - falsy.

Дальше - input и print, два инструмента, превращающие твои скрипты из молчаливых программ в разговор.