郭炜老师mooc第九章正则表达式

正则表达式

正则表达式是个某些字符有特殊含义字符串,表示一种字符串的模式(格式)

正则表达式中的功能字符

  •  d:digit
  • s:space
  • w:word

 花括号量词{m,n},逗号后面要紧跟数字,不能打空格,否则输出结果和你想象的不一样,当然我并不知道为什么!

import re
pt = "\d{1, 3}"
print(re.findall(pt, "1234567890"))

pt = "\d{1,3}"
print(re.findall(pt, "1234567890"))

pt = "\d*"
print(re.findall(pt, "1234567890"))

输出结果:

[]
['123', '456', '789', '0']
['1234567890', '']

 正则表达式中的特殊字符

正则表达式中常见的特殊字符有以下几个:
. + ? * $ [ ] ( ) ^ { } \
如果要在正则表达式中表示这几个字符本身,就应该在其前面加'\'。

 范围符号[XXX]的用法

用以表示“此处必须出现一个某某范围内的字符”,或者“此处必须出现一个字符,但不可以是某某范围内的字符”

 量词(+,*,?)的用法

使用正则表达式需要:模块re

 re模块是python独有的匹配字符串的模块,该模块种提供功能基于正则表达式实现的,对于字符串进行模糊匹配找到想要的内容信息,一般用于爬虫或者自动化测试前后端不分离项目。

 re.match函数

# re.match函数

import re
def match(pattern,string):
    x = re.match(pattern,string)
    if x != None:
        print(x.group()) #x.group是匹配上的字符串
    else:
        print("None")
        
match("a c","a cdkgh") #>>a c
match("abc","kabc") #>>None 虽然有abc,但不是在起始位置
match("a\tb*c","a\tbbcde") #>>a bbc b出现0次或任意多次,然后跟c
match("ab*c","ac") #>>ac
match("a\d+c","ac") #>>None b出现1次或更多次,然后跟c
match("a\d{2}c","a34c") #>>a34c
match("a\d{2,}c","a3474884c") #>>a3474884c
match(".{2}bc","cbcd") #>>None bc前面要有2个字符

 re.search函数

re.search(pattern, string, flags = 0)

  • 查找字符串中可以匹配成功的子串。若匹配成功,则返回匹配对象;
  • 若无法匹配,则返回None
# re.search函数

import re
def search(pattern,string):
    x = re.search(pattern,string)
    if x != None:
        print(x.group(),x.span()) #输出子串及起止位置
    else:
        print("None")
        
search("a.+bc*","dbaegsfbcef") #>>aegsfbc (2, 9)
search("a.+bc*","bcdbaegsfbccc") #>>aegsfbccc (4, 13)
search("a.?bc*d","dabccdc") #>>abccd (1, 6)
search("aa","baaaa") #>>aa (1, 3)
search("\([1-9]+\)","ab123(0456)(789)45ab") #>>(789) (11, 16)
search("[1-9]\d+","ab01203d45") #>>1203 (3, 7)

re.findall函数

re.findall(pattern, string, flags = 0)

  • 查找字符串中所有和模式匹配的子串(不重叠)放入列表。一个子串都找不到
    就返回空表 []
# re.finall函数

import re
print(re.findall('\d+',"this is 334 what me 774gw")) #>>['334','774']
print(re.findall('[a-zA-Z]+',"A dog has 4 legs.这是true"))
#>>['A', 'dog', 'has', 'legs', 'true']
print(re.findall('\d+',"this is good.")) #>>[]
print(re.findall("aaa","baaaa")) #>>['aaa']

re.finditer函数

re.finditer (pattern, string, flags = 0)

  • 查找字符串中所有和模式匹配的子串(不重叠),每个子串对应于一个匹配对象,返回匹配对象的序列(准确说是“可调用迭代器”)
  • 如果找不到匹配子串,返回值也不为None或空表。假设返回值为r,则list(r) 为[]
# re.finditer函数

import re
s = '233[32]88ab<433>(21)'
m = '\[\d+\]|<\d+>' # | 表示 '或'
for x in re.finditer(m,s): #x是匹配对象
    print(x.group(),x.span())
# [32] (3, 7)
# <433> (11, 16)

i = 0
for y in re.finditer(m,"aaaaa"):
    i += 1 #不会被执行

 正则表达式匹配选项

边界符号

  • \A 表示字符串的左边界,即要求从此往左边不能有任何字符
  • \Z 表示字符串的右边界,即要求从此往右边不能有任何字符
  • ^ 与\A同。但多行匹配模式下还可以表示一行文字的左边界
  • $ 与\Z同。但多行匹配模式下还可以表示一行文字的右边界

边界符号本身不会和任何字符匹配。
Python字符串 '\A', '\Z' 都是两个字符,而不是像'\n'那样的一个字符。

  • \b 表示此处应为单词的左边界或右边界,即不可是单词字符
  • \B 表示此处不允许是单词的左边界或右边界,即必须是单词字符
  •  正则表达式的边界符号'\b' 是两个字符。但是在Python字符串中,'\b'和'\t','\n'类似,是一个字符(Backspace)。因此在正则表达式中使用边界符号\b,要写 '\\b'。如果写 '\\\\b',则连续的两个'\'被看作是一个普通的'\',不会和后面的'b'一起被当作字符组合,变成边界符号'\b'。

分组

 括号中的表达式是一个分组。多个分组按左括号从左到右从1开始依次编号。

在Python中,正则表达式的group和groups方法是非常有用的函数,用于处理匹配结果的分组信息。
group方法是re.MatchObject类中的一个函数,用于返回匹配对象的整个匹配结果或特定的分组匹配结果。而groups方法同样是re.MatchObject类中的函数,它返回的是所有分组匹配结果组成的元组。

  • 当group方法不带参数时,它将返回整个匹配结果。该函数默认传参为0,传入参数0(默认值)将返回整个匹配的子串,而传入参数1将返回第一个匹配的捕获组(即正则表达式中用括号括起来的部分)。当正则表达式中包含分组时,group方法可以用于返回指定分组的匹配结果。
  • groups方法是re.MatchObject类的一个函数,用于返回所有分组匹配结果组成的元组。该方法不接受任何参数。

 参考文章:详解Python正则表达式中group与groups的用法_.group()-CSDN博客

 括号中的表达式是一个分组。多个分组按左括号从左到右从1开始依次编号。

# 括号中的表达式是一个分组。多个分组按左括号从左到右从1开始依次编号

import re
x = re.search('[a-z]+(\d+)[a-z]+',"ab 123d hello553world47")
print(x) # >> <re.Match object; span=(8, 21), match='hello553world'>
print(x.group()) #>>hello553world
print(x.group(1)) #>>553
m = "(((ab*)c)d)e"
r = re.match(m,"abcdefg")
print(r.group(0)) #>>abcde group(0)等价于group()
print(r.group(1)) #>>abcd
print(r.group(2)) #>>abc
print(r.group(3)) #>>ab
print(r.groups()) #>>('abcd', 'abc', 'ab')

 在分组的右边可以通过分组的编号引用该分组所匹配的子串

# 在分组的右边可以通过分组的编号引用该分组所匹配的子串

import re
m = r'(((ab*)c)d)e\3' #r表示字符串里的'\'不再转义
#要求 ab*cde后面跟着3号分组在本次匹配中匹配上的子串
r = re.match(m,"abbbcdeabbbkfg") # 红色部分少一个b则不能匹配
print(r.group(3)) # abbb
print(r.group()) # abbbcdeabbb

r = re.match(m,"abbbcdeabbkfg")
print(r)  # None
# 在分组的右边可以通过分组的编号引用该分组所匹配的子串
import re
pt = 'a(.)\\1*b' #或 pt = r'a(.)\1*b'
print(re.search(pt,'kacccccb').group()) #>>acccccb
print(re.search(pt,'kaxxxxb').group()) #>>axxxxb
print(re.search(pt,'kaxb').group()) #>>axb
x = re.search(pt,'kaxyb')
if x != None:
    print(x.group()) #不会执行

 分组作为一个整体,后面可以跟量词

# 分组作为一个整体,后面可以跟量词

import re
m = "(((ab*)+c)d)e"
r = re.match(m,"ababcdefg")
print(r.group())  # ababcde
print(r.groups()) #>>('ababcd', 'ababc', 'ab')
r = re.match(m,"abacdefg")
print(r.group()) # abacde
print(r.groups()) #>>('abacd', 'abac', 'a')

# 不要求分组的多次出现必须匹配相同字符串

 re.findall和分组

  •  在正则表达式中没有分组时,re.findall返回所有匹配子串构成的列表
  • 有且只有一个分组时,re.findall返回的是一个子串的列表,每个元素是一个匹配子串中分组对应的内容。
'''
在正则表达式中没有分组时,re.findall返回所有匹配子串构成的列表。
有且只有一个分组时,re.findall返回的是一个子串的列表,每个元素是一个匹配子串中分组对应的内容。
'''

import re
m = '[a-z]+(\d+)[a-z]+'
x = re.findall(m,"13 bc12de ab11 cd320ef")
print(x) #>>['12', '320']

m = '[a-z]+\d+[a-z]+'
x = re.findall(m,"13 bc12de ab11 cd320ef")
print(x) #>>[['bc12de', 'cd320ef']
  •  在正则表达式中有超过一个分组时,re.findall返回的是一个元组的列表,每个元组对应于一个匹配的子串,元组里的元素,依次是1号分组、2号分组、3号分组......匹配的内容
'''
在正则表达式中有超过一个分组时,re.findall返回的是一个元组的列表,
每个元组对应于一个匹配的子串,元组里的元素,依次是1号分组、2号分组、
3号分组......匹配的内容
'''

import re
m = '(\w+) (\w+)'
r = re.match(m,"hello world")
print(r.groups()) #>>('hello', 'world')
print(r.group(1)) #>>hello
print(r.group(2)) #>>world
r = re.findall(m,"hello world, this is very good")
#找出由所有能匹配的子串的 groups() 构成的元组,互相不重叠
print(r) #>>[('hello', 'world'), ('this', 'is'), ('very', 'good')]

 "|" 的用法

表示“或”,如果没有放在"()"中,则起作用范围是直到整个正则表达式开头或结尾或另一个 "|"

  • "\w{4}ce|c\d{3}|p\w"

可以匹配:
"c773"
"ab12ce"
"pk"

 从左到右短路匹配(匹配上一个后就不计算是否还能匹配后面的)

# "|" 的用法,从左到右短路匹配(匹配上一个后就不计算是否还能匹配后面的)

import re
pt = "\d+\.\d+|\d+"
print(re.findall(pt,"12.34 this is 125"))
#>>['12.34', '125']
pt = "aa|aab"
print(re.findall(pt,"aabcdeaa12aab"))
#>>['aa', 'aa', 'aa']

 '|' 也可以用于分组中,起作用范围仅限于分组内

# '|' 也可以用于分组中,起作用范围仅限于分组内

import re
m ="(((ab*)+c|12)d)e"
print(re.findall(m,'ababcdefgKK12deK'))
#>>[('ababcd', 'ababc', 'ab'), ('12d', '12', '')]
for x in re.finditer(m,'ababcdefgKK12deK'):
    print(x.groups())
#>>('ababcd', 'ababc', 'ab')
#>>('12d', '12', None)
m = '\[(\d+)\]|<(\d+)>'
for x in re.finditer(m,'233[32]88ab<433>'):
    print(x.group(),x.groups())
#>>[32] ('32', None)
#>><433> (None, '433')

贪婪模式和懒惰模式 

量词的贪婪模式, 量词 +,*,?,{m,n} 默认匹配尽可能长的子串

# 量词 +,*,?,{m,n} 默认匹配尽可能长的子串

import re
print(re.match("ab*", "abbbbk").group()) #>>abbbb
print(re.match("(ab)*", "abbbbk").group()) #>>ab

print(re.findall("<h3>(.*)</h3>","<h3>abd</h3><h3>bcd</h3>")) #>>['abd</h3><h3>bcd']
print(re.findall("<h3>.*</h3>","<h3>abd</h3><h3>bcd</h3>")) # ['<h3>abd</h3><h3>bcd</h3>']

print(re.findall('\(.+\)', "A dog has(have a).这(哈哈)true()me"))
#>>['(have a).这(哈哈)true()']

量词的非贪婪(懒惰)模式, 在量词 +,*,?,{m,n} 后面加 '?' 则匹配尽可能短的字符串 。

# 在量词 +,*,?,{m,n} 后面加 '?' 则匹配尽可能短的字符串 。

import re
m = "a.*?b"
for k in re.finditer(m,"aabab"):
    print(k.group(),end="\n") #>>aab ab
m = "<h3>.*?</h3>"
a = re.match(m,"<h3>abd</h3><h3>bcd</h3>")
print(a.group()) #>><h3>abd</h3>

a = re.findall(m,"<h3>abd</h3><h3>bcd</h3>")
print(a) #>>['<h3>abd</h3>', '<h3>bcd</h3>']

m = "<h3>.*?[M|K]</h3>"
a = re.match(m,"<h3>abd</h3><h3>bcK</h3>")
print(a.group()) #

匹配对象”(匹配成功时的返回结果)的属性

  • string: 匹配时使用的母串。
  • lastindex: 最后一个被匹配的分组的编号(不是最大编号)。如果没有被匹配的分组,将为None。
  • start([group]):返回指定的组匹配的子串在string中的起始位置。group默认值为0
  • end([group]):返回指定的组匹配的子串在string中的结束位置(子串最后一个字符的位置 +1)。group默认值为0。
  • span([group]):返回(start(group), end(group))。group可以是组编号,也可以是组名字,缺省为0

# 匹配对象”的函数

m = re.match(r'(\w+) (\w+)(.)', 'hello world!ss')
print( m.string) #>>hello world!ss
print(m.lastindex) #>>3
print(m.group(0,1,2,3))#>>('hello world!', 'hello', 'world', '!')
print(m.groups()) #>>('hello', 'world', '!')
print(m.start(2)) #>>6
print(m.end(2)) #>>11
print(m.span(2)) #>>(6, 11)

诸葛亮口中的曹操

小说txt文本可以去此网站免费下载:

鬼吹灯_无弹窗书友最值得收藏的网络小说阅读网

# 诸葛亮口中的曹操

import re
f = open("E:\jupyter_projects\python_projects\文本文件\三国演义.txt", "r", encoding="gbk")
txt = f.read()
# print(txt)

f.close()
pt = "(孔明.{0,2}曰:“[^”]*(曹操|曹贼|操贼|曹阿瞒|操).*?”)"

a = re.findall(pt, txt)
print(len(a)) #>>58
for x in a: #x形如: ('孔明答曰:“曹操乃汉贼也,又何必问?”', '操')
    print(x[0], end = '\n\n')
    

抽取ip地址、邮箱、网址

 

 

评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值