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
\|	左右表达式任选一个
{m}	扩展前一个字符m次	ab{2}c表示abbc
{m, n}	扩展前一个字符m至n次（含n）	ab{1,2}c表示abc、abbc
^	匹配字符串开头	^abc表示abc且在一个字符串的开头
$	匹配字符串结尾	abc$表示abc且在一个字符串的结尾
()	分组标记，内部只能使用\|操作符
\d	数字，等价于[0-9]
\w	单词字符，等价于[A-Za-z0-9_]

import re

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

正则表达式的表示类型

raw string类型（原生字符串类型），re库采用此类型，表示为 r’text’ 。raw string是不包含对转义符再次转义的字符串【原生字符串中间的\不被解释为转义字符】。例如
1
r'[1‐9]\d{5}'

也可以采用string类型表示正则表达式，但更繁琐。例如
1
'[1‐9]\\d{5}'

建议使用raw string类型

Re库主要功能函数	说明
re.search()	在一个字符串中搜索匹配正则表达式的第一个位置，返回match对象
re.match()	从一个字符串的开始位置起匹配正则表达式，返回match对象
re.findall()	搜索字符串，以列表类型返回全部能匹配的子串
re.split()	将一个字符串按照正则表达式匹配结果进行分割，返回列表类型
re.finditer()	搜索字符串，返回一个结果的迭代类型，每个迭代元素是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	正则表达式中的.操作符能够匹配所有字符，默认匹配除换行外的所有字符

用if判断匹配结果是否为空，否则会报错

import re

# re.search(pattern, string, flags=0)
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:
    print("--")
    print(match.group(0))  # 没有进到if
    print("--")
match = re.match(r'[1-9]\d{5}', '100081 BIT')
if match:
    print(match.group(0))

# re.findall(pattern, string, flags = 0)
ls = re.findall(r'[1-9]\d{5}', 'BIT100081 TSU100084')
print(ls)

# re.split(pattern, string, maxsplit=0, flag=0)
# maxsplit: 最大分割数，剩余部分作为最后一个元素输出
ls = re.split(r'[1-9]\d{5}', 'BIT100081 TSU100084')
print(ls)
ls = re.split(r'[1-9]\d{5}', 'BIT100081 TSU100084', maxsplit = 1)
print(ls)

# re.finditer(pattern, string, flags=0)
for m in re.finditer(r'[1-9]\d{5}', 'BIT100081 TSU100084'):
    if m:
        print(m.group(0))

# re.sub(pattern, repl, string, count=0, flags=0)
# repl: 替换匹配字符串的字符串
# string: 带匹配字符串
# count: 匹配的最大替换次数
str = re.sub(r'[1-9]\d{5}', ':zipcode', 'BIT100081 TSU100084')
print(str)

Re库的两种使用方式：

函数式用法：一次性操作

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

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

regex = re.compile(r'[1-9]\d{5}') #将正则表达式的字符串形式编译成正则表达式对象
rst = regex.search('BIT 100081')
'''
等价写法：

regex.search()
regex.match()
regex.findall()
regex.split()
regex.finditer()
regex.sub()

'''

Match对象是一次匹配的结果，包含匹配的很多信息

import re

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

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

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

import re

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

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

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

最小匹配字符串的操作符
*?
+?
??
{m, n}?

Python网络爬虫--正则表达式

谢谢大爷~