В Python, как вы находите число цифр в целых числах?
Длина целого числа в Python
Ответ 1
Если вам нужна длина целого числа, как в количестве цифр целого числа, вы всегда можете преобразовать его в строку типа str(133) и найти ее длину как len(str(123)).
Ответ 2
Без преобразования в строку
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
Ответ 3
Все решения math.log10 дадут вам проблемы.
math.log10 работает быстро, но дает проблему, когда ваш номер больше, чем 999999999999997. Это связано с тем, что у float слишком много .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
Ответ 4
Python 2.* int принимает либо 4, либо 8 байтов (32 или 64 бит), в зависимости от вашей сборки Python. sys.maxint (2**31-1 для 32-битных int, 2**63-1 для 64-битных ints) сообщит вам, какая из двух возможностей получает.
В Python 3 int (например, long в Python 2) может принимать произвольные размеры до объема доступной памяти; sys.getsizeof дает хороший признак для любого заданного значения, хотя он также учитывает некоторые фиксированные накладные расходы:
>>> import sys
>>> sys.getsizeof(0)
12
>>> sys.getsizeof(2**99)
28
Если, как говорят другие ответы, вы думаете о некотором строчном представлении целочисленного значения, тогда просто возьмите len этого представления, будь то в базе 10 или иначе!
Ответ 5
Пусть число будет n, тогда число цифр в n определяется следующим образом:
math.floor(math.log10(n))+1
Обратите внимание, что это даст правильные ответы для + ve целых чисел < 10e15. Кроме того, предел точности возвращаемого типа math.log10 срабатывает, и ответ может быть отключен на 1. Я бы просто использовал len(str(n)) дальше этого; для этого требуется время O(log(n)), которое аналогично итерации по степеням 10.
Благодаря @SetiVolkylany для привлечения моего внимания к этому ограничению. Удивительно, как, казалось бы, правильные решения имеют оговорки в деталях реализации.
Ответ 6
Ну, без преобразования в строку я бы сделал что-то вроде:
def lenDigits(x):
"""
Assumes int(x)
"""
x = abs(x)
if x < 10:
return 1
return 1 + lenDigits(x / 10)
Минималистская рекурсия FTW
Ответ 7
Как уже упоминалось, дорогой пользователь @Calvintwr, функция math.log10 имеет проблему в числе вне диапазона [-999999999999997, 99999999999999997], где мы получаем ошибки с плавающей запятой. У меня была эта проблема с JavaScript (Google V8 и NodeJS) и C (компилятор GNU GCC), поэтому решение 'purely mathematically' здесь невозможно.
На основе этого gist и ответ дорогой пользователь @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 в 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
Ответ 8
Прошло несколько лет с тех пор, как этот вопрос был задан, но я собрал эталонный тест нескольких методов для вычисления длины целого числа.
def libc_size(i):
return libc.snprintf(buf, 100, c_char_p(b'%i'), i) # equivalent to 'return snprintf(buf, 100, "%i", i);'
def str_size(i):
return len(str(i)) # Length of 'i' as a string
def math_size(i):
return 1 + math.floor(math.log10(i)) # 1 + floor of log10 of i
def exp_size(i):
return int("{:.5e}".format(i).split("e")[1]) + 1 # e.g. '1e10' -> '10' + 1 -> 11
def mod_size(i):
return len("%i" % i) # Uses string modulo instead of str(i)
def fmt_size(i):
return len("{0}".format(i)) # Same as above but str.format
(функция libc требует настройки, которую я не включил)
size_exp благодаря Брайану Преслопски, size_str благодаря GeekTantra, а size_math благодаря Джону Ла Руи
Вот результаты:
Time for libc size: 1.2204 μs
Time for string size: 309.41 ns
Time for math size: 329.54 ns
Time for exp size: 1.4902 μs
Time for mod size: 249.36 ns
Time for fmt size: 336.63 ns
In order of speed (fastest first):
+ mod_size (1.000000x)
+ str_size (1.240835x)
+ math_size (1.321577x)
+ fmt_size (1.350007x)
+ libc_size (4.894290x)
+ exp_size (5.976219x)
(Отказ от ответственности: функция запускается на входах от 1 до 1 000 000)
Вот результаты для sys.maxsize - 100000 до sys.maxsize:
Time for libc size: 1.4686 μs
Time for string size: 395.76 ns
Time for math size: 485.94 ns
Time for exp size: 1.6826 μs
Time for mod size: 364.25 ns
Time for fmt size: 453.06 ns
In order of speed (fastest first):
+ mod_size (1.000000x)
+ str_size (1.086498x)
+ fmt_size (1.243817x)
+ math_size (1.334066x)
+ libc_size (4.031780x)
+ exp_size (4.619188x)
Как видите, mod_size (len("%i" % i)) является самым быстрым, немного быстрее, чем использование str(i) и значительно быстрее, чем другие.
Ответ 9
Для потомков, несомненно, самое медленное решение этой проблемы:
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)
Ответ 10
from math import log10
digits = lambda n: ((n==0) and 1) or int(log10(abs(n)))+1
Ответ 11
Предполагая, что вы запрашиваете наибольшее число, которое вы можете сохранить в целочисленном размере, значение зависит от реализации. Я предлагаю вам не думать об этом при использовании python. В любом случае достаточно большое значение может быть сохранено в "integer" python. Помните, что Python использует утиную печать!
Изменить: Я дал свой ответ до выяснения того, что ассеру понадобилось количество цифр. Для этого я согласен с методом, предложенным принятым ответом. Больше ничего добавить!
Ответ 12
def length(i):
return len(str(i))
Ответ 13
Это можно сделать для целых чисел быстро, используя:
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
Для справок в будущем.
Ответ 14
Отформатируйте в научной записи и вычеркните экспоненту:
int("{:.5e}".format(1000000).split("e")[1]) + 1
Я не знаю о скорости, но это просто.
Обратите внимание на число значащих цифр после десятичной дроби ("5" в ".5e" может быть проблемой, если округлить десятичную часть научной нотации до другой цифры. Я установил ее произвольно большим, но мог бы отразить длина наибольшего числа, о котором вы знаете.
Ответ 15
Подсчитайте количество цифр без преобразования целого числа в строку:
x=123
x=abs(x)
i = 0
while x >= 10**i:
i +=1
# i is the number of digits
Ответ 16
>>> a=12345
>>> a.__str__().__len__()
5