对于子孙后代来说，这无疑是迄今为止解决这个问题最慢的方法:

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)

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

科学记数法格式，去掉指数:

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

我不知道速度如何，但很简单。

请注意小数点后的有效数位数(“5”在”。如果5e”将科学记数法的小数部分舍入到另一个数字，则可能会出现问题。我把它设得任意大，但可以反映出你所知道的最大数字的长度。

如果你必须要求用户输入，然后你必须数出有多少个数字，那么你可以这样做:

count_number = input('Please enter a number\t')

print(len(count_number))

注意:永远不要使用int作为用户输入。

正如其他答案所示，使用log10会导致大n的错误结果，而使用len(str(…))或手动循环会导致大n的性能变慢。Jodag的答案提供了一个非常好的替代方案，它只适用于可能会使您的计算机崩溃的整数，但我们可以做得更好，甚至更快(对于n足够小的数学。Log2保证是准确的)，避免使用对数，而是使用二进制:

def num_digits(n: int) -> int:
    assert n > 0
    i = int(0.30102999566398114 * (n.bit_length() - 1)) + 1
    return (10 ** i <= n) + i

让我们来分析一下。首先是奇怪的n.bit_length()。这将以二进制形式计算长度:

assert 4 == (0b1111).bit_length()
assert 8 == (0b1011_1000).bit_length()
assert 9 == (0b1_1011_1000).bit_length()

与对数不同，这对于整数来说既快速又精确。结果是，这个结果正好是(log2(n)) + 1。为了单独得到地板(log2(n))，我们减去1，因此n.bit_length() - 1。

接下来，我们乘以0.30102999566398114。这相当于log10(2)稍微舍入。这利用了对数规则，以便从地板(log2(n))计算地板(log10(n))的估计值。

现在，您可能想知道我们在这一点上可能有多差，因为尽管0.30102999566398114 * log2(n) ~ log10(n)，但对于floor(0.30102999566398114 * floor(log2(n))) ~ floor(log10(n))，情况并非如此。回想一下x - 1 < floor(x) <= x，我们可以做一些快速的计算:

log2(n) - 1 < floor(log2(n)) <= log2(n)

log10(n) - 0.30102999566398114 < 0.30102999566398114 * floor(log2(n)) <= log10(n)

floor(log10(n) - 0.30102999566398114) < floor(0.30102999566398114 * floor(log2(n))) <= floor(log10(n))

请注意，floor(log10(n) - 0.30102999566398114)至少是floor(log10(n)) - 1，这意味着我们与结果最多相差1。这是最后的修正，我们检查10 ** i <= n，当结果太小时导致额外的1 +，当结果刚刚好时导致0 +。

类似于Jodag的答案，这种方法实际上对非常非常大的n无效，大约在10 ** 2 ** 52左右，其中i的误差超过-1。然而，这种大小的整数可能会使您的计算机崩溃，所以这应该足够了。

这个问题已经问了好几年了，但是我已经编写了一个基准测试，其中包含了几种计算整数长度的方法。

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由Brian Preslopsky提供，size_str由GeekTantra提供，size_math由John La Rooy提供

以下是调查结果:

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 to 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)略快，比其他方法快得多。