正则表达式和 Re库

正则表达式

正则表达式(regular expression regex RE)

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

通用的字符串表达框架
简洁表达一组字符串的表达式
针对字符串表达“简洁”和“特征”思想的工具
判断某字符串的特征归属

作用:

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

使用正则表达式：

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

ps: 因为hexo的markdown解析器的bug解析不了html中的'*'之前直接用表格但是又会出现'|'解析不了的情况,html转义字符又没有这个,只能这样了。

真是垃圾解析器。我改了2天,换了解析器都不行。。

正则表达式语法实例

经典正则表达式实例

Re库

raw string类型(原生字符串类型)

表示为r'text'

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

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

raw string 是不包含转义符的字符串
string类型,更繁琐

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

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

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: 正则表达式使用时的控制标记

常用标记说明

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

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

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

常用标记	说明
re.I re.IGNORECASE	忽略正则表达式的大小写,[A-Z]能够匹配小写字符
re.M re.MULTILINE	正则表达式中的^操作符能够将给定字符串的每行当作匹配开始
re.S re.DOTALL	正则表达式中的.操作符能够匹配所有字符,默认匹配除换行符外的所有字符

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

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

在一个字符串的开始位置起匹配正则表达式,返回match对象.
- pattern: 正则表达式的字符串或原生字符串表示
- string: 待匹配字符串
- flags: 正则表达式使用时的控制标记

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

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

搜索字符串,以列表类型返回全部能匹配的字符串.
- pattern: 正则表达式的字符串或原生字符串表示
- string: 待匹配字符串
- flags: 正则表达式使用时的控制标记

>>> import re
>>> ls = re.findall(r'[1-9]\d{5}','SZU518060 CZ239000')
>>> ls
['518060', '239000']

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

将一根字符串按照正则表达式匹配结果进行分割,返回列表类型.
- pattern: 正则表达式的字符串或原生字符串表示
- string: 待匹配字符串
- maxsplit: 最大分割数,剩余部分作为最后一个元素输出
- flags: 正则表达式使用时的控制标记

>>> import re
>>> re.split(r'[1-9]\d{5}','SZU518060 CZ239000')
['SZU', ' CZ', '']
>>> re.split(r'[1-9]\d{5}','SZU518060 CZ239000',maxsplit=1)
['SZU', ' CZ239000']

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

搜索字符串,返回一个匹配结果的迭代类型,每个迭代元素是match对象.
- pattern: 正则表达式的字符串或原生字符串表示
- string: 待匹配字符串
- flags: 正则表达式使用时的控制标记

>>> import re
>>> for m in re.finditer(r'[1-9]\d{5}','SZU518060 CZ239000'):
...     if m:
...             print(m.group(0))
... 
518060
239000

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

在一个字符串中替换所有匹配正则表达式的子串,返回替换后的字符串.
- pattern: 正则表达式的字符串或原生字符串表示
- repl: 替换匹配字符串的字符串
- string: 待匹配字符串
- count: 匹配的最大替换次数
- flags: 正则表达式使用时的控制标记

1
2
3

>>> import re
>>> re.sub(r'[1-9]\d{5}','zipcode','BIT100081 TSU100084')
'BITzipcode TSUzipcode'

Re库的另一种等价用法

# 函数式用法:一次性操作
rst = re.search(r'[1-9]\d{5}','SZ 518060')
# 面向对象用法:编译后多次操作
pat = re.compile(r'[1-9]\d{5}')
rst = pat.search('SZ 518060')

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

将正则表达式的字符串形式编译成正则表达式对象
- pattern: 正则表达式的字符串或原生字符串表示
- flags: 正则表达式使用时的控制标记

1
2
3

>>> regex = re.compile(r'[1-9]\d{5}')
# 这里regex才是正则表达式
# r'[1-9]\d{5}'这种只是表示字符串

等价的函数用法

函数	说明
regex.search()	在一个字符串中搜索匹配正则表达式的第一个位置,返回match对象
regex.match()	在一个字符串的开始位置起匹配正则表达式,返回match对象
regex.findall()	搜索字符串,以列表类型返回全部能匹配的字符串
regex.split()	将一个字符串按照正则表达式匹配结果进行分割,返回列表类型
regex.finditer()	搜索字符串,返回一个匹配结果的迭代类型,每个迭代元素是match对象
regex.sub()	在一个字符串中替换所有匹配正则表达式的子串,返回替换后的字符串

Match对象

>>> import re
>>> match = re.search(r'[1-9]\d{5}','BIT 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}','BIT 100081 SZU518060')
>>> m.string
'BIT 100081 SZU518060'
>>> m.re
re.compile('[1-9]\\d{5}')
>>> m.pos
0
>>> m.endpos
20
>>> m.group(0)
'100081'
>>> m.start()
4
>>> m.end()
10
>>> m.span()
(4, 10)

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

贪婪匹配

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

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

最小匹配

1
2
3

>>> match = re.search(r'PY.*?N','PYANBNCNDN') # 在*后面加？
>>> match.group(0)
'PYAN'

最小匹配操作符

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

爬虫学习笔记(四)