Python基础学习（十一）

正则表达式

正则表达式模块 -- re

匹配字符串的需要条件

• 正则表达式模块 --re
• 匹配"针"的规则
• 取"针"的大海--字符串

正则表达式中的特殊字符

正则表达式中的符号

"""
正则表达式介绍:
    概述:
        全称是 Regular Expression, 正则表达式, 即: 正确的, 符合特定规则的式子.
    作用:
        校验, 匹配数据的.
    细节:
        1. 学正则就是学正则表达式的 规则, 不要背, 因为这么多年了, 校验邮箱, 校验手机...等一些列的规则前辈们都写出来, 网上一搜一堆.
        2. 我讲正则的目的: 能用我们学的规则, 看懂别人写的 (正则表达式)式子, 且会根据需求修改即可.
        3. 正则不独属于任意的一门语言, Java, Python...都支持, 且: 正则规则都是一样的, 不同的是 写法不一样.

    Python中 正则的使用步骤:
        1. 导包
            import re
        2. 正则校验.
            re.match(pattern=正则表达式, str, flag)       参1: 正则表达式,  参2: 要校验的字符串, 参3:可选项, 例如: 忽略大小写, 多行模式等.
            re.search(pattern=正则表达式, str, flag)
            re.compile(正则表达式).sub(用来替换的内容, 要被替换的内容)
        3. 获取匹配结果.
            result = re.group()
    上述函数 介绍:
        match:  匹配的意思, 从左往右, 逐个字符进行匹配, 不会跳过任意的1个字符, 要求: 全部匹配才行.
        search: 查找的意思, 从左往右, 从任意的某个字符开始, 只要能匹配上即可.
        compile: 用于替换的.

    我们要学习的正则规则如下:
        .           代表: 任意的1个字符
        \\.          取消.的特殊含义, 就是一个普通的. 校验邮箱的时候用, 例如: zhangsan@163.com
        a           代表: 就是1个普通的字符a
        [abc]
        [^abc]
        \d
        \D
        \s
        \S
        \w
        \W

        ^		匹配一个字符串的开头 等同于\A
        $		匹配一个字符串的结尾 等同于\Z

        ?
        +		 数量词, 代表前边的内容, 至少出现 1次, 至多出现 n次
        *        数量词, 代表前边的内容, 至少出现 0次, 至多出现 n次
        {n}
        {n,}
        {n,m}

        |        或的关系，只要存在就能捕获
        ()   	 在匹配规则中获取指定的数据
        \num

        扩展:
            (?P<分组名>)       给分组起名字
            (?P=分组名)        使用指定分组的内容
"""

import re

print(re.match(".it",'ait'))

正则表达式中的分组

"""
正则规则:
    |           或者的意思.
    ()
    \num

    扩展:
        (?P<分组名>)       给分组起名字
        (?P=分组名)        使用指定分组的内容
"""
import re

# 需求: 演示正则规则之 |

# 1. 定义列表, 记录水果.
fruit = ['apple', 'banana', 'orange', 'pear']

# 2. 遍历, 获取到每一种水果.
for value in fruit:
    # 3. 判断当前水果是否是喜欢吃的(苹果, 梨)水果, 并打印.
    result = re.match('apple|pear', value)
    # 4. 打印结果.
    if result:
        # print(f'喜欢吃: {value}')
        print(f'喜欢吃: {result.group()}')
    else:
        print(f'不喜欢吃: {value}')

匹配多个字符

"""
正则表达式介绍:
    概述:
        全称是 Regular Expression, 正则表达式, 即: 正确的, 符合特定规则的式子.
    作用:
        校验, 匹配数据的.
    细节:
        1. 学正则就是学正则表达式的 规则, 不要背, 因为这么多年了, 校验邮箱, 校验手机...等一些列的规则前辈们都写出来, 网上一搜一堆.
        2. 我讲正则的目的: 能用我们学的规则, 看懂别人写的 (正则表达式)式子, 且会根据需求修改即可.
        3. 正则不独属于任意的一门语言, Java, Python...都支持, 且: 正则规则都是一样的, 不同的是 写法不一样.

    Python中 正则的使用步骤:
        1. 导包
            import re
        2. 正则校验.
            re.match(pattern=正则表达式, str, flag)       参1: 正则表达式,  参2: 要校验的字符串, 参3:可选项, 例如: 忽略大小写, 多行模式等.
            re.search(pattern=正则表达式, str, flag)
            re.compile(正则表达式).sub(用来替换的内容, 要被替换的内容)
        3. 获取匹配结果.
            result = re.group()
    上述函数 介绍:
        match:  匹配的意思, 从左往右, 逐个字符进行匹配, 不会跳过任意的1个字符, 要求: 全部匹配才行.
        search: 查找的意思, 从左往右, 从任意的某个字符开始, 只要能匹配上即可.
        compile: 用于替换的.


"""

import re

# 演示正则数量词, ?           数量词, 至少0次,至多1次
result = re.match(r"{it\d}?", 'ita')        # .?   任意的0个或者1个字符
print(f'匹配到：{result.group()}' if result else '未匹配到')
# result = re.match('it.?', 'it\n')       # .?   任意的0个或者1个字符
# result = re.match('it.?', 'i t\n')      # 未匹配

# 演示正则数量词, +           数量词, 至少1次, 至多n次
result = re.match('it.+', 'it\n')       # 未匹配
result = re.match('it.+', 'it中')       # .+ 代表至少1个 至多任意个 任意的字符
result = re.match('it.+', 'it中, 真中, 非常中!')       # .+ 代表至少1个 至多任意个 任意的字符

result = re.match('it[abc]+', 'itaaabbc')   # [abc]+ 任意的1个或者多个 a,b,c组成的字符串
result = re.match('it[abc]+', 'itaaaa')   # [abc]+ 任意的1个或者多个 a,b,c组成的字符串
result = re.match('it[abc]+', 'it1aaaa')   # 未匹配


# 演示正则数量词, *           数量词, 代表前边的内容, 至少出现 0次, 至多出现 n次
result = re.match('it[abc]*', 'itaaabbc')   # [abc]+ 任意的1个或者多个 a,b,c组成的字符串
result = re.match('it[abc]*', 'itaaaa')   # [abc]+ 任意的1个或者多个 a,b,c组成的字符串
result = re.match('it[abc]*', 'i t1aaaa')   # 未匹配

# 演示正则数量词, {n}         恰好n次, 多一次少一次都不行.
# 前边恰好3个数字, 后续是啥无所谓.
result = re.match('[0-9][0-9][0-9].*', '623abc!@#')
result = re.match('[0-9]{3}.*', '623abc!@#')     # 效果同上
result = re.match('\d{3}.*', '623abc!@#')        # 效果同上
result = re.match('\d{3}.*', '6239abc!@#')        # 效果同上

# 演示正则数量词, {n,}        至少n次, 至多无所谓
# 前边至少2个整数, 后续是啥无所谓.
result = re.match('\d{2,}.*', '62123abc!@#')
result = re.match('\d{2,}.*', '6!@#')        # 未匹配

# 演示正则数量词, {n,m}       至少n次, 至多m次, 包括n和m
# 前边至少2个, 至多5个 整数或者字母或者下划线, 后续是啥无所谓.
result = re.match('[0-9a-zA-Z_]{2,5}.*', '62abc!@#')
result = re.match('[0-9a-zA-Z_]{2,5}.*', '__你12!@#')
result = re.match('[0-9a-zA-Z_]{2,5}.*', '6!2abc@#')     # 未匹配
result = re.match('[0-9a-zA-Z_]{2,5}.*', '_你12!@#')     # 未匹配


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

匹配开头或者结尾

"""
正则表达式介绍:
    概述:
        全称是 Regular Expression, 正则表达式, 即: 正确的, 符合特定规则的式子.
    作用:
        校验, 匹配数据的.
    细节:
        1. 学正则就是学正则表达式的 规则, 不要背, 因为这么多年了, 校验邮箱, 校验手机...等一些列的规则前辈们都写出来, 网上一搜一堆.
        2. 我讲正则的目的: 能用我们学的规则, 看懂别人写的 (正则表达式)式子, 且会根据需求修改即可.
        3. 正则不独属于任意的一门语言, Java, Python...都支持, 且: 正则规则都是一样的, 不同的是 写法不一样.

    Python中 正则的使用步骤:
        1. 导包
            import re
        2. 正则校验.
            re.match(pattern=正则表达式, str, flag)       参1: 正则表达式,  参2: 要校验的字符串, 参3:可选项, 例如: 忽略大小写, 多行模式等.
            re.search(pattern=正则表达式, str, flag)
            re.compile(正则表达式).sub(用来替换的内容, 要被替换的内容)
        3. 获取匹配结果.
            result = re.group()
    上述函数 介绍:
        match:  匹配的意思, 从左往右, 逐个字符进行匹配, 不会跳过任意的1个字符, 要求: 全部匹配才行.
        search: 查找的意思, 从左往右, 从任意的某个字符开始, 只要能匹配上即可.
        compile: 用于替换的.

"""

import re

# 演示  ^           代表: 开头
result = re.match(r'\d.*', '1abc')         # 必须以数字开头
result = re.search(r'\d.*', 'a1bc')       # 必须以数字开头
result = re.search(r'^\d.*', 'a1bc')       # 未匹配

# 演示  $           代表: 结尾
result = re.match('.*[a-zA-Z]', '123abc')
result = re.match('.*[a-zA-Z]', '123abc1')
result = re.match('.*[a-zA-Z]$', '123abc1')  # 未匹配

# 匹配手机号
result = re.match(r'^1[3-9]\d{9}$', '17866836a42')

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

替换

"""
案例: 演示正则 替换.

涉及到的 re 模块下的函数:
    写法1:
        re.compile(正则表达式).sub(用来替换的内容, 要被替换的内容)

    写法2: 即, 上述格式的语法糖.
        re.sub(正则表达式, 用来替换的内容, 要被替换的内容)

     回顾: 字符串中的replace()函数, 也可以替换, 但是是全词匹配, 不支持正则.
        字符串.replace(旧内容, 新内容)
"""
import re

# 扩展: r'字符串'   取消字符串中\的转移的含义, 就是1个普通的\
# print('d:\\aa\\bb\\cc')     # d:\aa\bb\cc,  \在python中有特殊含义(转移符), 两个\表示一个\
# print(r'd:\\aa\\bb\\cc')    # d:\\aa\\bb\\cc
# print(r'd:\aa\bb\cc')    # d:\\aa\\bb\\cc

# 需求1: 把字符串中的"敏感词" 给 替换成 *
old_str = "车主说: 你的刹车片应该换了啊, 嘿嘿"

# 1. 自定义正则规则.
p = r'啊|阿|嘿|呵|哈|啦|嘻|桀'        # pattern: 模板(可以理解为: 正则规则),  字符串前加r表示, 取消转移.

# 2. 基于正则规则, 获取正则对象.
res = re.compile(pattern=p)     # pattern=具体的正则字符串

# 3. 对上述的字符串进行替换.
result = res.sub('A', old_str)  # 返回的是: 字符串.

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

print('-' * 31)

# 需求2: 上述代码的简化版, 语法糖实现
old_str = "故人西辞黄鹤楼, 烟花三月黄鹤楼, 中华虽然好抽, 但是不要上瘾, 抽烟只抽煊赫门, 一生只爱一个人!"
# 参1: 正则表达式.
# 参2: 用来替换的字符串.
# 参3: 要被替换的字符串.
result = re.sub('黄鹤楼|中华|煊赫门', '*', old_str)
print(result)
print('-' * 31)

# 需求3: 回顾字符串的 replace()
s1 = "烟花三月黄鹤楼, 黄鹤楼虽然好抽, 大中华, 抽着黄鹤楼!"

# 参1: 旧字符串(要被替换的)  参2: 新字符串(用来替换的)  参3: 替换几个, 不写就替换所有.
result = s1.replace('黄鹤楼', '*', 2)
# result = s1.replace('黄鹤楼|中华', '*', 2)  # 无效, 不支持正则.
print(result)

校验单个字符

"""
正则表达式介绍:
    概述:
        全称是 Regular Expression, 正则表达式, 即: 正确的, 符合特定规则的式子.
    作用:
        校验, 匹配数据的.
    细节:
        1. 学正则就是学正则表达式的 规则, 不要背, 因为这么多年了, 校验邮箱, 校验手机...等一些列的规则前辈们都写出来, 网上一搜一堆.
        2. 我讲正则的目的: 能用我们学的规则, 看懂别人写的 (正则表达式)式子, 且会根据需求修改即可.
        3. 正则不独属于任意的一门语言, Java, Python...都支持, 且: 正则规则都是一样的, 不同的是 写法不一样.

    Python中 正则的使用步骤:
        1. 导包
            import re
        2. 正则校验.
            re.match(pattern=正则表达式, str, flag)       参1: 正则表达式,  参2: 要校验的字符串, 参3:可选项, 例如: 忽略大小写, 多行模式等.
            re.search(pattern=正则表达式, str, flag)
            re.compile(正则表达式).sub(用来替换的内容, 要被替换的内容)
        3. 获取匹配结果.
            result = re.group()
    上述函数 介绍:
        match:  匹配的意思, 从左往右, 逐个字符进行匹配, 不会跳过任意的1个字符, 要求: 全部匹配才行.
        search: 查找的意思, 从左往右, 从任意的某个字符开始, 只要能匹配上即可.
        compile: 用于替换的.

    我们要学习的正则规则如下:
        .           代表: 任意的1个字符
        \.          取消.的特殊含义, 就是一个普通的. 校验邮箱的时候用, 例如: zhangsan@163.com
        a           代表: 就是1个普通的字符a
        [abc]       代表: a,b,c其中的任意1个字符
        [^abc]      代表: 除了a,b,c外, 任意的1个字符
        \d          代表: 所有的数字, 等价于 [0-9]
        \D          代表: 所有的非数字, 等价于 [^0-9]
        \s          代表: 空白字符, \n, 空格, \t等...
        \S          代表: 非空白字符, 即: 上述取反.
        \w          代表: 非特殊字符, 即: 字母, 数字, _ 下划线, 汉字
        \W          代表: 特殊字符, 即: 上述取反.

        ^
        $

        ?
        +
        *           数量词, 代表前边的内容, 至少出现 0次, 至多出现 n次
        {n}
        {n,}
        {n,m}

        |           或者的意思.
        ()
        \num

        扩展:
            (?P<分组名>)       给分组起名字
            (?P=分组名)        使用指定分组的内容
"""


# 导包
import re

# 需求: 获取字符串中 以数字开头的内容, 后续是啥无所谓.
# 演示: .           代表: 任意的1个字符(除了\n)
# result = re.match('it.', 'itA')
# result = re.match('it.', 'it\t')
# result = re.match('it.', 'it\n')    # 不匹配
# result = re.match('it.', 'i t1')    # 不匹配

# 演示: \.          取消.的特殊含义, 就是一个普通的. 校验邮箱的时候用, 例如: zhangsan@163.com
# 演示: a           代表: 就是1个普通的字符a
# result = re.match('.it\.', ' ait.')      # .it\.  任意1个字符 + it + .
# result = re.match('.it\.', ' aitb')      # 未匹配
# result = re.match('.it\.', ' ait.123')   # 未匹配

# 演示: [abc]       代表: a,b,c其中的任意1个字符
# result = re.match('[abc].*', 'asafs')
# result = re.match('[abc].*', 'bsafs')
# result = re.match('[abc].*', 'c123')
# result = re.match('[abc].*', 'd123')    # 未匹配

# 演示: [^abc]      代表: 除了a,b,c外, 任意的1个字符
# result = re.match('[^abc].*', 'asafs')  # 未匹配
# result = re.match('[^abc].*', 'bsafs')  # 未匹配
# result = re.match('[^abc].*', 'c123')   # 未匹配
# result = re.match('[^abc].*', 'd123')   # d123

# 演示: \d          代表: 所有的数字, 等价于 [0-9]
# result = re.match('\d.*', '1abc') # True
# result = re.match('\d.*', 'a1bc') # False

# 演示: \D          代表: 所有的非数字, 等价于 [^0-9]
# result = re.match('\D.*', '1abc')   # False
# result = re.match('\D.*', 'a1bc')   # True

# 演示: \s          代表: 空白字符, \n, 空格, \t等...
# result = re.match('it\s', 'it ')
# result = re.match('it\s', 'it\t')
# result = re.match('it\s', 'it\n')
# result = re.match('it\s', 'ita')

# 演示: \S          代表: 非空白字符, 即: 上述取反.
# result = re.match('it\S', 'it ')    # False, 未匹配
# result = re.match('it\S', 'it\t')   # False, 未匹配
# result = re.match('it\S', 'it\n')   # False, 未匹配
# result = re.match('it\S', 'ita')    # True

# 演示: \w          代表: 非特殊字符, 即: 字母, 数字, _ 下划线, 汉字
# result = re.match('it\w', 'it好')
# result = re.match('it\w', 'it_')
# result = re.match('it\w', 'it1')
# result = re.match('it\w', 'itxa')
# result = re.match('it\w', 'it+')    # 未匹配

# 演示: \W          代表: 特殊字符, 即: 上述取反.
result = re.match('it\W', 'it好')   # 未匹配
result = re.match('it\W', 'it_')    # 未匹配
result = re.match('it\W', 'it1')    # 未匹配
result = re.match('it\W', 'itxa')   # 未匹配
result = re.match('it\W', 'it+')


# 打印匹配结果
if result:
    info = result.group()       # 获取匹配到的内容
    print(f'匹配到: {info}')
else:
    print('未匹配!')

# 上述格式的: 简化版.
print(f'匹配到: {result.group()}' if result else '未匹配!')

re模块其他额外匹配要求