blocks|key|1582191|text|您发布的这两行都很好，但是您可以完全用整数来完成，这将是最有效的：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1582192|def+sum_digits(n):
++++s+=+0
++++while+n:
++++++++s+%2B=+n+%25+10
++++++++n+//=+10
++++return+s|code-block|syntax|javascript|1582193|或使用divmod|offset|length|style|CODE|1582194|def+sum_digits2(n):
++++s+=+0
++++while+n:
++++++++n,+remainder+=+divmod(n,+10)
++++++++s+%2B=+remainder
++++return+s|1582195|使用单个赋值语句要稍微快一些：|1582196|def+sum_digits3(n):
+++r+=+0
+++while+n:
+++++++r,+n+=+r+%2B+n+%25+10,+n+//+10
+++return+r|1582197|>+%25timeit+sum_digits(n)
1000000+loops,+best+of+3:+574+ns+per+loop

>+%25timeit+sum_digits2(n)
1000000+loops,+best+of+3:+716+ns+per+loop

>+%25timeit+sum_digits3(n)
1000000+loops,+best+of+3:+479+ns+per+loop

>+%25timeit+sum(map(int,+str(n)))
1000000+loops,+best+of+3:+1.42+us+per+loop

>+%25timeit+sum([int(digit)+for+digit+in+str(n)])
100000+loops,+best+of+3:+1.52+us+per+loop

>+%25timeit+sum(int(digit)+for+digit+in+str(n))
100000+loops,+best+of+3:+2.04+us+per+loop|1582198|entityMap^0|0|0|3|6|0|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|@$I|Z|J|10|K|L]]|9|@]|A|$]]|$1|M|3|N|5|D|7|11|8|@]|9|@]|A|$E|F]]|$1|O|3|P|5|6|7|12|8|@]|9|@]|A|$]]|$1|Q|3|R|5|D|7|13|8|@]|9|@]|A|$E|F]]|$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|$]]

Both lines you posted are fine, but you can do it purely in integers, and it will be the most efficient:
<pre><code>def sum_digits(n):
 s = 0
 while n:
 s += n % 10
 n //= 10
 return s
</code></pre>
or with <code>divmod</code>:
<pre><code>def sum_digits2(n):
 s = 0
 while n:
 n, remainder = divmod(n, 10)
 s += remainder
 return s
</code></pre>
<hr />
Slightly faster is using a single assignment statement:
<pre><code>def sum_digits3(n):
 r = 0
 while n:
 r, n = r + n % 10, n // 10
 return r
</code></pre>
<hr />
<pre><code>&gt; %timeit sum_digits(n)
1000000 loops, best of 3: 574 ns per loop

&gt; %timeit sum_digits2(n)
1000000 loops, best of 3: 716 ns per loop

&gt; %timeit sum_digits3(n)
1000000 loops, best of 3: 479 ns per loop

&gt; %timeit sum(map(int, str(n)))
1000000 loops, best of 3: 1.42 us per loop

&gt; %timeit sum([int(digit) for digit in str(n)])
100000 loops, best of 3: 1.52 us per loop

&gt; %timeit sum(int(digit) for digit in str(n))
100000 loops, best of 3: 2.04 us per loop
</code></pre>

blocks|key|1582236|text|这可能会有帮助|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1582237|def+digit_sum(n):
++++num_str+=+str(n)
++++sum+=+0
++++for+i+in+range(0,+len(num_str)):
++++++++sum+%2B=+int(num_str[i])
++++return+sum|code-block|syntax|javascript|1582238|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|$]]

This might help

<pre><code>def digit_sum(n):
 num_str = str(n)
 sum = 0
 for i in range(0, len(num_str)):
 sum += int(num_str[i])
 return sum
</code></pre>

blocks|key|1582255|text|如果您想继续对数字进行求和，直到得到一个单数数字(我最喜欢的数字特征之一是可以被9整除)，那么您可以这样做：|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|1582256|def+digital_root(n):
++++x+=+sum(int(digit)+for+digit+in+str(n))
++++if+x+<+10:
++++++++return+x
++++else:
++++++++return+digital_root(x)|code-block|syntax|javascript|1582257|事实证明它本身非常快..。|1582258|%25timeit+digital_root(12312658419614961365)

10000+loops,+best+of+3:+22.6+µs+per+loop|1582259|entityMap^0|K|4|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|U|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|W|8|@]|D|@]|E|$]]]|P|$]]

If you want to keep summing the digits until you get a single-digit number (one of my favorite characteristics of numbers divisible by 9) you can do:

<pre><code>def digital_root(n):
 x = sum(int(digit) for digit in str(n))
 if x &lt; 10:
 return x
 else:
 return digital_root(x)
</code></pre>

Which actually turns out to be pretty fast itself...

<pre><code>%timeit digital_root(12312658419614961365)

10000 loops, best of 3: 22.6 µs per loop
</code></pre>

blocks|key|1582271|text|我解决了这个问题，解决了以下问题：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1582272|def+digit_sum(n):
++++digits+=+[]
++++nstr+=+str(n)
++++for+x+in+nstr:
++++++++digits.append(int(x))
++++return+sum(digits)|code-block|syntax|javascript|1582273|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|$]]

Doing some Codecademy challenges I resolved this like:
<pre><code>def digit_sum(n):
 digits = []
 nstr = str(n)
 for x in nstr:
 digits.append(int(x))
 return sum(digits)
</code></pre>

blocks|key|2372541|text|您也可以使用名为divmod()+;的built_in_function来尝试这种方法。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|2372542|number+=+int(input('enter+any+integer:+=+'))
sum+=+0
while+number!=0:+
++++take+=+divmod(number,+10)+
++++dig+=+take[1]+
++++sum+%2B=+dig+
++++number+=+take[0]+
print(sum)+|code-block|syntax|javascript|2372543|你可以取任意数量的数字|2372544|entityMap^0|0|I|0|0|0|B|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|R|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|S|8|@$9|T|A|U|B|C]]|D|@]|E|$]]|$1|M|3|-4|5|6|7|V|8|@]|D|@]|E|$]]]|N|$]]

you can also try this with built_in_function called divmod() ;

<pre><code>number = int(input('enter any integer: = '))
sum = 0
while number!=0: 
 take = divmod(number, 10) 
 dig = take[1] 
 sum += dig 
 number = take[0] 
print(sum) 
</code></pre>

you can take any number of digit

blocks|key|2372567|text|这是在一个解决问题的挑战网站上发现的。不是我的，但很管用。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2372568|num+=+0++++++++++++#+replace+0+with+whatever+number+you+want+to+sum+up
print(sum([int(k)+for+k+in+str(num)]))|code-block|syntax|javascript|2372569|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|$]]

Found this on one of the problem solving challenge websites. Not mine, but it works.
<pre><code>num = 0 # replace 0 with whatever number you want to sum up
print(sum([int(k) for k in str(num)]))
</code></pre>

blocks|key|261866|text|尝尝这个|type|unstyled|depth|inlineStyleRanges|entityRanges|data|261867|++++print(sum(list(map(int,input("Enter+your+number+")))))|code-block|syntax|javascript|261868|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|$]]

Try this

<pre><code> print(sum(list(map(int,input("Enter your number ")))))
</code></pre>

blocks|key|2372599|text|这里有一个没有任何循环或递归的解决方案，但只适用于非负整数(Python3)：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2372600|def+sum_digits(n):
++++if+n+>+0:
++++++++s+=+(n-1)+//+9++++
++++++++return+n-9*s
++++return+0|code-block|syntax|javascript|2372601|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|$]]

Here is a solution without any loop or recursion but works for non-negative integers only (Python3):

<pre><code>def sum_digits(n):
 if n &gt; 0:
 s = (n-1) // 9 
 return n-9*s
 return 0
</code></pre>

blocks|key|261929|text|这里处理数学或字符串的速度是否更快取决于输入数字的大小。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|261930|对于小数(长度小于20位数)，使用除法和模数：|261931|def+sum_digits_math(n):
++++r+=+0
++++while+n:
++++++++r,+n+=+r+%2B+n+%25+10,+n+//+10
++++return+r|code-block|syntax|javascript|261932|对于大数(长度大于30位数)，请使用字符串域：|261933|def+sum_digits_str_fast(n):
++++d+=+str(n)
++++return+sum(int(s)+*+d.count(s)+for+s+in+"123456789")|261934|对于长度在20到30位之间的数字也有一个狭小的窗口，其中sum(map(int,+str(n)))是最快的。这是下图中的紫色线(单击这里放大)。|offset|length|style|CODE|261935|​|261936|📷|atomic|261937|261938|当输入数较大时，使用数学标度的性能配置文件很差，但是在字符串域中工作的每一种方法在输入的长度上似乎都是线性的。生成这些图的代码是这里，我在macOS上使用了CPython+3.10.6。|261939|entityMap|0|LINK|mutability|MUTABLE|url|https://i.stack.imgur.com/dmCkr.png|1|IMAGE|IMMUTABLE|imageUrl|https://developer.qcloudimg.com/http-save/yehe-900000/3f998263d070d6bf54f629bb4d698253.png|imageAlt|2|https://github.com/wimglenn/scratch/blob/master/sum_digits.py^0|0|0|0|0|0|S|L|1U|2|0|0|0|0|1|1|0|0|1S|2|2|0^^$0|@$1|2|3|4|5|6|7|1G|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1H|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|1I|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|1J|8|@]|9|@]|A|$]]|$1|K|3|L|5|F|7|1K|8|@]|9|@]|A|$G|H]]|$1|M|3|N|5|6|7|1L|8|@$O|1M|P|1N|Q|R]]|9|@$O|1O|P|1P|1|1Q]]|A|$]]|$1|S|3|T|5|6|7|1R|8|@]|9|@]|A|$]]|$1|U|3|V|5|W|7|1S|8|@]|9|@$O|1T|P|1U|1|1V]]|A|$]]|$1|X|3|T|5|6|7|1W|8|@]|9|@]|A|$]]|$1|Y|3|Z|5|6|7|1X|8|@]|9|@$O|1Y|P|1Z|1|20]]|A|$]]|$1|10|3|-4|5|6|7|21|8|@]|9|@]|A|$]]]|11|$12|$5|13|14|15|A|$16|17]]|18|$5|19|14|1A|A|$1B|1C|1D|-4]]|1E|$5|13|14|15|A|$16|1F]]]]

Whether it's faster to work with math or strings here depends on the size of the input number.
For small numbers (fewer than 20 digits in length), use division and modulus:
<pre><code>def sum_digits_math(n):
 r = 0
 while n:
 r, n = r + n % 10, n // 10
 return r
</code></pre>
For large numbers (greater than 30 digits in length), use the string domain:
<pre><code>def sum_digits_str_fast(n):
 d = str(n)
 return sum(int(s) * d.count(s) for s in &quot;123456789&quot;)
</code></pre>
There is also a narrow window for numbers between 20 and 30 digits in length where <code>sum(map(int, str(n)))</code> is fastest. That is the purple line in the graph shown below (click <a href="https://i.stack.imgur.com/dmCkr.png" rel="nofollow noreferrer">here</a> to zoom in).
<img src="https://i.stack.imgur.com/5pPgE.png" alt="profile" />
The performance profile for using math scales poorly as the input number is bigger, but each approach working in string domain appears to scale linearly in the length of the input. The code that was used to generate these graphs is <a href="https://github.com/wimglenn/scratch/blob/master/sum_digits.py" rel="nofollow noreferrer">here</a>, I'm using CPython 3.10.6 on macOS.

blocks|key|2372724|text|为什么评分最高的答案3.70x比这个慢？|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|2372725|%25+echo;+(+time+(nice+echo+33785139853861968123689586196851968365819658395186596815968159826259681256852169852986+\
+%7C+mawk2+'gsub(//,($_)($_)($_))%2Bgsub(//,($_))%2B1'+%7C+pvE0+\
+%7C+mawk2+'
+++
+++function+__(_,___,____,_____)+{

++++++++++++++++++____=gsub("[%5E1-9]%2B","",_)~""
++++++++++++++++___=10
+++++++while((%2B____<--___)+&&+_)+{
++++++++++++_____%2B=___*gsub(___,"",_)+
+++++++}
+++++++return+_____%2Blength(_)+}+

++++BEGIN+{+FS=OFS=ORS
++++++++++++++++RS="%5E$"+
++++}+END+{+
++++++++++++print+__($!_)+}'+)%7C+pvE9+)+%7C+gcat+-n+%7C+lgp3+;

++++++in0:++173MiB+0:00:00+[1.69GiB/s]+[1.69GiB/s]+[<=>++++++++++++++++++++++++++++++++++++++++++++]
+++++out9:+11.0+B+0:00:09+[1.15+B/s]+[1.15+B/s]+[<=>+++++++++++++++++++++++++++++++++++++++++++++++]
++++++in0:++484MiB+0:00:00+[2.29GiB/s]+[2.29GiB/s]+[++<=>++++++++++++++++++++++++++++++++++++++++++]
(+nice+echo++%7C+mawk2+'gsub(//,($_)($_)($_))%2Bgsub(//,($_))%2B1'+%7C+pvE+0.1+in0+%7C+)++

+8.52s+user+1.10s+system+100%25+cpu+9.576+total
+1++2822068024



%25+echo;+(+time+(+nice+echo+33785139853861968123689586196851968365819658395186596815968159826259681256852169852986+\
+++++\
+++++%7C+mawk2+'gsub(//,($_)($_)($_))%2Bgsub(//,($_))%2B1'+%7C+pvE0+\
+++++%7C++gtr+-d+'\n'+\
+++++\
+++++%7C++python3+-c+'import+math,+os,+sys;

++++++++[+print(sum(int(digit)+for+digit+in+str(ln)),+\
++++++++++++++++++++++++++++++++++++++++++++end="\n")+\
+++++++++\
+++++++++for+ln+in+sys.stdin+]'+)%7C+pvE9+)+%7C+gcat+-n+%7C+lgp3+;


++++++in0:++484MiB+0:00:00+[+958MiB/s]+[+958MiB/s]+[+++++<=>+++++++++++++++++++++++++++++++++++++++]
+++++out9:+11.0+B+0:00:35+[+317miB/s]+[+317miB/s]+[<=>+++++++++++++++++++++++++++++++++++++++++++++]
(+nice+echo++%7C+mawk2+'gsub(//,($_)($_)($_))%2Bgsub(//,($_))%2B1'+%7C+pvE+0.1+in0+%7C+)++

+35.22s+user+0.62s+system+101%25+cpu+35.447+total
+++++1++2822068024|code-block|syntax|javascript|2372726|这已经有点慷慨了。在这个2.82GB的大型综合创建的测试用例上，它是19.2x慢。|2372727|+%25+echo;+(+time+(+pvE0+<+testcases_more108.txt++%7C++mawk2+'function+__(_,___,____,_____)+{+____=gsub("[%5E1-9]%2B","",_)~"";___=10;+while((%2B____<--___)+&&+_)+{+_____%2B=___*gsub(___,"",_)+};+return+_____%2Blength(_)+}+BEGIN+{+FS=RS="%5E$";+CONVFMT=OFMT="%25.20g"+}+END+{+print+__($_)+}'++)+%7C+pvE9+)+%7Cgcat+-n+%7C+ggXy3++%7C+lgp3;+

++++++in0:++284MiB+0:00:00+[2.77GiB/s]+[2.77GiB/s]+[=>+++++++++++++++++++++++++++++]++9%25+ETA+0:00:00
+++++out9:+11.0+B+0:00:11+[1016miB/s]+[1016miB/s]+[<=>+++++++++++++++++++++++++++++++++++++++++++++]
++++++in0:+2.82GiB+0:00:00+[2.93GiB/s]+[2.93GiB/s]+[=============================>]+100%25++++++++++++
(+pvE+0.1+in0+<+testcases_more108.txt+%7C+mawk2+;+)

++8.75s+user+2.36s+system+100%25+cpu+11.100+total
+++++1++3031397722

%25+echo;+(+time+(+pvE0+<+testcases_more108.txt++%7C+gtr+-d+'\n'+%7C++python3+-c+'import+sys;+[+print(sum(int(_)+for+_+in+str(__)))+for+__+in+sys.stdin+]'+)+%7C+pvE9+)+%7Cgcat+-n+%7C+ggXy3++%7C+lgp3;++


++++++in0:+2.82GiB+0:00:02+[1.03GiB/s]+[1.03GiB/s]+[=============================>]+100%25++++++++++++
+++++out9:+11.0+B+0:03:32+[53.0miB/s]+[53.0miB/s]+[<=>+++++++++++++++++++++++++++++++++++++++++++++]
(+pvE+0.1+in0+<+testcases_more108.txt+%7C+gtr+-d+'\n'+%7C+python3+-c+;+)++

++211.47s+user+3.02s+system+100%25+cpu+3:32.69+total
+++++1++3031397722|2372728|更新:这个概念的原生python3代码--即使我有可怕的python技巧，我也看到了4x的加速：|2372729|%25+echo;+(+time+(+pvE0+<+testcases_more108.txt++\
\
+%7Cpython3+-c+'import+re,+sys;

++print(sum([+sum(int(_)*re.subn(_,"",__)[1]+

+++++for+_+in+[r"1",r"2",+r"3",r"4",
+++++++++++++++r"5",r"6",r"7",r"8",r"9"])

+for+__+in+sys.stdin+]))'+%7CpvE9))%7Cgcat+-n%7C+ggXy3%7Clgp3+++

++++++in0:+1.88MiB+0:00:00+[18.4MiB/s]+[18.4MiB/s]+[>++++++++++++++++++++++++++++++]++0%25+ETA+0:00:00
+++++out9:+0.00+B+0:00:51+[0.00+B/s]+[0.00+B/s]+[<=>+++++++++++++++++++++++++++++++++++++++++++++++]
++++++in0:+2.82GiB+0:00:51+[56.6MiB/s]+[56.6MiB/s]+[=============================>]+100%25++++++++++++
+++++out9:+11.0+B+0:00:51+[+219miB/s]+[+219miB/s]+[<=>+++++++++++++++++++++++++++++++++++++++++++++]

(+pvE+0.1+in0+<+testcases_more108.txt+%7C+python3+-c++%7C+pvE+0.1+out9;+)+



48.07s+user+3.57s+system+100%25+cpu+51.278+total
+1++3031397722|2372730|即使是较小的测试用例也能加快1.42x的速度：|2372731|+echo;+(+time+(nice+echo+33785139853861968123689586196851968365819658395186596815968159826259681256852169852986+\+
+%7C+mawk2+'gsub(//,($_)($_)$_)%2Bgsub(//,$_)%2B1'+ORS=''+%7C+pvE0+%7C+python3+-c+'import+re,+sys;+print(sum([+sum(int(_)*re.subn(_,"",__)[1]+for+_+in+[r"1",r"2",+r"3",r"4",r"5",r"6",r"7",r"8",r"9"])+for+__+in+sys.stdin+]))'++%7C+pvE9++))++%7Cgcat+-n+%7C+ggXy3+%7C+lgp3+


++++++in0:++484MiB+0:00:00+[2.02GiB/s]+[2.02GiB/s]+[++<=>++++++++++++++++++++++++++++++++++++++++++]
+++++out9:+11.0+B+0:00:24+[+451miB/s]+[+451miB/s]+[<=>+++++++++++++++++++++++++++++++++++++++++++++]
(+nice+echo++%7C+mawk2+'gsub(//,($_)($_)$_)%2Bgsub(//,$_)%2B1'+ORS=''+%7C+pvE+0.1+in0)

+20.04s+user+5.10s+system+100%25+cpu+24.988+total
+++1++++2822068024|2372732|entityMap^0|A|5|0|0|Y|6|0|0|0|J|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Y|8|@$9|Z|A|10|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|11|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|12|8|@$9|13|A|14|B|C]]|D|@]|E|$]]|$1|M|3|N|5|H|7|15|8|@]|D|@]|E|$I|J]]|$1|O|3|P|5|6|7|16|8|@$9|17|A|18|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|H|7|19|8|@]|D|@]|E|$I|J]]|$1|S|3|T|5|6|7|1A|8|@]|D|@]|E|$]]|$1|U|3|V|5|H|7|1B|8|@]|D|@]|E|$I|J]]|$1|W|3|-4|5|6|7|1C|8|@]|D|@]|E|$]]]|X|$]]

Why is the highest rated answer 3.70x slower than this ?
<pre><code>% echo; ( time (nice echo 33785139853861968123689586196851968365819658395186596815968159826259681256852169852986 \
 | mawk2 'gsub(//,($_)($_)($_))+gsub(//,($_))+1' | pvE0 \
 | mawk2 '
 
 function __(_,___,____,_____) {

 ____=gsub(&quot;[^1-9]+&quot;,&quot;&quot;,_)~&quot;&quot;
 ___=10
 while((+____&lt;--___) &amp;&amp; _) {
 _____+=___*gsub(___,&quot;&quot;,_) 
 }
 return _____+length(_) } 

 BEGIN { FS=OFS=ORS
 RS=&quot;^$&quot; 
 } END { 
 print __($!_) }' )| pvE9 ) | gcat -n | lgp3 ;

 in0: 173MiB 0:00:00 [1.69GiB/s] [1.69GiB/s] [&lt;=&gt; ]
 out9: 11.0 B 0:00:09 [1.15 B/s] [1.15 B/s] [&lt;=&gt; ]
 in0: 484MiB 0:00:00 [2.29GiB/s] [2.29GiB/s] [ &lt;=&gt; ]
( nice echo | mawk2 'gsub(//,($_)($_)($_))+gsub(//,($_))+1' | pvE 0.1 in0 | ) 

 8.52s user 1.10s system 100% cpu 9.576 total
 1 2822068024



% echo; ( time ( nice echo 33785139853861968123689586196851968365819658395186596815968159826259681256852169852986 \
 \
 | mawk2 'gsub(//,($_)($_)($_))+gsub(//,($_))+1' | pvE0 \
 | gtr -d '\n' \
 \
 | python3 -c 'import math, os, sys;

 [ print(sum(int(digit) for digit in str(ln)), \
 end=&quot;\n&quot;) \
 \
 for ln in sys.stdin ]' )| pvE9 ) | gcat -n | lgp3 ;


 in0: 484MiB 0:00:00 [ 958MiB/s] [ 958MiB/s] [ &lt;=&gt; ]
 out9: 11.0 B 0:00:35 [ 317miB/s] [ 317miB/s] [&lt;=&gt; ]
( nice echo | mawk2 'gsub(//,($_)($_)($_))+gsub(//,($_))+1' | pvE 0.1 in0 | ) 

 35.22s user 0.62s system 101% cpu 35.447 total
 1 2822068024
</code></pre>
And that's being a bit generous already. On this large synthetically created test case of 2.82 GB, it's 19.2x slower.
<pre><code> % echo; ( time ( pvE0 &lt; testcases_more108.txt | mawk2 'function __(_,___,____,_____) { ____=gsub(&quot;[^1-9]+&quot;,&quot;&quot;,_)~&quot;&quot;;___=10; while((+____&lt;--___) &amp;&amp; _) { _____+=___*gsub(___,&quot;&quot;,_) }; return _____+length(_) } BEGIN { FS=RS=&quot;^$&quot;; CONVFMT=OFMT=&quot;%.20g&quot; } END { print __($_) }' ) | pvE9 ) |gcat -n | ggXy3 | lgp3; 

 in0: 284MiB 0:00:00 [2.77GiB/s] [2.77GiB/s] [=&gt; ] 9% ETA 0:00:00
 out9: 11.0 B 0:00:11 [1016miB/s] [1016miB/s] [&lt;=&gt; ]
 in0: 2.82GiB 0:00:00 [2.93GiB/s] [2.93GiB/s] [=============================&gt;] 100% 
( pvE 0.1 in0 &lt; testcases_more108.txt | mawk2 ; )

 8.75s user 2.36s system 100% cpu 11.100 total
 1 3031397722

% echo; ( time ( pvE0 &lt; testcases_more108.txt | gtr -d '\n' | python3 -c 'import sys; [ print(sum(int(_) for _ in str(__))) for __ in sys.stdin ]' ) | pvE9 ) |gcat -n | ggXy3 | lgp3; 


 in0: 2.82GiB 0:00:02 [1.03GiB/s] [1.03GiB/s] [=============================&gt;] 100% 
 out9: 11.0 B 0:03:32 [53.0miB/s] [53.0miB/s] [&lt;=&gt; ]
( pvE 0.1 in0 &lt; testcases_more108.txt | gtr -d '\n' | python3 -c ; ) 

 211.47s user 3.02s system 100% cpu 3:32.69 total
 1 3031397722
</code></pre>
—————————————————————
UPDATE : native python3 code of that concept - even with my horrific python skills, i'm seeing a 4x speedup :
<pre><code>% echo; ( time ( pvE0 &lt; testcases_more108.txt \
\
 |python3 -c 'import re, sys;

 print(sum([ sum(int(_)*re.subn(_,&quot;&quot;,__)[1] 

 for _ in [r&quot;1&quot;,r&quot;2&quot;, r&quot;3&quot;,r&quot;4&quot;,
 r&quot;5&quot;,r&quot;6&quot;,r&quot;7&quot;,r&quot;8&quot;,r&quot;9&quot;])

 for __ in sys.stdin ]))' |pvE9))|gcat -n| ggXy3|lgp3 

 in0: 1.88MiB 0:00:00 [18.4MiB/s] [18.4MiB/s] [&gt; ] 0% ETA 0:00:00
 out9: 0.00 B 0:00:51 [0.00 B/s] [0.00 B/s] [&lt;=&gt; ]
 in0: 2.82GiB 0:00:51 [56.6MiB/s] [56.6MiB/s] [=============================&gt;] 100% 
 out9: 11.0 B 0:00:51 [ 219miB/s] [ 219miB/s] [&lt;=&gt; ]

( pvE 0.1 in0 &lt; testcases_more108.txt | python3 -c | pvE 0.1 out9; ) 



48.07s user 3.57s system 100% cpu 51.278 total
 1 3031397722
</code></pre>
Even the smaller test case managed a 1.42x speed up :
<pre><code> echo; ( time (nice echo 33785139853861968123689586196851968365819658395186596815968159826259681256852169852986 \ 
 | mawk2 'gsub(//,($_)($_)$_)+gsub(//,$_)+1' ORS='' | pvE0 | python3 -c 'import re, sys; print(sum([ sum(int(_)*re.subn(_,&quot;&quot;,__)[1] for _ in [r&quot;1&quot;,r&quot;2&quot;, r&quot;3&quot;,r&quot;4&quot;,r&quot;5&quot;,r&quot;6&quot;,r&quot;7&quot;,r&quot;8&quot;,r&quot;9&quot;]) for __ in sys.stdin ]))' | pvE9 )) |gcat -n | ggXy3 | lgp3 


 in0: 484MiB 0:00:00 [2.02GiB/s] [2.02GiB/s] [ &lt;=&gt; ]
 out9: 11.0 B 0:00:24 [ 451miB/s] [ 451miB/s] [&lt;=&gt; ]
( nice echo | mawk2 'gsub(//,($_)($_)$_)+gsub(//,$_)+1' ORS='' | pvE 0.1 in0)

 20.04s user 5.10s system 100% cpu 24.988 total
 1 2822068024
</code></pre>

If I want to find the sum of the digits of a number, i.e.:
<ul>
<li>Input: <code>932</code></li>
<li>Output: <code>14</code>, which is <code>(9 + 3 + 2)</code></li>
</ul>
What is the fastest way of doing this?
I instinctively did:
<pre><code>sum(int(digit) for digit in str(number))
</code></pre>
and I found this online:
<pre><code>sum(map(int, str(number)))
</code></pre>
Which is best to use for speed, and are there any other methods which are even faster?

Sum the digits of a number

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

如果我想找到一个数字的数字之和，即：输入：932输出：14，即(9 + 3 + 2)最快的方法是什么？我本能地做了：sum(int(digit) for digit in str(number))我在网上发现了这个：sum(map(int, str(number)))哪种方法最适合用于速度，还有其他更快的方法吗？

问一个数字的数字之和
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问一个数字的数字之和EN