python——RE模块的基础应用及正则表达式的使用

Posted 2020-12-12 booksxx

python——RE模块的基础应用及正则表达式的使用

Python re模块

re模块是python独有的匹配字符串的模块，该模块中提供的很多功能是基于正则表达式实现的，而正则表达式是对字符串进行模糊匹配，提取自己需要的字符串部分，他对所有的语言都通用。

• re模块是python独有的
• 正则表达式所有编程语言都可以使用
• re模块、正则表达式是对字符串进行操作

注意点：正则表达式会对特殊字符进行转义，如果要保持原模样，只需加个r前缀。例如：r‘ hello- world‘

禁止转义！反斜杠不会被任何特殊方式处理。
Python编译器用‘’（反斜杠）来表示字符串常量中的转义字符。
如果反斜杠后面跟着一串编译器能够识别的特殊字符，那么整个转义序列将被替换成对应的特殊字符（例如，‘ ’将被编译器替换成换行符）
本质上来讲，使用r，你在告诉编译器完全不要去干涉你的字符串
常见转义符

元字符

元字符就是指那些在正则表达式中具有特殊意义的专用字符，可以用来规定其前导字符（即位于元字符前面的字符）在目标对象中的出现模式。

字符	说明
.	匹配除换行符以外的所有字符
[...]	匹配字符集
w	匹配字母、数字及下划线_，等价于[A-Za-z0-9_]
W	匹配所有与w不匹配的字符（取反）
s	匹配单个空格符、包括tab键和换行符
S	匹配除单个空格之外的字符
d	匹配从0到9的数字，等价于[0-9]
D	匹配非数字
^	匹配输入字符串开始的位置
$	匹配输入字符串结尾的位置

限定符(重复)

限定符用来限定一个目标子表达式要重复出现多少次才匹配成功

限定符	说明
*	匹配前面的字符0次或多次
+	匹配前面的字符1次或多次
？	匹配前面的字符0次或1次
{n}	匹配前面的字符n次
{n,}	匹配前面的字符至少n次
{n,m}	匹配前面的字符至少n次，最多m次

字符串转义：

www.baidu.com

www.baodu.com

贪婪与非贪婪

贪婪匹配:正则表达式一般趋向于最大长度匹配，也就是所谓的贪婪匹配。

非贪婪匹配：就是匹配到结果就好，最少的匹配字符。

默认是贪婪模式；在量词后面直接加上一个问号？就是非贪婪模式。

字符	说明
*	允许前一个字符可以出现0次或者无数次
+	前一个字符至少出现1次
?	前一个字符只能出现一次或者不出现
{n}	允许前一个字符只能出现n次
{n,m}	允许前一个字符出现n到m次
{n, }	允许前一个字符至少出现n次

转义符

转义字符	描述
(在行尾时)	续行符
\\	反斜杠符号
‘	单引号
"	双引号
a	响铃
	退格（Backspace）
e	转义
00	空
	换行
v	纵向制表符
	横向制表符
	回车
f	换页
oyy	八进制数，例如：o12代表换行
xyy	十进制数，例如：x0a代表换行
other	其他的字符以普通格式输出

标志位

标志	说明
re.S	匹配包括换行在内的所有字符
re.I	使匹配对大小写不敏感
re.L	做本地化识别（locale-aware)匹配，法语等
re.M	多行匹配，影响^和$
re.X	该标志通过给予更灵活的格式以便将正则表达式写得更易于理解
re.U	根据Unicode字符集解析字符，这个标志影响w,W,,B

1. re.I 使匹配对大小写不敏感，如下：

   # re.I 的学习，忽略大小写
   S1 = ‘CoN‘   #定义字符串i1
   S2 = ‘www.xiao.con‘    #定义字符串i2
   #print(re.search(‘CoN‘,‘www.xiao.con‘).group())  #区分大小写的子组输出,报有错
   print(re.search(S1,S2,re.I).group())  #不区分大小写的子组输出
   # con
   

2. re.M 使用^ 和 $ 符号，实现多行多行匹配。如将所有行的末尾字符串输出得：

   # re.M 的学习，将所有行的尾字母或者首部输出
   S3 = ‘‘‘I am girl
           you are boy
           we are friends
           ‘‘‘                   #定义初始字符串
   print(re.findall(r"w+$",S3,re.M))   #输出S3的每行最后一个字符串
   # [‘girl‘, ‘boy‘, ‘friends‘]
   

3. re.S匹配包括换行在内的所有字符。如下：

   s1 = ‘‘‘jduedhhelloworld：    
           11630
           passgrthgdg
           ‘‘‘                     #初始字符串，有换行所以用三引号
   b = re.findall(‘hello(.*?)pass‘,s1)   #findal返回字符串中某个正则表达式模式全部的非重复出现的情况，不包含换行,返回列表
   c = re.findall(‘hello(.*?)pass‘,s1,re.S)  #包含换行
   print(‘b is‘,b)  #输出B匹配的结果 b is []
   print(‘c is‘,c)   #输出C，包行匹配输出的结果 c is [‘world：    
           11630
           ‘]
   

正则表达式常用函数

1、re.findall()函数

语法：re.findall(pattern, string, flags=0) ——> list(列表)

pattern 匹配的正则表达式
string 要匹配的字符串。
flags 标志位，用于控制正则表达式的匹配方式

列出字符串中模式的所有匹配项，并作为一个列表返回。如果无匹配，则返回空列表！

import re
print(re.findall(r"ab","abcaaaab"))
[‘ab‘, ‘ab‘]               #匹配的值作为一个列表范围

2、re.compile()函数

语法：re.compile(pattern, flags=0) ——> pattern object

根据包含正则表达式的字符串创建模式对象，可以实现更有效率地匹配！用了re.compile以后，正则对象会得到保留，这样在需要多次运用这个正则对象的时候，效率会有较大的提升

import re
s=r"^010-d{8}$"
print(re.findall(s,"010-12345678"))
# [‘010-12345678‘]
p_tel=re.compile(s)     #对s这个正则表达式创建模式对象p_tel
print(p_tel)
# <_sre.SRE_Pattern object at 0x7f3ab3776d78>
print(p_tel.findall("010-12345678"))  
#经过compile转换的正则表达式对象也能用于普通的re函数，跟上面的re.findall(s,"010-12345678")一样的效果
# [‘010-12345678‘]

3、re.match()函数

语法：re.match(pattern, string, flags=0) ——> match object or None

在字符串的开始位置匹配正则！如果无匹配，则返回 None 。

import re
s=r"abc"
com=re.compile(s)
com.match("abcdef")                          #abc在开始的位置，可以匹配
# <_sre.SRE_Match object at 0x7f3ab3480cc8>
print(com.match("hhhabc"))                    #abc不在开始的位置，不可以匹配
# None

# 使用group()-返回匹配的数据
com.match("abcddddd").group()   			 #使用group()返回匹配的对象
# ‘abc‘

4、re.search()函数

语法：re.search(pattern, string, flags=0) ——> match object or None

re.search函数会在字符串内查找模式匹配,只要找到第一个匹配然后返回，如果字符串没有匹配，则返回None

 

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

5、re.sub()函数

语法:re.sub(pattern, repl, string, count=0, flags=0) ——> string

将字符串中所有 pattern 的匹配项用 repl 替换！

import re
re.sub(r"abc","123","abcdefabc")
# ‘123def123‘

6、re.split()函数

语法：re.split(pattern, string, maxsplit=0, flags=0) ——> list

根据模式的匹配项来分割字符串

import re
re.split(r"d+","aa11bb22cc")  #以正则表达式d+为分割符
[‘aa‘, ‘bb‘, ‘cc‘]
re.split(r"d","aa11bb22cc")   #以正则表达式d+为分割符
[‘aa‘, ‘‘, ‘bb‘, ‘‘, ‘cc‘]