《精通Python网络爬虫》核心技术篇5（1）

第 5 章 正则表达式与 Cookie 的使用（1）

前言：有时我们在进行字符串处理的时候，希望按自定义的规则进行处理，我们将这些规则称为模式。我们可以用正则表达式来描述这些自定义规则，正则表达式也称为模式表达式。

• 什么是正则表达式
  
• 正则表达式基础知识
  
• 正则表达式常见函数
  
• 常见实例解析

5.1 什么是正则表达式

# 正则表达式就是描述字符串排列的一套规则。

# 利用正则表达式可以做很多事情，主要用于字符串的匹配。

# 学习正则表达式，对于后续学习爬虫做铺垫。

5.2 正则表达式基础知识

1. 原子

正则表达式中最基本的组成单位：原子

常见原子分类：① 普通字符作为原子② 非打印字符作为原子③ 通用字符作为原子④ 原子表

（1）普通字符作为原子

定义：一些普通的字符，比如数字、大小写字母、下划线等都可以用作原子使用。

实例：如下例使用“yue”作为原子使用，这里有三个原子，分别是“y”“u”“e”。

import re     #导入re模块
pattern='yue'
string="http://wangljyue.com"
result1=re.search(pattern, string)   #利用 re.search 查找匹配
print(result1) 
#<_sre.SRE_Match object; span=(13, 16), match='yue'> #span（n，m）中代表索引值，索引值从0开始；sapn范围[n,m-1]。
#[Finished in 0.2s]

（2）非打印字符作为原子

定义：一些在字符串中用于控制格式的符号。

实例：换行符 \n，制表符 \t。

import re
pattern='\n'
string='''http://wangljyue.com
http://baidu.com'''#这里包含一个换行符，注意单引号使用
print(string)
#http://wangljyue.com
#http://baidu.com
result1=re.search(pattern, string)
print(result1)
#<_sre.SRE_Match object; span=(20, 21), match='\n'>
#[Finished in 0.2s]

如果这样写，就将匹配不成功，返回 none。

import re
pattern='\n'
string='''http://wangljyue.comhttp://baidu.com'''
result1=re.search(pattern, string)
print(result1)

（3）通用字符作为原子

定义：一个原子可以匹配一类字符。

常用通用字符及其含义

符号	含义
\w	匹配任意一个字母、数字或者下划线
\W	匹配除字母、数字或者下划线以外的任意一个字符
\d	匹配任意一个十进制数
\D	匹配除十进制以外的任意一个其他字符
\s	匹配任意一个空白字符
\S	匹配除空白字符以外的任意一个其他字符

实例：使用“\w\dpython\w”对“python”字符进行匹配。

如“67python8”、“u2python”均可以匹配成功。

import re
pattern='\w\dpython\w'
string="abcsddwljdsa520pythonw_lj"
result1=re.search(pattern, string)
print(result1)
#<_sre.SRE_Match object; span=(13, 22), match='20pythonw'>
#[Finished in 0.2s]

（4）原子表

定义：可以定义一组地位平等的原子，然后匹配的时候会取该原子表中的任意一个原子进行匹配。原子表由 [] 表示。

实例：[xyz]可以表示一个原子表，其中定义了3个原子，这3个原子地位平等。

import re
pattern1='\w\dpython[xyz]\w'
pattern2='\w\dpython[^xyz]\w'
pattern3='\w\dpython[xyz]\W'#\W非字母数字下划线
string="abcsddwljdsa520pythonw_lj"
result1=re.search(pattern1, string)
result2=re.search(pattern2, string)
result3=re.search(pattern3, string)
print(result1)
print(result2)
print(result3)
#None
#<_sre.SRE_Match object; span=(13, 23), match='20pythonw_'>
#None
#[Finished in 0.2s]

2. 元字符

定义：正则表达式中具有一些特殊含义的字符，比如重复 N 次前面的字符等。

常见的元字符及其含义

符号	含义
.	匹配除换行符以外的任意字符
^	匹配字符串的开始位置
$	匹配字符串的结束位置
*	匹配0次、1次或多次前面的原子
?	匹配0次或1次前面的原子
+	匹配1次或多次前面的原子
{n}	前面的原子恰好出现 n 次
{n,}	前面的原子至少出现 n 次
{n,m}	前面的原子至少出现 n 次，至多出现 m次
|	模式选择符
()	模式单元符
其他	其他

（1）任意匹配元字符

使用“.”匹配一个除换行符以外的任意字符。

实例：“.python...”匹配“5python20w”。

import re
pattern='.python...'
string="dshajds5python20wdsad"
result1=re.search(pattern, string)
print(result1)
#<_sre.SRE_Match object; span=(7, 17), match='5python20w'>
#[Finished in 0.2s]

（2）边界限制元字符

使用“^”“$”匹配字符串开始与结束。

实例：

import re
pattern1='^abd' #以abd开头
pattern2='^abc' #以abc开头
pattern3='py$'  #以py结尾
pattern4='ay$'  #以ay结尾
string="abcdsajkphp345pythony_py"
result1=re.search(pattern1, string)
result2=re.search(pattern2, string)
result3=re.search(pattern3, string)
result4=re.search(pattern4, string)
print(result1)
print(result2)
print(result3)
print(result4)
#None
#<_sre.SRE_Match object; span=(0, 3), match='abc'>
#<_sre.SRE_Match object; span=(22, 24), match='py'>
#None
#[Finished in 0.2s]

（3）限定符

常用限定符包括 *、？、+、{n}、{n,}、{n,m}。

实例：

import re
pattern1='py.*n' 
pattern2='cd{2}' #两个d
pattern3='cd{3}'  #三个d
pattern4='cd{2,}'  #至少两个d
string="abcdddfphp345pythony_py"
result1=re.search(pattern1, string)
result2=re.search(pattern2, string)
result3=re.search(pattern3, string)
result4=re.search(pattern4, string)
print(result1)
print(result2)
print(result3)
print(result4)
#<_sre.SRE_Match object; span=(13, 19), match='python'>
#<_sre.SRE_Match object; span=(2, 5), match='cdd'>
#<_sre.SRE_Match object; span=(2, 6), match='cddd'>
#<_sre.SRE_Match object; span=(2, 6), match='cddd'>
#[Finished in 0.2s]

（4）模式选择符

模式选择符“|”可以设置多个模式，匹配时可以从中选择任意一个模式匹配。

实例：“python|php”可匹配“python”和“php”

import re
pattern='python|php' 
string="abcdfphp345python_py"
result1=re.search(pattern, string)
print(result1)
#<_sre.SRE_Match object; span=(5, 8), match='php'>
#[Finished in 0.2s]

（5）模式单元符

使用“()”将一些原子组合成一个大原子使用，小括号括起来的部分会被当作一个整体去使用。

import re
pattern1='(cd){1,}' #cd整合出现至少一次
pattern2="cd{1,}"   #c一次，d至少一次
string="abcdcdcdcdcdcdfphp345python_py"
result1=re.search(pattern1, string)
result2=re.search(pattern2, string)
print(result1)
print(result2)
#<_sre.SRE_Match object; span=(2, 14), match='cdcdcdcdcdcd'>
#<_sre.SRE_Match object; span=(2, 4), match='cd'>
#[Finished in 0.2s]

3. 模式修正

定义：在不改变正则表达式的情况下，通过模式修正符来改变正则表达式的含义，从而实现一些匹配结果的调整等功能。

常见的模式修正符及其含义

符号	含义
I	匹配时忽略大小写
M	多行匹配
L	做本地化识别匹配
U	根据 Unicode 字符及解析匹配
S	让. 匹配包括行匹配

import re
pattern1='python' 
pattern2="python"   
string="abcdcdcdcdcdcdfphp345Python_py"
result1=re.search(pattern1, string)
result2=re.search(pattern2, string,re.I) #修正匹配，忽略大小写
print(result1)
print(result2)
#None
#<_sre.SRE_Match object; span=(21, 27), match='Python'>
#[Finished in 0.2s]

4. 贪婪模式与懒惰模式

贪婪模式：尽可能多地匹配

懒惰模式：尽可能少地匹配

import re
pattern1='p.*y'  #贪婪#可以这样理解：找不到结尾字符y才停止
pattern2="p.*?y"   #懒惰#可以这样理解，找到第一个结尾字符y就停止
string="abfphp345python_py"
result1=re.search(pattern1, string)  
result2=re.search(pattern2, string)
print(result1)
print(result2)
#<_sre.SRE_Match object; span=(3, 18), match='php345python_py'>
#<_sre.SRE_Match object; span=(3, 11), match='php345py'>
#[Finished in 0.2s]

5.3 正则表达式常见函数

1. re.match() 函数

从源字符串的起始位置开始匹配一个模式。

re.match(pattern,string,flag)

pattern: 正则表达式

string: 对应的源字符

flag: 可供参数，代表对应的标志位，可以放模式修正符等信息

实例：

import re
string = "apythonhellomypythonhispythonourpythonend"
pattern=".python."
result1=re.match(pattern,string)
result2=re.match(pattern,string).span() #设置过滤信息，只留下匹配成功的结果在源字符串中的位置
print(result1)
print(result2)
#<_sre.SRE_Match object; span=(0, 8), match='apythonh'>
#(0, 8)

2. re.search() 函数

re.search()	会扫描整个字符串并进行对应的匹配
re.match()	从源字符串的开头进行匹配

实例：

import re
string = "ahdhapythonhellomypythonhispythonourpythonend"
pattern=".python."
result1=re.match(pattern,string)  #匹配不到结果
result2=re.search(pattern,string)
print(result1)
print(result2)
#None
#<_sre.SRE_Match object; span=(4, 12), match='apythonh'>

3. 全局匹配函数

如何将符合模式的全部内容全部都匹配出来？

1）使用 re.compile() 对正则表达式进行编译；

2）编译后，使用 findall() 根据正则表达式从源字符串中将匹配的结果全部找出。

实例：

import re
string = "ahdhapythonhellomypythonhispythonourpythonend"
pattern=re.compile(".python.") #预编译
result1=pattern.findall(string)
print(result1) #['apythonh', 'ypythonh', 'spythono', 'rpythone']

整合：

import re
string = "ahdhapythonhellomypythonhispythonourpythonend"
pattern=".python."
result1=re.compile(pattern).findall(string)
print(result1)
#['apythonh', 'ypythonh', 'spythono', 'rpythone']

4. re.sub() 函数

功能：替换某些字符串

re.sub(pattern, rep,string,max)

pattern: 对应的正则表达式

rep: 要替换的字符串

string: 源字符串

max: 可选项，代表最多替换的次数，如果忽略不写，则会将符合模式的结果全部替换

import re
string = "ahdhapythonhellomypythonhispythonourpythonend"
pattern="python"
result1=re.sub(pattern,"php",string)  #全部替换
result2=re.sub(pattern,"php",string,2)  #只替换两个
print(result1)
print(result2)
#ahdhaphphellomyphphisphpourphpend
#ahdhaphphellomyphphispythonourpythonend

5.4 常见实例解析

实例一：匹配 .com 或 .cn 后缀的 URL 网址

import re
pattern = "[a-zA-Z]+://[^\s]*[.com|.cn]"
string="百度首页"
result=re.search(pattern,string)
print(result)
#<_sre.SRE_Match object; span=(9, 29), match='http://www.baidu.com'>

1）"://"是固定的，可以写出来；

2）"[.com|.cn]" 说明结尾要求；

3）在 "://" 和 "[.com|.cn]" 之间，不能有空格，所以我们写 "[^\s]"；

4）在 "://" 前，必须要有内容，所以此时至少要有一次重复，我们用"+"不用"*"；

5）任意字母大小写 "[a-zA-Z]"。

实例二：匹配电话号码

import re
pattern = "\d{4}-\d{7}|\d{3}-\d{8}"# 区位号
string="021-6728263653682382265236"
ressult=re.search(pattern,string)
print(ressult)
#<_sre.SRE_Match object; span=(0, 12), match='021-67282636'>

实例三：匹配电子邮件地址

import re
pattern = "\w+([.+-]\w+)*@\w+([.-]\w+)*\.\w+([.-]\w+)*" #匹配电子邮件的正则表达式，注意@周围的字符
string="百度首页
电子邮件地址"
ressult=re.search(pattern,string)
print(ressult)
#<_sre.SRE_Match object; span=(59, 81), match='[email protected]'>