1.正则表达式介绍

"""
正则表达式 介绍:
    概述:
        全称叫: Regular Expression, 就是 正确的 符合特定规则的 字符串, 就叫: 正则表达式.
    作用:
        可以用来校验, 匹配, 过滤指定的数据.
    使用步骤:
        1. 导包.
            import re
        2. 正则校验.
            result = re.match(pattern=正则规则, str=要校验的字符串, flag=0)     参1: 正则表达式,  参2: 要校验的字符串,  参3: 可选项, 例如: 忽略大小写, 多行模式等...
        3. 获取到匹配的数据.
            result.group()
    正则表达式 涉及到的函数:
        1. 用于做校验的, 替换的.
            match()             从左往右, 逐个字符的匹配, 不会跳过某个字符, 即: 全词匹配.
            search()            从左往右, 依次匹配, 即: 只要某部分满足条件即可.
            compile().sub()     替换
        2. 用于 获取值的 .
            group()
    细节:
        1. 正则表达式不独属于Python语言, 市场上你见过的绝大多数的语言都支持正则, 例如: Python, PHP, Java, Go, JavaScript..  且规则都是一样的.
        2. 我们学正则表达式, 主要学习的是: 正则表达式的规则, 因为正则表达式已经存在很多年了, 你的需求(校验邮箱, 手机号, 身份证号), 网上一搜一大堆.
        3. 关于正则, 要求大家: 能看懂别人写的式子, 且会基于需求简单的修改即可.
    正则表达式 常用规则:
        .           任意的1个字符
        \.          取消.的特殊用法, 就是1个普通的.
        a           代表1个字符a
        [abc]       代表: a,b,c中任意的1个字符
        [^abc]      代表: 除了a,b,c以外的任意1个字符

        [0-9]       代表: 任意的1个整数, 例如: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
        \d          代表: 任意的1个整数, 效果同上.  \d = [0-9]
        \D          代表: 除了整数外的任意1个字符, 即: \D = [^0-9]
        \s
        \S
        \w
        \W

        ^
        $

        ?           数量词, 代表: 前边的内容出现 0次 或者 1次
        *           数量词, 代表: 前边的内容出现 0 ~ n
        +           数量词, 代表: 前边的内容出现 1 ~ n

        {n}
        {n,}
        {n,m}

        |           表示: 或者的意思.
        ()
        \num

        扩展:
            (?P<分组名>)   设置分组
            (?P=分组名)    使用指定的分组
"""
import re

# match()             从左往右, 逐个字符的匹配, 不会跳过某个字符, 即: 全词匹配.
# 案例1: 正则表达式 匹配 字符.
# 正则表达式:  .it 意思是:  第1个字符任意写, 后续两个字符必须是 it
# print(re.match('.it', 'ait'))       # 能匹配, 返回的是: 正则对象.
# print(re.match('.it', 'aait'))      # 不能匹配, 返回的是: None
# print(re.match('.it', 'aitb'))      # 能匹配, 返回的是: 正则对象.

# result = re.match('.it', 'ait')
# result = re.match('.it', 'aait')


# 案例2: 校验字符串是否是 ait, bit, cit, hit, git
# result = re.match('[abchg]it', 'git')

# 案例3: 校验字符串第1个字符: 可以是除了a,b,c外任意1个字符, 后两个字符必须是hm
# result = re.match('[^abc]hm', ' hm')

# 案例4: 校验 数字开头, 任意多个字符结尾.
# [0-9]     代表任意的1个整数.
# .*        代表任意个任意字符
# result = re.match('[0-9].*', 'a1hmit')               # match是从左往右, 从第1个字符开始匹配的, 不能跳.
# result = re.search('[0-9].*', 'a1hmit')  # search是从左往右, 开始匹配的, 从任意字符开始, 只要能匹配即可.

result = re.match('\d.*', '1hmit')       # \d 等价于 [0-9]

# 判断是否匹配到, 匹配到就打印: 匹配到的内容, 没有匹配到就提示.
if result != None:
    print(f'匹配到: {result.group()}')
else:
    print('未匹配到!')

2.正则表达式-match和search函数

"""
正则表达式 介绍:
    概述:
        全称叫: Regular Expression, 就是 正确的 符合特定规则的 字符串, 就叫: 正则表达式.
    作用:
        可以用来校验, 匹配, 过滤指定的数据.
    使用步骤:
        1. 导包.
            import re
        2. 正则校验.
            result = re.match(pattern=正则规则, str=要校验的字符串, flag=0)     参1: 正则表达式,  参2: 要校验的字符串,  参3: 可选项, 例如: 忽略大小写, 多行模式等...
        3. 获取到匹配的数据.
            result.group()
    正则表达式 涉及到的函数:
        1. 用于做校验的, 替换的.
            match()             从左往右, 逐个字符的匹配, 不会跳过某个字符, 即: 全词匹配.
            search()            从左往右, 依次匹配, 即: 只要某部分满足条件即可.
            compile().sub()     替换
        2. 用于 获取值的 .
            group()
    细节:
        1. 正则表达式不独属于Python语言, 市场上你见过的绝大多数的语言都支持正则, 例如: Python, PHP, Java, Go, JavaScript..  且规则都是一样的.
        2. 我们学正则表达式, 主要学习的是: 正则表达式的规则, 因为正则表达式已经存在很多年了, 你的需求(校验邮箱, 手机号, 身份证号), 网上一搜一大堆.
        3. 关于正则, 要求大家: 能看懂别人写的式子, 且会基于需求简单的修改即可.
    正则表达式 常用规则:
        .           任意的1个字符
        \.          取消.的特殊用法, 就是1个普通的.
        a           代表1个字符a
        [abc]       代表: a,b,c中任意的1个字符
        [^abc]      代表: 除了a,b,c以外的任意1个字符

        [0-9]       代表: 任意的1个整数, 例如: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
        \d          代表: 任意的1个整数, 效果同上.  \d = [0-9]
        \D          代表: 除了整数外的任意1个字符, 即: \D = [^0-9]
        \s
        \S
        \w
        \W

        ^
        $

        ?           数量词, 代表: 前边的内容出现 0次 或者 1次
        *           数量词, 代表: 前边的内容出现 0 ~ n
        +           数量词, 代表: 前边的内容出现 1 ~ n

        {n}
        {n,}
        {n,m}

        |           表示: 或者的意思.
        ()
        \num

        扩展:
            (?P<分组名>)   设置分组
            (?P=分组名)    使用指定的分组
"""
import re

# match()             从左往右, 逐个字符的匹配, 不会跳过某个字符, 即: 全词匹配.
# 案例1: 正则表达式 匹配 字符.
# 正则表达式:  .it 意思是:  第1个字符任意写, 后续两个字符必须是 it
# print(re.match('.it', 'ait'))       # 能匹配, 返回的是: 正则对象.
# print(re.match('.it', 'aait'))      # 不能匹配, 返回的是: None
# print(re.match('.it', 'aitb'))      # 能匹配, 返回的是: 正则对象.

# result = re.match('.it', 'ait')
# result = re.match('.it', 'aait')


# 案例2: 校验字符串是否是 ait, bit, cit, hit, git
# result = re.match('[abchg]it', 'git')

# 案例3: 校验字符串第1个字符: 可以是除了a,b,c外任意1个字符, 后两个字符必须是hm
# result = re.match('[^abc]hm', ' hm')

# 案例4: 校验 数字开头, 任意多个字符结尾.
# [0-9]     代表任意的1个整数.
# .*        代表任意个任意字符
# result = re.match('[0-9].*', 'a1hmit')               # match是从左往右, 从第1个字符开始匹配的, 不能跳.
# result = re.search('[0-9].*', 'a1hmit')  # search是从左往右, 开始匹配的, 从任意字符开始, 只要能匹配即可.

result = re.match('\d.*', '1hmit')       # \d 等价于 [0-9]

# 判断是否匹配到, 匹配到就打印: 匹配到的内容, 没有匹配到就提示.
if result != None:
    print(f'匹配到: {result.group()}')
else:
    print('未匹配到!')

3.compile函数

"""
正则表达式 替换, 介绍:
    涉及到的函数:
        import re
        re.compile(正则表达式1).sub(用来替换的字符串2, 要被操作的字符串3)     # 把 3中 能和1 匹配的内容, 用2来替换.

    上述格式的语法糖:
        re.sub(正则表达式1, 用来替换的字符串2, 要被操作的字符串3)

    回顾:
        字符串.replace()   也可以替换, 但是不支持正则写法.
"""
import re
# 案例1: 演示 正则替换, 格式: re.compile(正则表达式1).sub(用来替换的字符串2, 要被操作的字符串3)
# 1. 定义原字符串
s1 = '车主说, 你的刹车片该换了啊, 嘿嘿, 桀桀桀, 你笑的好甜!'
# 2. 定义正则表达式.
rg = r'啊|嘿|桀'

# 3. 开始具体的替换动作.
# 分解版.
# rg_obj = re.compile(rg)              # 传入正则表达式(规则), 获取: 正则对象.
# result = rg_obj.sub('1', s1)    # 通过正则对象, 实现: 正则替换.

# 合并版.
result = re.compile(rg).sub('1', s1)

# 4. 打印处理后的内容
print(result)

# 案例2: 演示正则替换的语法糖, 即: re.sub(正则表达式1, 用来替换的字符串2, 要被操作的字符串3)
s2 = "抽过的烟名: 煊赫门, 荷花, 南京, 中华, 利群, 黄鹤楼..."

# 需求: 把 煊赫门, 荷花, 利群 用 * 来替换.
result2 = re.sub(r'煊赫门|荷花|利群', '*', s2)
print(result2)


# 回顾: 字符串的replace
s3 = '抽过的烟名: 煊赫门, 荷花, 南京'
# result3 = s3.replace('煊赫门', '*')              # 可以
result3 = s3.replace(r'煊赫门|荷花', '*')    # 不可以, replace()不支持正则
print(result3)

4.正则-匹配单个字符

"""
正则规则:
    .           任意的1个字符, 除了\n
    \.          取消.的特殊用法, 就是1个普通的.
    a           代表1个字符a
    [abc]       代表: a,b,c中任意的1个字符
    [^abc]      代表: 除了a,b,c以外的任意1个字符

    [0-9]       代表: 任意的1个整数, 例如: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
    \d          代表: 任意的1个整数, 效果同上.  \d = [0-9]
    \D          代表: 除了整数外的任意1个字符, 即: \D = [^0-9]
    \s          代表: 空白字符, 例如: 空格, tab键等...
    \S          代表: 非空白字符.
    \w          代表: 非特殊字符, 例如: 字母, 数字, 下划线(_), 汉字
    \W          代表: 特殊字符.
"""
import re

# 案例: 正则校验 单个字符.
# 演示 .           任意的1个字符, 除了\n
result = re.match('it.', 'ita')     # 可以匹配(Y)
result = re.match('it.', 'it1')     # 可以匹配(Y)
result = re.match('it.', 'it\t')     # 可以匹配(Y)
result = re.match('it.', 'it\n')     # 不可以匹配(N)

# 演示 \.          取消.的特殊用法, 就是1个普通的.
result = re.match('hm\.', 'hma')     # N
result = re.match('hm\.', 'hm.')     # Y

# 演示 [abc]       代表: a,b,c中任意的1个字符
result = re.match('[abc]hm', 'ahm')     # Y
result = re.match('[abc]hm', 'bhm')     # Y
result = re.match('[abc]hm', 'xhm')     # N

# 演示 [^abc]      代表: 除了a,b,c以外的任意1个字符
result = re.match('[^abc]hm', 'bhm')     # N
result = re.match('[^abc]hm', 'xhm')     # Y

# 演示 [0-9]       代表: 任意的1个整数, 例如: 0, 1, 2, 3, 4, 5, 6, 7, 8, 9
result = re.match('[0-9]hm', '1hm')     # Y
result = re.match('[0-9]hm', '6hm')     # Y
result = re.match('[0-9]hm', 'ahm')     # N

# 演示 \d          代表: 任意的1个整数, 效果同上.  \d = [0-9]
result = re.match('\dhm', '6hm')     # Y
result = re.match('\dhm', 'ahm')     # N

# 演示 \D          代表: 除了整数外的任意1个字符, 即: \D = [^0-9]
result = re.match('\Dhm', '6hm')     # N
result = re.match('\Dhm', 'ahm')     # Y

# 演示 \s          代表: 空白字符, 例如: 空格, tab键等...
result = re.match('\shm', '\nhm')     # Y
result = re.match('\shm', ' hm')      # Y
result = re.match('\shm', '\thm')     # Y
result = re.match('\shm', 'ahm')      # N

# 演示 \S          代表: 非空白字符.
result = re.match('\Shm', '\nhm')     # N
result = re.match('\Shm', ' hm')      # N
result = re.match('\Shm', '\thm')     # N
result = re.match('\Shm', 'ahm')      # Y

# 演示 \w          代表: 非特殊字符, 例如: 字母, 数字, 下划线(_), 汉字
result = re.match('\whm', 'ahm')      # Y
result = re.match('\whm', '1hm')      # Y
result = re.match('\whm', '_hm')      # Y
result = re.match('\whm', '爱hm')      # Y

result = re.match('\whm', '\hm')      # N
result = re.match('\whm', '@hm')      # N

# 演示 \W          代表: 特殊字符.
result = re.match('\Whm', '爱hm')      # N
result = re.match('\Whm', '\hm')      # Y
result = re.match('\Whm', '@hm')      # Y

# 打印匹配结果.
# if result != None:
if result:
    print(f'匹配到: {result.group()}')
else:
    print('未匹配到!')

# 三元写法.
print(f'匹配到: {result.group()}' if result else '未匹配到!')

5.正则-匹配多个字符

"""
正则规则, 如下都是 和 数量词 相关:
     ?           数量词, 代表: 前边的内容出现 0次 或者 1次
     *           数量词, 代表: 前边的内容出现 0 ~ n
     +           数量词, 代表: 前边的内容出现 1 ~ n
     {n}         数量词, 恰好n次, 多一次, 少一次都不行.
     {n,}        数量词, 至少n次, 至多无所谓
     {n,m}       数量词, 至少n次, 至多m次, 包括 n 和 m
"""
import re

# 案例: 演示正则表达式, 校验多个字符.
# \d?  要么1个\d, 要么1个\d也没有, 即: 要么1个任意的整数, 要么没有.
result = re.match('\d?it', 'ait')   # N
result = re.match('\d?it', '2it')   # Y
result = re.match('\d?it', 'it')   # Y

# 验证 *           数量词, 代表: 前边的内容出现 0 ~ n
result = re.match('\d*it', '123321it')   # Y
result = re.match('\d*it', 'it')   # Y
result = re.match('\d*it', 'ait')   # N

# 验证 +           数量词, 代表: 前边的内容出现 1 ~ n
result = re.match('\d+it', '123321it')   # Y
result = re.match('\d+it', 'it')   # N
result = re.match('\d+it', 'ait')   # N

# 验证 {n}         数量词, 恰好n次, 多一次, 少一次都不行.
result = re.match('\d{3}it', '235it')   # Y
result = re.match('\d{3}it', '2345it')   # N
result = re.match('\d{3}it', 'abcit')    # N

# 验证 {n,}       数量词, 至少n次, 至多无所谓.
result = re.match('\d{3,}it', '235it')    # Y
result = re.match('\d{3,}it', '2345it')   # Y
result = re.match('\d{3,}it', '23it')   # N
result = re.match('\d{3,}it', 'abcit')   # N

# 验证 {n,m}      数量词, 至少n次, 最多m次, 包括n 和 m
result = re.match('\d{3,5}it', '23it')    # N
result = re.match('\d{3,5}it', '234it')    # Y
result = re.match('\d{3,5}it', '2345it')    # Y
result = re.match('\d{3,5}it', '23456it')    # Y
result = re.match('\d{3,5}it', '234567it')    # N

# 打印匹配结果.
# if result != None:
if result:
    print(f'匹配到: {result.group()}')
else:
    print('未匹配到!')

# 三元写法.
print(f'匹配到: {result.group()}' if result else '未匹配到!')

6.正则-校验开头和结尾

"""
正则表达式的规则:
     ^  代表正则的开头
     $  代表正则的结尾
"""
import re

# 需求: 演示 正则表达式的开头 和 结尾.
# 演示: ^  代表正则的开头
result = re.match('^\dit', '1it')       # Y
result = re.match('^\dit', 'a1it')      # N

result = re.search('^\dit', '1it')       # Y
result = re.search('^\dit', 'a1it')      # Y => N

# 演示: $  代表正则的结尾
# 需求: 必须以 xyz任意1个字符 或者 任意1个数字结尾
result = re.match('it[xyz0-9]', 'it1')      # Y
result = re.match('it[xyz0-9]', 'itx')      # Y
result = re.match('it[xyz0-9]', 'itxabc')   # Y
result = re.match('it[xyz0-9]$', 'itxabc')  # N

# 扩展: 校验手机号.  规则: 1. 长度必须是11位.  2. 第2位数字必须是3,4,5,6,7,8,9    3.第1位数字必须是1.  4.必须是纯数字.
result = re.match('^1[3-9]\d{9}$', '13123456789')     # Y
result = re.match('^1[3-9]\d{9}$', '131234567890')    # N
result = re.match('^1[3-9]\d{9}$', '1312345678a')     # N
result = re.match('^1[3-9]\d{9}$', '12123456789')     # N
result = re.match('^1[3-9]\d{9}$', '26123456789')     # N

# 打印匹配结果.
# if result != None:
if result:
    print(f'匹配到: {result.group()}')
else:
    print('未匹配到!')

# 三元写法.
print(f'匹配到: {result.group()}' if result else '未匹配到!')

7.正则-或者

"""
正则表达式的规则:
    |           表示: 或者的意思.
    ()          表示: 括号内的内容是1个组
    \num        表示: 引用num分组的内容, 例如: \1 表示引用第1组的数据,  \2 表示引用第2组的数据

    扩展:
        (?P<分组名>)   设置分组
        (?P=分组名)    使用指定的分组
"""
import re

# 需求1: 列表中有一些水果, 喜欢吃: apple 和 pear, 请用正则验证, 下述的水果, 哪些是喜欢吃的, 哪些是不喜欢吃的.
# 1. 定义列表, 记录: 水果.
fruits = ['apple', 'banana', 'orange', 'pear']

# 2. 遍历, 获取到每一种水果.
for fruit in fruits:
    # fruit 就是列表中的 每一种水果, 校验即可.
    if re.match('apple|pear', fruit):
        # 进这里, 说明是: 喜欢吃的水果.
        print(f'喜欢吃: {fruit}')
    else:
        # 走这里, 说明 是不喜欢吃的水果.
        print(f'不喜欢吃: {fruit}')
print("-" * 20)


# 需求2: 匹配出 163, 126, qq等邮箱.
# 邮箱例子: liuli@163.com,   386021668@ .com
# 邮箱规则: 4~16位数字,字母,下划线  +   @标记符 +  邮箱域名 + .com 或者 .cn

# 1. 定义变量, 记录要被校验的邮箱.
email = '386021668@qq.com'
# email = 'liuli@163.com'
# email = 'liuli@163.xyz'

# 2. 具体的校验动作.
result = re.match('^[0-9a-zA-Z_]{4,16}@(163|126|qq)\.(com|cn)$', email) # 以左小括号为依据, 数数字, 是几就是第几组.

# 3. 打印匹配结果.
# if result != None:
if result:
    print(f'匹配到 所有的数据: {result.group()}')     # 获取所有匹配到的数据
    print(f'匹配到 第0组数据: {result.group(0)}')     # 获取匹配到的第0组数据, 效果同上, 即: 0组 = 原串
    print(f'匹配到 第1组数据: {result.group(1)}')     # 获取匹配到的第1组数据, 即: 域名 163
    print(f'匹配到 第2组数据: {result.group(2)}')     # 获取匹配到的第2组数据, 即: 后缀 com
else:
    print('未匹配到!')
print("-" * 20)

8.正则-校验邮箱

# 案例: 演示正则校验邮箱.
​
"""
正则规则:
    |           或者的意思.
    ()          代表分组.
    \num
​
    扩展:
        (?P<分组名>)       给分组起名字
        (?P=分组名)        使用指定分组的内容
"""
import re
​
# 需求: 匹配出163, 126, qq等邮箱, 格式为:  4 ~ 20位任意字母, 数字, _  + @标记符 + 域名163,126,qq + .com
​
# 校验邮箱, 格式为:  4 ~ 20位任意字母, 数字, _  + @标记符 + 域名163,126,qq + . + 后缀(任意2~3个字符)
result = re.match('[a-zA-Z0-9_]{4,20}@(163|126|qq)\.com', 'hello@163.com')
​
# 打印结果
if result:
    print(f'匹配到: {result.group()}')         # hello@163.com
    print(f'group(0), 即: 0组, 结果为: {result.group(0)}')   # 同上, hello@163.com
    print(f'group(0), 即: 0组, 结果为: {result.group(1)}')   # 同上, 163
else:
    print('未匹配到!')

9.正则-获取指定分组内容

# 案例: 演示正则-获取指定分组内容.
​
"""
正则规则:
    |           或者的意思.
    ()          代表分组.
    \num
​
    扩展:
        (?P<分组名>)       给分组起名字
        (?P=分组名)        使用指定分组的内容
"""
import re
​
# 需求: 从 qq:qq号 这个格式的字符串中, 提取出qq 和 qq号
​
result = re.match('(qq):(\d{5,11})', 'qq:12306')
​
​
if result:
    print(f'匹配到: {result.group()}')       # qq:12306
    print(f'group(0), {result.group(0)}')   # qq:12306
    print(f'group(1), {result.group(1)}')   # qq
    print(f'group(2), {result.group(2)}')   # 12306
else:
    print('未匹配到!')




"""
正则表达式的规则:
    |           表示: 或者的意思.
    ()          表示: 括号内的内容是1个组
    \num        表示: 引用num分组的内容, 例如: \1 表示引用第1组的数据,  \2 表示引用第2组的数据

    扩展:
        (?P<分组名>)   设置分组
        (?P=分组名)    使用指定的分组
"""
import re

# 需求1: 列表中有一些水果, 喜欢吃: apple 和 pear, 请用正则验证, 下述的水果, 哪些是喜欢吃的, 哪些是不喜欢吃的.
# 1. 定义列表, 记录: 水果.
fruits = ['apple', 'banana', 'orange', 'pear']

# 2. 遍历, 获取到每一种水果.
for fruit in fruits:
    # fruit 就是列表中的 每一种水果, 校验即可.
    if re.match('apple|pear', fruit):
        # 进这里, 说明是: 喜欢吃的水果.
        print(f'喜欢吃: {fruit}')
    else:
        # 走这里, 说明 是不喜欢吃的水果.
        print(f'不喜欢吃: {fruit}')
print("-" * 20)


# 需求2: 匹配出 163, 126, qq等邮箱.
# 邮箱例子: liuli@163.com,   386021668@ .com
# 邮箱规则: 4~16位数字,字母,下划线  +   @标记符 +  邮箱域名 + .com 或者 .cn

# 1. 定义变量, 记录要被校验的邮箱.
email = '386021668@qq.com'
# email = 'liuli@163.com'
# email = 'liuli@163.xyz'

# 2. 具体的校验动作.
result = re.match('^[0-9a-zA-Z_]{4,16}@(163|126|qq)\.(com|cn)$', email) # 以左小括号为依据, 数数字, 是几就是第几组.

# 3. 打印匹配结果.
# if result != None:
if result:
    print(f'匹配到 所有的数据: {result.group()}')     # 获取所有匹配到的数据
    print(f'匹配到 第0组数据: {result.group(0)}')     # 获取匹配到的第0组数据, 效果同上, 即: 0组 = 原串
    print(f'匹配到 第1组数据: {result.group(1)}')     # 获取匹配到的第1组数据, 即: 域名 163
    print(f'匹配到 第2组数据: {result.group(2)}')     # 获取匹配到的第2组数据, 即: 后缀 com
else:
    print('未匹配到!')
print("-" * 20)

​

10.正则-校验html标签

"""
正则表达式的规则:
    |           表示: 或者的意思.
    ()          表示: 括号内的内容是1个组
    \num        表示: 引用num分组的内容, 例如: \1 表示引用第1组的数据,  \2 表示引用第2组的数据

    扩展:
        (?P<分组名>)   设置分组
        (?P=分组名)    使用指定的分组
"""
import re

# 需求: 校验html标签
s1 = '<html>我是内容</html>'
# 标签规则: 字母, 数字(1-6), 2 ~ 4位
# 思路1: 常规思路
result = re.match('^<[a-zA-Z1-6]{2,4}>.*</[a-zA-Z1-6]{2,4}>$', s1)
# 思路2: 引用 \num, 可以通过它 引用指定组的内容.
result = re.match('^<([a-zA-Z1-6]{2,4})>.*</\\1>$', s1)    # \1是引用第1组的内容, 即: [a-zA-Z1-6]{2,4}
result = re.match(r'^<([a-zA-Z1-6]{2,4})>.*</\1>$', s1)    # \1是引用第1组的内容, 即: [a-zA-Z1-6]{2,4}


# 外部标签规则: 字母, 数字(1-6), 2 ~ 4位
# 内部标签规则: h数字(1-6), 2位
s2 = '<html><h1>我是标题</h1></html>'
result = re.match(r'^<[a-zA-Z1-6]{2,4}><h[1-6]>.*</h[1-6]></[a-zA-Z1-6]{2,4}>$', s2)    # \1是引用第1组的内容, 即: [a-zA-Z1-6]{2,4}

#                            第1组                第2组
result = re.match(r'^<([a-zA-Z1-6]{2,4})><(h'
                  r'[1-6])>.*</\2></\1>$', s2)    # \1是引用第1组的内容, 即: [a-zA-Z1-6]{2,4}  \2是引用第2组的内容, 即:h[1-6]

# 扩展: 给分组起名字, 方便引用.
result = re.match(r'^<(?P<g1>[a-zA-Z1-6]{2,4})><(?P<g2>h[1-6])>.*</(?P=g2)></(?P=g1)>$', s2)    # \1是引用第1组的内容, 即: [a-zA-Z1-6]{2,4}  \2是引用第2组的内容, 即:h[1-6]

if result:
    print(f'匹配到: {result.group()}')     # 获取所有匹配到的数据
else:
    print('未匹配到!')
print("-" * 20)

【上一篇】【Python进阶】13. 多线程&生成器

【下一篇】