python正则表达式笔记-新手小白的福利呀

前言：很多小伙伴在学习python尤其是爬虫相关的编程时难免会需要正则表达式的帮助。本人学习python时也遇到了相关的需求，于是便学习并作了相关的笔记，有需要的小伙伴可以拿去看看哦。
代码说明：每行代码后面的注释就是在编译器中跑出来的结果。

                               python正则表达式笔记
                                      查询方法

#返回的都是re.Match类型对象
import re
#1.match方法
#只能对字符串查找一次，返回的对象是re match类型,match方法从头开始匹配
x = 'hello the good world'
a1 = re.match(r'hello', x)
print(a1) #<_sre.SRE_Match object; span=(0, 5), match='hello'>

x = 'hello the good world'
a1_1 = re.match(r'the', x)
print(a1_1) #None


#2.search方法
#只能对字符串查找一次，返回的对象是re match类型,方法从整个字符串开始匹配
x = 'hello the good world'
a2 = re.search('hello', x)
print(a2) #<_sre.SRE_Match object; span=(0, 5), match='hello'>

x = 'hello the good world'
a2_1 = re.search('the', x)
print(a2_1) #<_sre.SRE_Match object; span=(6, 9), match='the'>


#3.finditer方法
#查找所有匹配的数据放在一个可迭代对象里
x = 'hello the good world'
a3 = re.finditer(r'l',x)
print(a3) #<callable_iterator object at 0x000001A2EAB10278>
for i in a3:
    print(i) #<_sre.SRE_Match object; span=(2, 3), match='l'>
             #<_sre.SRE_Match object; span=(3, 4), match='l'>
             #<_sre.SRE_Match object; span=(18, 19), match='l'>


#4.findall方法
#查找所有匹配的数据并返回列表
x = 'hello the good world'
a4 = re.findall(r'l',x)
print(a4) #['l', 'l', 'l']


#5.fullmatch方法
#查看是否完整匹配
x = 'hello the good world'
a5 = re.fullmatch(r'he llo the good',x)
print(a5) #None

x = 'hello the good world'
a5_1 = re.fullmatch(r'hello the good world',x)
print(a5_1) #<_sre.SRE_Match object; span=(0, 20), match='hello the good world'>



                                        
                      group方法与compile方法

# . 表示除了空格以外的任意字符 ；  * 表示前面的元素出现任意次数，0次或者0次以上
x =  '1aa2bb3cc4dd5'
b1 = re.search(r'2.*5',x)
print(b1) #<_sre.SRE_Match object; span=(3, 13), match='2bb3cc4dd5'>
print(b1.span()) #(3, 13) span()方法可以返回匹配到数据的位置下标，以元组的形式返回
print(b1.group()) #2bb3cc4dd5 group()方法可以返回匹配到的数据


#group()方法表示的正则表达式的分组
#1.在正则表达式中用一个()表示一个分组
#2.如果没有分组默认一个分组
#3.分组的下标从0开始

x = '1aa2bb3cc4dd5'
b1_1 = re.search(r'(2.*)(3.*)(4.*)',x)
print(b1_1) #<_sre.SRE_Match object; span=(3, 13), match='2bb3cc4dd5'>
print(b1_1.group()) #2bb3cc4dd5
print(b1_1.group(0)) #2bb3cc4dd5 第0组默认的是一个匹配到的数据的整体
print(b1_1.group(1)) #2bb
print(b1_1.group(2)) #3cc
print(b1_1.groups()) #('2bb', '3cc', '4dd5') groups()方法将匹配的数据变成元组返回


#(?P<name>表达式) 给每个组起一个组名
x = '1aa2bb3cc4dd5'
b1_2 = re.search(r'(?P<第一组>2.*)(?P<第二组>3.*)(?P<第三组>4.*)', x)
print(b1_2.groupdict()) #{'第一组': '2bb', '第二组': '3cc', '第三组': '4dd5'} groupdict()方法返回字典
print(b1_2.span(2)) #(6, 9) 第二组的下标


#compile方法
#生成一个正则对象
x = '1aa2bb3cc4dd5'
r = re.compile(r'2.*5')
y = r.search(x)
print(y) #<_sre.SRE_Match object; span=(3, 13), match='2bb3cc4dd5'>

							正则替换方法
#sub方法
		#第一个参数是正则表达式
		#第二个参数是新字符或者一个函数
		#第三个参数是原字符串
#第二参数为字符
c2 = re.sub(r'\d','X','abc12f')
print(c2) #abcXXf

#第二参数调用函数
def text(x):
    x = x.group()#返回的是re.Match类型，需要转换
    x = 'X'
    return x
c2_1 = re.sub(r'\d',text,'ab12f')
print(c2_1) #abXXf




                            正则修饰符
#正则修饰符是对正则表达式的修饰
#re.S 是让点 . 匹配换行
x = '1aa2\nbb3cc4dd5'
b2 = re.search(r'2.*5',x,re.S)
print(b2) #<_sre.SRE_Match object; span=(3, 14), match='2\nbb3cc4dd5'>

#re.I 是转换大小写
x = '1aa2\nbb3cc4dd5'
b3 = re.search(r'Aa',x,re.I)
print(b3.group()) #aa

#re.M 是让 $ 匹配到换行
# \w :指的是字母，数字，下划线  + ：指的是前面的元素出现一次或者一次以上  $ :指的是以指定内容结尾
x = '1aa2\nbb3cc4dd5'
b4 = re.findall(r'\w+$',x,re.M)
print(b4) #['1aa2', 'bb3cc4dd5']


                            正则表达式规则

#1.数字和字母都表示它本身
#2.很多字母前面添加\会有特殊含义
#3.绝大多数标点符号都有特殊含义
#4.如果想要使用标点符号，需要 \符号
print(re.search(r'\+','1+2')) #<_sre.SRE_Match object; span=(1, 2), match='+'>


                             字母的特殊含义

#\n 表示换行；  \t 表示制表符；

#\d 表示数字，等价于{0，9}
 
#\D 表示非数字，等价于[^0-9]
b9 = re.search(r'\D+','Hello123')
b9_1 = re.search(r'[^0-9]+','Hello123')
print(b9.group()) #Hello
print(b9_1.group()) #Hello

#\w 表示字母，数字，下划线，汉字等非标点符号
c1 = re.findall(r'\w+','Hel_+9lo大家好')
print(c1) #['Hel_', '9lo大家好']

#\W 表示标点符号 
c1_1 =re.findall(r'\W+','Hel_+9lo大家好')
print(c1_1) #['+']


# \s 表示非打印字符(空白，\n，\t)
print(re.search(r'\s','1 2')) #<_sre.SRE_Match object; span=(1, 2), match=' '>
print(re.search(r'\s.','1\n\t2')) #<_sre.SRE_Match object; span=(1, 3), match='\n\t'>
print(re.search(r'\s','1\t2')) #<_sre.SRE_Match object; span=(1, 2), match='\t'>

#\S 表示打印字符
print(re.search(r'\S.*','\n \t211')) #<_sre.SRE_Match object; span=(3, 6), match='211'>


                           标点符号的特殊含义

#[]表示可选项范围 [x-y],从x到y的区间，包含x和y
b5 = re.search(r'a[0-5]b','a3bc')
print(b5.group()) #a3b
b5_1 = re.search(r'a[0-5]+b','a035bc')
print(b5_1.group()) #a035b
b5_2 = re.search(r'a[0-5a-dx]+b','a035cxbc')
print(b5_2.group()) #a035cxb

# | 表示或者
# b6 = re.search(r'a(2|3|23b)c','a23bcf') #a后面跟着2或者3或者23bc
# print(b6.group()) #a23bc

#{} 表示前面元素出现的次数
b7 = re.search(r'go{2}d','good')
print(b7.group()) #good
#{n,} 表示前面的元素出现n次以上
b7_1 = re.search(r'go{1,}d','good')
print(b7_1.group()) #good
#{,n} 表示前面的元素出现n次一下
b7_2 = re.search(r'go{,2}d','good')
print(b7_2.group()) #good
#{m,n} 前面的元素出现m到n次
b7_3 = re.search(r'go{1,2}d','good')
print(b7_3.group()) #good

# * :指的是*前面的元素出现任意次数，0次或者0次以上，等价于{0，}
b8 = re.search(r'go*d','gd')
print(b8.group()) #gd

# + ：指的是+前面的元素出现一次或者一次以上，等价于{1，}
b8_1 = re.search(r'go+d','god')
print(b8_1.group()) #god

# ? :两种用法 1.指的是前面的是前面的元素最多出现一次，等价于{，1}
           #2.将贪婪模式转换为非贪婪模式
b8_2 = re.search(r'go?d','gd')
print(b8_2.group()) #gd

# ^ :1.指的是^后面的元素开头 2.指的是在[]里取反，非；$ :指的是以$前面的元素结尾
b8_3 = re.search(r'^a.*b$','a111b')
print(b8_3.group()) #a111b

					 贪婪模式和非贪婪模式
#在python的正则表达式中，默认是贪婪模式，尽可能多的匹配
#在贪婪模式后面添加 ？ 可以将贪婪模式转换为非贪婪模式