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

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

1356   15  

15 ответов:

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

199  
2013-03-23 04:19:29

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

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 '-'

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

вот некоторые ориентиры. Элемент 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  
2010-02-03 08:47:34

вся математика.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  
2015-03-07 06:36:59

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

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

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

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

20  
2010-02-03 07:06:44

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

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

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

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

12  
2017-03-14 00:51:40

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

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

    x = abs(x)

    if x < 10:
        return 1

    return 1 + lenDigits(x / 10)

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

10  
2015-09-18 06:50:17

как уже упоминалось Уважаемый пользователь @Calvintwr, функция math.log10 имеет проблему в числе за пределами диапазона [-999999999999997, 999999999999997], где мы получаем ошибки с плавающей запятой. У меня была эта проблема с JavaScript (Google V8 и NodeJS) и C (компилятор GNU GCC), поэтому a '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 (включительно) и все в порядке. Этого должно быть достаточно, так как длина max integer number в 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  
2017-05-23 13:31:38

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

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  
2014-05-16 16:50:44 
from math import log10
digits = lambda n: ((n==0) and 1) or int(log10(abs(n)))+1
2  
2010-07-16 00:10:12

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

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

1  
2010-02-03 07:02:43 
def length(i):
  return len(str(i))
1  
2010-12-17 21:32:53

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

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  
2016-10-13 14:42:01

формат в научной нотации и срывать экспоненту:

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

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

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

0  
2018-03-06 23:01:18

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

x=123
x=abs(x)
i = 0
while x >= 10**i:
    i +=1
# i is the number of digits
0  
2018-08-12 20:03:30 
>>> a=12345
>>> a.__str__().__len__()
5
-9  
2010-02-03 07:22:28

Comments

    Ничего не найдено.
Click here to cancel reply.