basforge

Ищем по названиям, тексту и разборам «Если не работает».

    EN
    Глава 3PythonОсновы

    Числа в Python: целые без предела, дроби с погрешностью

    У Python два вида чисел. Целые (int) — любой длины и точные. Дроби (float) — с погрешностью, поэтому 0.1 + 0.2 — это 0.30000000000000004. Переводим аптайм сервера из секунд в дни и часы, разбираем деление, остаток и округление и выясняем, куда делись 69 ГБ у диска на 1 ТБ.

    Новое здесьАрифметика: //, %, roundimport

    Что получим

    В Linux время работы сервера лежит в /proc/uptime — в секундах. Переводим его в дни, часы и минуты:

    # uptime.py
    uptime = 1_234_567   # секунд
    days = uptime // 86400
    hours = uptime % 86400 // 3600
    minutes = uptime % 3600 // 60
    print(days, "д", hours, "ч", minutes, "мин")
    python uptime.py
    # 14 д 6 ч 56 мин

    // — деление без остатка, % — остаток. 86 400 секунд в сутках: целых суток 14, а из остатка тем же способом достаём часы и минуты. Подчёркивания в 1_234_567 — для глаз, Python их пропускает.

    Что напечатает?
    print(round(2.5), round(3.5))
    Что напечатает?
    Ответ:
    2 4

    Половину Python округляет к чётному: 2.5 — к 2, 3.5 — к 4. Так при сумме многих округлённых чисел ошибки гасят друг друга, а не копятся в одну сторону.

    Как устроено: целые точные, дроби — нет

    Целое int занимает столько памяти, сколько нужно, поэтому длина не ограничена и счёт точный:

    >>> 2 ** 100
    1267650600228229401496703205376

    Дробь float — 64 бита в двоичной записи: около 16 значащих цифр и предел около 1.8e308. Большинство десятичных дробей в двоичном виде бесконечны, как ⅓ в десятичном, и хранится ближайшее значение:

    >>> 0.1 + 0.2
    0.30000000000000004
    >>> 0.1 + 0.2 == 0.3
    False
    >>> 10 / 3
    3.3333333333333335

    Для измерений — размеров, времени, скорости — погрешность в 16-м знаке не видна. Видна она в двух местах: при сравнении через == и в деньгах, где копейки складываются тысячами. Сравниваем через math.isclose, деньги считаем модулем decimal или в целых копейках:

    import math
    from decimal import Decimal
    
    print(math.isclose(0.1 + 0.2, 0.3))       # True
    print(Decimal("0.1") + Decimal("0.2"))    # 0.3

    import math подключает модуль math — он из стандартной библиотеки, ставить ничего не нужно («Запуск Python»). Дальше его функции пишем через точку: math.isclose, math.ceil. from decimal import Decimal берёт из модуля одно имя, и его пишем без приставки. Строки import ставим в начало файла.

    Деление, остаток и степень

    Код Результат Что делает
    7 / 2 3.5 деление; ответ всегда float, даже 6 / 2 — это 3.0
    7 // 2 3 деление без остатка, вниз: -7 // 2 — -4
    7 % 2 1 остаток: чётное число — n % 2 == 0
    2 ** 10 1024 степень; 2 ** 0.5 — корень, 1.4142135623730951
    abs(-5) 5 модуль числа
    max(3, 7, 1), min(…) 7, 1 наибольшее и наименьшее
    round(2.675, 2) 2.67 до двух знаков; 2.675 хранится чуть меньше, поэтому не 2.68
    math.ceil(4.1) 5 вверх до целого: сколько дисков нужно под 4,1 ТБ
    math.floor(4.9) 4 вниз до целого

    Целое с дробью дают дробь: 3 * 0.5 — 1.5. Целое из строки — int("100"), из дроби — int(4.7), хвост отбрасывается: это разобрано в «Переменные и типы».

    Куда делись 69 ГБ: десятичные и двоичные приставки

    Диск на 1 ТБ Windows показывает как 931 ГБ. Производитель считает килобайт за 1000 байт, Windows — за 1024:

    >>> 1_000_000_000_000 / 1000 ** 3
    1000.0
    >>> 1_000_000_000_000 / 1024 ** 3
    931.3225746154785

    Байты те же, единицы разные. В стандарте двоичные зовутся КиБ, МиБ, ГиБ; Windows пишет «ГБ», а имеет в виду ГиБ. Провайдер, как и производитель дисков, считает десятичными — поэтому в «Переменные и типы» мы делили на 1000.

    Шестнадцатеричные, восьмеричные, двоичные

    В конфигах числа бывают не только десятичные: цвет #ff8800, MAC-адрес, права chmod 755. Python пишет их с приставкой и переводит в обе стороны:

    Код Результат Где встречается
    0xff, int("ff", 16) 255 цвета, MAC, байты в дампе
    0o755, int("755", 8) 493 права файлов в Linux
    0b1010 10 биты, маски
    hex(255), oct(493), bin(10) '0xff', '0o755', '0b1010' обратно в строку

    int("0x1f") без основания — ValueError: строку с приставкой читаем с основанием, int("0x1f", 16), или без неё.

    Доработать самим

    Сколько дисков по 4 ТБ нужно под 10,5 ТБ данных

    Делим объём на размер диска и округляем вверх — math.ceil. Модуль подключаем первой строкой: import math.

    import math
    
    print(math.ceil(10.5 / 4))
    # 3
    Права 644 — в число и обратно в восьмеричную запись

    int с основанием 8 читает строку цифр, oct возвращает запись с приставкой 0o.

    mode = int("644", 8)
    print(mode, oct(mode))
    # 420 0o644
    Чётное ли число и делится ли год на 4

    Остаток от деления на 2 у чётного — 0. Сравнение == даёт True или False, его можно сразу печатать.

    print(10 % 2 == 0)      # True
    print(2026 % 4 == 0)    # False

    Если не работает

    0.1 + 0.2 == 0.3 даёт False

    Причина
    Дробь хранится в двоичном виде, и 0.1 в нём не записать точно: сумма выходит 0.30000000000000004.
    Делаем
    Дроби не сравниваем через ==: math.isclose(0.1 + 0.2, 0.3) или round(…, 2) == 0.3. Для денег — decimal.Decimal("0.1") или счёт в целых копейках и центах.

    round(2.5) даёт 2, а round(3.5) — 4

    Причина
    Python округляет половину к чётному — так меньше копится ошибка, когда округляют много чисел подряд.
    Делаем
    Нужно «половину вверх» для положительных — math.floor(x + 0.5). Для показа на экране округление не нужно: f"{x:.1f}".

    ZeroDivisionError: division by zero

    Причина
    Делим на ноль: /, // и % одинаково. Обычно ноль пришёл из данных — пустой файл, нулевой счётчик.
    Делаем
    Проверяем делитель до деления — условия — в главе «Условия».

    OverflowError: (34, 'Result too large')

    Причина
    Дробь вышла за предел float — около 1.8e308: 10.0 ** 400. У целых предела нет, у дробей есть.
    Делаем
    Считаем в целых, если можно: 10 ** 400 работает. Нужна огромная дробь — модуль decimal.

    ValueError: Exceeds the limit (4300 digits) for integer string conversion

    Причина
    Целое число длиннее 4300 цифр переводим в строку — print, str(), f-строка. Предел защищает от медленного перевода гигантских чисел.
    Делаем
    Поднимаем предел: import sys, потом sys.set_int_max_str_digits(0) — без предела.