问题
def checksum(card_without_check):
card_without_check = card_without_check[-1::-1]
def numbers(string):
return [int(x) for x in string]
print(card_without_check)
odd_numbers = numbers(card_without_check[0::2])
even_numbers = numbers(card_without_check[1::2])
odd_numbers = [x * 2 for x in odd_numbers]
odd_numbers = [x - 9 if x > 9 else x for x in odd_numbers]
print(even_numbers)
print(odd_numbers)
return sum(odd_numbers) + sum(even_numbers)
def check(checksum, check):
return checksum % 10 == int(check)
card_number = input("Enter card number:\n")
print(checksum(card_number[:-1]))
print("Card is", check(checksum(card_number[:-1]), card_number[-1]))
This algorithm appears to work on examples like "4556737586899855", but not on examples like "30569309025904". I've followed the process and can't find flaws in how it's handling the numbers, I'm probably just missing some piece of the puzzle here.
I'm following the outline here and have used examples here.
回答1:
I used this solution for a codeeval problem based on Luhn's formula:
def checksum(n):
nums = reversed(list(map(int, n)))
doubled = (ele * 2 if ind % 2 else ele for ind, ele in enumerate(nums))
return not sum(sum(map(int, str(ele))) for ele in doubled) % 10
The steps are listed in the problem description:
From the rightmost digit, which is the check digit, moving left, double the value of every second digit; if the product of this doubling operation is greater than 9 (for example, 7×2=14), then sum the digits of the products (for example, 12:1+2=3, 14:1+4=5). Take the sum of all the digits. If the total modulo 10 is equal to 0 (if the total ends in zero) then, according to the Luhn formula, the number is valid; otherwise, it is not valid.
回答2:
This is the code for MOD10 (the Luhn algorithm) that I wrote from the description on (the Norwegian) Wikipedia:
def weights(n, base):
"""Repeating series of numbers from base.
For kontroll_10 it returns the series: 2,1,2,1,2,1...
which is equivalent to multiplying every other digit
by two (code is originally from a broader checsum module).
"""
for i in range(n):
yield base[i % len(base)]
def luhn_algorithm(s):
"""Also known as the MOD10 algorithm.
"""
digits = map(int, list(s))[::-1] # reversed
_weights = weights(len(digits), [2, 1])
products = ''.join(str(s * v) for (s, v) in zip(digits, _weights))
sum_of_digits = sum(int(c) for c in products)
check_digit = sum_of_digits % 10
if check_digit == 0:
checksum = check_digit
else:
checksum = 10 - check_digit
return str(checksum)
Looks like you might have skipped the special handling when the entallsiffer is zero, and you're also not subtracting from 10, meaning you'll only get the correct answer when the control/checksum digit is 5.
回答3:
You nearly got it right, except for the initial cutting off of the last digit. You cannot reverse and slice one off in one slice notation but in two:
card_without_check = card[::-1][1:]
And then in the call to the checksum() routine the logic went overboard. Try this:
def checksum(card):
def numbers(string):
return [int(x) for x in string]
card_without_check = card[::-1][1:]
print(card_without_check)
odd_numbers = numbers(card_without_check[0::2])
even_numbers = numbers(card_without_check[1::2])
odd_numbers = [x * 2 for x in odd_numbers]
odd_numbers = [x - 9 if x > 9 else x for x in odd_numbers]
print odd_numbers
print even_numbers
return (sum(odd_numbers) + sum(even_numbers)) % 10
def check(card):
return checksum(card) == int(card[-1])
def main():
card = str(input("Enter card number:\n"))
print "Valid? ", check(card)
An input of 4556737586899855 yields:Valid? 589986857376554
[1, 9, 7, 7, 5, 5, 1, 8]
[8, 9, 6, 5, 3, 6, 5]
True
回答4:
Here is a credit card utils library I wrote that covers luhn checksum as well as other credit card checks.
import re
import logging
import datetime
VISA_CC = 'Visa' # Visa
MASTERCARD_CC = 'MasterCard' # MasterCard
AMEX_CC = 'American Express' # American Express
JCB_CC = 'JCB'
DISCOVER_CC = 'DISCOVER'
DINERS_CC = 'DINERS'
MAESTRO_CC = 'MAESTRO'
LASER_CC = 'LASER'
OTHER_CC = '' # UNKNOWN
# Set which cards you accept
ACCEPTED_CARDS = [VISA_CC, MASTERCARD_CC, AMEX_CC]
def is_american_express(cc_number):
"""Checks if the card is an american express. If us billing address country code, & is_amex, use vpos
https://en.wikipedia.org/wiki/Bank_card_number#cite_note-GenCardFeatures-3
:param cc_number: unicode card number
"""
return bool(re.match(r'^3[47][0-9]{13}$', cc_number))
def is_visa(cc_number):
"""Checks if the card is a visa, begins with 4 and 12 or 15 additional digits.
:param cc_number: unicode card number
"""
# Standard Visa is 13 or 16, debit can be 19
if bool(re.match(r'^4', cc_number)) and len(cc_number) in [13, 16, 19]:
return True
return False
def is_mastercard(cc_number):
"""Checks if the card is a mastercard. Begins with 51-55 or 2221-2720 and 16 in length.
:param cc_number: unicode card number
"""
if len(cc_number) == 16 and cc_number.isdigit(): # Check digit, before cast to int
return bool(re.match(r'^5[1-5]', cc_number)) or int(cc_number[:4]) in range(2221, 2721)
return False
def is_discover(cc_number):
"""Checks if the card is discover, re would be too hard to maintain. Not a supported card.
:param cc_number: unicode card number
"""
if len(cc_number) == 16:
try:
# return bool(cc_number[:4] == '6011' or cc_number[:2] == '65' or cc_number[:6] in range(622126, 622926))
return bool(cc_number[:4] == '6011' or cc_number[:2] == '65' or 622126 <= int(cc_number[:6]) <= 622925)
except ValueError:
return False
return False
def is_jcb(cc_number):
"""Checks if the card is a jcb. Not a supported card.
:param cc_number: unicode card number
"""
# return bool(re.match(r'^(?:2131|1800|35\d{3})\d{11}$', cc_number)) # wikipedia
return bool(re.match(r'^35(2[89]|[3-8][0-9])[0-9]{12}$', cc_number)) # PawelDecowski
def is_diners_club(cc_number):
"""Checks if the card is a diners club. Not a supported card.
:param cc_number: unicode card number
"""
return bool(re.match(r'^3(?:0[0-6]|[68][0-9])[0-9]{11}$', cc_number)) # 0-5 = carte blance, 6 = international
def is_laser(cc_number):
"""Checks if the card is laser. Not a supported card.
:param cc_number: unicode card number
"""
return bool(re.match(r'^(6304|670[69]|6771)', cc_number))
def is_maestro(cc_number):
"""Checks if the card is maestro. Not a supported card.
:param cc_number: unicode card number
"""
possible_lengths = [12, 13, 14, 15, 16, 17, 18, 19]
return bool(re.match(r'^(50|5[6-9]|6[0-9])', cc_number)) and len(cc_number) in possible_lengths
# Child cards
def is_visa_electron(cc_number):
"""Child of visa. Checks if the card is a visa electron. Not a supported card.
:param cc_number: unicode card number
"""
return bool(re.match(r'^(4026|417500|4508|4844|491(3|7))', cc_number)) and len(cc_number) == 16
def is_total_rewards_visa(cc_number):
"""Child of visa. Checks if the card is a Total Rewards Visa. Not a supported card.
:param cc_number: unicode card number
"""
return bool(re.match(r'^41277777[0-9]{8}$', cc_number))
def is_diners_club_carte_blanche(cc_number):
"""Child card of diners. Checks if the card is a diners club carte blance. Not a supported card.
:param cc_number: unicode card number
"""
return bool(re.match(r'^30[0-5][0-9]{11}$', cc_number)) # github PawelDecowski, jquery-creditcardvalidator
def is_diners_club_carte_international(cc_number):
"""Child card of diners. Checks if the card is a diners club international. Not a supported card.
:param cc_number: unicode card number
"""
return bool(re.match(r'^36[0-9]{12}$', cc_number)) # jquery-creditcardvalidator
def get_card_type_by_number(cc_number):
"""Return card type constant by credit card number
:param cc_number: unicode card number
"""
if is_visa(cc_number):
return VISA_CC
if is_mastercard(cc_number):
return MASTERCARD_CC
if is_american_express(cc_number):
return AMEX_CC
if is_discover(cc_number):
return DISCOVER_CC
if is_jcb(cc_number):
return JCB_CC
if is_diners_club(cc_number):
return DINERS_CC
if is_laser(cc_number): # Check before maestro, as its inner range
return LASER_CC
if is_maestro(cc_number):
return MAESTRO_CC
return OTHER_CC
def get_card_type_by_name(cc_type):
"""Return card type constant by string
:param cc_type: dirty string card type or name
"""
cc_type_str = cc_type.replace(' ', '').replace('-', '').lower()
# Visa
if 'visa' in cc_type_str:
return VISA_CC
# MasterCard
if 'mc' in cc_type_str or 'mastercard' in cc_type_str:
return MASTERCARD_CC
# American Express
if cc_type_str in ('americanexpress', 'amex'):
return AMEX_CC
# Discover
if 'discover' in cc_type_str:
return DISCOVER_CC
# JCB
if 'jcb' in cc_type_str:
return JCB_CC
# Diners
if 'diners' in cc_type_str:
return DINERS_CC
# Maestro
if 'maestro' in cc_type_str:
return MAESTRO_CC
# Laser
if 'laser' in cc_type_str:
return LASER_CC
# Other Unsupported Cards Dankort, Union, Cartebleue, Airplus etc..
return OTHER_CC
def credit_card_luhn_checksum(card_number):
"""Credit card luhn checksum
:param card_number: unicode card number
"""
def digits_of(cc):
return [int(_digit) for _digit in str(cc)]
digits = digits_of(card_number)
odd_digits = digits[-1::-2]
even_digits = digits[-2::-2]
checksum = sum(odd_digits)
for digit in even_digits:
checksum += sum(digits_of(digit * 2))
return checksum % 10
def is_valid_cvv(card_type, cvv):
"""Validates the cvv based on card type
:param cvv: card cvv security code
:param card_type: string card type
"""
if card_type == AMEX_CC:
return len(str(cvv)) == 4
else:
return len(str(cvv)) == 3
def is_cc_luhn_valid(card_number):
"""Returns true if the luhn code is 0
:param card_number: unicode string for card_number, cannot be other type.
"""
is_valid_cc = card_number.isdecimal() and credit_card_luhn_checksum(card_number) == 0
if not is_valid_cc:
logging.error("Invalid Credit Card Number, fails luhn: {}".format(card_number))
return is_valid_cc
def is_valid_cc_expiry(expiry_month, expiry_year):
"""Returns true if the card expiry is not good.
Edge case: It's end of month, the expiry is on the current month and user is in a different timezone.
:param expiry_year: unicode two digit year
:param expiry_month: unicode two digit month
"""
try:
today = datetime.date.today()
cur_month, cur_year = today.month, int(str(today.year)[2:])
expiry_month, expiry_year = int(expiry_month), int(expiry_year)
is_invalid_year = expiry_year < cur_year
is_invalid_month = False
if not is_invalid_year:
is_invalid_month = ((expiry_month < cur_month and cur_year == expiry_year) or
expiry_month not in range(1, 13))
if is_invalid_year or is_invalid_month:
logging.info("Invalid credit card expiry {}/{}.".format(expiry_month, expiry_year))
return False
except ValueError:
logging.error("Could not calculate valid expiry for month year {}/{}.".format(expiry_month, expiry_year))
return False
return True
def is_supported_credit_card(card_type):
"""Checks if card type is in accepted cards
:param card_type: string card type
"""
if card_type in ACCEPTED_CARDS:
return True
logging.error("Card type not supported, {}.".format(card_type))
return False # (OTHER_CC, DISCOVER_CC)
def cc_card_to_mask(cc_number, show_first=6, show_last=4):
"""Returns masked credit card number
:param show_last: beginning of card, chars not to mask
:param show_first: end of card, chars not to mask
:param cc_number: unicode card number
"""
cc_number = str(cc_number)
if cc_number:
return "{}{}{}".format(cc_number[:show_first],
"X" * (len(cc_number) - show_first - show_last),
cc_number[show_last * -1:])
else:
return ""
def string_to_full_mask(cc_field):
"""Returns credit card field or any string converted to a full mask.
I.e. cvv, expiry month, expiry year, password.
:param cc_field: a generic credit card field, other than cc card no
"""
try:
cc_field = cc_field.strip()
return "X" * len(cc_field)
except (TypeError, AttributeError):
return ""
Please feel free to comment if there is anything missing that is useful. Cheers.
来源：https://stackoverflow.com/questions/29197219/credit-card-number-validator-doesnt-work-correctly