Python 正则表达式

re 常用操作符

.         表示任何单个字符
[ ]         字符集，对单个字符给出取值范围[abc]表示a、b、c，[a‐z]表示a到z单个字符
[^ ]         非字符集，对单个字符给出排除范围[^abc]表示非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]           匹配中文字符
\d{3}‐\d{8}|\d{4}‐\d{7}    国内电话号码，010‐68913536

匹配ip地址的正则表达式

IP地址字符串形式的正则表达式（IP地址分4段，每段0‐255）

\d+.\d+.\d+.\d+ 或\d{1,3}.\d{1,3}.\d{1,3}.\d{1,3}

精确写法      0‐99： [1‐9]?\d
            100‐199: 1\d{2}
            200‐249: 2[0‐4]\d
            250‐255: 25[0‐5]
(([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 库的使用

正则表达式的表示类型

raw string类型（原生字符串类型）
re库采用raw string类型表示正则表达式，表示为：
            r'text'
例如：   r'[1‐9]\d{5}'
        r'\d{3}‐\d{8}|\d{4}‐\d{7}'
raw string 是不包含对转义符再次转义的字符串


re库也可以采用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对象
re.sub()     在一个字符串中替换所有匹配正则表达式的子串，返回替换后的字符串

re.search(pattern, string, flags=0)
    在一个字符串中搜索匹配正则表达式的第一个位置返回match对象
∙ pattern : 正则表达式的字符串或原生字符串表示
∙ string : 待匹配字符串
∙ flags : 正则表达式使用时的控制标记

∙ flags : 正则表达式使用时的控制标记
re.I re.IGNORECASE 忽略正则表达式的大小写，[A‐Z]能够匹配小写字符
re.M re.MULTILINE 正则表达式中的^操作符能够将给定字符串的每行当作匹配开始
re.S re.DOTALL 正则表达式中的.操作符能够匹配所有字符，默认匹配除换行外的所有字符

练习

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

>>> import re
>>> match = re.search(r'[1-9]\d{5}','NEAU 150036')
>>> print(match)
<_sre.SRE_Match object; span=(5, 11), match='150036'>
>>> print(match.group(0))
150036

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

>>> import re
>>> match = re.match(r'[1-9]\d{5}','NEAU 150036')
>>> 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}','150036 NEAU')
>>> print(match.group(0))
150036
# 从开始位置匹配，开始没有匹配到就不匹配了

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

>>> import re
>>> ls = re.findall(r'[1-9]\d{5}','NEAU 150036 600')
>>> ls
['150036']
>>> ls = re.findall(r'[1-9]\d{5}','NEAU 150036 408200')
>>> ls
['150036', '408200']

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

maxsplit: 最大分割数，剩余部分作为最后一个元素输出
>>> import re
>>> re.split(r'[1-9]\d{5}','NEAU150036 CQFD408200',maxsplit=1)
['NEAU', ' CQFD408200']

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

>>> import re
>>> item = re.finditer(r'[1-9]\d{5}','NEAU150036 CQFD408200')
>>> for i in item:print (i.group(0))
...
150036
408200

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

在一个字符串中替换所有匹配正则表达式的子串
返回替换后的字符串

∙ pattern : 正则表达式的字符串或原生字符串表示
∙ repl : 替换匹配字符串的字符串
∙ string : 待匹配字符串
∙ count : 匹配的最大替换次数
∙ flags : 正则表达式使用时的控制标记


>>> import re
>>> re.sub(r'[1-9]\d{5}',':zipecode','NEAU150036 CQFD408200')
'NEAU:zipecode CQFD:zipecode'

re 的另一种用法

>>> rst = re.search(r'[1‐9]\d{5}', 'BIT 100081')
    函数式用法：一次性操作
>>> pat = re.compile(r'[1‐9]\d{5}')
>>> rst = pat.search('BIT 100081')
    面向对象用法：编译后的多次操作


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

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

∙ pattern : 正则表达式的字符串或原生字符串表示
∙ flags : 正则表达式使用时的控制标记
>>> regex = re.compile(r'[1‐9]\d{5}')

Re 库的match 对象

Match 对象的属性

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

>>> macth = re.search(r'[1-9]\d{5}','NEAU 150036')
>>> macth
<_sre.SRE_Match object; span=(5, 11), match='150036'>
>>> print(macth.group(0))
150036
>>> print(macth.re)
re.compile('[1-9]\\d{5}')
>>> print(macth.string)
NEAU 150036
>>> print(macth.pos)
0
>>> print(macth.endpos)
11

Match 对象的方法

.group(0)     获得匹配后的字符串
.start()     匹配字符串在原始字符串的开始位置
.end()       匹配字符串在原始字符串的结束位置
.span()      返回(.start(), .end())

>>> macth.start()
5
>>> macth.end()
11
>>> macth.span()
(5, 11)

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

贪婪匹配

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

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

最小匹配

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



操作符        说明
*?         前一个字符0次或无限次扩展，最小匹配
+?         前一个字符1次或无限次扩展，最小匹配
??         前一个字符0次或1次扩展，最小匹配
{m,n}?     扩展前一个字符m至n次（含n），最小匹配

匹配最小的可能次数


>>> m = re.search(r'PYA??N','PYANBNCNDN')
>>> m.group(0)
'PYAN'

>>> m = re.search(r'PY[A-Z]+?N','PYANBNCNDN')
>>> m.group(0)
'PYAN'

>>> m = re.search(r'PY[A-Z]*?','PYANBNCNDN')
>>> m.group(0)
'PY'

>>> m = re.search(r'PY[A-Z]{2,5}?','PYANBNCNDN')
>>> m.group(0)
'PYAN'