1，正则表达式

    - 正则表达式（Regular Expression）在诸多编程语言中都是较为重要的一部分。它是一个由特殊字符组成的字符串，这个特殊的字符串描述了匹配一系列字符的规则。
    - 正则表达式为高级的文本模式匹配、抽取、与/或文本形式的搜索和替换功能提供了基础。
    - 大多数编程语言中正则表达式的书写形式和规则是一样的。

2，正则表达式的执行流程

    - 正则表达式的大致匹配过程是：依次将文本中的字符和正则表达式做匹配，如果所有字符都能匹配，则匹配成功；一旦有匹配不成功的字符则匹配失败。

3，特殊符号和字符 - 符号

'''
    表示法：re1|re2
    描述：匹配正则表达式re1或者re2
    匹配的表达式：res=re.search("foo|bar","xxxfooxxx")
    预期输出结果：foo
'''
import re
res=re.search("foo|bar","xxxfooxxx")
print(res.group())  # foo
'''
    表示法：.
    描述：匹配任何字符（除\n之外）
    匹配的表达式：res=re.search("b.b","xxxbobxxx")
    预期输出结果：bob
'''
import re
res=re.search("b.b","xxxbobxxx")
print(res.group())  # bob
'''
    表示法：^
    描述：匹配字符串起始部分
    匹配的表达式：res=re.search("^b.b","bobx xx")
    预期输出结果：bob
'''
import re
res=re.search("^b.b","bobx xx")
print(res.group())  # bob
'''
    表示法：$
    描述：匹配字符串结尾部分
    匹配的表达式：res=re.search("b.b$","xx xbob")
    预期输出结果：bob
'''
import re
res=re.search("b.b$","xx xbob")
print(res.group())  # bob
'''
    表示法：*
    描述：匹配0次或者多次前面出现的正则表达式（从字符串开头匹配）
    匹配的表达式：res=re.search("bob*","bobbo")
                res1=re.search(".*","bobbobdd")
    预期输出结果：bobb
                bobbobdd
'''
import re
res=re.search("bob*","bobbo")
res1=re.search(".*","bobbobdd")
print(res.group())  # bobb
print(res1.group())  # bobbobdd
'''
    表示法：+
    描述：匹配1次或者多次前面出现的正则表达式
    匹配的表达式：res=re.search("bob+","xxxxbobbbbob")
    预期输出结果：bobbbb
'''
import re
res=re.search("bob+","xxxxbobbbbob")
print(res.group())  # bobbbb
'''
    表示法：?
    描述：匹配0次或者1次前面出现的正则表达式
    匹配的表达式：res=re.search("bob?","bobbob")
    预期输出结果：bob
'''
import re
res=re.search("bob?","bobbob")
print(res.group())  # bob
'''
    表示法：{N}
    描述：匹配N次前面出现的正则表达式
    匹配的表达式：res=re.search("bob{2}","bobbbbob")
    预期输出结果：bobb
'''
import re
res=re.search("bob{2}","bobbbbob")
print(res.group())  # bobb
'''
    表示法：{M,N}
    描述：匹配M到N次前面出现的正则表达式
    匹配的表达式：res=re.search("bob{2,3}","bobbbbob")
    预期输出结果：bobbb
'''
import re
res=re.search("bob{2,3}","bobbbbob")
print(res.group())  # bobbb
'''
    表示法：[...]
    描述：匹配来自字符集的任意单一字符
    匹配的表达式：res=re.search("[b,o,b]","xxbobxx")
    预期输出结果：b
'''
import re
res=re.search("[b,o,b]","xxbobxx")
print(res.group())  # b
'''
    表示法：[...X-Y...]
    描述：匹配x-y范围中任意单一字符
    匹配的表达式：res=re.search("[a-z]","xxbobxx")
    预期输出结果：x
'''
import re
res=re.search("[a-z]","xxxbobxxx")
print(res.group())  # x
'''
    表示法：[^...]
    描述：不匹配字符串中任何一个字符，包括某一范围的字符
    匹配的表达式：res=re.search("[^a-z]","xx214bobxx")
                res1=re.search("[^2,x,1]","xx214bobxx")
    预期输出结果：2
                4
'''
import re
res=re.search("[^a-z]","xx214bobxx")
res1=re.search("[^2,x,1]","xx214bobxx")
print(res.group())  # 2
print(res1.group())  # 4
'''
    表示法：(*|+|{})?
    描述：用于匹配频繁出现或者重复出现的符号的非贪婪版本
    匹配的表达式：res=re.search(".[+|?]?[1-9]","ds4b")
    预期输出结果：s4
'''
import re
res=re.search(".[+|?]?[1-9]","ds4b")
print(res.group())  # s4

4，特殊符号和字符 - 字符

'''
    表示法：\w
    描述：匹配字母数字及下划线
'''
import re
str_="996.ICU指工作996、生病ICU，也就是工作从早上9点上班到晚上9点下班，每周工作6天，生病了就住进ICU"
num1=re.findall(r"\w+",str_)
print(num1)  # ['996', 'ICU指工作996', '生病ICU', '也就是工作从早上9点上班到晚上9点下班', '每周工作6天', '生病了就住进ICU']

'''
    表示法：\W
    描述：匹配非字母数字及下划线
'''
import re
str_="996.ICU指工作996、生病ICU，也就是工作从早上9点上班到晚上9点下班，每周工作6天，生病了就住进ICU"
num1=re.findall(r"\W+",str_)
print(num1)  # ['.', '、', '，', '，', '，']
'''
    表示法：\s
    描述：匹配任意空白字符，等价于[\t\n\r\f]
'''
import re
str_="一二三四五，上山打老虎，老虎打不到，打到小松鼠"
res=re.findall(r"\s+",str_)
print(res)  # []
'''
    表示法：\S
    描述：匹配任意非空字符
'''
import re
str_="一二三四五，上山打老虎，老虎打不到，打到小松鼠"
res=re.findall(r"\S+",str_)
print(res)  # ['一二三四五，上山打老虎，老虎打不到，打到小松鼠']
'''
    表示法：\d
    描述：匹配任意数字，等价于[0-9]
'''
import re
str_="996.ICU指工作996、生病ICU，也就是工作从早上9点上班到晚上9点下班，每周工作6天，生病了就住进ICU"
num1=re.findall(r"\d+",str_)  # \d匹配数字，+匹配多次
print(num1)  # ['996', '996', '9', '9', '6']
'''
    表示法：\D
    描述：匹配任意非数字
'''
import re
str_="996.ICU指工作996、生病ICU，也就是工作从早上9点上班到晚上9点下班，每周工作6天，生病了就住进ICU"
num1=re.findall(r"\D+",str_)  # \d匹配数字，+匹配多次
print(num1)  # ['.ICU指工作', '、生病ICU，也就是工作从早上', '点上班到晚上', '点下班，每周工作', '天，生病了就住进ICU']

5，常见的正则表达式

'''
    描述：n位数字
    匹配的表达式：^\d{n}$

    描述：汉字
    匹配的表达式：^[\u4e00-\u9fa5]{0,}$

    描述：英文和数字
    匹配的表达式：^[A-Za-z0-9]+$ 或 ^[A-Za-z0-9]{4,40}$

    描述：匹配英文字母
    匹配的表达式：^[A-Za-z]+$

    描述：中文、英文、数字包括下划线
    匹配的表达式：^[\u4E00-\u9FA5A-Za-z0-9_]+$

    描述：邮箱
    匹配的表达式：^\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*$

    描述：域名
    匹配的表达式：[a-zA-Z0-9][-a-zA-Z0-9]{0,62}(/.[a-zA-Z0-9][-a-zA-Z0-9]{0,62})+/.?

    描述：URL
    匹配的表达式：^http://([\w-]+\.)+[\w-]+(/[\w-./?%&=]*)?$

    描述：手机号码
    匹配的表达式：^(13[0-9]|14[5|7]|15[0|1|2|3|5|6|7|8|9]|18[0|1|2|3|5|6|7|8|9])\d{8}$

    描述：身份证匹配
    匹配的表达式：^\d{15}|\d{18}$
'''

6，贪婪匹配

    - 当正则表达式中包含能接受到重复的限定符时，通常的行为是匹配尽可能多的字符，这种匹配方式叫做贪婪匹配。特征是一次性读入整个字符串进行匹配，
        每当不匹配就舍弃最右边一个字符，继续匹配，依次匹配和舍弃，直到匹配成功或者把整个字符串舍弃为止，因此它是一种最大化数据返回。
        res=re.search(r"(\d+)","Python955wlb").group(1)  # 955

7，非贪婪（懒惰）匹配

    - 当正则表达式中包含能接受重复的限定符时，通常的行为是匹配尽可能少的字符，这种匹配方式叫做懒惰匹配。
    - 特征：从左到右，从字符串的最左边开始匹配，每次试图不读入字符匹配，匹配成功，则完成匹配，否则读入一个字符再匹配，依次循环（读入字符，匹配）直到匹配成功或者把字符串的字符匹配完为止。
        res=re.search(r"(\d+?)","Python955wlb").group(1)  # 955

8，正则表达式注意事项

    - 转义字符 /：如果在表达式中需要匹配一些有特殊意义的字符，可以使用转义字符（如："//"，匹配/）。
    - 原始字符串 r：要匹配多个/，可以使用r。
    - 非贪婪操作符 ？：在表达式中使用"?"可以让表达式尽可能少的去匹配，实现非贪婪模式。

9，re模块

    - 在Python中通过正则表达式对字符串进行匹配的时候，需要使用标准库re模块。
    - re模块中通过给定的匹配规则，匹配文本中符合规则的字符进行操作。
    - 匹配规则可以是字符串，也可以是正则表达式。
    - 字符串操作：
        分割，替换，查找。
    - re模块常用匹配方法

'''
    函数/方法：match(pattern,string,flag=0)
    描述：匹配以给定限制开头的字符串
'''
import re
res=re.match("www","www.python.org")
print(res.group())  # www
res1=re.match("www","p.www.python.org")
print(res1.group())  # AttributeError: 'NoneType' object has no attribute 'group'
'''
    函数/方法：search(pattern,string,flag=0)
    描述：在整个字符串中寻找匹配规则的字符串
'''
import re
res=re.search("www","p.www.python.org")
print(res.group())  # www
'''
    函数/方法：findall(pattern,string,flag=0)
    描述：查找字符串中所有出现的正则表达式模式，返回列表
'''
import re
res=re.findall("w","wasdw")
print(res)  # ['w', 'w']
'''
    函数/方法：sub(pattern,string,flag=0)
    描述：将选中的字符串替换为给定的字符串
'''
import re
res=re.sub(r"\d+","997","Python=996")
print(res)  # Python=997
'''
    函数/方法：split(pattern,string[,maxsplit=0,flags=0])
    描述：根据给定字符串切分字符串
'''
import re
res=re.split("\.","www.huawei.com")
print(res)  # ['www', 'huawei', 'com']
'''
    函数/方法：compile(pattern[,flags])
    描述：编译正则表达式，获得一个正则表达式对象
'''
import re
pattern=re.compile(r"\d+")
res=pattern.search("www.996icu.com")
print(res)  # <re.Match object; span=(4, 7), match='996'>

    - 常用的匹配对象方法

'''
    函数/方法：group(num=0)
    描述：返回整个匹配对象，或者编号为num的特定子组
'''
import re
res=re.search("([0-9]*)([a-z]*)([0-9]*)","123abc456")
print(res.group())  # 123abc456
print(res.group(1))  # 123
print(res.group(2))  # abc
print(res.group(3))  # 456
'''
    函数/方法：groups(default=None)
    描述：返回一个包含所有子组的元组
'''
import re
res=re.search("(\w\w\w)-(\d\d\d)","abc-123")
print(res.groups())  # ('abc', '123')
'''
    函数/方法：groupdict(default=None)
    描述：返回一个包含所有匹配的命名子组的字典，子组名称为键值
'''
import re
res=re.search("(?P<lamb>\w\w\w)-(?P<num>\d\d\d)","abc-123")
print(res.groupdict())  # {'lamb': 'abc', 'num': '123'}
'''
    函数/方法：re.i,re.IGNORECASE
    描述：不区分大小写
'''
import re
res=re.search("abc","aBcxx",re.I)
print(res.group())  # aBc
'''
    函数/方法：re.M,re.MULTILINE
    描述：^和$分别匹配目标字符串的起始和结尾，而不是严格匹配字符串本身的起始和结尾
'''
import re
res=re.search("^aB","aBcxx",re.M)
print(res.group())  # aB