Длина целого числа в Python

в Python, как вы находите количество цифр в целом числе?

157
count integer python

15 ответов

Если вы хотите длину целого числа, как в количестве цифр в целом, вы всегда можете преобразовать его в строку, как str(133) и находим его длину как len(str(123)).

199

без преобразования в строку

import math
digits = int(math.log10(n))+1

также обрабатывать нулевые и отрицательные числа

import math
if n > 0:
    digits = int(math.log10(n))+1
elif n == 0:
    digits = 1
else:
    digits = int(math.log10(-n))+2 # +1 if you don't count the '-'

вы, вероятно, захотите поместить это в функцию:)

вот некоторые ориентиры. The len(str()) уже отстает даже для совсем небольших чисел 

timeit math.log10(2**8)
1000000 loops, best of 3: 746 ns per loop
timeit len(str(2**8))
1000000 loops, best of 3: 1.1 µs per loop

timeit math.log10(2**100)
1000000 loops, best of 3: 775 ns per loop
 timeit len(str(2**100))
100000 loops, best of 3: 3.2 µs per loop

timeit math.log10(2**10000)
1000000 loops, best of 3: 844 ns per loop
timeit len(str(2**10000))
100 loops, best of 3: 10.3 ms per loop
171

вся математика.решения log10 дадут вам проблемы.

математика.log10 быстро, но дает проблему, когда ваш номер больше, чем 999999999999997. Это потому, что поплавков слишком много .9s, в результате чего результат округляется.

решение состоит в том, чтобы использовать метод счетчика while для чисел выше этого порога.

чтобы сделать это еще быстрее, создайте 10^16, 10^17 и так далее и сохраните как переменные в списке. Таким образом, это как стол уважать.

def getIntegerPlaces(theNumber):
    if theNumber <= 999999999999997:
        return int(math.log10(theNumber)) + 1
    else:
        counter = 15
        while theNumber >= 10**counter:
            counter += 1
        return counter
24

Python 2.* ints возьмите 4 или 8 байт (32 или 64 бита), в зависимости от вашей сборки Python. sys.maxint (2**31-1 для 32-битных ints,2**63-1 для 64-битных ints) скажет вам, какая из двух возможностей получает.

В Python 3, ints (как longs в Python 2) может принимать произвольные размеры до объема доступной памяти;sys.getsizeof дает вам хорошее указание для любого заданного значения, хотя это тут также подсчитайте некоторые фиксированные накладные расходы:

>>> import sys
>>> sys.getsizeof(0)
12
>>> sys.getsizeof(2**99)
28

если, как показывают другие ответы, вы думаете о некотором строковом представлении целочисленного значения, то просто возьмите len этого представления, будь то в базе 10 или иначе!

20

пусть будет n тогда количество цифр в n дано:

math.floor(math.log10(n))+1

обратите внимание, что это даст правильные ответы для целых чисел +ve math.log10 кайф и ответ может быть от 1. Я бы просто использовал len(str(n)) помимо этого; это требует O(log(n)) время, которое совпадает с итерацией по степеням 10.

спасибо @SetiVolkylany за attenstion этого ограничения. Свой удивительно, как, казалось бы, правильные решения имеют оговорки в деталях реализации.

12

Ну, без преобразования в строку я бы сделал что-то вроде:

def lenDigits(x): 
    """
    Assumes int(x)
    """

    x = abs(x)

    if x < 10:
        return 1

    return 1 + lenDigits(x / 10)

минималистская рекурсия FTW

10

как уже упоминалось Уважаемый пользователь @Calvintwr, функция math.log10 имеет проблему в числе вне диапазона [-999999999999997, 999999999999997], где мы получаем ошибки с плавающей запятой. У меня была эта проблема с JavaScript (Google V8 и NodeJS) и C (компилятор GNU GCC), поэтому 'purely mathematically' решение здесь невозможно.

основываясь на этом суть и ответ Уважаемый пользователь @Calvintwr

import math


def get_count_digits(number: int):
    """Return number of digits in a number."""

    if number == 0:
        return 1

    number = abs(number)

    if number <= 999999999999997:
        return math.floor(math.log10(number)) + 1

    count = 0
    while number:
        count += 1
        number //= 10
    return count

я проверял это по номерам длиной до 20 (включительно) и все в порядке. Этого должно быть достаточно, потому что максимальное целое число длины в 64-битной системе равно 19 (len(str(sys.maxsize)) == 19).

assert get_count_digits(-99999999999999999999) == 20
assert get_count_digits(-10000000000000000000) == 20
assert get_count_digits(-9999999999999999999) == 19
assert get_count_digits(-1000000000000000000) == 19
assert get_count_digits(-999999999999999999) == 18
assert get_count_digits(-100000000000000000) == 18
assert get_count_digits(-99999999999999999) == 17
assert get_count_digits(-10000000000000000) == 17
assert get_count_digits(-9999999999999999) == 16
assert get_count_digits(-1000000000000000) == 16
assert get_count_digits(-999999999999999) == 15
assert get_count_digits(-100000000000000) == 15
assert get_count_digits(-99999999999999) == 14
assert get_count_digits(-10000000000000) == 14
assert get_count_digits(-9999999999999) == 13
assert get_count_digits(-1000000000000) == 13
assert get_count_digits(-999999999999) == 12
assert get_count_digits(-100000000000) == 12
assert get_count_digits(-99999999999) == 11
assert get_count_digits(-10000000000) == 11
assert get_count_digits(-9999999999) == 10
assert get_count_digits(-1000000000) == 10
assert get_count_digits(-999999999) == 9
assert get_count_digits(-100000000) == 9
assert get_count_digits(-99999999) == 8
assert get_count_digits(-10000000) == 8
assert get_count_digits(-9999999) == 7
assert get_count_digits(-1000000) == 7
assert get_count_digits(-999999) == 6
assert get_count_digits(-100000) == 6
assert get_count_digits(-99999) == 5
assert get_count_digits(-10000) == 5
assert get_count_digits(-9999) == 4
assert get_count_digits(-1000) == 4
assert get_count_digits(-999) == 3
assert get_count_digits(-100) == 3
assert get_count_digits(-99) == 2
assert get_count_digits(-10) == 2
assert get_count_digits(-9) == 1
assert get_count_digits(-1) == 1
assert get_count_digits(0) == 1
assert get_count_digits(1) == 1
assert get_count_digits(9) == 1
assert get_count_digits(10) == 2
assert get_count_digits(99) == 2
assert get_count_digits(100) == 3
assert get_count_digits(999) == 3
assert get_count_digits(1000) == 4
assert get_count_digits(9999) == 4
assert get_count_digits(10000) == 5
assert get_count_digits(99999) == 5
assert get_count_digits(100000) == 6
assert get_count_digits(999999) == 6
assert get_count_digits(1000000) == 7
assert get_count_digits(9999999) == 7
assert get_count_digits(10000000) == 8
assert get_count_digits(99999999) == 8
assert get_count_digits(100000000) == 9
assert get_count_digits(999999999) == 9
assert get_count_digits(1000000000) == 10
assert get_count_digits(9999999999) == 10
assert get_count_digits(10000000000) == 11
assert get_count_digits(99999999999) == 11
assert get_count_digits(100000000000) == 12
assert get_count_digits(999999999999) == 12
assert get_count_digits(1000000000000) == 13
assert get_count_digits(9999999999999) == 13
assert get_count_digits(10000000000000) == 14
assert get_count_digits(99999999999999) == 14
assert get_count_digits(100000000000000) == 15
assert get_count_digits(999999999999999) == 15
assert get_count_digits(1000000000000000) == 16
assert get_count_digits(9999999999999999) == 16
assert get_count_digits(10000000000000000) == 17
assert get_count_digits(99999999999999999) == 17
assert get_count_digits(100000000000000000) == 18
assert get_count_digits(999999999999999999) == 18
assert get_count_digits(1000000000000000000) == 19
assert get_count_digits(9999999999999999999) == 19
assert get_count_digits(10000000000000000000) == 20
assert get_count_digits(99999999999999999999) == 20

все примеры кодов, протестированных с Python 3.5

4

для потомков, без сомнения, самое медленное решение этой проблемы:

def num_digits(num, number_of_calls=1):
    "Returns the number of digits of an integer num."
    if num == 0 or num == -1:
        return 1 if number_of_calls == 1 else 0
    else:
        return 1 + num_digits(num/10, number_of_calls+1)
3
from math import log10
digits = lambda n: ((n==0) and 1) or int(log10(abs(n)))+1
2

предполагая, что вы запрашиваете наибольшее число, которое вы можете сохранить в целом числе, значение зависит от реализации. Я предлагаю вам не думать таким образом при использовании python. В любом случае, довольно большое значение может быть сохранено в Python 'integer'. Помните, что Python использует утиный ввод!

Edit: Я дал свой ответ до разъяснения, что спрашивающий хотел количество цифр. Для этого, я согласен с методом, предложенным принято отвечать. Ничего больше добавить!

1
def length(i):
  return len(str(i))
1

Это можно сделать для целых чисел быстро, используя:

len(str(abs(1234567890)))

который получает длину строки абсолютного значения "1234567890"

abs возвращает число без отрицательных значений (только величина числа), str слепки/преобразует его в строку и len возвращает длину строки этой строки.

если вы хотите, чтобы он работал для поплавков, вы можете использовать одно из следующих:

# Ignore all after decimal place
len(str(abs(0.1234567890)).split(".")[0])

# Ignore just the decimal place
len(str(abs(0.1234567890)))-1

для будущее ссылка.

1

формат в научной нотации и снять показатель:

int("{:.5e}".format(1000000).split("e")[1]) + 1

Я не знаю о скорости, но это просто.

обратите внимание на количество значащих цифр после десятичного знака ("5"в".5e " может быть проблемой, если она округляет десятичную часть научной нотации до другой цифры. Я установил его произвольно большим, но мог бы отразить длину самого большого числа, о котором вы знаете.

0

подсчитайте количество цифр без преобразования целого числа в строку:

x=123
x=abs(x)
i = 0
while x >= 10**i:
    i +=1
# i is the number of digits
0
>>> a=12345
>>> a.__str__().__len__()
5
-9