一、正则表达式的概念

正则表达式　　"一行胜千言"

regular expression　　regex　　RE

是用来简洁表达一组字符串的表达式。

'PN'

'PYN'

'PYTN'　　<===========>正则表达式：P(Y|YT|YTH|YTHO)?N

'PYTHN'

'PYTHON'　

通用的字符串表达框架

是用来简洁表达一组字符串的表达式。

针对字符串表达“简洁”和“特征”思想的工具

判断某字符串的特征归属

正则表达式在文本处理中十分常用

　　　　表达文本类型的特征（病毒、入侵等）

　　　　同时查找或替换一组字符串

　　　　匹配字符串的全部或部分

　　主要应用在字符串匹配中

正则表达式的使用

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

　　我们可以说正则表达式是某一种语法格式，但是在程序中我们必须用字符串的形式来表达他，但是字符串就是字符串，他不是一组字符串，所以我们需要通过编译的形式，将一个字符串变成一个特征，而这个特征可以表达一组字符串，这就是编译的作用。我们也可以认为编译后的特征与一组字符串是对应的，而编译之前的正则表达式只是一个符合正则表达式语法的单一字符串，但他并不是真正意义上的正则表达式。

二、正则表达式的语法

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

正则表达式的常用操作符

操作符　　　　说明　　　　　　　　　　　　　　　　　　　　　　　　　　　　实例

.　　　　　　表示任何单个字符，它可以代表字符表上所有出现的一个字符　　　　　　　　　　　　　

[ ]　　　　　 字符集，对单个字符给出取值范围　　　　　　　　　　　　　　　[abc]表示a、b、c，[a-z]表示a到z单个字符

[^ ]　　　　   非字符集，对单个字符给出排除范围　　　　　　　　　　　　　　[^abc]表示非a或b或c的单个字符，（出现一个字符，但这个字符不是a，不是b，也不是c）

*　　　　　   前一个字符0次或无限次扩展　　　　　　　　　　　　　　　　　 abc*表示ab、abc、abcc、abccc等

+　　　　　  前一个字符1次或无限次扩展　　　　　　　　　 　　　　　　　　abc+表示abc、abcc、abccc等

？　　　　　 前一个字符0次或1次扩展　　　　　　　　　　　　　　　　　　　abc？表示ab、abc

|　　　　　   左右表达式任意一个　　　　　　　　　　　　　　　　　　　　   abc|def表示abc、def

{m}　　　　  扩展前一个字符m次　　　　　　　　　　　　　　　　　　　　　ab{2}c表示abbc

　　　　　　注意，大括号只对大括号前的一个字符进行扩展　　　　　　　　　　　　　　　　　

{m,n}　　　   扩展前一个字符m至n次（含n）　　　　　　　　　　　　　　　   ab{1,2}c表示abc，abbc

^　　　　　  匹配字符串开头　　　　　　　　　　　　　　　　　　　　　　　^abc表示abc且在一个字符串的开头

$　　　　　 匹配字符串结尾　　　　　　　　　　　　　　　　　　　　　　　abc$表示abc且在一个字符串的结尾

()　　　　　分组标记，内部只能使用|操作符　　　　　　　　　　　　　　　　(abc)表示abc，(abc|def)表示abc、def

\d　　　　　数字，等价于[0-9]

\w　　　　   单词字符，等价于[A-Za-z0-9_]

经典正则表达式实例

^[A-Za-z]+$　　　　　　　　　　由26个字母组成的字符串

^[A-Za-z0-9]+$　　　　　　　　  由26个字母和数字组成的字符串

^-?\d+$　　　　　　　　　　　　整数形式的字符串

^[0-9]*[1-9][0-9]*$　　　　　　　 正整数形式的字符串

[1-9]\d{5}　　　　　　　　　　　中国境内邮政编码，6位

[\u4e00-\u9fa5]　　　　　　　　 匹配中文字符   采用utf-8编码来约定了中文字符的取值范围

\d{3}-\d{8}|\d{4}-\d{7}　　　　　   国内电话号码，010-68913536

匹配IP地址的正则表达式

　　　　　　IP地址字符串形式的正则表达式

　　　　　　（IP地址分4段，每段0-255）由4段由.分隔的数字构成，每段取值0-255　　　　

　　　　　　　\d+.\d+.\d+.\d+　　不考虑每一段的取值范围和空间，只考虑他们之前出现的.来分隔

　　　　　　　\d{1,3}.\d{1,3}.\d{1,3}.\d{1,3}中间的每一串数字出现的范围都是1个，2个或到3个的字符串的长度

　　　　　　　不精确300.300.300.300 　　　　✘

　　　　　　　精确写法

　　　　　　　0-99：[1-9]?\d　　　　　　　　100-199：1\d{2}　　　　200-249：2[0-4]\d　　　　250-255：25[0-5]

0-255这样一个空间事实上是由0-99,100-199,200-249,250-255这四段正则表达式组合而成，我们可以采用|操作符以及()形式将他们组织起来

([1-9]?\d|1\d{2}|2[0-4]\d|25[0-5])

再表达了0-255之后，我们可以使用{}和.的形式来构成IP地址的正则表达式

(([1-9]?\d|1\d{2}|2[0-4]\d|25[0-5]).){3}([1-9]?\d|1\d{2}|2[0-4]\d|25[0-5])

三、Re库的基本使用

RE库是Python的标准库，主要用于字符串匹配。

调用方式：import re

正则表达式的表示类型

　　raw string类型（原生字符串类型）：不包含转义符的字符串，原生字符串中的\不会被解释成转义符

　　　　re库采用raw string类型表示正则表达式，表示为：r'text'

　　　　例如：　　r'[1-9]\d{5}'

　　　　   　　　　 r'\d{3}-\d{8}|\d{4}-\d{7}'

　　　　原生字符串类型和字符串类型所不同 的是，只需要在字符串的表示前加一个小写的字符r

　　string类型，更繁琐。：string类型中将\理解为转义符

　　　　例如：　　'[1-9]\\d{5}'

　　　　   　　　　 '\\d{3}-\\d{8}|\\d{4}-\\d{7}'

当【正则表达式】包含《转义符》时，使用raw string

RE库主要功能函数

函数　　　　　　　　　　　　　　　　说明

re.search()　　　　　　　　　　　　在一个字符串中搜索匹配正则表达式的第一个位置，返回match对象（在一个字符串中完整的搜索可能匹配正则表达式的位置）

re.match()　　　　　　　　　　　　 从一个字符串的开始位置起匹配正则表达式，返回match对象（从头开始匹配）

re.findall()　　　　　　　　　　　　  搜索字符串，以列表类型返回全部能匹配的子串（发现里面所有子串，并以列表形式返回）

re.split()　　　　　　　　　　　　　 将一个字符串按照正则表达式匹配结果进行分割，返回列表类型（根据正则表达式进行分割，返回相关列表）

re.finditer()　　　　　　　　　　　　搜索字符串，返回一个匹配结果的迭代类型，每个迭代元素是match对象（返回一个迭代类型，每个类型都是每次匹配的一个match对象）

re.sub()　　　　　　　　　　　　　 在一个字符串中替换所有匹配正则表达式的子串，返回替换后的字符串（用正则表达式匹配的地方替换为另外一个字符串，并返回替换后的字符串）

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

pattern：正则表达式的字符串或原生字符串表示

string：待匹配字符串

flags：正则表达式使用时的控制标记

　　flags：正则表达式使用时的控制标记

　　常用标记　　　　　　　　　　　　说明

　　re.I　　re.IGNORECASE　　　　  忽略正则表达式的大小写，[A-Z]能够匹配小写字符

　　re.M     re.MULTILINE　　　　　　正则表达式中的^操作符 能够将给定字符串的每行当做匹配开始

　　re.S　  re.DOTALL　　　　　　　 正则表达式中的.操作符 能够匹配所有字符，默认匹配除换行外的所有字符

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

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

>>> match = re.match(r'[1-9]\d{5}','BIT 100081')
>>> if match:
... match.group(0)
...
>>> match.group(0)
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
AttributeError: 'NoneType' object has no attribute 'group'
>>> match = re.match(r'[1-9]\d{5}','100081 BIT')
>>> if match:
... match.group(0)
...
'100081'

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

>>> ls = re.findall(r'[1-9]\d{5}','BIT100081 TSU100084')
>>> ls
['100081', '100084']

re.split(pattern,string,maxsplit=0,flags=0)

maxsplit：最大分割数，剩余部分作为最后一个元素输出

>>> re.split(r'[1-9]\d{5}','BIT100081 TSU100084')
['BIT', ' TSU', '']

split函数是将一个正则表达式去匹配字符串，匹配的部分去掉，去掉之后的部分分别做为分割的字符串元素放到一个列表里

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

maxsplit=1在整个字符串中只匹配第一个位置，匹配之后，将BIT分割出来一个部分，剩下的所有部分作为一个完整的字符串，不再进行正则表达式的匹配，作为列表的最后一个变量输出出来

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

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

通过finditer这个函数，能够迭代的获得每一次正则表达式匹配的结果，并对这个结果单独进行处理

re.sub(pattern,repl,string,count=0,flags=0)

用一个新的字符串替换正则表达式匹配上的那些字符串，并与原来的字符串进行组合，返回一个新的字符串

repl：替换匹配字符串的字符串（当pattern匹配上某一个字符串后，替换的那个字符串）

count：匹配的最大替换次数

>>> re.sub(r'[1-9]\d{5}',':zipcode','BIT100081 TSU100084')
'BIT:zipcode TSU:zipcode'

Re库的另一种等价用法

>>> rst = re.search(r'[1-9]\d{5}','BIT 100081')

函数式用法：一次性操作

||

　　　   ||

面向对象用法：编译后的多次操作

另外一种用法：面向对象的方式来使用正则表达式，它包含两个部分，第一个部分首先使用re.compile()将一个正则表达式的字符串编译成为一个正则表达式类型，叫pat也叫pattern类型

然后就可以用这个pattern对象直接调用match，search等6个方法来获得相关结果

>>> pat = re.compile(r'[1-9]\d{5}')

>>> rst = pat.search('BIT 100081')

这种方法的好处是，经过一次编译，当我们需要多次对正则表达式进行匹配和使用时，可以使用这种方式，加快整个程序的运行

regex = re.compile(pattern,flags=0)

将正则表达式的字符串形式编译成正则表达式对象

pattern：正则表达式的字符串或原生字符串表示

flags：正则表达式使用时的控制标记

字符串或原生字符串表示并不是正则表达式，他只是一种表示，如果通过compile编译生成了一个对象regex，这个regex才是正则表达式，它代表了一组字符串，所以我们可以通过这样的函数来实现正则表达式、表示之间的对应，而这种对应，使得我们能够更好的理解正则表达式对象的这种使用方式，经过了compile之后的正则表达式，就可以使用它的对象的方法，而这个对象的方法与RE库提供的6个操作方法是一致的

regex.search()

regex.match()

regex.findall()

regex.split()

regex.finditer()

regex.sub()

在这6个函数使用的过程中，需要注意，正是由于前面已经给了regex正则表达式对象，所以在调用这些函数的时候，需要将其中的正则表达式那个参数去掉，因为我们已经不再需要正则表达式的参数，只需要直接给出相关的需要匹配的字符串就可以了

四、Re库的match对象

match对象就是一次匹配的结果，它包含了很多匹配的相关信息

>>> match = re.search(r'[1-9]\d{5}','BIT 100081')
>>> if match:
... print(match.group(0))
...
100081
>>> type(match)
<class '_sre.SRE_Match'>

Match对象的属性

属性　　　　　　　　说明

.string　　　　　　　 待匹配的文本

.re　　　　　　　　　匹配时使用的pattern对象（正则表达式）

.pos　　　　　　　　 正则表达式搜索文本的开始位置

.endpos　　　　　　  正则表达式搜索文本的结束位置

Match对象的方法

方法　　　　　　　　说明

.group(0)　　　　　　获得匹配后的字符串

.start()　　　　　　　 匹配字符串在原始字符串的开始位置

.end()　　　　　　　  匹配字符串在原始字符串的结束位置

.span()　　　　　　　返回(.start(),.end())

>>> m = re.search(r'[1-9]\d{5}','BIT100081 TSU100084')
>>> m.string
'BIT100081 TSU100084'
>>> m.re
re.compile('[1-9]\\d{5}')
>>> m.pos
0
>>> m.endpos
19
>>> m.group(0)
'100081'
>>> m.start()
3
>>> m.end()
9
>>> m.span()
(3, 9)

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

>>> match = re.search(r'PY.*N','PYANBNCNDN')　　#以PY字母开头，以N结尾，中间可以有若干个字符串的这样的字符串
>>> match.group()
'PYANBNCNDN'

同时匹配长短不同的多项，返回哪一个呢？

贪婪匹配

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

最小匹配

如何输出最短的子串呢？

>>> match = re.search(r'PY.*?N','PYANBNCNDN')

>>> match.group(0)
'PYAN'

最小匹配操作符

操作符　　　　　　　　　　说明

*？　　　　　　　　　　　  前一个字符0次或无限次扩展，最小匹配

+？　　　　　　　　　　　 前一个字符1次或无限次扩展，最小匹配

？？　　　　　　　　　　   前一个字符0次或1次扩展，最小匹配

{m,n}?　　　　　　　　　　扩展前一个字符m至n次（含n），最小匹配

总结：