Validieren Sie Zahlen mit dem Luhn-Algorithmus in Python

  2. How-To's
  3. Python How-To's
  4. Validieren Sie Zahlen mit dem …
Jay Shaw 10 Oktober 2023
Python Python Checksum
  1. Validieren Sie Zahlen mit dem Luhn-Algorithmus in Python
  2. Verwenden Sie Funktionen, um Zahlen durch den Luhn-Algorithmus zu validieren
  3. Verwenden Sie verschachtelte Schleifen, um Zahlen durch den Luhn-Algorithmus zu validieren
  4. Verwenden Sie funktionale Programmierung, um Zahlen durch den Luhn-Algorithmus zu validieren
  5. Abschluss
Validieren Sie Zahlen mit dem Luhn-Algorithmus in Python

Der deutsche Informatiker Hans Peter Luhn entwickelte in den 1960er Jahren die Formel des Luhn-Algorithmus. Es handelt sich um einen Prüfsummenalgorithmus, der von großen internationalen Organisationen für den elektronischen Geldtransfer wie Visa und Master Card verwendet wird, um Online-Zahlungen und -Transaktionen zu beschleunigen.

Dieser Artikel erklärt das Schreiben des Luhn-Algorithmus in Python und validiert Zahlen gemäß dem Algorithmus.

Validieren Sie Zahlen mit dem Luhn-Algorithmus in Python

Der Luhn-Algorithmus-Validator hilft bei der Untersuchung und Trennung legitimer Zahlen von falschen oder falsch geschriebenen Eingaben. Um mehr darüber zu erfahren, überprüfen Sie diesen Link.

Lassen Sie uns verstehen, wie man ein Programm erstellt, das Zahlen mit dem Luhn-Algorithmus in Python validiert.

Verwenden Sie Funktionen, um Zahlen durch den Luhn-Algorithmus zu validieren

Dieses Programm nimmt eine Zahl und validiert sie mit dem Luhn-Algorithmus in Python. Das Programm hat drei Methoden - separate_digits(), luhn_algo() und check_if_valid.

Schritt-für-Schritt-Beschreibung:

  1. Die erste Codezeile erstellt eine Methode luhn_algo mit einem Parameter num.

  2. Innerhalb der Methode wird eine weitere verschachtelte Methode separate_digits() erstellt. Diese verschachtelte Methode trennt die Ziffern der übergebenen Zahl und gibt die getrennten Zahlen als Python-Liste zurück.

    Die Methode verwendet eine for-Schleife, um die Ziffern innerhalb der Liste zu durchlaufen.

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

  3. Eine neue Variable, digits, verwendet die Methode separate_digits, um die Werte in num in eine Liste von Ziffern umzuwandeln.

    digits = separate_digits(num)

  4. Sobald die Ziffern in einer Python-Liste gespeichert sind, muss die Liste umgekehrt werden, und gerade und ungerade Ziffern müssen getrennt werden. Dies wird durch die Verwendung des Slice-Operators :: erreicht.

    In der Syntax odd_digits = digits[-1::-2] zum Beispiel kehrt -1:: die Liste um und nimmt den 1. Index.

    Das ::-2 nimmt jedes zweite Element ab dem 1. Index auf. Dadurch wird eine neue Liste mit nur ungeraden Ziffern erstellt.

    Ebenso wird die Liste für gerade Ziffern mit dem Operator -2::-2 erstellt.

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

  5. Der Luhn-Algorithmus addiert die ungeraden Ziffern, während die geraden Ziffern nach der Multiplikation mit 2 addiert werden.

    Wenn das Produkt gerader Ziffern größer als 9 ist, wird die Summe ihrer Ziffern addiert. Zum Schluss werden alle ungeraden und geraden Ziffern zusammengezählt.

    Eine Variable Prüfsumme wird erstellt, um alle Ziffern zu summieren. Die Summe der ungeraden Ziffern wird mit der folgenden Syntax berechnet:

    checksum += sum(odd_digits)

    Eine for-Schleife wird erstellt, um die Liste der geraden Ziffern zu durchlaufen. Auf diese Weise wird jede Ziffer mit 2 multipliziert, und dann trennt die Methode separate_digits die Ziffern des Produkts und berechnet dann ihre Summe.

    Zuletzt wird es der Variablen checksum hinzugefügt.

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

  6. Eine Zahl, die vom Luhn-Algorithmus validiert werden soll, ihr Endprodukt muss durch 10 teilbar sein. Der Wert des Ergebnisses wird am Ende der Methode zurückgegeben.

    return checksum % 10

  7. Um das Ergebnis des Luhn-Algorithmus zu validieren, wird eine Methode check_if_valid mit einem Parameter num erstellt. Die Methode prüft, ob das von der Methode luhn_algo zurückgegebene Ergebnis mit Hilfe der Equity-Operatoren gleich Null ist und gibt das Ergebnis zurück.

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

  8. Zum Drucken der Ergebnisse wird der Methode check_if_valid eine Zahl übergeben und die Ergebnisse gedruckt.

Code:

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))

Ausgang:

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

Auf diese Weise kann einfach ein Programm erstellt werden, das Zahlen mit dem Luhn-Algorithmus in Python validiert.

Verwenden Sie verschachtelte Schleifen, um Zahlen durch den Luhn-Algorithmus zu validieren

Eine andere Möglichkeit, Zahlen durch den Luhn-Algorithmus in Python zu validieren, ist die Verwendung von verschachtelten Schleifen. Dieses Programm verwendet eine einzige Funktion, um eine Zahl mit dem Luhn-Algorithmus in Python zu validieren.

Lassen Sie uns verstehen, wie der Code funktioniert.

  1. Die erste Codezeile erstellt eine Methode luhn_algo mit einem Parameter num.

  2. Eine Variable check_sum wird mit Null initialisiert.

    def luhn_algo(num):
    check_sum = 0

  3. Eine Variable num_parity findet die Länge der gegebenen Zahl und überprüft ihre Parität, ob sie gerade oder ungerade ist.

    num_parity = len(num) % 2

  4. Es entsteht eine for-Schleife, die rückwärts von ihrer 0. Position bis zu ihrer Länge läuft. Der Wert des l-ten Index wird in eine Variable j kopiert.

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

  5. An dieser Stelle kommt die Variable num_parity. Wenn num_parity Null ist, bedeutet dies, dass num eine gerade Zahl ist und umgekehrt für eine ungerade Zahl.

    Da alle geraden Ziffern mit 2 multipliziert werden müssen, prüft das Programm die Parität seines l+1-ten Index. Angenommen, die Parität ist 0 und l + 1 % 2 gleich Parität, bedeutet dies, dass der l-te Index eine ungerade Ziffer ist.

    Wenn die Parität 0 ist und nicht gleich l + 1 % 2 ist, handelt es sich analog um eine gerade Ziffer. Bei dieser Logik wird jede gerade Ziffer mit 2 multipliziert, und wenn das Produkt größer als 9 ist, wird 9 davon dividiert.

    Die Variable check_sum erhöht sich um den Wert von j. Am Ende der Schleifeniteration berechnet check_sum die endgültige Summe aus geraden und ungeraden Ziffern.

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

  6. Da bekannt ist, dass die Endsumme durch 10 teilbar sein muss, um mit dem Luhn-Algorithmus in Python validiert zu werden, gibt die Funktion check_sum % 10 == 0 zurück.

Code:

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)))

Ausgang:

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

Verwenden Sie funktionale Programmierung, um Zahlen durch den Luhn-Algorithmus zu validieren

Die ersten beiden Beispiele verwendeten eine prozedurale Methode zur Validierung von Zahlen mit dem Luhn-Algorithmus in Python. Dieses Beispiel verwendet funktionale Programmierung, um Zahlen mit dem Luhn-Algorithmus in Python zu validieren.

Die Verwendung der funktionalen Programmiermethode spart dem Programmierer Zeit und Mühe. Das folgende Python-Programm validiert eine Zahl in weniger Codezeilen.

  1. Eine Methode luhn_algo wird mit einem Parameter num erstellt.

  2. In einer neuen Variablen rev werden die Ziffern aus dem Parameter num in einer Liste gespeichert. Dazu wird eine for-Schleife verwendet, die über die Anzahl der Ziffern von num iteriert.

    Der Slicing-Operator ::-1 kehrt die Ziffern innerhalb der Liste um.

  3. Die return-Anweisung berechnet die ganze Operation auf einmal.

    Die Summe der ungeraden Ziffern wird mit der Syntax (sum(rev[0::2]) berechnet, die geraden Ziffern werden in einer for-Schleife durchlaufen (for d in r[1::2]).

    Jede Ziffer wird mit 2 multipliziert und die Ziffern des Produkts werden mit der Funktion divmod() addiert.

    Die Funktion divmod() übernimmt zwei Parameter – Zähler und Nenner und gibt zwei Werte zurück – Quotient und Rest.

    Die Syntax divmod(d * 2, 10) verwendet d*2 als Zähler und 10 als Nenner. Das Ergebnis wird addiert, um die Quersumme zu erhalten.

    Zuletzt prüft die Funktion, ob die Endsumme durch 10 teilbar ist und gibt das Ergebnis zurück.

  4. Mittels einer for-Schleife werden vier Zahlen als Eingabe bereitgestellt und das Ergebnis ausgegeben.

Code:

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))

Ausgang:

49927398716 True
49927398717 False
1234567812345678 False
1234567812345670 True

Abschluss

Dieser Artikel enthält drei Programme, mit denen der Leser verstehen kann, wie Zahlen mit dem Luhn-Algorithmus in Python validiert werden.

Es wird empfohlen, dass der Leser den Artikel durchgeht, versucht, den Code selbst zu schreiben, und für Hinweise zurückkommt. Auf diese Weise kann der Leser Programme erstellen, die Zahlen mit dem Luhn-Algorithmus validieren.

Verwandter Artikel - Python Checksum