正则表达式

正则的元字符

w3c的零基础教程：https://www.w3cschool.cn/regexp/zoxa1pq7.html

正则表达式30分钟入门教程：http://deerchao.net/tutorials/regex/regex.htm

微软的正则表达式https://docs.microsoft.com/zh-cn/dotnet/standard/base-types/regular-expression-language-quick-reference

正则速查：http://www.uedsc.com/lookup-tables.html

'*'，'+'和'?' 表示字符重复出现的次数，分别表示“零或更多”，“一次或更多”还有“零次或一次”。

'*'，'+'和'?' 相当于"{0,}"，"{1,}"和"{0,1}"。

"ab*"：表示一个字符串有一个a后面跟着零个或若干个b。（"a", "ab", "abbb",……）；
"ab+"：表示一个字符串有一个a后面跟着至少一个b或者更多；#贪婪匹配，尽可能多的匹配
"ab?"：表示一个字符串有一个a后面跟着零个或者一个b；#非贪婪匹配，尽可能少的匹配
"a?b+$"：表示在字符串的末尾有零个或一个a跟着一个或几个b。

"ab{2}"：表示一个字符串有一个a跟着2个b（"abb"）；
"ab{2,}"：表示一个字符串有一个a跟着至少2个b；
"ab{3,5}"：表示一个字符串有一个a跟着3到5个b。

"hi¦hello"：表示一个字符串里有"hi"或者"hello"；
"(b¦cd)ef"：表示"bef"或"cdef"；
"(a¦b)*c"：表示一串"a""b"混合的字符串后面跟一个"c"；

[]方括号是字符集合，表示匹配方括号中所包含的任意一个字符

中括号里的^称为脱字符，表示不匹配集合中的字符

"a.[0-9]"：表示一个字符串有一个"a"后面跟着一个任意字符和一个数字；
"^.{3}$"：表示有任意三个字符的字符串（长度为3个字符）；

"[ab]"：表示一个字符串有一个"a"或"b"（相当于"a¦b"）；
"[a-d]"：表示一个字符串包含小写的'a'到'd'中的一个（相当于"a¦b¦c¦d"或者"[abcd]"）；
"^[a-zA-Z]"：表示一个以字母开头的字符串；
"[0-9]%"：表示一个百分号前有一位的数字；
",[a-zA-Z0-9]$"：表示一个字符串以一个逗号后面跟着一个字母或数字结束。
"%[^a-zA-Z]%"表示两个百分号中间不应该出现字母
[^good]     匹配除了good这几个字母以外的所有字符，
[^0-9]      匹配所有的非数字字符

'''
^   行首匹配，和在[]里的^不是一个意思，注意：写在最前面，表示一个字符串的开始
$   行尾匹配，注意：写在正则最后面，表示一个字符串的结束
.   匹配除换行符以外的任意字符
说明：下方的x，y均为假设的普通字符，n，m(非负整数)，不是正则表达式的元字符
(xyz)   匹配小括号内的xyz(作为一个整体去匹配)
x?      匹配0个或者1个x
x*      匹配0个或者任意多个x(.*表示匹配0个或者任意多个字符(换行符除外))
x+      匹配至少一个x
x{n,}   匹配至少n个x
x{n}    匹配确定的n个x(n是一个非负整数)
x{n,m}  匹配至少n个最多m个x，注意n<=m
x|y     |表示或，匹配的是x或y

\d          匹配数字，效果同[0-9]
\D          匹配非数字字符，效果同[^0-9]
\w          匹配数字，字母和下划线，效果同[0-9a-zA-Z_]
\W          匹配非数字，字母和下划线，效果同[^0-9a-zA-Z_ ]
\s          匹配任意的空白符(空格、回车、换行、制表、换页)，效果同[\r\n\t\f]
\S          匹配任意的非空白符，效果同[^\f\n\r\t]
'''
注意：
通常情况下？与*或者是+一起连用，来起到一个限制贪婪匹配的作用
*与+一般情况下与“.”,代表匹配任意多个任意字符
'''
\A  匹配字符串开始，它和^的区别是，\A只匹配整个字符串的开头，即使在re.M模式（,flags=re.m）下也不会匹配其他行的行首
\Z  匹配字符串结束，它和$的区别是，\Z只匹配整个字符串的结束，即使在re.M模式下也不会匹配其它行的行尾
注意：若不指定re.M模式，则^与\A,$与\Z匹配结果相同。
\b  匹配一个单词的边界，也就是指单词和空格的位置，'er\b'可以匹配never，不能匹配nerve。
    注意：当\b添加在单词左边的时候，它会从单词左边的边界开始匹配,
        当\b添加添加单词的右边的时候，它会从单词的右边边界开始匹配.
        若想匹配整个单词，我们需要给这个单词左右两边都添加\b
\B  匹配非单词边界 
    #注意：当\B写在左边，它表示非左边边界开始匹配
        当\B写在右边，它表示非右边边界开始匹配
        若单词两边都有\B,它只匹配单词非边界中含有字符。
'''

为了逐字表达，你必须在"^.$()¦[]+?{"这些字符前*加上转义字符\''。

请注意在方括号中，不需要转义字符。

贪婪与懒惰

当正则表达式中包含能接受重复的限定符时，通常的行为是（在使整个表达式能得到匹配的前提下）匹配尽可能多的字符。

以这个表达式为例：a.b，它将会匹配最长的以a开始，以b结束的字符串。如果用它来搜索aabab的话，它会匹配整个字符串aabab。这被称为贪婪*匹配。

有时，我们更需要懒惰匹配，也就是匹配尽可能少的字符。前面给出的限定符都可以被转化为懒惰匹配模式，只要在它后面加上一个问号?。

这样.?*就意味着匹配任意数量的重复，但是在能使整个匹配成功的前提下使用最少的重复。现在看看懒惰版的例子吧：

a.?b匹配最短的，以a开始，以b结束的字符串。如果把它应用于aabab*的话，它会匹配aab（第一到第三个字符）和ab（第四到第五个字符）。

为什么第一个匹配是aab（第一到第三个字符）而不是ab（第二到第三个字符）？简单地说，因为正则表达式有另一条规则，比懒惰／贪婪规则的优先级更高：最先开始的匹配拥有最高的优先权。

练习题

'''功能1：提取：you...man'''
str1 = "you are a good man,you are a nice man ,you are a great man,you are a..."
print(re.findall(r"you.*?\bman\b",str1))
#\b的用法
str1 = "good man,you are a nice man ,you are a great man,you are a..."
print(re.findall(r"\bman\b",str1))  # ['man', 'man', 'man']
'''功能2：/* part1 */ /* part2 */'''
print(re.findall(r"/\*.*?\*/",r"/* part1 */ /* part2 */"))#\转义字符给*转义

'''功能3：判断电话号码是否以134开头'''
print(re.findall("^134\d{8}$","12345678901"))
'''
功能4：判断QQ号码是否合法：
1.位数6~10
2.全部是数字
3.不能以0开头
'''
^[1-9]\d{5,9}$
'''
功能5:校验普通电话、传真号码：可以“+”或数字开头，可含有“-” 和 “ ”
'''
/^[+]{0,1}(\d){1,3}[ ]?([-]?((\d)|[ ]){1,12})+$/
#可以匹配的字符串如：+123 -999 999 ； +123-999 999 ；123 999 999 ；+123 999999等
'''功能6:校验URL'''
/^http[s]{0,1}:\/\/.+$/ 
或 /^http[s]{0,1}:\/\/.{1,n}$/ (表示url串的长度为length(“https://”) + n )
'''功能7：校验密码：只能输入6-20个字母、数字、下划线'''
^(\w){6,20}$

#功能8：对用户输入的数据进行限制6位0或者1，若不是则重新输入。
def test_num():
    while True:
        num = input("请输入一位6位的中奖号码（0/1）组成：")
        res = re.findall("^[01]{6}$", num)
        if len(res) == 1:
            return num
        else:
            print("输入非法，请重新输入。。。")
            continue  
'''
功能9
1.身份证正则
2.电话号码的正则
3.邮箱正则
封装成一个功能模块。
'''
import re


def checkIdcard(idcard):
    Errors = ['验证通过!', '身份证号码位数不对!', '身份证号码出生日期超出范围或含有非法字符!', '身份证号码校验错误!', '身份证地区非法!']
    area = {"11": "北京", "12": "天津", "13": "河北", "14": "山西", "15": "内蒙古", "21": "辽宁", "22": "吉林", "23": "黑龙江",
            "31": "上海",
            "32": "江苏", "33": "浙江", "34": "安徽", "35": "福建", "36": "江西", "37": "山东", "41": "河南", "42": "湖北", "43": "湖南",
            "44": "广东", "45": "广西", "46": "海南", "50": "重庆", "51": "四川", "52": "贵州", "53": "云南", "54": "西藏", "61": "陕西",
            "62": "甘肃", "63": "青海", "64": "宁夏", "65": "新疆", "71": "台湾", "81": "香港", "82": "澳门", "91": "国外"}
    idcard = str(idcard)
    idcard = idcard.strip()
    idcard_list = list(idcard)

    # 地区校验
    key = idcard[0: 2]  # TODO： cc  地区中的键是否存在
    if key in area.keys():
        if (not area[(idcard)[0:2]]):
            return Errors[4]
    else:
        return Errors[4]
    # 15位身份号码检测

    if (len(idcard) == 15):
        if ((int(idcard[6:8]) + 1900) % 4 == 0 or (
                (int(idcard[6:8]) + 1900) % 100 == 0 and (int(idcard[6:8]) + 1900) % 4 == 0)):
            erg = re.compile(
                '[1-9][0-9]{5}[0-9]{2}((01|03|05|07|08|10|12)(0[1-9]|[1-2][0-9]|3[0-1])|(04|06|09|11)(0[1-9]|[1-2][0-9]|30)|02(0[1-9]|[1-2][0-9]))[0-9]{3}$')  # //测试出生日期的合法性
        else:
            ereg = re.compile(
                '[1-9][0-9]{5}[0-9]{2}((01|03|05|07|08|10|12)(0[1-9]|[1-2][0-9]|3[0-1])|(04|06|09|11)(0[1-9]|[1-2][0-9]|30)|02(0[1-9]|1[0-9]|2[0-8]))[0-9]{3}$')  # //测试出生日期的合法性
        if (re.match(ereg, idcard)):
            return Errors[0]
        else:
            return Errors[2]
    # 18位身份号码检测
    elif (len(idcard) == 18):
        # 出生日期的合法性检查
        # 闰年月日:((01|03|05|07|08|10|12)(0[1-9]|[1-2][0-9]|3[0-1])|(04|06|09|11)(0[1-9]|[1-2][0-9]|30)|02(0[1-9]|[1-2][0-9]))
        # 平年月日:((01|03|05|07|08|10|12)(0[1-9]|[1-2][0-9]|3[0-1])|(04|06|09|11)(0[1-9]|[1-2][0-9]|30)|02(0[1-9]|1[0-9]|2[0-8]))
        if (int(idcard[6:10]) % 4 == 0 or (int(idcard[6:10]) % 100 == 0 and int(idcard[6:10]) % 4 == 0)):
            ereg = re.compile(
                '[1-9][0-9]{5}(19[0-9]{2}|20[0-9]{2})((01|03|05|07|08|10|12)(0[1-9]|[1-2][0-9]|3[0-1])|(04|06|09|11)(0[1-9]|[1-2][0-9]|30)|02(0[1-9]|[1-2][0-9]))[0-9]{3}[0-9Xx]$')  # //闰年出生日期的合法性正则表达式
        else:
            ereg = re.compile(
                '[1-9][0-9]{5}(19[0-9]{2}|20[0-9]{2})((01|03|05|07|08|10|12)(0[1-9]|[1-2][0-9]|3[0-1])|(04|06|09|11)(0[1-9]|[1-2][0-9]|30)|02(0[1-9]|1[0-9]|2[0-8]))[0-9]{3}[0-9Xx]$')  # //平年出生日期的合法性正则表达式
        # //测试出生日期的合法性
        if (re.match(ereg, idcard)):
            # //计算校验位
            S = (int(idcard_list[0]) + int(idcard_list[10])) * 7 + (int(idcard_list[1]) + int(idcard_list[11])) * 9 + (
                        int(
                            idcard_list[2]) + int(idcard_list[12])) * 10 + (
                            int(idcard_list[3]) + int(idcard_list[13])) * 5 + (int(
                idcard_list[4]) + int(idcard_list[14])) * 8 + (int(idcard_list[5]) + int(idcard_list[15])) * 4 + (int(
                idcard_list[6]) + int(idcard_list[16])) * 2 + int(idcard_list[7]) * 1 + int(idcard_list[8]) * 6 + int(
                idcard_list[9]) * 3
            Y = S % 11
            M = "F"
            JYM = "10X98765432"
            M = JYM[Y]  # 判断校验位
            if (M == idcard_list[17]):  # 检测ID的校验位
                return Errors[0]
            else:
                return Errors[3]
        else:
            return Errors[2]
    else:
        return Errors[1]

re模块常用函数

complie()

'''
re.compile(patten,flags=0)
参数一：正则表达式
参数二：标志位re.M
功能：返回一个编译正则的对象
优点：
提高效率，对于常用的一些正则我们将其编译为对象，需要正则的的时候，调用此对象即可
'''
com = re.compile("^134\d{8}")
print(com.findall("1234345566676"))
print(com.findall("13455666761"))

match()

'''
re.match(patten,string,flags=0)
功能：只在字符串开始的位置进行匹配，匹配成功的返回一个匹配对象，匹配失败的时候返回None
注意：这个方法并不是完全匹配，若patten匹配到最后仍有剩余字符串，仍然视为匹配成功
    若想完全匹配可以在表达式的结尾添加”$“.
'''
print(re.match("134\d{8}$","1345566677711"))
print(re.match("134\d{8}","1345566677711"))

search()函数

'''
re.search(patten,string,flags=0)
功能:匹配整个字符串，返回第一个匹配结果【匹配对象】
若找不到就返回None。
'''
print(re.search(r"\bgood\b","you are a good good man").group())

findall()

'''
re.findall(patten,string,flags=0)
功能:遍历匹配，匹配整个字符串，返回所有的匹配结果【列表】.
当匹配失败的时候，返回一个空的列表。
'''
print(re.findall("good","you are a goods good man"))

p = re.compile(r"\d+")
print(p.findall('o1n2m3k4'))

sub()

'''
re.sub(patten,repl,string,count,flags)
替换string中每一个匹配的子串后返回替换后的【新字符串】。
参数一：要匹配的字符串【旧串】
参数二：替换的字符串 【新串】
参数三：传入的字符串
参数四：指定替换的次数【若不指定则默认为0，全部替换】
参数五：标志位 
'''
print(re.sub("\d+","\t","hello122hello222hello11113",count=2))
print(re.sub("\d+","\t","hello122hello222hello11113"))
text = "Bob is a handsome boy, he is cool, clever, and so on..."
print(re.sub(r'\s+', '-', text))

split()

'''
re.split(patten,string[,maxsplit])
功能：以指定的匹配正则的字符串来进行切片，返回一个【列表】
注意：当maxsplit不指定的时候，默认整个字符串全部切片。
'''
print(re.split("\d+","hello122hello222hello11113",maxsplit=2))

正则表达式修饰符 - 可选标志

正则表达式可以包含一些可选标志修饰符来控制匹配的模式。修饰符被指定为一个可选的标志。多个标志可以通过按位 OR(|) 它们来指定。如 re.I | re.M 被设置成 I 和 M 标志：