Fastest way to loop through each digit in a number?

Bengt Richter bokr at oz.net
Mon Sep 6 18:02:52 CEST 2004

```On Mon, 06 Sep 2004 04:56:54 +0200, Rune Strand <rst at _nospam_.drlug.org._nospam_> wrote:

>Hi,
>If I have a lot of integers and want do something with each digit as
>integer, what is the fastest way to get there?
>
How many is "a lot" ? And what are the bounds on your integers' values? ;-)
Keep in mind that whatever you are computing, it is a mapping from imput to output,
and sometimes it pays to implement a subproblem literally as a mapping.

>Eg. Make 12345 into an iterable object, like [1,2,3,4,5] or "12345"

E.g., if you had a bazillion numbers that were all positive and five digits max,
then your fastest mapping from number to digit sequence would probably be a precomputed
list or tuple with data like (untested):

digitseqs = [[0],[1],[2],...[8],[9],[1,0],[1,1],[1,2]... [1,2,3,4,5],[1,2,3,4,6], ... [9,9,9,9,9]]

and then there would be no computation of the digits in

for d in digitseqs[number]:
foo(d)

If your numbers are bigger, you can still use the same technique, chunkwise, e.g.,
if you know you have positive 32-bit integers, that's 0<= number <= 1073741824

if number >= 1000000000:
foo(1)
number -= 1000000000
low5 = number % 100000
for d in digitseqs[number//100000]: foo(d)
for d in zdigitseqs[low5]: foo(d)

(zdigitseqs are all 5-digit sequences with leading zeroes included, [[0,0,0,0,0],[0,0,0,0,1], ...])

If your numbers are unbounded, you can still do something along these lines, but
numbers have to be _huge_ before you gain more than you lose in complication.
You could wrap the above in a function like def fooit(number, foo=foofunc): ...
but calls are relatively expensive in time, so you may want to forego the nicer style.

Obviously 100k lists of lists take a fair chunk of memory, and take a little time to
pre-compute, but it may pay off if you have REALLY "a lot" of input numbers ;-)

>
>(Btw: What is the English term for this process; itemize? tokenize?
>digitize?  sequence?)
>
>Some examples:
>
>n = 12345
>
>#1.
>s = str(n)
>for i in s:
>    d = int(i)
>    foo(d)
>
>#2.
>nl = map(int, str(n))
>for d in nl:
>    foo(d)
>
>#3.
>nl = [int(x) for x in str(n)]
>for d in nl:
>    foo(d)
>
>Of those, I have, a bit surprised, found that #1 is the fastest, and
>that #2 using map() is faster than #3 using list comprehension. I also
>registered that that repr(n) is about 8% faster than str(n).
>
>Are there faster ways? Is it possible to avoid casting types?
>