使用regex python验证卡号

Question

我随身携带一些信用卡号码，希望通过以下规则验证它们。

►必须只包含数字（0-9）

► 它可以有4个一组的数字，由一个连字符“-”分隔

► 它不能有4个或更多连续重复的数字

►它可以包含没有任何空格的精确数字

输入：

>

61234-567-8912-3456

4123356789123456

5133-3367-8912-3456

输出：

>

有效的

无效（因为卡号没有分成4个相等的组）

有效

无效（连续33位重复4次）

我在这里试过，它的工作，只有当我包括连字符在最后。有人能给我一个正确的reg ex。

编辑：

正则表达式代码：（[0-9]{4}-{4}

要匹配的输入6244-5567-8912-3458

直到我把连字符放在末尾才匹配。

编辑

import re
import itertools
text="5133-3367-8912-3456"
print(len(text))

l=[(k, sum(1 for i in g)) for k,g in itertools.groupby(text)]  #To calculate frequency of characters and later we can filter it with the condition v<=3 for checking the concurrency condition

if re.search(r'^[456]+',text) and len(text)==16  and re.search(r'[\d]',text) and all(v<=3 for k,v in l) and bool(re.search(r'\s',text)) is False and bool(re.search(r'[a-z]',text)) is False or( bool(re.search(r'-',text))is True and len(text)==19) :
    print("it passed")

else :
    print("False")

Answer 1

除非您真的想/需要使用正则表达式，否则可以通过以下简单的python代码来解决此任务：

import itertools
card = "5133-3467-8912-.456"

# Check if hyphens are ok
if (len(card.split('-')) == 1 and len(card) == 16) or (len(card.split('-')) == 4 and all(len(i) == 4 for i in card.split("-"))):
    # Remove all hyphens (if any)
    card = card.replace("-", "")
    try:
        # Check if numbers only
        int(card)
        # Check if more than 3 repeated digits
        if max(len(list(g)) for _, g in itertools.groupby(card)) > 3:
            print("Failed: 4+ repeated digits")
        else:
            print("Passed")
    except ValueError as e:
        print("Failed: non-digit characters")
else:
    print("Failed: bad hyphens or length")

Answer 2

你的正则表达式几乎是正确的。它要求四组以破折号结尾的数字。您需要的是三个以破折号结尾的组，然后是一个以非破折号结尾的组，或者一个没有破折号的blob：

(?:[0-9]{4}-){3}[0-9]{4}|[0-9]{16}

[链接]

因为你不需要捕捉内容，所以我将该组设置为非捕捉。您也可以使用\d而不是[0-9]：

(?:\d{4}-?){3}\d{4}

[链接]

在单独的步骤中，验证连续数字可能更容易。正则表达式匹配通过后，删除所有破折号：

num = num.replace('-', '')

现在使用itertools检查重复的数字。groupby，类似于这个问题/答案：

from itertools import groupby

if max(len(list(g)) for _, g in groupby(num)) >= 4:
    print('Invalid: too many repeated digits')

完整代码

from itertools import groupby
import re

pattern = re.compile(r'(?:\d{4}-){3}\d{4}|\d{16}')

def count_consecutive(num):
    return max(len(list(g)) for _, g in groupby(num)

num = '6244-5567-8912-3458'
if not pattern.fullmatch(num) or count_consecutive(num.replace('-', '')) >= 4:
    print('Failed')
else:
   print('Success')

Answer 3

我的解决方案有一个两步逻辑。你不能一次完成的原因与python re的局限性有关。我们将把它保存到以后。如果你感兴趣，看看附录1。

2步：第一步检查“-”是否在正确的位置，第二步检查是否有4个连续相等的数字。

我将从第二步开始，这是最消耗内存的一步：一个检查是否没有连续4个数字的正则表达式。下面的正则表达式可以：

((\d)(?!\2{3})){16}

说明：

(                       # group 1 start
  (\d)                  # group 2: match a digit
  (?!\2{3})             # negative lookahead: not 3 times group 2
){16}                   # repeat that 16 times.

看看例子1

第一步是匹配由4个数字组成的组，最终以“-”分隔（参见示例2）。这里要解决的问题是，如果第一组和第二组数字以“-”分隔，那么所有组都需要以“-”分隔。我们通过在下一个正则表达式中使用对第2组的反向引用来实现这一点。

(\d{4})(-?)(\d{4})(\2\d{4}){2}

说明：

(\d{4})                 # starting 4 digits
(-?)                    # group 2 contains a '-' or not
(\d{4})                 # 2nd group of 4 digits
(\2\d{4}){2}            # last 2 groups, starting with a backreference
                        # to group 2 ( a '-' or not)

示例程序：

 import re

 pattern1 = r"(\d{4})(-?)(\d{4})(\2\d{4}){2}"
 pattern2 = r"((\d)(?!\2{3})){16}"

 tests = ["5123-4567-8912-3456"]

 for elt in tests:
     if re.match( pattern1, elt):
         print "example has dashes in correct place"
         elt = elt.replace("-", "")
         if re.match(pattern2, elt):
             print "...and has the right numbers."

附录：现在是沙漠。我已经把一个正则表达式放在一起，一次就完成了。让我们根据每个数字在一组中的位置来考虑每个数字需要什么：

• 第1位：后面跟着3位
• 第2位：后跟3位或数字，数字，破折号，数字
• 第3位：后接3位或数字，破折号，数字，数字
• 第4位：后接3位或破折号，数字，数字，数字

因此，对于示例1中使用的前瞻，我们需要为每个数字显示所有后续操作的可能性。让我们来看一组4位数字的模式：

(
  (\d)             # the digit at hand
  (?!              # negative lookahead
   \2{3}           # digit, digit, digit
  |\2{2}-\2        # OR digit, digit, dash, digit
  |\2-\2{2}        # OR digit, dash, digit, digit
  |-\2{3}          # OR dash, digit, digit, digit
  )
){4}               # 4 times, for each digit in a group of 4

当然，我们想把这个数字扩大到16位。我们需要定义是否可以在数字前加“-”。一个简单的- 不行，因为信用卡不是以破折号开头的。让我们使用交替：

(?                 # if
  (?<=\d{4})       # lookbehind: there are 4 preceding digits
  -?               # then: '-' or not
  |                # else: nothing
)

综合起来，这让我们想到：

\b((?(?<=\d{4})-?|)(\d)(?!\2{3}|\2{2}-\2|\2-\2{2}|-\2{3})){16}\b

请看示例3。我们需要两边的\b，因为我们想确保无论何时匹配成功，它都与完成字符串匹配。

让我们公平地说：人们怀疑这是否是一条道路。从好的方面来看，我们现在有一个合理的理由可以分两步来做：python的标准re不支持条件句等等。你可以通过使用替代品来解决这个问题。或切换编程语言。；-）

附录2：人们问我例3中的16来自哪里。完整的字符串可以是19个字符，这不是真的吗？原因是每当内部html" target="_blank">正则表达式（组1）匹配一次时，它就会与[0-9]或-[0-9]匹配。那场比赛必须成功整整16次。