Question

What is the best practice for iterating over an integer in Python? I find that I need to do so often, typically with verbose results. For example, here are two functions I wrote for Project Euler problems:

def is_permutation_of(n, m):
    """ Return True if n is a permutation of m, else False
    """
    if len(str(n)) != len(str(m)):
        return False
    for d in str(n):
        if d not in str(m):
            return False
    return True

And another:

def has_even_digit(n):
    """ Return True if n has an even digit, else False
    """
    evens = ['0', '2', '4', '6', '8']
    for e in evens:
        if e in str(n):
            return True
    return False

In addition to the verbosity, 1) there must be a computational expense associated with each type conversion and 2) it just feels completely inelegant. Is there another way of dealing with this issue? Am I going about these functions in entirely the wrong way, i.e. should I not have to ever iterate over an integer?

Thanks for any help.

Answer 1

I prefer my variant instead of your is_permutation_of:

def is_perm(a,b): return sorted(str(a)) == sorted(str(b))

And I think this is better for has_even_digit

def has_even_digit(n):
    evens=set(['0', '2', '4', '6', '8'])
    return any(c in evens for c in str(n))

Or, even use a tuple rather than a set:

def has_even_digit(n):
    return any(c in ('0', '2', '4', '6', '8') for c in str(n))

---

Edit

From the comment thread, I thing you are looking for something like this:

# pseudo code -- don't use -- not syntactically correct
for d in 123456:      # integer
   # do something with each digit...

This does not work because integers do not support iteration in Python. Additionally, there is no real need have something like an integer iteration since it is so idiomatic and easy to do it with strings.

Here is a Python framework to do it with strings but produce single integer digit:

for d in [int(c) for c in str(123456)]:
    # d is a left (most significant) to right integer digit - do what you want with it...

If you want the same number right to left:

for d in [int(c) for c in str(123456)[::-1]]:
    # Now right (least significant digit) to left (most significant digit)

Compare those two simple cases with doing it with actual math with the integer or long:

def int_iter(n,reverse=False):
    rtr=[]
    if not isinstance(n, (int,long)):
        raise ValueError('n must be int or long')

    while n:
        rtr.append(n%10)
        n/=10

    if reverse:
        return rtr[::-1]    
    else:
        return rtr  

It is really a lot easier to use strings and probably faster. If you need blazing speed, do it in C.