blocks|key|1125222|text|如果您希望整数的长度与整数中的位数相同，则始终可以将其转换为像str(133)这样的字符串，并像len(str(123))一样找到它的长度。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1125223|entityMap^0|V|8|1C|D|0^^$0|@$1|2|3|4|5|6|7|H|8|@$9|I|A|J|B|C]|$9|K|A|L|B|C]]|D|@]|E|$]]|$1|F|3|-4|5|6|7|M|8|@]|D|@]|E|$]]]|G|$]]

If you want the length of an integer as in the number of digits in the integer, you can always convert it to string like <code>str(133)</code> and find its length like <code>len(str(123))</code>.

blocks|key|1125276|text|不转换为字符串|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1125277|import+math
digits+=+int(math.log10(n))%2B1|code-block|syntax|javascript|1125278|还可以处理零和负数|1125279|import+math
if+n+>+0:
++++digits+=+int(math.log10(n))%2B1
elif+n+==+0:
++++digits+=+1
else:
++++digits+=+int(math.log10(-n))%2B2+#+%2B1+if+you+don't+count+the+'-'+|1125280|您可能希望将其放入一个函数中:)|1125281|以下是一些基准测试。即使是很小的数字，len(str())也已经落后了|offset|length|style|CODE|1125282|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|1125283|entityMap^0|0|0|0|0|0|J|A|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Y|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|Z|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|10|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|11|8|@$O|12|P|13|Q|R]]|9|@]|A|$]]|$1|S|3|T|5|D|7|14|8|@]|9|@]|A|$E|F]]|$1|U|3|-4|5|6|7|15|8|@]|9|@]|A|$]]]|V|$]]

Without conversion to string

<pre><code>import math
digits = int(math.log10(n))+1
</code></pre>

To also handle zero and negative numbers

<pre><code>import math
if n &gt; 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 '-' 
</code></pre>

You'd probably want to put that in a function :)

Here are some benchmarks. The <code>len(str())</code> is already behind for even quite small numbers 

<pre><code>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
</code></pre>

blocks|key|1340555|text|所有的math.log10解决方案都会给你带来问题。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1340556|math.log10很快，但是当你的数字大于999999999999997的时候会出问题。这是因为浮点数的.9s太多，导致结果向上舍入。|1340557|解决方案是对超过该阈值的数字使用while计数器方法。|1340558|为了更快，可以创建10%5E16、10%5E17等等，并将其作为变量存储在列表中。这样，它就像一个表查找。|1340559|def+getIntegerPlaces(theNumber):
++++if+theNumber+<=+999999999999997:
++++++++return+int(math.log10(theNumber))+%2B+1
++++else:
++++++++counter+=+15
++++++++while+theNumber+>=+10**counter:
++++++++++++counter+%2B=+1
++++++++return+counter|code-block|syntax|javascript|1340560|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|P|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|Q|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|R|8|@]|9|@]|A|$]]|$1|H|3|I|5|J|7|S|8|@]|9|@]|A|$K|L]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

<h2>All math.log10 solutions will give you problems.</h2>

math.log10 is fast but gives problem when your number is greater than 999999999999997. This is because the float have too many .9s, causing the result to round up.

The solution is to use a while counter method for numbers above that threshold.

To make this even faster, create 10^16, 10^17 so on so forth and store as variables in a list. That way, it is like a table lookup.

<pre><code>def getIntegerPlaces(theNumber):
 if theNumber &lt;= 999999999999997:
 return int(math.log10(theNumber)) + 1
 else:
 counter = 15
 while theNumber &gt;= 10**counter:
 counter += 1
 return counter
</code></pre>

blocks|key|1340853|text|这个问题已经提出好几年了，但我已经编写了一个基准测试，其中包含了几种计算整数长度的方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1340854|def+libc_size(i):+
++++return+libc.snprintf(buf,+100,+c_char_p(b'%25i'),+i)+#+equivalent+to+`return+snprintf(buf,+100,+"%25i",+i);`

def+str_size(i):
++++return+len(str(i))+#+Length+of+`i`+as+a+string

def+math_size(i):
++++return+1+%2B+math.floor(math.log10(i))+#+1+%2B+floor+of+log10+of+i

def+exp_size(i):
++++return+int("{:.5e}".format(i).split("e")[1])+%2B+1+#+e.g.+`1e10`+->+`10`+%2B+1+->+11

def+mod_size(i):
++++return+len("%25i"+%25+i)+#+Uses+string+modulo+instead+of+str(i)

def+fmt_size(i):
++++return+len("{0}".format(i))+#+Same+as+above+but+str.format|code-block|syntax|javascript|1340855|(+libc函数需要一些设置，我没有包括这些设置)|1340856|感谢Brian+Preslopsky感谢size_exp，感谢GeekTantra感谢size_str，感谢John+La+Rooy感谢size_math|offset|length|style|CODE|1340857|结果如下：|1340858|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):
%2B+mod_size+(1.000000x)
%2B+str_size+(1.240835x)
%2B+math_size+(1.321577x)
%2B+fmt_size+(1.350007x)
%2B+libc_size+(4.894290x)
%2B+exp_size+(5.976219x)|1340859|(免责声明:该函数在输入1到1,000,000上运行)|1340860|以下是从sys.maxsize+-+100000到sys.maxsize的结果|1340861|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):
%2B+mod_size+(1.000000x)
%2B+str_size+(1.086498x)
%2B+fmt_size+(1.243817x)
%2B+math_size+(1.334066x)
%2B+libc_size+(4.031780x)
%2B+exp_size+(4.619188x)|1340862|正如您所看到的，mod_size+(len("%25i"+%25+i))是最快的，比使用str(i)稍微快一点，但比其他方法快得多。|1340863|entityMap^0|0|0|0|K|8|17|8|1W|9|0|0|0|0|4|K|P|B|0|0|8|8|I|D|14|6|0^^$0|@$1|2|3|4|5|6|7|12|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|13|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|14|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|15|8|@$K|16|L|17|M|N]|$K|18|L|19|M|N]|$K|1A|L|1B|M|N]]|9|@]|A|$]]|$1|O|3|P|5|6|7|1C|8|@]|9|@]|A|$]]|$1|Q|3|R|5|D|7|1D|8|@]|9|@]|A|$E|F]]|$1|S|3|T|5|6|7|1E|8|@]|9|@]|A|$]]|$1|U|3|V|5|6|7|1F|8|@$K|1G|L|1H|M|N]|$K|1I|L|1J|M|N]]|9|@]|A|$]]|$1|W|3|X|5|D|7|1K|8|@]|9|@]|A|$E|F]]|$1|Y|3|Z|5|6|7|1L|8|@$K|1M|L|1N|M|N]|$K|1O|L|1P|M|N]|$K|1Q|L|1R|M|N]]|9|@]|A|$]]|$1|10|3|-4|5|6|7|1S|8|@]|9|@]|A|$]]]|11|$]]

It's been several years since this question was asked, but I have compiled a benchmark of several methods to calculate the length of an integer. 

<pre class="lang-python prettyprint-override"><code>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` -&gt; `10` + 1 -&gt; 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
</code></pre>

(the libc function requires some setup, which I haven't included)

<code>size_exp</code> is thanks to Brian Preslopsky, <code>size_str</code> is thanks to GeekTantra, and <code>size_math</code> is thanks to John La Rooy

Here are the results:

<pre><code>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)
</code></pre>

(Disclaimer: the function is run on inputs 1 to 1,000,000)

Here are the results for <code>sys.maxsize - 100000</code> to <code>sys.maxsize</code>:

<pre><code>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)
</code></pre>

As you can see, <code>mod_size</code> (<code>len("%i" % i)</code>) is the fastest, slightly faster than using <code>str(i)</code> and significantly faster than others.

blocks|key|1125357|text|假设数字为n，则n中的位数由下式给出：|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1125358|math.floor(math.log10(n))%2B1|code-block|syntax|javascript|1125359|请注意，这将给出<+10e15的%2Bve整数的正确答案。除此之外，math.log10的返回类型的精度限制开始发挥作用，答案可能会超出1。我会简单地使用len(str(n))；这需要O(log(n))时间，这与在10的幂上迭代相同。|1125360|感谢@SetiVolkylany将我的注意力引向这一限制。令人惊讶的是，看似正确的解决方案在实现细节中具有警告。|1125361|entityMap^0|5|1|8|1|0|0|W|A|23|B|2I|9|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]|$9|T|A|U|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|W|8|@$9|X|A|Y|B|C]|$9|Z|A|10|B|C]|$9|11|A|12|B|C]]|D|@]|E|$]]|$1|M|3|N|5|6|7|13|8|@]|D|@]|E|$]]|$1|O|3|-4|5|6|7|14|8|@]|D|@]|E|$]]]|P|$]]

Let the number be <code>n</code> then the number of digits in <code>n</code> is given by:

<pre><code>math.floor(math.log10(n))+1
</code></pre>

Note that this will give correct answers for +ve integers &lt; 10e15. Beyond that the precision limits of the return type of <code>math.log10</code> kicks in and the answer may be off by 1. I would simply use <code>len(str(n))</code> beyond that; this requires <code>O(log(n))</code> time which is same as iterating over powers of 10.

Thanks to @SetiVolkylany for bringing my attenstion to this limitation. Its amazing how seemingly correct solutions have caveats in implementation details.

blocks|key|1340599|text|好吧，在不转换为字符串的情况下，我会这样做：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1340600|def+lenDigits(x):+
++++"""
++++Assumes+int(x)
++++"""

++++x+=+abs(x)

++++if+x+<+10:
++++++++return+1

++++return+1+%2B+lenDigits(x+/+10)|code-block|syntax|javascript|1340601|极简递归FTW|1340602|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

Well, without converting to string I would do something like:

<pre><code>def lenDigits(x): 
 """
 Assumes int(x)
 """

 x = abs(x)

 if x &lt; 10:
 return 1

 return 1 + lenDigits(x / 10)
</code></pre>

Minimalist recursion FTW

blocks|key|1125635|text|在不将整数转换为字符串的情况下计算位数：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1125636|x=123
x=abs(x)
i+=+0
while+x+>=+10**i:
++++i+%2B=1
#+i+is+the+number+of+digits|code-block|syntax|javascript|1125637|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Count the number of digits w/o convert integer to a string:

<pre><code>x=123
x=abs(x)
i = 0
while x &gt;= 10**i:
 i +=1
# i is the number of digits
</code></pre>

blocks|key|1340506|text|对于子孙后代来说，毫无疑问，这个问题最慢的解决方案是：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1340507|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+%2B+num_digits(num/10,+number_of_calls%2B1)|code-block|syntax|javascript|1340508|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

For posterity, no doubt by far the slowest solution to this problem:

<pre><code>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)
</code></pre>

blocks|key|1341117|text|以下是一个庞大但快速的版本：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1341118|def+nbdigit+(+x+):
++++if+x+>=+10000000000000000+:+#+17+-
++++++++return+len(+str(+x+))
++++if+x+<+100000000+:+#+1+-+8
++++++++if+x+<+10000+:+#+1+-+4
++++++++++++if+x+<+100+++++++++++++:+return+(x+>=+10)%2B1+
++++++++++++else+++++++++++++++++++:+return+(x+>=+1000)%2B3
++++++++else:+#+5+-+8+++++++++++++++++++++++++++++++++++++++++++++++++
++++++++++++if+x+<+1000000+++++++++:+return+(x+>=+100000)%2B5+
++++++++++++else+++++++++++++++++++:+return+(x+>=+10000000)%2B7
++++else:+#+9+-+16+
++++++++if+x+<+1000000000000+:+#+9+-+12
++++++++++++if+x+<+10000000000+++++:+return+(x+>=+1000000000)%2B9+
++++++++++++else+++++++++++++++++++:+return+(x+>=+100000000000)%2B11
++++++++else:+#+13+-+16
++++++++++++if+x+<+100000000000000+:+return+(x+>=+10000000000000)%2B13+
++++++++++++else+++++++++++++++++++:+return+(x+>=+1000000000000000)%2B15|code-block|syntax|javascript|1341119|对于不太大的数字，只有5次比较。在我的电脑上，它比math.log10版本快约30%25，比len(+str())版本快5%25。好的..。如果你不狂热地使用它，就不会那么有吸引力。|offset|length|style|CODE|1341120|下面是我用来测试/测量我的函数的一组数字：|1341121|n+=+[+int(+(i%2B1)**(+17/7.+))+for+i+in+xrange(+1000000+)]+%2B+[0,10**16-1,10**16,10**16%2B1]|1341122|注:它不管理负数，但适应很容易…|1341123|entityMap^0|0|0|P|A|18|B|0|0|0|0^^$0|@$1|2|3|4|5|6|7|U|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|W|8|@$I|X|J|Y|K|L]|$I|Z|J|10|K|L]]|9|@]|A|$]]|$1|M|3|N|5|6|7|11|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|12|8|@]|9|@]|A|$E|F]]|$1|Q|3|R|5|6|7|13|8|@]|9|@]|A|$]]|$1|S|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|T|$]]

Here is a bulky but fast version :

<pre><code>def nbdigit ( x ):
 if x &gt;= 10000000000000000 : # 17 -
 return len( str( x ))
 if x &lt; 100000000 : # 1 - 8
 if x &lt; 10000 : # 1 - 4
 if x &lt; 100 : return (x &gt;= 10)+1 
 else : return (x &gt;= 1000)+3
 else: # 5 - 8 
 if x &lt; 1000000 : return (x &gt;= 100000)+5 
 else : return (x &gt;= 10000000)+7
 else: # 9 - 16 
 if x &lt; 1000000000000 : # 9 - 12
 if x &lt; 10000000000 : return (x &gt;= 1000000000)+9 
 else : return (x &gt;= 100000000000)+11
 else: # 13 - 16
 if x &lt; 100000000000000 : return (x &gt;= 10000000000000)+13 
 else : return (x &gt;= 1000000000000000)+15
</code></pre>

Only 5 comparisons for not too big numbers.
On my computer it is about 30% faster than the <code>math.log10</code> version and 5% faster than the <code>len( str())</code> one.
Ok... no so attractive if you don't use it furiously.

And here is the set of numbers I used to test/measure my function:

<pre><code>n = [ int( (i+1)**( 17/7. )) for i in xrange( 1000000 )] + [0,10**16-1,10**16,10**16+1]
</code></pre>

NB: it does not manage negative numbers, but the adaptation is easy...

blocks|key|1125299|text|from+math+import+log10
digits+=+lambda+n:+((n==0)+and+1)+or+int(log10(abs(n)))%2B1|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1125300|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>from math import log10
digits = lambda n: ((n==0) and 1) or int(log10(abs(n)))+1
</code></pre>

blocks|key|1125310|text|def+length(i):
++return+len(str(i))|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1125311|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>def length(i):
 return len(str(i))
</code></pre>

blocks|key|1340663|text|对于整数，可以使用以下命令快速完成此操作：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1340664|len(str(abs(1234567890)))|code-block|syntax|javascript|1340665|它获取绝对值为"1234567890“的字符串的长度。|1340666|abs返回不带任何负值的数字(只返回数字的大小)，str将其强制转换/转换为字符串，len返回该字符串的字符串长度。|offset|length|style|CODE|1340667|如果希望它适用于浮点数，则可以使用以下任一方法：|1340668|#+Ignore+all+after+decimal+place
len(str(abs(0.1234567890)).split(".")[0])

#+Ignore+just+the+decimal+place
len(str(abs(0.1234567890)))-1|1340669|将来可以用来作参考。|1340670|entityMap^0|0|0|0|0|3|P|3|16|3|0|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Y|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|Z|8|@$K|10|L|11|M|N]|$K|12|L|13|M|N]|$K|14|L|15|M|N]]|9|@]|A|$]]|$1|O|3|P|5|6|7|16|8|@]|9|@]|A|$]]|$1|Q|3|R|5|D|7|17|8|@]|9|@]|A|$E|F]]|$1|S|3|T|5|6|7|18|8|@]|9|@]|A|$]]|$1|U|3|-4|5|6|7|19|8|@]|9|@]|A|$]]]|V|$]]

It can be done for integers quickly by using:

<pre><code>len(str(abs(1234567890)))
</code></pre>

Which gets the length of the string of the absolute value of "1234567890"

<code>abs</code> returns the number WITHOUT any negatives (only the magnitude of the number), <code>str</code> casts/converts it to a string and <code>len</code> returns the string length of that string.

If you want it to work for floats, you can use either of the following:

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

# Ignore just the decimal place
len(str(abs(0.1234567890)))-1
</code></pre>

For future reference.

blocks|key|1125564|text|用科学记数法格式化，取指数：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1125565|int("{:.5e}".format(1000000).split("e")[1])+%2B+1|code-block|syntax|javascript|1125566|我不知道速度，但它很简单。|1125567|请注意小数点后的有效位数(+".5e“中的"5”如果将科学记数法的小数部分四舍五入为另一个数字，则可能是一个问题。我将其设置为任意大小，但可以反映出您所知道的最大数的长度。|1125568|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

Format in scientific notation and pluck off the exponent:

<pre><code>int("{:.5e}".format(1000000).split("e")[1]) + 1
</code></pre>

I don't know about speed, but it's simple. 

Please note the number of significant digits after the decimal (the "5" in the ".5e" can be an issue if it rounds up the decimal part of the scientific notation to another digit. I set it arbitrarily large, but could reflect the length of the largest number you know about.

blocks|key|1340879|text|def+count_digit(number):
++if+number+>=+10:
++++count+=+2
++else:
++++count+=+1
++while+number//10+>+9:
++++count+%2B=+1
++++number+=+number//10
++return+count|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1340880|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>def count_digit(number):
 if number &gt;= 10:
 count = 2
 else:
 count = 1
 while number//10 &gt; 9:
 count += 1
 number = number//10
 return count
</code></pre>

blocks|key|1340977|text|def+digits(n)
++++count+=+0
++++if+n+==+0:
++++++++return+1
++++
++++if+n+<+0:
++++++++n+*=+-1

++++while+(n+>=+10**count):
++++++++count+%2B=+1
++++++++n+%2B=+n%2510

++++return+count

print(digits(25))+++#+Should+print+2
print(digits(144))++#+Should+print+3
print(digits(1000))+#+Should+print+4
print(digits(0))++++#+Should+print+1|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1340978|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre class="lang-python prettyprint-override"><code>def digits(n)
 count = 0
 if n == 0:
 return 1
 
 if n &lt; 0:
 n *= -1

 while (n &gt;= 10**count):
 count += 1
 n += n%10

 return count

print(digits(25)) # Should print 2
print(digits(144)) # Should print 3
print(digits(1000)) # Should print 4
print(digits(0)) # Should print 1
</code></pre>

blocks|key|1340953|text|如果你必须要求用户输入，然后你必须计算有多少个数字，那么你可以这样做：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1340954|count_number+=+input('Please+enter+a+number\t')

print(len(count_number))|code-block|syntax|javascript|1340955|注意:永远不要将int作为用户输入。|1340956|entityMap^0|0|0|0^^$0|@$1|2|3|4|5|6|7|K|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|L|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|M|8|@]|9|@]|A|$]]|$1|I|3|-4|5|6|7|N|8|@]|9|@]|A|$]]]|J|$]]

If you have to ask an user to give input and then you have to count how many numbers are there then you can follow this:

<pre><code>count_number = input('Please enter a number\t')

print(len(count_number))
</code></pre>

Note: Never take an int as user input.

blocks|key|1341044|text|我的代码如下所示；我使用了log10方法：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1341045|from+math+import+*|code-block|syntax|javascript|1341046|def+digit_count(编号)：|1341047|if+number>1+and+round(log10(number))>=log10(number)+and+number%2510!=0+:
++++return+round(log10(number))
elif++number>1+and+round(log10(number))<log10(number)+and+number%2510!=0:
++++return+round(log10(number))%2B1
elif+number%2510==0+and+number!=0:
++++return+int(log10(number)%2B1)
elif+number==1+or+number==0:
++++return+1|1341048|我必须指定1和0的情况，因为log10(1)=0和log10(0)=ND，因此前面提到的条件不满足。但是，此代码仅适用于整数。|1341049|entityMap^0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Q|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$]]|$1|M|3|-4|5|6|7|T|8|@]|9|@]|A|$]]]|N|$]]

My code for the same is as follows;i have used the log10 method:

<pre><code>from math import *
</code></pre>

def digit_count(number):

<pre><code>if number&gt;1 and round(log10(number))&gt;=log10(number) and number%10!=0 :
 return round(log10(number))
elif number&gt;1 and round(log10(number))&lt;log10(number) and number%10!=0:
 return round(log10(number))+1
elif number%10==0 and number!=0:
 return int(log10(number)+1)
elif number==1 or number==0:
 return 1
</code></pre>

I had to specify in case of 1 and 0 because log10(1)=0 and log10(0)=ND and hence the condition mentioned isn't satisfied. However, this code works only for whole numbers.

blocks|key|1126059|text|最好的答案是mathlog10更快，但我得到的结果表明len(str(n))更快。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1126060|arr+=+[]
for+i+in+range(5000000):
++++arr.append(random.randint(0,12345678901234567890))|code-block|syntax|javascript|1126061|%25%25timeit

for+n+in+arr:
++++len(str(n))
//2.72+s+±+304+ms+per+loop+(mean+±+std.+dev.+of+7+runs,+1+loop+each)|1126062|%25%25timeit

for+n+in+arr:
++++int(math.log10(n))%2B1
//3.13+s+±+545+ms+per+loop+(mean+±+std.+dev.+of+7+runs,+1+loop+each)|1126063|此外，我没有在数学方法中添加逻辑来返回准确的结果，我只能想象它会进一步减慢速度。|1126064|我不知道之前的答案是如何证明数学方法更快的。|1126065|entityMap^0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|R|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|D|7|S|8|@]|9|@]|A|$E|F]]|$1|I|3|J|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|U|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|V|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|W|8|@]|9|@]|A|$]]]|P|$]]

Top answers are saying mathlog10 faster but I got results that suggest len(str(n)) is faster.
<pre><code>arr = []
for i in range(5000000):
 arr.append(random.randint(0,12345678901234567890))
</code></pre>
<pre><code>%%timeit

for n in arr:
 len(str(n))
//2.72 s ± 304 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
</code></pre>
<pre><code>%%timeit

for n in arr:
 int(math.log10(n))+1
//3.13 s ± 545 ms per loop (mean ± std. dev. of 7 runs, 1 loop each)
</code></pre>
Besides, I haven't added logic to the math way to return accurate results and I can only imagine it slows it even more.
I have no idea how the previous answers proved the maths way is faster though.

blocks|key|1341297|text|n+=+3566002020360505
count+=+0
while(n>0):
++count+%2B=+1
++n+=+n+//10
print(f"The+number+of+digits+in+the+number+are:+{count}")|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1341298|输出:数字中的位数为:+16|unstyled|1341299|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|J|8|@]|9|@]|A|$]]|$1|G|3|-4|5|F|7|K|8|@]|9|@]|A|$]]]|H|$]]

<pre><code>n = 3566002020360505
count = 0
while(n&gt;0):
 count += 1
 n = n //10
print(f&quot;The number of digits in the number are: {count}&quot;)
</code></pre>
output: The number of digits in the number are: 16

blocks|key|1126213|text|如果您正在寻找不使用内置函数的解决方案。唯一的警告是当你发送a+=+000的时候。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1126214|def+number_length(a:+int)+->+int:
++++length+=+0
++++if+a+==+0:
++++++++return+length+%2B+1
++++else:
++++++++while+a+>+0:
++++++++++++a+=+a+//+10
++++++++++++length+%2B=+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|code-block|syntax|javascript|1126215|entityMap^0|U|7|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@$9|N|A|O|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|P|8|@]|D|@]|E|$I|J]]|$1|K|3|-4|5|6|7|Q|8|@]|D|@]|E|$]]]|L|$]]

If you are looking for a solution without using inbuilt functions.
Only caveat is when you send <code>a = 000</code>.
<pre><code>def number_length(a: int) -&gt; int:
 length = 0
 if a == 0:
 return length + 1
 else:
 while a &gt; 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
</code></pre>

blocks|key|1126279|text|以下是计算任何数字小数之前的位数的另一种方法|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1126280|from+math+import+fabs

len(format(fabs(100),".0f"))
Out[102]:+3

len(format(fabs(1e10),".0f"))
Out[165]:+11

len(format(fabs(1235.4576),".0f"))
Out[166]:+4|code-block|syntax|javascript|1126281|我做了一个简短的基准测试，测试了10,000个循环|1126282|num+++++len(str(num))+++++----++len(format(fabs(num),".0f"))+----+speed-up
2**1e0++2.179400e-07+sec++----+++++8.577000e-07+sec++++++++++----+0.2541
2**1e1++2.396900e-07+sec++----+++++8.668800e-07+sec++++++++++----+0.2765
2**1e2++9.587700e-07+sec++----+++++1.330370e-06+sec++++++++++----+0.7207
2**1e3++2.321700e-06+sec++----+++++1.761305e-05+sec++++++++++----+0.1318|1126283|它速度较慢，但是一个更简单的选择。|1126284|但即使是这个解决方案也给出了错误的9999999999999998结果|1126285|len(format(fabs(9999999999999998),".0f"))
Out[146]:+16
len(format(fabs(9999999999999999),".0f"))
Out[145]:+17|1126286|entityMap^0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|S|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|T|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|U|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|V|8|@]|9|@]|A|$E|F]]|$1|K|3|L|5|6|7|W|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|X|8|@]|9|@]|A|$]]|$1|O|3|P|5|D|7|Y|8|@]|9|@]|A|$E|F]]|$1|Q|3|-4|5|6|7|Z|8|@]|9|@]|A|$]]]|R|$]]

Here is another way to compute the number of digit before the decimal of any number
<pre class="lang-py prettyprint-override"><code>from math import fabs

len(format(fabs(100),&quot;.0f&quot;))
Out[102]: 3

len(format(fabs(1e10),&quot;.0f&quot;))
Out[165]: 11

len(format(fabs(1235.4576),&quot;.0f&quot;))
Out[166]: 4
</code></pre>
I did a brief benchmark test, for 10,000 loops
<pre class="lang-py prettyprint-override"><code>num len(str(num)) ---- len(format(fabs(num),&quot;.0f&quot;)) ---- speed-up
2**1e0 2.179400e-07 sec ---- 8.577000e-07 sec ---- 0.2541
2**1e1 2.396900e-07 sec ---- 8.668800e-07 sec ---- 0.2765
2**1e2 9.587700e-07 sec ---- 1.330370e-06 sec ---- 0.7207
2**1e3 2.321700e-06 sec ---- 1.761305e-05 sec ---- 0.1318
</code></pre>
It is slower but a simpler option.
But even this solution does give wrong results from 9999999999999998
<pre class="lang-py prettyprint-override"><code>len(format(fabs(9999999999999998),&quot;.0f&quot;))
Out[146]: 16
len(format(fabs(9999999999999999),&quot;.0f&quot;))
Out[145]: 17
</code></pre>

blocks|key|1126325|text|一种快速的解决方案，它使用基于"Better+way+to+compute+floor+of+log(n,b)+for+integers+n+and+b?“的floor(log10(n))的自校正实现。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1126326|import+math

def+floor_log(n,+b):
++++res+=+math.floor(math.log(n,+b))
++++c+=+b**res
++++return+res+%2B+(b*c+<=+n)+-+(c+>+n)

def+num_digits(n):
++++return+1+if+n+==+0+else+1+%2B+floor_log(abs(n),+10))|code-block|syntax|javascript|1126327|这是相当快的，并且在任何时候n+<+10**(2**52)+(它真的真的很大)都可以工作。|1126328|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/a/69421255/2790047^0|27|F|G|1P|0|0|0|E|F|0^^$0|@$1|2|3|4|5|6|7|U|8|@$9|V|A|W|B|C]]|D|@$9|X|A|Y|1|Z]]|E|$]]|$1|F|3|G|5|H|7|10|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|11|8|@$9|12|A|13|B|C]]|D|@]|E|$]]|$1|M|3|-4|5|6|7|14|8|@]|D|@]|E|$]]]|N|$O|$5|P|Q|R|E|$S|T]]]]

A fast solution that uses a self-correcting implementation of <code>floor(log10(n))</code> based on &quot;<a href="https://stackoverflow.com/a/69421255/2790047">Better way to compute floor of log(n,b) for integers n and b?</a>&quot;.
<pre class="lang-py prettyprint-override"><code>import math

def floor_log(n, b):
 res = math.floor(math.log(n, b))
 c = b**res
 return res + (b*c &lt;= n) - (c &gt; n)

def num_digits(n):
 return 1 if n == 0 else 1 + floor_log(abs(n), 10))
</code></pre>
This is quite fast and will work whenever <code>n &lt; 10**(2**52)</code> (which is really really big).

blocks|key|1126374|text|没有导入和像str()这样的函数的解决方案|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1126375|def+numlen(num):
++++result+=+1
++++divider+=+10
++++while+num+%25+divider+!=+num:
++++++++divider+*=+10
++++++++result+%2B=+1
++++return+result|code-block|syntax|javascript|1126376|entityMap^0|0|0^^$0|@$1|2|3|4|5|6|7|I|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|J|8|@]|9|@]|A|$E|F]]|$1|G|3|-4|5|6|7|K|8|@]|9|@]|A|$]]]|H|$]]

Solution without imports and functions like str()
<pre><code>def numlen(num):
 result = 1
 divider = 10
 while num % divider != num:
 divider *= 10
 result += 1
 return result
</code></pre>

blocks|key|1126290|text|coin_digit+=+str(coin_fark).split(".")[1]
coin_digit_len+=+len(coin_digit)
print(coin_digit_len)|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1126291|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

<pre><code>coin_digit = str(coin_fark).split(&quot;.&quot;)[1]
coin_digit_len = len(coin_digit)
print(coin_digit_len)
</code></pre>

blocks|key|1340381|text|>>>+a=12345
>>>+a.__str__().__len__()
5|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|1340382|unstyled|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|G|8|@]|9|@]|A|$B|C]]|$1|D|3|-4|5|E|7|H|8|@]|9|@]|A|$]]]|F|$]]

问如何在整数中找到数字的长度？
EN

回答 25

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在整数中找到数字的长度？EN

回答 25

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问如何在整数中找到数字的长度？
EN