Validar números usando el algoritmo de Luhn en Python

1. Validar números usando el algoritmo de Luhn en Python
2. Usar funciones para validar números a través del algoritmo de Luhn
3. Use bucles anidados para validar números a través del algoritmo de Luhn
4. Use la programación funcional para validar números a través del algoritmo de Luhn
5. Conclusión

El informático alemán Hans Peter Luhn desarrolló la fórmula del algoritmo de Luhn en la década de 1960. Es un algoritmo de suma de verificación utilizado por las principales organizaciones financieras internacionales de transferencia electrónica de fondos como Visa y Master Card para acelerar los pagos y transacciones en línea.

Este artículo explica cómo escribir el algoritmo de Luhn en Python y valida los números según el algoritmo.

Validar números usando el algoritmo de Luhn en Python

El validador del algoritmo de Luhn ayuda a examinar y separar los números legítimos de las entradas incorrectas o mal escritas. Para saber más al respecto, consulte este enlace.

Comprendamos cómo crear un programa que valide números usando el algoritmo de Luhn en Python.

Usar funciones para validar números a través del algoritmo de Luhn

Este programa toma un número y lo valida usando el algoritmo de Luhn en Python. El programa tiene tres métodos: separate_digits(), luhn_algo() y check_if_valid.

Descripción paso a paso:

1. La primera línea de código crea un método luhn_algo con un parámetro num.

2. Dentro del método, se crea otro método anidado, separate_digits(). Este método anidado separa los dígitos del número que se le pasa y devuelve los números separados como una lista de Python.

   El método usa un bucle for para iterar los dígitos dentro de la lista.

   def luhn_algo(num):
       def separate_digits(n):
           return [int(d) for d in str(n)]
   

3. Una nueva variable, digits, utiliza el método separate_digits para convertir los valores dentro de num en una lista de dígitos.

   digits = separate_digits(num)
   

4. Una vez que los dígitos se almacenan en una lista de Python, la lista debe invertirse y los dígitos pares e impares deben separarse. Esto se logra utilizando el operador de corte ::.

   Por ejemplo, en la sintaxis odd_digits = digits[-1::-2], -1:: invierte la lista y toma el primer índice.

   El ::-2 recoge cada segundo elemento a partir del primer índice. Esto crea una nueva lista con solo dígitos impares.

   Del mismo modo, la lista de dígitos pares se crea utilizando el operador -2::-2.

   digits = separate_digits(num)
   odd_digits = digits[-1::-2]
   even_digits = digits[-2::-2]
   

5. El algoritmo de Luhn suma los dígitos impares, mientras que los dígitos pares se suman después de multiplicarlos por 2.

   Si el producto de cifras pares es mayor que 9, se suma la suma de sus cifras. Por último, se suman todos los dígitos pares e impares.

   Se crea una variable checksum para sumar todos los dígitos. La suma de dígitos impares se calcula usando la sintaxis:

   checksum += sum(odd_digits)
   

   Se crea un bucle for para iterar la lista de dígitos pares. De esta manera, cada dígito se multiplica por 2, y luego el método separate_digits separa los dígitos del producto, y luego se calcula su suma.

   Por último, se añade a la variable checksum.

```python
for d in even_digits:
    checksum += sum(separate_digits(d * 2))
```

6. Un número para ser validado por el algoritmo de Luhn, su producto final debe ser divisible por 10. El valor del resultado se devuelve al final del método.

   return checksum % 10
   

7. Para validar el resultado del algoritmo de Luhn se crea un método check_if_valid con un parámetro num. El método comprueba si el resultado devuelto por el método luhn_algo es igual a cero utilizando los operadores de equidad y devuelve el resultado.

   def check_if_valid(num):
       return luhn_algo(num) == 0
   

8. Para imprimir los resultados, se pasa un número al método check_if_valid, y se imprimen los resultados.

Código:

def luhn_algo(num):
    print("Number = ", num)

    def separate_digits(n):
        # Separates digits of num and stores them in a python list
        return [int(d) for d in str(n)]

    digits = separate_digits(num)
    # Creates a new reversed list with just odd digits
    odd_digits = digits[-1::-2]
    # Creates another reversed list with even digits
    even_digits = digits[-2::-2]

    checksum = 0
    checksum += sum(odd_digits)  # Finds sum of odd digits

    for d in even_digits:
        checksum += sum(
            separate_digits(d * 2)
        )  # Multiplies even digits with 2 and sums digits > 9

    return checksum % 10


def check_if_valid(num):
    return luhn_algo(num) == 0


result = check_if_valid(4532015112830366)
print("Correct:" + str(result))
result = check_if_valid(6011514433546201)
print("Correct:" + str(result))
result = check_if_valid(6771549495586802)
print("Correct:" + str(result))

Producción :

Number =  4532015112830366
Correct:True
Number =  6011514433546201
Correct:True
Number =  6771549495586802
Correct:True

De esta manera, se puede crear fácilmente un programa que valide números utilizando el algoritmo de Luhn en Python.

Use bucles anidados para validar números a través del algoritmo de Luhn

Otra forma de validar números a través del algoritmo de Luhn en Python es mediante el uso de bucles anidados. Este programa usa una sola función para validar un número usando el algoritmo de Luhn en Python.

Entendamos cómo funciona el código.

1. La primera línea de código crea un método luhn_algo con un parámetro num.

2. Una variable check_sum se inicializa con cero.

   def luhn_algo(num):
       check_sum = 0
   

3. Una variable num_parity encuentra la longitud del número dado y comprueba su paridad, si es par o impar.

```python
num_parity = len(num) % 2
```

4. Se crea un bucle for que se ejecuta hacia atrás desde su posición 0 hasta su longitud. El valor del índice l se copia inicializado en una variable j.

   for l in range(len(num) - 1, -1, -1):
       j = int(num[l])
   

5. En este punto entra la variable num_parity. Si num_parity es cero, esto implica que num es un número par, y viceversa para un número impar.

   Como todos los dígitos pares debían ser multiplicados por 2, el programa verifica la paridad de su índice l+1. Supongamos que la paridad es 0 y l + 1 % 2 es igual a la paridad, significa que el índice l es un dígito impar.

   Asimismo, si la paridad es 0 y no es igual a l + 1 % 2, es un dígito par. Al usar esta lógica, cada dígito par se multiplica por 2, y si el producto es mayor que 9, entonces se divide 9.

   La variable check_sum se incrementa con el valor de j. Al final de la iteración del bucle, check_sum calcula la suma final de los dígitos pares e impares.

   if (l + 1) % 2 != num_parity:
       j = j * 2
       if j > 9:
           j = j - 9
       check_sum = check_sum + j
   

6. Como se sabe que la suma final debe ser divisible por 10 para ser validada usando el algoritmo de Luhn en Python, la función devuelve check_sum % 10 == 0.

Código:

def luhn_algo(num):
    check_sum = 0
    num_parity = len(num) % 2
    for l in range(len(num) - 1, -1, -1):
        j = int(num[l])
        if (l + 1) % 2 != num_parity:
            j = j * 2
        if j > 9:
            j = j - 9
        check_sum = check_sum + j
    print("value calculated = ", str(check_sum))
    return check_sum % 10 == 0


for n in (49927398716, 49927398717, 1234567812345678, 1234567812345670):
    print(str(n) + " =>", luhn_algo(str(n)))

Producción :

value calculated =  70
49927398716 => True
value calculated =  71
49927398717 => False
value calculated =  68
1234567812345678 => False
value calculated =  60
1234567812345670 => True

Use la programación funcional para validar números a través del algoritmo de Luhn

Los primeros dos ejemplos usaron un método de procedimiento para validar números usando el algoritmo de Luhn en Python. Este ejemplo usa programación funcional para validar números usando el algoritmo de Luhn en Python.

El uso del método de programación funcional ahorra tiempo y esfuerzo al programador. El siguiente programa de Python valida un número en menos líneas de código.

1. Se crea un método luhn_algo con un parámetro num.

2. En una nueva variable rev, los dígitos del parámetro num se almacenan en una lista. Se utiliza un bucle for para este propósito que itera por el número de dígitos que hay en num.

   El operador de corte ::-1 invierte los dígitos dentro de la lista.

3. La sentencia return calcula toda la operación a la vez.

   La suma de los dígitos impares se calcula utilizando la sintaxis (sum(rev[0::2]).Los dígitos pares se ejecutan en un bucle for (for d in r[1::2]).

   Cada dígito se multiplica por 2, y los dígitos del producto se suman mediante la función divmod().

   La función divmod() toma dos parámetros - numerador y denominador, y devuelve dos valores - cociente y resto.

   La sintaxis divmod(d * 2, 10) toma d*2 como numerador y 10 como denominador. La resultante se suma para obtener la suma de dígitos.

   Por último, la función comprueba si la suma final es divisible por 10 y devuelve el resultado.

4. Usando un bucle for, se proporcionan cuatro números como entrada y se imprime el resultado.

Código:

def luhn_algo(num):
    rev = [int(ch) for ch in str(num)][::-1]
    return (sum(rev[0::2]) + sum(sum(divmod(d * 2, 10)) for d in rev[1::2])) % 10 == 0


for num2 in (49927398716, 49927398717, 1234567812345678, 1234567812345670):
    print(num2, luhn_algo(num2))

Producción :

49927398716 True
49927398717 False
1234567812345678 False
1234567812345670 True

Conclusión

Este artículo proporciona tres programas para que el lector comprenda cómo validar números utilizando el algoritmo de Luhn en Python.

Se sugiere que el lector lea el artículo, intente escribir el código por sí mismo y regrese en busca de sugerencias. De esta forma, el lector puede crear programas que validen números utilizando el algoritmo de Luhn.