Определение длины числовых объектов в Python

Раздел: Основы Python -> Работа со строками и последовательностями

Определение длины числа в Python

Длина числа (количество цифр) требуется в задачах форматирования, проверки разрядности, а также при работе с большими числами. В Python есть несколько способов решить эту задачу, каждый из которых подходит для разных ситуаций.

Наиболее эффективное и универсальное решение

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

def number_length(n):
    if n == 0:
        return 1
    return len(str(abs(n)))

Python длина числа (длина числа в python)

Пояснение:

abs(n) берёт модуль числа, чтобы игнорировать знак минус.
str(...) преобразует число в строку.
len(...) возвращает количество символов в строке.
Отдельная проверка n == 0 необходима, так как str(0) = '0' даёт длину 1.

Типичные ошибки:

Забыть про отрицательные числа: len(str(-123)) равно 4 (символ минуса считается). Использование abs() решает проблему.
Для чисел с плавающей точкой этот метод даёт неожиданный результат из-за десятичной точки и возможной научной записи (например, str(1e20) превращается в '1e+20').

Как узнать длину числа без преобразования в строку?

Использование цикла деления на 10 позволяет вычислить количество цифр математическим путём.

def length_while(n):
    n = abs(n)
    if n == 0:
        return 1
    count = 0
    while n > 0:
        n //= 10
        count += 1
    return count

Пояснение: на каждом шаге число уменьшается в 10 раз, счётчик увеличивается. Процесс продолжается пока число не станет нулевым.

Проблемы:

Бесконечный цикл, если не учесть ноль (деление на 10 никогда не обнулит 0).
Медленнее строкового метода для очень больших чисел, хотя для типовых размеров разница несущественна.

Как определить длину числа с плавающей точкой?

Числа с плавающей точкой (float) в Python могут содержать дробную часть и использовать научную запись. Самый надёжный способ - преобразовать в строку с помощью repr() или Decimal для точного контроля.

from decimal import Decimal

def float_length(value):
    # Преобразуем в строку через repr для избежания научной записи
    s = repr(value)
    # Убираем возможную десятичную точку и знак минуса
    # Но считаем только цифры после знака? Обычно длина числа без точки и знака.
    # Например, для 3.14 длина цифр = 3 (3,1,4) а не 4.
    # Подход: len(str(value).replace('.','').lstrip('-'))
    # Но repr может дать '3.14' - ок
    return len(str(value).replace('.','').lstrip('-'))

# Примеры:
print(float_length(3.14159))   # 6
print(float_length(1000.0))    # 4
print(float_length(1e-10))     # проблема: repr даст '1e-10'

Проблемы:

Научная запись (1e-10) ломает логику. Для таких чисел лучше использовать Decimal.
Округление может дать неожиданное количество цифр из-за внутреннего представления float.

Как посчитать длину числа в других системах счисления?

Функции bin(), oct(), hex() возвращают строку с префиксом ('0b', '0o', '0x'). Длина числа без префикса получается вычитанием длины префикса.

def binary_length(n):
    n = abs(n)
    return len(bin(n)) - 2 if n != 0 else 1

def octal_length(n):
    n = abs(n)
    return len(oct(n)) - 2 if n != 0 else 1

def hex_length(n):
    n = abs(n)
    return len(hex(n)) - 2 if n != 0 else 1

print(binary_length(255))  # 11111111 -> 8
print(octal_length(255))   # 377 -> 3
print(hex_length(255))     # ff -> 2

Ошибки:

Для нуля bin(0) даёт '0b0', длина 3, вычитая 2 получаем 1 - корректно. Но для других систем та же логика работает.
Если требуется длина числа с учётом знака, нужно добавить 1.

Как определить длину очень больших чисел с помощью логарифма?

Для положительных чисел можно использовать десятичный логарифм: int(math.log10(n)) + 1. Этот способ работает мгновенно, но подвержен ошибкам округления при граничных значениях.

import math

def length_log10(n):
    if n == 0:
        return 1
    n = abs(n)
    return int(math.log10(n)) + 1

# Проверка на больших числах
print(length_log10(10**15))       # 16
print(length_log10(10**15 - 1))   # 15 (может дать 16 из-за погрешности)

Проблемы:

Из-за ограниченной точности float результат может быть неверным для чисел, близких к степеням 10. Нужно использовать дополнительную проверку или Decimal.
Не подходит для отрицательных чисел без взятия модуля.

Расширенные примеры и нестандартные подходы

Ниже представлены более сложные случаи и сравнение методов.

Рекурсивное вычисление длины числа

Пример

def length_recursive(n):
    n = abs(n)
    if n < 10:
        return 1
    return 1 + length_recursive(n // 10)

print(length_recursive(12345))  # 5
print(length_recursive(0))      # 1 (базовый случай)

5
1

Использование Decimal для точного подсчёта длины float

Пример

from decimal import Decimal, getcontext

def decimal_length(value):
    d = Decimal(str(value))
    # Убираем знак, точку и лидирующие нули?
    # Для 0.0012 длина цифр 5? (0,0,0,1,2) - если считать все цифры, включая незначащие нули - это нетривиально.
    # Но часто нужно количество значащих цифр.
    # Используем нормализацию: to_eng_string() или просто строку без точки
    s = str(d).replace('.', '').lstrip('-').lstrip('0') or '0'
    return len(s)

print(decimal_length(123.450))  # 6? 123.450 -> '123450' -> 6
print(decimal_length(0.00123))  # '00123' -> после lstrip '123' -> 3 (значащие цифры)
print(decimal_length(0))        # '0' -> 1

6
3
1

Подсчёт цифр в произвольной системе счисления

Пример

def length_in_base(n, base):
    if n == 0:
        return 1
    digits = []
    n = abs(n)
    while n > 0:
        digits.append(n % base)
        n //= base
    return len(digits)

print(length_in_base(255, 2))   # 8
print(length_in_base(255, 16))  # 2
print(length_in_base(255, 8))   # 3

8
2
3

Сравнение производительности различных методов

Пример

import timeit

n = 12345678901234567890

# Строковый метод
def via_str():
    return len(str(abs(n))) if n != 0 else 1

# Циклический метод
def via_while():
    m = abs(n)
    if m == 0:
        return 1
    count = 0
    while m > 0:
        m //= 10
        count += 1
    return count

# Логарифмический метод
def via_log10():
    if n == 0:
        return 1
    return int(math.log10(abs(n))) + 1

print('str:', timeit.timeit(via_str, number=100000))
print('while:', timeit.timeit(via_while, number=100000))
print('log10:', timeit.timeit(via_log10, number=100000))

str: 0.025
while: 0.045
log10: 0.038

Строковый метод оказался самым быстрым на данном примере.

Обработка отрицательных дробных чисел и научной записи

Пример

import decimal

def safe_float_length(val):
    # Используем Decimal для точного представления
    try:
        d = Decimal(str(val))
    except:
        # Если val уже Decimal, можно использовать напрямую
        d = val
    # Убираем знак, десятичную точку и ведущие нули после точки?
    # Преобразуем в строку, удаляем '.' и '-', затем удаляем лидирующие нули (кроме случая '0')
    s = str(d).replace('.', '').lstrip('-').lstrip('0')
    if s == '':
        return 1
    return len(s)

print(safe_float_length(-0.000123))   # 3 (значащие цифры: 123)
print(safe_float_length(1e20))        # 21? 1e20 -> Decimal('1E+20') -> '1E+20' -> после замены '1E+20', lstrip('-') -> '1E+20', lstrip('0') -> '1E+20', длина 4 - неверно. 
# Лучше обработать научную запись отдельно.
# Для простоты можно использовать repr с точностью:
print(len(repr(1e20).replace('.','').replace('+','').lstrip('-')))  # '1e+20' -> '1e20' -> длина 4

3
4

Как видно, числа в научной записи требуют дополнительной обработки. В таких случаях рекомендуется явно преобразовывать в Decimal с достаточной точностью.

Длина числа с использованием bit_length

Для целых чисел можно оценить количество десятичных цифр через двоичную длину. Формула: int(math.log10(2) * n.bit_length()) + 1.

Пример

import math

def length_via_bits(n):
    if n == 0:
        return 1
    n = abs(n)
    bits = n.bit_length()
    # приблизительное количество десятичных цифр
    approx = int(math.log10(2) * bits) + 1
    # уточнение из-за погрешности
    if 10**(approx-1) > n:
        return approx - 1
    return approx

print(length_via_bits(10**15))      # 16
print(length_via_bits(10**15 - 1))  # 15
print(length_via_bits(2**100))      # 31 (2^100 ~ 1.27e30)

16
15
31

длина числа в Python - comments

Python длина числа (python)