迹忆客 专注技术分享

德国计算机科学家 Hans Peter Luhn 在 1960 年代开发了 Luhn 算法公式。 它是 Visa 和 Master Card 等主要国际金融电子资金转账组织使用的一种校验和算法，用于加快在线支付和交易速度。

这篇文章解释了用 Python 编写 Luhn 算法并根据算法验证数字。

在 Python 中使用 Luhn 算法验证数字

Luhn 算法验证器有助于检查合法数字并将其与不正确或拼写错误的输入分开。

让我们了解如何使用 Python 中的 Luhn 算法创建一个验证数字的程序。

使用函数通过 Luhn 算法验证数字

该程序接受一个数字并使用 Python 中的 Luhn 算法对其进行验证。 该程序具有三个方法 - separate_digits()、luhn_algo() 和 check_if_valid。

分步说明：

1. 第一行代码创建一个带有参数 num 的方法 luhn_algo。
2. 在该方法内部，创建了另一个嵌套方法 separate_digits()。 此嵌套方法将传递给它的数字的数字分开，并将分开的数字作为 Python 列表返回。

   该方法使用 for 循环来迭代列表中的数字。

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

3. 新变量 digits 使用 separate_digits 方法将 num 内的值转换为数字列表。

   digits = separate_digits(num)
   

4. 一旦数字存储在 Python 列表中，就需要反转列表，并且需要将偶数和奇数分开。 这是通过使用切片运算符 :: 来实现的。

   例如，在语法 odd_digits = digits[-1::-2] 中，-1:: 反转列表并采用第一个索引。

   ::-2 从第一个索引开始每隔一个元素拾取一次。 这将创建一个只有奇数位的新列表。

   同样，偶数位列表是使用运算符 -2::-2 创建的。

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

5. Luhn算法是奇数位相加，偶数位乘以2后相加。

   如果偶数位的乘积大于 9，则将它们的位数相加。 最后，将所有奇数和偶数加在一起。

   创建一个变量校验和来对所有数字求和。 使用以下语法计算奇数位的总和：

   checksum += sum(odd_digits)
   

   创建一个 for 循环来迭代偶数位列表。 这样每个数字都乘以2，然后separate_digits方法将乘积的数字分开，然后计算它们的和。

   最后，它被添加到变量校验和中。

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

6. 要通过 Luhn 算法验证的数字，其最终产品必须能被 10 整除。结果的值在方法结束时返回。

   return checksum % 10
   

7. 为了验证 Luhn 算法的结果，创建了一个带有参数 num 的方法 check_if_valid。 该方法使用权益运算符检查方法 luhn_algo 返回的结果是否等于零并返回结果。

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

8. 为了打印结果，将一个数字传递给方法 check_if_valid，然后打印结果。

代码：

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)
    odd_digits = digits[-1::-2]  # Creates a new reversed list with just odd digits
    even_digits = digits[-2::-2]  # Creates another reversed list with even digits

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

输出:

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

这样，可以轻松创建一个程序，使用 Python 中的 Luhn 算法验证数字。

使用嵌套循环通过 Luhn 算法验证数字

在 Python 中通过 Luhn 算法验证数字的另一种方法是使用嵌套循环。 该程序使用单个函数通过 Python 中的 Luhn 算法验证数字。

让我们了解代码的工作原理。

1. 第一行代码创建一个带有参数 num 的方法 luhn_algo。
2. 变量 check_sum 初始化为零。

   def luhn_algo(num):
   check_sum = 0
   

3. 变量 num_parity 查找给定数字的长度并检查其奇偶校验，无论是偶数还是奇数。

   num_parity = len(num) % 2
   

4. 创建一个 for 循环，从它的第 0 个位置向后运行到它的长度。 第 l 个索引的值被复制初始化为变量 j。

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

5. 变量 num_parity 就在此时出现。 如果 num_parity 为零，这意味着 num 是偶数，反之亦然。

   由于所有偶数位都需要乘以 2，因此程序检查其第 l+1 个索引的奇偶性。 假设奇偶校验为 0，l + 1 % 2 等于奇偶校验，则表示第 l 个索引为奇数。

   同样，如果奇偶校验为 0 且不等于 l + 1 % 2，则为偶数。 通过使用此逻辑，每个偶数位都乘以 2，如果乘积大于 9，则除以 9。

   check_sum 变量用 j 的值自增。 在循环迭代结束时，check_sum 计算偶数和奇数的最终和。

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

6. 众所周知，最终的总和需要被 10 整除才能使用 Python 中的 Luhn 算法进行验证，因此该函数返回 check_sum % 10 == 0。

代码：

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

输出:

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

使用函数式编程通过 Luhn 算法验证数字

前两个示例使用程序方法通过 Python 中的 Luhn 算法验证数字。 此示例使用函数式编程在 Python 中使用 Luhn 算法来验证数字。

使用函数式编程方法可以节省程序员的时间和精力。 下面的 Python 程序用更少的代码行验证了一个数字。

1. 使用参数 num 创建方法 luhn_algo。
2. 在新变量 rev 中，参数 num 中的数字存储在列表中。 for 循环用于此目的，它迭代 num 中的位数。

    

   切片运算符 ::-1 反转列表中的数字。

    

3. return 语句一次计算整个操作。

   使用语法 (sum(rev[0::2]) 计算奇数位的总和。偶数位在 for 循环中运行（for d in r[1::2]）。

   每个数字乘以 2，乘积的数字使用 divmod() 函数相加。

   divmod() 函数接受两个参数——分子和分母，并返回两个值——商和余数。

   divmod(d * 2, 10) 语法将 d*2 作为分子，将 10 作为分母。 结果相加得到位数之和。

   最后，该函数检查最终总和是否可以被 10 整除并返回结果。

4. 使用 for 循环，提供四个数字作为输入，并打印结果。

代码:

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

输出:

49927398716 True
49927398717 False
1234567812345678 False
1234567812345670 True

总结

本文提供了三个程序，让读者了解如何在 Python 中使用 Luhn 算法验证数字。

建议读者通读文章，尝试自己编写代码，然后回来寻求提示。 这样，读者可以创建使用 Luhn 算法验证数字的程序。