python常用模块-re正则匹配

前言

• re模块是python本地库中匹配字符串的模块，学习re模块的前提必须要学习一些基础的正则表达式，明白正则表达式中的一些概念，你才能更好的掌握这个模块。

正则表达式

常用元字符

反义元字符

常用量词

• \ ： 斜杠字符转义
• ()：括号代表分组
• | ： 或者的意思
• []： 字符集
• ? ： 正则表达式默认规则是贪婪匹配，在后面加个问号可取消贪婪匹配

# 常用正则表达式
compile = ".*?"

. 是任意字符
* 是取 0 至 无限长度
? 是非贪婪模式。

全意：除换行符外匹配尽量少的任意字符

# 最常写的方式是在后面加一个字符作为终止字符：
.*?a

举例：

匹配IP地址：192.168.120.121

# 简易IP正则
(\d{3}\.){3}\d{3}

# 精确IP正则表达式
((2[0-4]\d|25[0-5]|[01]?\d\d?)\.){3}(2[0-4]\d|25[0-5]|[01]?\d\d?)

身份证

^(\d{6})(\d{4})(\d{2})(\d{2})(\d{3})([0-9]|X)$

邮箱

[\w!#$%&'*+/=?^_`{|}~-]+(?:\.[\w!#$%&'*+/=?^_`{|}~-]+)*@(?:[\w](?:[\w-]*[\w])?\.)+[\w](?:[\w-]*[\w])?

简易手机号正则表达式

1\d{10}

/^[1]([3-9])[0-9]{9}$/

re模块

常用函数

• 注意：传入的被匹配对象必须是字符串str类型

re匹配对象函数

函数详解

1、compile()

编译正则表达式，返回一个对象的模式。（可以把那些常用的正则表达式编译成正则表达式对象，这样可以提高一点效率。）

格式：re.compile(pattern,flags=0)

• pattern: 正则匹配表达式。

• flags 编译标志位，用于修改正则表达式的匹配方式，如：是否区分大小写，多行匹配等。常用的flags有：

import re

text = "Cats are very cute animals"
partten = re.compile(r'\w*')
print(partten.search(text).group()) 

# 执行结果如下： 
Cats

2、match()

re.match 从字符串的起始位置进行匹配，匹配成功返回match对象，否则返回None。

// 注：这个方法并不是完全匹配。当pattern结束时若string还有剩余字符，仍然视为成功。想要完全匹配，可以在表达式末尾加上边界匹配符’$’

如何加深理解呢？

• 可以简单理解为开头必须完全匹配，后面可以不完全匹配，取头不必取尾；
• 比如字符串"Cats are very cute animals" 必须从C字母开始匹配，不能从a开始；

格式：re.match(pattern, string, flags=0)

import re

print(re.match("Cats", "Cats are very cute animals").group())
print(re.match("cats", "Cats are very cute animals", re.I).group())

# 执行结果如下：
Cats
Cats

3、search()

查找整个字符串，匹配成功返回第一个match对象，失败则返回None。

格式：re.search(pattern, string, flags=0)

import re

print(re.search("animals", "Cats are very cute animals").group())

# 执行结果如下： 
animals

• 注：match和search一旦匹配成功，就是一个match object对象，而match object对象有以下方法：

  • group()： 返回被 RE 匹配的字符串
  • start()： 返回匹配开始的位置
  • end()： 返回匹配结束的位置
  • span()： 返回一个元组包含匹配 (开始,结束) 的位置
  • groups()： 返回re整体匹配的字符串，可以一次输入多个组号，对应组号匹配的字符串。

4、findall()

查找字符串中所有匹配的对象，并返回一个列表，如果为空，则返回空列表。

• 注意： match 和 search 是只匹配一次，而 findall 是匹配所有。

格式：re.findall(pattern, string, flags=0)

import re

p = re.compile(r'\d+')
print(p.findall('o1n2m3k4z45'))

# 执行结果如下：
['1', '2', '3', '45']

text = "Cats are very cute animals and I like it!"
print(re.findall(r'\w*n\w*', text))

# 执行结果如下：
['animals', 'and']

5、finditer()

与 findall() 函数相似，查找字符串中所有匹配的对象，并作为一个迭代器返回

• 与 findall() 区别就是 返回的对象类型不一样

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

import re

text = "Cats are very cute animals and I like it!"
iter_ = re.finditer(r'\w*n\w*', text)
for i in iter:
    print(i)
    print(i.group())
    
# 执行结果如下： 
<re.Match object; span=(19, 26), match='animals'>
animals
<re.Match object; span=(27, 30), match='and'>
and

6、split()

按照能够匹配的子串将string分割后返回列表。

可以使用re.split来分割字符串，如：re.split(r’\s+’, text)；将字符串按空格分割成一个单词列表。

格式：re.split(pattern, string[, maxsplit])

• maxsplit用于指定最大分割次数，不指定将全部分割。

import re
print(re.split('\d+','one1two2three3four4five5')) 

# 执行结果如下： 
['one', 'two', 'three', 'four', 'five', '']

7、sub()

使用re匹配字符串中的所有对象后，进行替换，并返回替换后新的字符串。

格式：re.sub(pattern, repl, string, count=0)

import re 

text = "JGood is a handsome boy, he is cool, clever, and so on..." 
print(re.sub(r'\s+', '-', text)) 

# 执行结果如下： 
JGood-is-a-handsome-boy,-he-is-cool,-clever,-and-so-on... 

repl 参数也可以是函数

import re
 
# 将匹配的数字乘以 2
def double(matched):
    value = int(matched.group('value'))
    return str(value * 2)
 
s = 'A23G4HFD567'
print(re.sub('(?P<value>\d+)', double, s))

8、subn()

返回替换次数

subn(pattern, repl, string, count=0, flags=0)

import re

print(re.subn('[1-2]','A','123456abcdef')) print(re.sub("g.t","have",'I get A,  I got B ,I gut C')) print(re.subn("g.t","have",'I get A,  I got B ,I gut C')) 

# 执行结果如下：
('AA3456abcdef', 2) 
I have A,  I have B ,I have C 
('I have A,  I have B ,I have C', 3)

四、一些注意点

1、re.match与re.search与re.findall的区别：

• re.match：只匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回None；
• re.search：匹配整个字符串，直到找到一个匹配;

import re

a = re.search('[\d]',"abc33").group() 
print(a) 

p = re.match('[\d]',"abc33") print(p) b=re.findall('[\d]',"abc33") 
print(b) 
 
# 执行结果： 
None 
['3', '3']

2、贪婪匹配与非贪婪匹配

import re

a = re.match('<(.*)>', 'title').group()
print(a) 
b = re.match('<(.*?)>', 'title').group() 
print(b) 

# 执行结果： 
title

a = re.findall(r"a(\d+)b",'a3333b') print(a) 
b = re.findall(r"a(\d+?)b",'a3333b') print(b) 

# 执行结果如下： 
['3333']
['3333']

• 这里需要注意的是如果前后均有限定条件的时候，就不存在什么贪婪模式了，非匹配模式失效。