正则表达式学习记录

最新推荐文章于 2024-06-30 14:54:00 发布

Lee_2002

最新推荐文章于 2024-06-30 14:54:00 发布

阅读量32

点赞数

文章标签：正则表达式 python

本文链接：https://blog.csdn.net/Lee_2002/article/details/133277968

版权

import re

str1 = "To be or not be , that is a question"
str2 = "1234part12334part"
str3 = "<html><h1>www.itcast.cn</h1></html>"
str4 = "xxxxx<html><h1>www.itcast.cn</h1></html>"
str5 = "dsaf213asdf1s32adsfa56464asdfasdf213asdfasdf2adsfasdf123"

pattern = r"<(?P<p1>\w*)><(?P<p2>\w*)>.*</(?P=p2)></(?P=p1)>"
pattern2 = r"\d+"


def add(temp):
    strNum = temp.group()
    num = int(strNum) + 1
    return str(num)


# 匹配式
'''
.	匹配任意1个字符（除了\n）
[ ]	匹配[ ]中列举的字符
\d	匹配数字
\D	匹配⾮数字
\s	匹配空⽩
\S	匹配⾮空⽩字符
\w	匹配单词字符
\W	匹配⾮单词字符

*	    匹配前⼀个字符出现0次或者⽆限次
+	    匹配前⼀个字符出现1次或者⽆限次，即⾄少有1次
?  	匹配前⼀个字符出现1次或者0次
{m}	匹配前⼀个字符出现m次	用在字符或(...)之后	ab{2}c	abbc
{m,n}	匹配前⼀个字符出现从m到n次
          若省略m {,n} 则匹配0到n次
          若省略n {m,} 则匹配m到无限次

^	    匹配字符串开头
$ 	匹配字符串结尾

|	            匹配左右任意⼀个表达式
(ab)  	    将括号中字符作为⼀个分组
\num	        引⽤分组num匹配到的字符串 eg \1 \2
(?P<name>)	分组起别名 (结合第二个)
(?P=name)	    引⽤别名为name分组匹配到的字符串


(?=pattern)    零宽正向先行断言 放于匹配式后方->表示匹配的式子后面应该是pattern
(?!pattern)    零宽负向先行断言 放于匹配式后方->表示匹配的式子后面不可以是pattern
(?<=pattern)   零宽正向后行断言 放于匹配式前方->表示匹配的式子前面应该是pattern
(?<!pattern)   零宽负向后行断言 放于匹配式前方->表示匹配的式子前面不可以是pattern
'''

# 函数
'''
1.  re.match 匹配string从开始位置是否符合模式串
    尝试从字符串的起始位置匹配一个模式，
    如果不是起始位置匹配成功的话，match()就返回none。匹配成功re.match方法返回一个匹配的对象。
    ret = re.match(pattern, string, flags=0)

2.  group()
    对于ret 返回的结果  
    group()用来提出分组截获的字符串，（）用来分组，group() 同group（0）就是匹配正则表达式整体结果，
    group(1) 列出第一个括号匹配部分，group(2) 列出第二个括号匹配部分，group(3) 列出第三个括号匹配部分。没有匹配成功的，re.search()返回None。
    group()只能传入整数 不能传入别名
    print(ret.group())
    
3.  start() , end() , span()
    对于ret 返回的结果  使用start(x) 可以获取第x个匹配项在源字符串的起始位置
                     使用end(x) 可以获取第x个匹配项在源字符串的结束位置(开区间)
                     使用span(x) 可以获取第x个匹配项在在源字符串的其实和结束位置(start(x) , end(x))
    print(ret.span(0))

4.  re.search 匹配string整个串 返回第一个匹配 没有返回none 
    ret = re.search(pattern, string, flags=0)
    
5.  re.compile()
    compile用于编译正则表达式 生成正则表达式对象提供给match() 和 search() findall() finditer
    
6.  re.findall()
    找到所有符合的串 匹配多次返回一个列表
    ret = re.findall(pattern, string, flags=0)
    
7.  re.finditer()
    效果相同与re.findall() 不过是使用了迭代器的方式
    ret = re.finditer(pattern, string, flags=0)
    返回值类型：<callable_iterator object at 0x000002D8C646FCD0>
    ret = re.finditer(pattern, str)
    for i in ret:
        print(i.group())
        
8.  re.sub()
    replacement 是指替换的字符串 
                如果是函数 那么匹配到的结果会被当作入参传入
                也可以是正则表达式 此时这个正则表达式会使用源匹配匹配到的序号
    count 是指替换的最大次数
    ret = re.sub(pattern, replacement, string, count=0, flags=0)
    ret是修改过的原字符串
    
8.  re.subn()
    replacement 是指替换的字符串 
                如果是函数 那么匹配到的结果（re.match类型）会被当作入参传入
                也可以是正则表达式 此时这个正则表达式会使用源匹配匹配到的序号同样不可是别名
    count 是指替换的最大次数
    ret = re.subn(pattern, replacement, string, count=0, flags=0)
    ret返回元组 （修改后的字符串 ,修改次数）
    
9.  re.split函数
    根据匹配进⾏切割字符串，并返回⼀个列表。
    re.split(pattern, string, maxsplit=0, flags=0)

10. 贪婪模式和非贪婪模式
    默认的数量匹配都是贪婪模式 也就是从左到右匹配且尽量的匹配更长的串
'''
print("test1: 尝试match")
ret = re.match(pattern, str3)
print(ret.group())
print(ret.group(1))
print(ret.group(2))
print(ret.span(1))
print(ret.span(2))
print("\n\n")

print("test2: 尝试search")
ret1 = re.match(pattern, str4)
ret2 = re.search(pattern, str4)
if ret1 is None:
    print("ret1 == none")
else:
    print(ret1.group())
if ret2 is None:
    print("ret2 == none")
else:
    print(ret2.group())
print("\n\n")

print("test3: 尝试complie")
pat = re.compile(pattern)
ret1 = pat.match(str3)
ret2 = pat.search(str3)
print(ret1.group())
print(ret2.group())
print("\n\n")

print("test4: 尝试findall")
pat = re.compile(pattern2)
ret1 = pat.findall(str5)
ret2 = pat.search(str5)
print(ret1)
print(ret2.group())
print("\n\n")

print("test5: 尝试finditer")
pat = re.compile(pattern2)
ret1 = pat.findall(str5)
ret2 = pat.finditer(str5)
print(ret1)
for i in ret2:
    print(i.group())
print("\n\n")

print("test6: 尝试sub")
ret = re.sub(r"\d+", add, "python = 997")
print(ret)
ret = re.sub(r"\d+", add, "python = 99")
print(ret)
print("\n\n")


print("test7: 尝试subn")
ret = re.subn(r"\d+", add, "python = 997")
print(ret)
ret = re.subn(r"\d+", add, "python = 99")
print(ret)
print("\n\n")

print("test8: 尝试split")
#str5 = "dsaf213asdf1s32adsfa56464asdfasdf213asdfasdf2adsfasdf123"
ret = re.split("[0-9]+" , str5);
print(ret)
ret = re.split("[0-9]+" , str5 , maxsplit=3);
print(ret)
print("\n\n")


print("test9: 贪婪模式和非贪婪模式")
print(re.match(r"aa(\d+)","aa2343ddd").group(1))
print(re.match(r"aa(\d+?)","aa2343ddd").group(1))
print(re.match(r"aa(\d+)ddd","aa2343ddd").group(1))
print(re.match(r"aa(\d+?)ddd","aa2343ddd").group(1))
print("\n\n")

> python——正则表达式(re模块)详解_python re正则表达式_nee~的博客-CSDN博客

> 正则表达式的先行断言(lookahead)和后行断言(lookbehind) | 菜鸟教程 (runoob.com)