正则表达式

1.查找方法

• match方法(只匹配字符串开头)

• search方法(扫描整个字符串，找到第一个匹配)

• findall方法(扫描整个字符串，找到所有的匹配) 返回的是匹配的字符串

• finditer方法(扫描整个字符串，找到所有的匹配，并返回一个可迭代对象)

 

print(re.match('h', 'ellh')) #None
print(re.search('h','elhsh')) #<re.Match object; span=(2, 3), match='h'>
print(re.findall('h', 'heeldhssh')) #['h', 'h', 'h']
a=re.finditer('h', 'sdhsdh') # <callable_iterator object at 0x000000000221D988>
print(list(a)) # [<re.Match object; span=(2, 3), match='h'>, <re.Match object; span=(5, 6), match='h'>] 可用for循环迭代  或者next()获取

 

当我们调用re.match方法、re.search方法，或者对re.finditer方法的结果进行迭代时，拿到的数据类型都是re.Match对象。

这个类里定义了相关的属性，可以直接让我们来使用。

属性和方法	说 明
pos	搜索的开始位置
endpos	搜索的结束位置
string	搜索的字符串
re	当前使用的正则表达式的对象
lastindex	最后匹配的组索引
lastgroup	最后匹配的组名
group(index=0)	某个分组的匹配结果。如果index等于0，便是匹配整个正则表达式
groups()	所有分组的匹配结果，每个分组的结果组成一个列表返回
groupdict()	返回组名作为key，每个分组的匹配结果座位value的字典
start([group])	获取组的开始位置
end([group])	获取组的结束位置
span([group])	获取组的开始和结束位置
expand(template)	使用组的匹配结果来替换模板template中的内容，并把替换后的字符串返回

 

a = re.search(r'h(\d+)m(?P<sa>.?)', 'h12m3dsmass')
print(a.group())  # h12m3 获得整个匹配到的字符串
print(a.group(0))  # h12m3 获得整个匹配到的字符串
print(a.group(1))  # 12  获得第一个分组
print(a.group(2))  # 3 获得第二个分组
print(a.group('sa'))  # 3  通过名字获得分组
print(a.groups())  # ('12', '3') 获得所有分组，通过元组显示
print(a.end(2))  # 5 第二个分组的结束位置
print(a.span(2))  # (4,5)  第二个分组的下标范围
print(a.string) #h12m3dsmass  原字符串
print(a.pos)  # 0 匹配查找的开始位置，默认0
print(a.endpos)  # 11  匹配查找的结束位置

 

• compile 调用re.compile方法，生成一个正则表达式对象，再调用这个正则表达式对象的相关方法实现匹配。

a=re.compile('\d+')
print(a.search('we231w').span()) # (2,5)
print(a.findall('sd12ww22')) # ['12','22']

• 模式字符串使用特殊的语法来表示一个正则表达式：

  1. 字母和数字表示他们自身，一个正则表达式模式中的字母和数字匹配同样的字符串。

     re.search(r'H','Hello')  # 这里的 H 表示的就是字母 H 自身，代表有特殊含义

  2. 多数字母和数字前加一个反斜杠时会拥有不同的含义。

     ret = re.search(r'\d','he12ms90') # 这里的 \d 表示的是匹配数字

  3. 标点符号只有被转义时才匹配自身，否则它们表示特殊的含义。

     ret = re.search(r'.','hello') # 这里的 . 表示的是匹配任意字符
     ret = re.search(r'\.','he.llo')  # 这里的 \. 进行了转义，才表示标点符号自身。

  4. 反斜杠本身需要使用反斜杠转义。由于正则表达式通常都包含反斜杠，所以你最好使用原始字符串来表示它们。模式元素(如 r'\t'，等价于\\t )匹配相应的特殊字符。

 

2.特殊字符

• 1.字母前面加反斜杠\

\s 匹配空白字符 \S匹配非空白字符

\d 匹配数字 \D匹配非数字

\w匹配数字、字母、下划线、中文 \W匹配数字、字母、下划线、中文以外的字符

• 2.标点符号

（） 分组

(?=)表示一个非捕获分组

. 除了换行以外的任意字符

+ 出现1次或多次 {1,}

？ 出现0次或1次 {0,1}

*出现任意次 {0,}

x{n,m} 表示x出现[n,m]次

x{n,} 表示x至少出现n次

x{,m} 表示x最多出现m次

注意：次数都是放在要匹配的字符次数后面，如：a？表示a出现0次或1次

[ ]表示选项 如[0-9]表示0到9的数字都可以匹配

| 表示可选项

^ 匹配输入字符串的开始位置，例如：^h匹配以h开头 ；如果在中括号内表示取反；

$ 匹配以什么字符结尾 如 a$ 表示以a结尾

print(re.findall('\s','  sd  sdaew 123!_'))#[' ', ' ', ' ', ' ', ' ']
print(re.findall('\w','  sd  sd 123!_'))#['s', 'd', 's', 'd', '1', '2', '3', '_']
print(re.search(r'\(.*\)','hi(你好)'))#<re.Match object; span=(2, 6), match='(你好)'>
print(re.findall(r'.','ad.we.ss\n?'))  #['a', 'd', '.', 'w', 'e', '.', 's', 's', '?']
print(re.findall(r'a+','ssaaddsadsaaaaas'))#['aa', 'a', 'aaaaa']
print(re.findall(r'sa?s','ssaaddsadsaaaaas'))#['ss']
print(re.findall(r'sa{1,2}d','asadwwcsaadff'))#['sad', 'saad']
print(re.findall(r'a[1-5]b','a22bqa3b')) # ['a3b']
print(re.findall(r'[0-9]','123sdssd2')) # ['1', '2', '3', '2']
print(re.findall(r'[a-j]','123sdssd2')) # ['d', 'd']
print(re.findall(r'a|b|c|1|s','123sdssd2')) # ['1', 's', 's', 's']
print(re.findall(r'^a[0-9]*g$','a2340g')) # ['a2340g']

 

 

• 3.修饰符

re.I 修饰符用来忽略大小写

re.S 用来让点匹配包括换行的任意字符

re.M 多行匹配，影响 ^ 和 $ ， 用来忽略换行字符

print(re.search('A','ai',re.I)) #<re.Match object; span=(0, 1), match='a'>
​
print(re.findall(r'^.+','hello\ngod\nyes'))#['hello']
print(re.findall(r'^.+','hello\ngod\nyes',re.S))#['hello\ngod\nyes']
​
print(re.findall(r'^h.*s$','hells\nhos\nhes'))#['hello\ngod\nyes']
print(re.findall(r'^h.*s$','hells\nhos\nhes',re.M))#['hello\ngod\nyes']

 

3.正则替换

re.sub('匹配的字符’，‘新字符’(也可以是函数)，‘查找的字符串’，‘替换次数’(默认0，替换所有))

print(re.sub('l','a','helllo',2)) # heaalo
​
def test(s):
    a=int(s.group())*2
    print(a)
    return str(a)
​
print(re.sub(r'\d+', test, 'sd12fe78'))  # sd24fe156
​
print(re.sub(r'\d+', lambda s:str(int(s.group())*2), 'sd12fe78')) #sd24fe156

 

4.贪婪模式

Python里数量词默认是贪婪的，总是尝试匹配尽可能多的字符；

非贪婪则相反，总是尝试匹配尽可能少的字符。

在*,?,+,{m,n}后面加上 ?使贪婪变成非贪婪。

a=re.search(r'.*(\d+).*','sad123swe')  # 贪婪模式尽可能多的拿
b=re.search(r'.*?(\d+).*','sad123swe')  # 非贪婪尽可能少的拿
c=re.search(r'.*?(\d+?).*','sad123swe') 
print(a.group(1)) #3
print(b.group(1)) #123
print(c.group(1)) #1