Python爬虫与信息提取（六）Re正则表达式

1.正则表达式

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

-正则表达式的优势：使用特征来表达字符串，非常简洁

-正则表达式可以用来判断某字符串的特征归属，在文本处理中十分常用，主要应用在字符串的匹配中

2.正则表达式的使用

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

import re
regex = 'P(Y|YT|YTH|YTHO)?N'
p = re.compile(regex)

3.正则表达式的语法

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

'P(Y|YT|YTH|YTHO)?N'
代表：'PN'、'PYN'、'PYTN'、'PYTHN'、'PYTHON'
'PYTHON+'
代表：'PYTHON'、'PYTHONN'、''PYTHONNN...
'PY[TH]ON'
代表：'PYTON'、'PYHON'

4.Re库的基本使用

-正则表达式的表示类型：raw string类型（原生字符串类型）

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

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

raw string是不包含对转义字符再次转义的字符串

-re库也可以采用string类型表示正则表达式，但是更加繁琐：' [1 - 9]\\d{5} '

建议当正则表达式包含转义符时，使用raw string

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

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

>>>100010

import re

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

match = re.match(r'[1-9]\d{5}', 'BIT 100010')
if match:
    print(match.group(0))
上面的是没有结果的，因为match是从字符串开头进行匹配，因此匹配不到100010

import re
match = re.match(r'[1-9]\d{5}', '100010 BIT')
if match:
    print(match.group(0))
这种就可以正常匹配到
>>>100010

import re

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

import re
ls = re.findall(r'[1-9]\d{5}', 'str1 100010 str2 100011')
print(ls)
>>>['100010', '100011']

import re

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

import re
ls = re.split(r'[1-9]\d{5}', 'str1 100010 str2 100013')
print(ls)
>>>['str1 ', ' str2 ', '']

import re
ls = re.split(r'[1-9]\d{5}', 'str1 100010 str2 100013', maxsplit=1)
print(ls)
>>>['str1 ', ' str2 100013']

import re

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

import re
for i in re.finditer(r'[1-9]\d{5}', 'str1 100010 str2 100013'):
    if i :
        print(i.group(0))
>>>100010
>>>100013

import re

re.sub(pattern, repl, string, count, flags=0)
搜索字符串，返回一个匹配结果的迭代类型，每个迭代类型是match对象
pattern:    正则表达式的字符串或者原生字符串表示
repl:       替换匹配字符串的字符串
string:     待匹配字符串
count:      匹配的最大替换次数
flags:      正则表达式使用时的控制标记

import re
a = re.sub(r'[1-9]\d{5}', '数字', 'str1 100010 str2 100013')
print(a)
>>>str1 数字 str2 数字

5.Re库的一种等价用法

函数式用法：

a = re.search(r'[1-9]\d{5}', 'str1 100010')

面向对象用法：

a = re.compile(r'[1-9]\d{5}')
b = a.search('str1 100010')

re.compile

import re
a = re.compile(pattern, flags=0)
将正则表达式的字符串形式编译成正则表达式的对象
pattern:    正则表达式的字符串或原生字符串
falgs:      正则表达式使用时的控制标记

经过compile之后的结果使用的方法和上面的6种相同

6.Re库match对象

match对象是一次匹配的结果，包含了匹配的信息

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

match对象的属性：

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

match对象的方法：

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

实例：

import re
match = re.search(r'[1-9]\d{5}', 'str1 100010 str2 100013')
print(match.string)
>>>str1 100010 str2 100013
print(match.re)
>>>re.compile('[1-9]\\d{5}')
print(match.pos)
>>>0
print(match.endpos)
>>>23

print(match.group(0))
>>>100010
print(match.start())
>>>5
print(match.end())
>>>11
print(match.span())
>>>(5, 11)

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

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

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

（2）最小匹配：输出匹配到的最短的子串

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

只要长度输出可能不同的，都可以通过操作符后增加 ? 变成最小匹配