Python Luhn checksum for credit card validation (Python recipe) by David Shaw

ActiveState Code (http://code.activestate.com/recipes/172845/)

Checksum calculation.

""" easy checksum """
def checksum(a):
    return (10 - sum([int(y)*[7,3,1][x%3] for x, y in enumerate(str(a)[::-1])])%10)%10

Another take...

# Return the "Luhn transform" of a digit.
luhnify = lambda digit: sum(divmod( digit*2, 10 ))

def luhn_checksum( digits ):
    """Return the Luhn checksum of a sequence of digits.
    """
    digits = map( int, digits )
    odds, evens = digits[-2::-2], digits[-1::-2]
    return sum( map(luhnify,odds) + evens ) % 10

That checksum is wrong. It does not match the other 2 listed here, and it returns "7" for my credit card. What is it for?

Integer only version. Here is a integer-only version that avoids string casts. You may need "from __future__ import division" to use the "//" floor operator.

def luhn(n):
    """luhnsum(int)->bool
    Mod 10 checksum by Hans Peter Luhn (1896–1964)
    """
    sum=0
    while n:
        r=n%100
        n//=100
        z=r%10
        r=r//10*2
        sum+=r//10+r%10+z
    return 0==sum%10

generating many luhn numbers.

def nextLuhn(n):
    """nextLuhn(int) -> int
    Gets the smallest Luhn number greater than n.
    Uses a naive (exhaustive) algorithm that must try
    the Luhn checksum an average of 10 times.
    """
    n+=1
    while not luhn(n):
        n+=1
    return n

def biggerLuhn(n):
    """ biggerLuhn(int) -> int
    Gets a Luhn number greater than n.
    Uses a probability model that is very efficient if
    n passes the Luhn checksum.
    It may be possible to miss a Luhn number with this method.
    """
    for t in [8, 18, 7, 17, 6, 16]:
        if luhn(n+t):
            return n+t
    return nextLuhn(n)

def xluhn(seed,howmany):
    """xluhn(int,int) ->*int
    Yields Luhn numbers greater than the seed.
    Some numbers may be left out of the sequence.
    """
    while howmany:
        seed=biggerLuhn(seed)
        howmany-=1
        yield seed

Incorrect LUHN checksum implementation. This LUHN implementation is actually incorrect. The card number digits must be traversed from end to beginning (reverse the direction the for loop counts) or some (but not all) perfectly valid card numbers will be rejected.

http://david.theresistance.net/files/creditValidation.py <-- Address Not Found

Here's another version, just written to see how Python compares to C in such a case.

def luhn( l ):

    s, i = 0, 16

    while i > 0:
        i -= 1
        v = ord( l[ 15 - i ] ) - 48 << i % 2
        if ( v > 9 ):
            s += v - 9
        else:
            s += v

    return s % 10 < 1

You can find details and execution timing results here.

As this is my very first coding experience with Python, comments and advices are welcome :-)