Python’da Luhn Algoritması’na Hakim Olma: Dört Uygulama

Luhn algoritması, kredi kartı numaraları ve IMEI numaraları dahil olmak üzere çeşitli kimlik numaralarını doğrulamak için kullanılan basit bir kontrol toplamı formülüdür. Veri bütünlüğünü korumak ve giriş sırasında hataları tespit etmek için değerli bir araçtır. Bu makale, çeşitli programlama stillerini ve bunların göreceli verimliliğini sergileyen Luhn algoritmasının farklı Python uygulamalarını inceliyor.

İçerik Tablosu

• Temel Uygulama
• Fonksiyonel Ayrıştırma
• Yinelemeli Yaklaşım (İç İçe Döngüler)
• Gelişmiş Fonksiyonel Programlama
• Sonuç

Temel Uygulama

Luhn algoritması şu adımları içerir:

1. Sağdan sola doğru her ikinci basamağı ikiyle çarpın.
2. Çarpılmış değer 9’u aşarsa, 9 çıkarın.
3. Tüm basamakları toplayın.
4. Toplamın 10 modülosunun 0 olması durumunda sayı geçerlidir; aksi takdirde geçersizdir.

İşte basit bir Python uygulaması:

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" {number1} geçerli mi? {luhn_check(number1)}")  # Çıktı: True
print(f" {number2} geçerli mi? {luhn_check(number2)}")  # Çıktı: False

Fonksiyonel Ayrıştırma

Okunabilirliği ve sürdürülebilirliği artırmak için, algoritmayı daha küçük, daha odaklı fonksiyonlara ayırabiliriz:

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" {number1} geçerli mi (fonksiyonel)? {luhn_check_functional(number1)}")  # Çıktı: True
print(f" {number2} geçerli mi (fonksiyonel)? {luhn_check_functional(number2)}")  # Çıktı: False

Yinelemeli Yaklaşım (İç İçe Döngüler)

İç içe döngüler kullanan yinelemeli bir yaklaşım, daha az verimli olsa da, algoritmanın adım adım daha net bir şekilde gösterimini sağlar (esas olarak eğitim amaçlı):

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" {number1} geçerli mi (yinelemeli)? {luhn_check_iterative(number1)}")  # Çıktı: True
print(f" {number2} geçerli mi (yinelemeli)? {luhn_check_iterative(number2)}")  # Çıktı: False

Gelişmiş Fonksiyonel Programlama

Python’ın map ve reduce fonksiyonlarından yararlanarak fonksiyonel yaklaşım daha da geliştirilir:

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" {number1} geçerli mi (fonksiyonel programlama)? {luhn_check_fp(number1)}")  # Çıktı: True
print(f" {number2} geçerli mi (fonksiyonel programlama)? {luhn_check_fp(number2)}")  # Çıktı: False

Sonuç

Bu makale, farklı programlama paradigmalarını gösteren Luhn algoritmasının çeşitli Python uygulamalarını sundu. Yinelemeli yaklaşım anlayışı kolaylaştırırken, özellikle gelişmiş olan fonksiyonel yaklaşımlar, pratik uygulamalar için daha iyi okunabilirlik ve verimlilik sunar. Luhn algoritmasının bir kontrol toplamı olduğunu, eksiksiz bir güvenlik çözümü olmadığını ve diğer doğrulama yöntemleriyle birlikte kullanılması gerektiğini unutmayın.