Maîtriser l’algorithme de Luhn en Python : quatre implémentations

L’algorithme de Luhn est une formule de somme de contrôle simple utilisée pour valider divers numéros d’identification, notamment les numéros de carte de crédit et les numéros IMEI. C’est un outil précieux pour maintenir l’intégrité des données et détecter les erreurs lors de la saisie. Cet article explore différentes implémentations Python de l’algorithme de Luhn, présentant divers styles de programmation et leur efficacité relative.

Table des matières

• Implémentation de base
• Décomposition fonctionnelle
• Approche itérative (boucles imbriquées)
• Programmation fonctionnelle avancée
• Conclusion

Implémentation de base

L’algorithme de Luhn implique les étapes suivantes :

1. Multiplier par deux chaque deuxième chiffre en partant de la droite.
2. Si la valeur doublée dépasse 9, soustraire 9.
3. Faire la somme de tous les chiffres.
4. Si le total modulo 10 est égal à 0, le nombre est valide ; sinon, il est invalide.

Voici une implémentation Python simple :

def luhn_check(number):
    try:
        digits = [int(d) for d in str(number)]
    except ValueError:
        return False

    odd_sum = sum(digits[-1::-2])
    even_sum = sum([sum(divmod(2 * d, 10)) for d in digits[-2::-2]])
    return (odd_sum + even_sum) % 10 == 0

number1 = 49927398716
number2 = 1234567890123456

print(f"Est-ce que {number1} est valide ? {luhn_check(number1)}")  # Sortie : True
print(f"Est-ce que {number2} est valide ? {luhn_check(number2)}")  # Sortie : False

Décomposition fonctionnelle

Pour une meilleure lisibilité et une meilleure maintenabilité, nous pouvons décomposer l’algorithme en fonctions plus petites et plus ciblées :

def double_digit(digit):
    return sum(divmod(2 * digit, 10))

def sum_digits(digits):
    return sum(digits)

def luhn_check_functional(number):
    try:
        digits = [int(d) for d in str(number)]
    except ValueError:
        return False
    odd_sum = sum_digits(digits[-1::-2])
    even_sum = sum_digits([double_digit(d) for d in digits[-2::-2]])
    return (odd_sum + even_sum) % 10 == 0

print(f"Est-ce que {number1} est valide (fonctionnel) ? {luhn_check_functional(number1)}")  # Sortie : True
print(f"Est-ce que {number2} est valide (fonctionnel) ? {luhn_check_functional(number2)}")  # Sortie : False

Approche itérative (boucles imbriquées)

Une approche itérative utilisant des boucles imbriquées, bien que moins efficace, fournit une illustration étape par étape plus claire de l’algorithme (principalement à des fins pédagogiques) :

def luhn_check_iterative(number):
    try:
        digits = [int(x) for x in str(number)]
    except ValueError:
        return False
    total = 0
    for i in range(len(digits) - 1, -1, -1):
        if i % 2 == 0:
            total += digits[i]
        else:
            doubled = digits[i] * 2
            if doubled > 9:
                doubled -= 9
            total += doubled
    return total % 10 == 0

print(f"Est-ce que {number1} est valide (itératif) ? {luhn_check_iterative(number1)}")  # Sortie : True
print(f"Est-ce que {number2} est valide (itératif) ? {luhn_check_iterative(number2)}")  # Sortie : False

Programmation fonctionnelle avancée

L’utilisation des fonctions map et reduce de Python améliore encore l’approche fonctionnelle :

from functools import reduce

def luhn_check_fp(number):
    try:
        digits = list(map(int, str(number)))
    except ValueError:
        return False
    odd_sum = sum(digits[-1::-2])
    even_sum = reduce(lambda x, y: x + y, map(lambda d: sum(divmod(2 * d, 10)), digits[-2::-2]))
    return (odd_sum + even_sum) % 10 == 0

print(f"Est-ce que {number1} est valide (programmation fonctionnelle) ? {luhn_check_fp(number1)}")  # Sortie : True
print(f"Est-ce que {number2} est valide (programmation fonctionnelle) ? {luhn_check_fp(number2)}")  # Sortie : False

Conclusion

Cet article a présenté diverses implémentations Python de l’algorithme de Luhn, démontrant différents paradigmes de programmation. Si l’approche itérative facilite la compréhension, les approches fonctionnelles, notamment la plus avancée, offrent une meilleure lisibilité et une meilleure efficacité pour les applications pratiques. N’oubliez pas que l’algorithme de Luhn est une somme de contrôle, et non une solution de sécurité complète ; il doit être utilisé avec d’autres méthodes de validation.