Python中的正则表达式

何为正则表达式

正则表达式是用来简洁表达一组字符串的表达式。又称为regular expression 、regex或 RE

作用：

1、表达文本类型的特征（病毒、入侵等）
2、同时查找或替换一组字符串
3、匹配字符串的全部或部分

使用：

编译：将符合正则表达式语法的字符串转换成正则表达式特征。

语法：

正则表达式语法由字符和操作符构成

常用操作符

操作符	说明	实例
.	表示任何单个字符
[ ]	字符集，对单个字符给出取值范围	[abc]表示a、b、c，[a-z]表示a到z单个字符
[ ^ ]	非字符集，对单个字符给出排除范围	[^abc]表示非a或b或c的单个字符
*	前一个字符0次或无限次扩展	abc*表示ab、abe、abcc、abecc等
+	前一个字符1次或无限次扩展	abc+表示abc、abec、abccc等
？	前一个字符出现或者不出现	abe？表示ab、abe
|	左右表达式任意一个	abcldef 表示abc、def
{m}	扩展前一个字符m次	ab{2}c表示abbe
{m，n}	扩展前一个字符m至n次（含n）	ab{1，2}c表示abc、abbc
^	匹配字符串开头	^abc表示abe且在一个字符串的开头
$	匹配字符串结尾	abes表示abc且在一个字符串的结尾
()	分组标记，内部只能使用 | 操作符	（abc）表示abc，（abc | def）表示abe、def
\d	数字，等价于[0-9]
\w	单词字符，等价于[A-Za-z0-9_]

值得注意的是：

1、多数字母和数字前加一个反斜杠时会拥有不同的含义。
2、标点符号只有被转义时才匹配自身，否则它们表示特殊的含义。
3、反斜杠本身需要使用反斜杠转义。

正则表达式语法实例：

经典正则表达式实例：

匹配IP地址的正则表达式

Re库的基本使用

主要功能函数

1、search(pattern, string, flags=0)
在一个字符串中搜索匹配正则表达式的第一个位置，返回match对象。
即正则表达式是一种简洁的代表一类字符串的表达式，我们通过它（pattern）来在已知的字符串（string）中寻找（匹配）这一类字符串（子串）
·pattern：正则表达式的字符串或原生字符串表示
·string：待匹配字符串
·flags：正则表达式使用时的控制标记
常用标记
re.I ( re.IGNORECASE) 忽略正则表达式的大小写，[A-Z]能够匹配小写字符
re.M ( re.MULTILINE) 正则表达式中的操作符能够将给定字符串的每行当作匹配开始
re.S (re.DorALL)正则表达式中的操作符能够匹配所有字符，默认匹配除换行外的所有字符

import re
match = re.search(r'[1-9]\d{5}','BIT 100081')
if match :
    print(match.group(0))
此例中我们通过邮政编码的正则表达式r'[1-9]\d{5}'来在已知字符串BIT 100081中寻找符合邮政编码类型的子串即10081

Output：
100081

2、match(pattern,string,flags=0)
从一个字符串的开始位置起匹配正则表达式，返回match对象。需要注意的是 match 函数是从字符串开始处开始查找的，如果开始处不匹配，则不再继续寻找，返回值为 一个 SRE_Match 对象，找不到时返回 None

import re
match = re.match(r'[1-9]\d{5}','BIT 100081')
if match:
    print(match.group(0))

Output：

我们发现结果为空

由于是从开始位置起匹配，而给出的字符串的开始是BIT，不符合[1-9]\d{5}，故没有匹配结果

import re
match = re.match(r'[1-9]\d{5}','BIT 100081')
print(type(match))

Output：
<class 'NoneType'>

我们改变一下字符串的顺序

import re
match = re.match(r'[1-9]\d{5}','100081 BIT')
if match:
    print(match.group(0))

Output：
100081

可见search与match的区别在于：
match要求待匹配的子串必须在字符串的起始位置，而search则无此要求
3、findall（pattern，string，flags=0）
搜索字符串，以列表类型返回全部能匹配的子串。

import re
ls = re.findall(r'[1-9]\d{5}','100081BIT TSU100084')
print(type(ls))
print(ls)

Output：
<class 'list'>
['100081', '100084']

4、split（pattern，string，maxsplit=0，flags=0）
将一个字符串按照正则表达式匹配结果进行分割，返回列表类型。
maxsplit：最大分割数，剩余部分作为最后一个元素输出

import re
ls = re.split(r'[1-9]\d{5}','BIT100081 TSU100084')
print(type(ls))
print(ls)


Output：
<class 'list'>
['BIT', ' TSU', '']

可见此函数是将匹配的子串去掉，去掉之后的部分分别作为分割的字符串元素放在列表里
增加maxsplit

import re
ls = re.split(r'[1-9]\d{5}','BIT100081 TSU100084',maxsplit=1)
print(ls)

Output：
['BIT', ' TSU100084']

可见只匹配第一个位置的字符串，之后的不分割，作为一个列表的元素输出
此方法也可弥补.split方法只能分割单个字符的不足，可以实现对字符串的多次分割，实例如下：

import re
str = "Name:Yuanzheng,Age:21"
l = re.split(r'\:|\,',str)
print(l)

Output：
['Name', 'Yuanzheng', 'Age', '21']

5、finditer（pattern，string，flags=0）
搜索字符串，返回一个匹配结果的迭代类型，每个迭代元素是match对象。

import re
for m in re.finditer(r'[1-9]\d{5}','BIT100081 TSU100084'):
    if m:
        print(m.group(0))
  
Output:
100081
100084

6、sub（pattern，repl，string，count=0，flags=0）
在一个字符串中替换所有匹配正则表达式的子串，返回替换后的字符串。
repl：替换匹配字符串的字符串
count：匹配的最大替换次数

import re
m = re.sub(r'[1-9]\d{5}','zipcode','BIT100081 TSU100084')
if m:
    print(m)

Output:
BITzipcode TSUzipcode

Re库的另一种等价用法

正则表达式的表示类型
raw string类型（原生字符串类型，是不包含转义符的字符串）re库采用此类型表示正则表达式，表示为：r’text’
string类型，更繁琐。

regex=re.compile（pattern，flags=0）
将正则表达式的字符串形式编译成正则表达式对象
·pattern：正则表达式的字符串或原生字符串表示
·flags：正则表达式使用时的控制标记

无论是raw string还是string类型都只是一种表示类型，而经过编译后的regex才是正则表达式对象，它代表了一组字符串

需要注意的是，由于这种方法是对raw string经过了编译，故这6个函数后面的参数就不需要pattern了！

Re库的match对象

属性
.string 待匹配的文本
.re 匹配时使用的pattern对象（正则表达式）
.pos 正则表达式搜索文本的开始位置
.endpos 正则表达式搜索文本的结束位置

方法
.group（0） 获得匹配后的字符串
.start() 匹配字符串在原始字符串的开始位置
.end() 匹配字符串在原始字符串的结束位置
.span() 返回（start）…end0）

import re
match = re.search(r'[1-9]\d{5}','BIT100081 TSU100084')
print(match.string)
print(match.re)
print(match.pos)
print(match.endpos)
print(match.group(0))
print(match.start())
print(match.end())
print(match.span())

Output:
BIT100081 TSU100084
re.compile('[1-9]\\d{5}')#可见python默认匹配时使用的pattern对象（正则表达式）是经过编译后的
0
19
100081
3
9
(3, 9)

Re库的贪婪匹配和最小匹配

Re库默认采用贪婪匹配，即输出匹配最长的子串。

import re
match = re.search(r'PY.*N','PYANBNCNDN')
print(match.group(0))

Output：
PYANBNCNDN

改为最小匹配的方法：在扩展操作符后加？

import re
match = re.search(r'PY.*?N','PYANBNCNDN')
print(match.group(0))

Output：
PYAN