正则表达式的基本使用

import re
from typing import Pattern

"""
re模块使python语言拥有了全部的正则表达式功能
match()
search()
findall()


"""
r"""
 match 原型：def match(pattern, string, flags=0)
    参数：
        pattern:匹配的正则表达式
        string:要匹配的字符串
        flags:标志位，用于控制正则表达式的匹配方式（是否大小写，是否多行匹配等等）
            re.I:使匹配对大小写不敏感
            re.L:做本地化识别匹配
            re.M:多行匹配，影响^和$
            re.S:使.匹配包括换行符在内的所有字符
            re.U:根据Unicode字符集解析字符,影响\w、\W、\b、\B
            re.X:通过给予我们功能灵活的格式以便更好地理解正则表达式
"""
# 功能：尝试从字符串string的起始位置匹配一个pattern模式，如果不是起始位置匹配成功的话就返回None

print(re.match("www", "www.sunck.wang"))
print(re.match("www", "WwW.sunck.wang", flags=re.I))

"""
search
原型：search(pattern, string, flags = 0)
功能：扫描整个字符串string，并返回第一个成功的匹配
参数：

"""
# print(re.search("www", "sunck.wangwww"))

"""
findall
原型：findall(pattern, string, flags = 0)
功能：扫描整个字符串string并返回结果的列表
"""
print(re.findall("www", "suwwwnck.wwwwang"))

# 正则表达式元字符
# 1.匹配单个字符与数字
r"""
.           匹配除换行符以外的任意字符，当flags被指定为re.S时可以匹配包括换行符以内的所有字符，如果没有指定并且还想匹配所有字符，可以使用[.\n]
[]          里面是字符的集合，匹配[]里面任意一个字符
[0-9]       匹配任意一个数字
[a-z]       匹配任意一个小写英文字母
[A-Z]       匹配任意一个大写英文字母
[a-zA-Z]    匹配任意一个字母
[a-zA-Z0-9] 匹配任意一个数字或字母
[^sunck]    []里的^称为脱字符匹配除了"s","u","n","c","k"以外的任意一个字符   
\d          匹配任意一个数字字符， 类似[0-9]
\D          匹配任意一个非数字字符， 类似[^0-9]
\w          匹配字母、数字、下划线 类似[0-9a-zA-Z_]
\W          匹配非字母、下划线、数字    类似[^0-9a-zA-Z_]
\s          匹配任意空白符(空格、换页、换行、回车、制表等) [ \f\n\r\t]
\S          匹配非空白符      [^ \f\n\r\t]

"""

# 2.锚字符
"""
^           行首匹配，和[]中的^不是一个意思
$           行尾匹配


"""
# 3.边界字符，基本上很少使用完
r"""
\A         匹配字符串开始，和^的区别是\A只匹配整个字符的开头，即使在re.M模式下，也不会匹配其他的行首
\Z         匹配字符的结尾，和$的区别是\Z只匹配整个字符的结尾，即使在re.M模式下，也不会匹配其他的字符
\b         匹配一个单词的边界，指单词和空格的位置
\B         匹配非单词边界

"""
s = """zhf is a good man
zhf is a nice man
zhf is a cool man
"""
print(re.findall(r"^zhf", s, re.M))
print(re.findall(r"\Azhf", s, re.M))  # 基本不使用

print(re.findall(r"ck\b", "sunck"))  # 很少使用
print(re.findall(r"ck\b", "suckn"))
print(re.findall(r"ck\B", "sunck"))  # 很少使用
print(re.findall("ck\B", "suckn"))

# 4.匹配多个字符
"""以下使用的是x,y,z均为假设的普通字符，n、m表示一个数字，不是正则表达式的元字符
(xyz)       匹配括号内的xyz(作为一个整体去匹配)
x?          匹配0个或1个x，非贪婪匹配
x*          匹配0个或任意多个x
x+          匹配至少一个x
x{n}        匹配确定n个x，x是非负整数
x{n,}       匹配至少n个x
x{n,m}      匹配至少n个，最多m个x
x|y         |表示或，匹配x或y

"""
print(re.findall(r"(zhf)", "zhf is a good man! zhf is a nice man"))  # ['zhf', 'zhf']
print(re.findall(r"a?", "abbbaabbaaa"))  # 结果：['a', '', '', '', 'a', 'a', '', '', 'a', 'a', 'a', '']
print(re.findall(r"a*", "aaa"))  # 结果：['aaa', '']

print(re.findall(r"((p|P)ython)", "pythonaaaPython"))

# 切分字符串 split
str1 = "zhf        is    a      good       man"
print(re.split(r" +", str1))

"""
    原型：finditer(pattern, string, flags = 0)
    作用：类似findall,返回一个迭代器
    
    区别：findall返回所有匹配的字符，并存为一个列表，如果数据过多，占用内存。而finditer并不是直接返回找到的所有字符，而是返回一个迭代器，可以通过next迭代

"""
str1 = "zhf is a good man! zhf is a nice man"
res = re.finditer(r"(zhf)", str1)
print(res)
print(type(res))
for x in res:
    print(x)

# 字符串替换
"""
sub(pattern, repl, string, count=0, flags=0)
subn(pattern,repl,string,count=0,flags=0)
作用：在目标字符串string中查找匹配的pattern模式字符，再把它们替换成指定的repl字符串，可以指定最多替换count次，否则替换所有

参数：
    pattern：正则表达式
    repl：指定用来替换的字符串
    string：目标字符串
    count:最多替换次数
    flags:模式
    
两个函数的区别：
    sub返回一个被替换的字符串,subn返回一个元组，元组的第一个元素为被替换的字符串，第二个元素为发生了多少次替换
"""

str1 = "zhf is a good man! zhf is a nice man! zhf is a cool man"
print(re.sub(r"(zhf)", "fa", str1))
# 返回：fa is a good man! fa is a nice man! fa is a cool man
print(re.subn(r"(fa)", "zhf", re.sub(r"(zhf)", "fa", str1)))
# 返回：('zhf is a good man! zhf is a nice man! zhf is a cool man', 3)

# 分组
"""
概念：除了简单地判断是否匹配外，正则表达式还有提取子串的功能，用()表示的就是要提取的分组
"""
m = re.search(r"(?P<quhao>\d{3})-(?P<phone>\d{8})", "aaa010-56781234bbbb")
# 组的排序，从外到内，从左到右
print(m)
# 使用组序号获取匹配的字符串，0表示原数据
print(m.group(0))
# 根据名字获取组内容
print(m.group(1))
print(m.group("quhao"))
print(m.group(2))
print(m.group("phone"))
print(m.groups())

# 编译正则表达式
"""
概念：当在python中使用正则表达式时，re模块会做两件事情，一件是编译正则表达式，如果表达式的字符串本身不合法，会报错。一件是用编译后的正则表达式取匹配字符串
"""
# 编译正则表达式，得到的是一个正则表达式对象
# 好处，一次编译，多次使用
re_phone: Pattern[str] = re.compile(r"(?P<quhao>\d{3})-(?P<phone>\d{8})")
"""
findall
原型：findall(self,string,pos=0,endpos=-1)
"""
print(re_phone.findall("010-56781234"))

# 贪婪匹配
# 概念：匹配尽可能多的字符
print(re.match(r"(\d+)(0*)$", "120345 000").groups())
"""尽可能匹配少的字符串
*?
+?
??
"""

 

---

如果您觉得阅读本文对您有帮助，请点一下“推荐”按钮，您的“推荐”将是我最大的写作动力！欢迎各位转载，但是未经作者本人同意，转载文章之后必须在文章页面明显位置给出作者和原文连接，否则保留追究法律责任的权利。