如果您正在寻找一个不使用内置函数的解决方案。 唯一需要注意的是当你发送a = 000时。

def number_length(a: int) -> int:
    length = 0
    if a == 0:
        return length + 1
    else:
        while a > 0:
            a = a // 10
            length += 1
        return length
    

if __name__ == '__main__':
    print(number_length(123)
    assert number_length(10) == 2
    assert number_length(0) == 1
    assert number_length(256) == 3
    assert number_length(4444) == 4

设数字为n，则n中的位数为:

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

注意，这将为+ve个整数< 10e15给出正确答案。除此之外，返回类型的数学的精度限制。Log10开始起作用，结果可能相差1。我可以简单地在后面用len(str(n));这需要O(log(n))时间，相当于10的幂次迭代。

感谢@SetiVolkylany让我注意到这个限制。令人惊讶的是，看似正确的解决方案在实现细节中有警告。

这里是最简单的方法，不需要将int转换为字符串:

假设给出的数字为15位，例如;n = 787878899999999;

n=787878899999999 
n=abs(n) // we are finding absolute value because if the number is negative int to string conversion will produce wrong output

count=0 //we have taken a counter variable which will increment itself till the last digit

while(n):
    n=n//10   /*Here we are removing the last digit of a number...it will remove until 0 digits will left...and we know that while(0) is False*/
    count+=1  /*this counter variable simply increase its value by 1 after deleting a digit from the original number
print(count)   /*when the while loop will become False because n=0, we will simply print the value of counter variable

输入:

n=787878899999999

输出:

15

Python 2。* int需要4或8字节(32或64位)，这取决于你的Python版本。sys。Maxint(2**31-1用于32位int, 2**63-1用于64位int)将告诉您两种可能性中哪一种获得。

在Python 3中，int(就像Python 2中的long)可以取任意大小，直到可用内存的数量;sys。Getsizeof为任何给定值提供了一个很好的指示，尽管它也计算了一些固定开销:

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

如果像其他答案所建议的那样，您正在考虑整数值的某个字符串表示，那么只需取该表示的len，以10为基底或以其他方式!

from math import log10
digits = lambda n: ((n==0) and 1) or int(log10(abs(n)))+1

正如其他答案所示，使用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。然而，这种大小的整数可能会使您的计算机崩溃，所以这应该足够了。