Python爬虫学习笔记（三）：从XPath到正则表达式

Python爬虫学习笔记（三）：从XPath到正则表达式

一.XPath

XPath是在XML文档中查找信息的一门语言，是很多高级XML应用的基础

XPath在XML中通过元素和属性，使用路径表达式在 XML 文档中进行导航

节点

在XPath中，XML 文档被视作节点树，节点树的根节点也被称作文档节点

节点（Node）分为七类：元素（Element），属性（Attribute），文本（Text），命名空间（Namespace），处理指令（Processing-instruction），注释（Comment），文档节点（Document nodes）

XPath的路径表达式是基于某个节点之上的，选取节点的表达式描述

nodeName	选取已匹配节点下名为 nodeName 的子元素节点
/	若以 / 开头，表示从根节点作为选取起点
//	在已匹配节点后代中选取节点，不考虑目标节点的位置
.	选取当前节点
…	选取当前节点的父元素节点
@	选取属性

节点间的关系

节点间关系：父（parent），子（children），兄弟（sibling），先辈（ancestor），后代（descendant）

父（Parent）：每个元素都肯定有一个父节点，最顶层的元素父节点是根节点，每个属性有一个父，它们的父是元素

子（Children）：元素可以有零或多个子

兄弟（Sibling）：父节点相同的节点之间互为同胞，也称兄弟节点

先辈（Ancestor）：某节点的父节点、父的父……一直追溯至根节点之间所有节点

后代（Descendant）：某节点的子节点、子的子……至最后一个子节点之间所有节点

轴和路径

轴：用于定义当对当前节点的节点集合

坐标轴名称	含义
ancestor	选取当前节点的所有先辈元素及根节点
ancestor-or-self	选取当前节点的所有先辈以及当前节点本身
attibute	选取当前节点的所有属性
child	选取当前节点的所有子元素
descendant	选取当前节点的所有后代元素
descendant-or-self	选取当前节点的所有后代元素以及当前节点本身
following	选取文档中当前节点的结束标签之后的所有节点
following-sibling	选取当前节点之后的所有同级节点
namespace	选取当前节点的所有命名空间节点
parent	选取当前节点的父节点
preceding	选取当前节点的开始标签之前的所有节点
preceding-sibling	选取当前节点之前的所有同级节点
self	选取当前节点

位置路径：绝对路径以 “/” 开头，每条路径包括一个或多个步，每步之间以“/”分隔

每步（step）根据当前节点集合中的节点计算：

轴（axis）： 定义所选节点与当前节点之间的关系
节点测试（node-test）：识别某个坐标轴内部的节点
预判（predicate）： 提出预判条件对节点集合进行筛选

步的语法：坐标轴::节点测试[预判]

路径	表示方法
绝对路径	/ # 根节点
相对路径	// # 从根节点开始递归下降
若干路径	# 节点之间的联合

XML文档中的信息查找

预判（Predicates）：查找某个特定的节点或符合某种条件的节点

预判表达式位于方括号中，使用 “|” 运算符选取符合“或”条件的若干路径

通配符

*	匹配任何元素
@*	匹配任何属性
node()	匹配任何类型的节点

在Python中，可用第三方库lxml来处理XML

使用：from lxml import etree

二.BeautifulSoup4

是HTML/XML的解析器，处理不规范标记并生成剖析树(parse tree)

BeautifulSoup将复杂HTML文档转换成一个复杂的树形结构,每个节点都是Python对象: Tag , NavigableString , BeautifulSoup, Comment

BeautifulSoup支持Python标准库中的HTML解析器，还支持上文提到的第三方的解析器lxml

BeautifulSoup对象表示的是一个文档的全部内容，可以把它当作 Tag 对象，支持 遍历文档树和搜索文档树中描述的大部分的方法

BeautifulSoup对象并不是真正的HTML或XML的tag，所以没有name和attribute属性，但BeautifulSoup对象包含了一个值为 “[document]” 的特殊属性 .name

具体操作在之后更深入学习

三.正则表达式（re 模块）

正则表达式（Regular Expression）：通常被用来检索、替换那些符合某个模式(规则)的文本

Python 的 re 模块提供 Perl 风格的正则表达式模式，使其拥有全部的正则表达式功能

Perl一种功能丰富的计算机程序语言，运行在超过100种计算机平台上，适用广泛，最初是为文本处理而开发的

Perl易于使用、高效、完整，同时支持过程和面向对象编程，对文本处理具有强大的内置支持

基础知识

修饰符

一些可选标志修饰符来控制匹配的模式，被指定为一个可选的标志，多个标志可以通过按位 OR(|) 来指定

修饰符	描述
re.I	忽略大小写
re.L	做本地化识别（locale-aware）匹配
re.M	多行模式，影响 ^ 和 $
re.S	为 . 并且包括换行符在内的任意字符（. 不包括换行符）
re.U	特殊字符集 \w, \W, \b, \B, \d, \D, \s, \S 依赖于 Unicode 字符属性数据库
re.X	通过更灵活的格式以便将正则表达式写得更易于理解，忽略空格和 # 后面的注释

模式

模式	描述
^	匹配字符串的开头
$	匹配字符串的末尾
.	匹配任意字符，除了换行符
[…]	用来表示一组字符,单独列出：[amk] 匹配 ‘a’，‘m’或’k’
[^…]	不在[]中的字符：[^abc] 匹配除了a,b,c之外的字符
re*	匹配0个或多个的表达式
re+	匹配1个或多个的表达式
re?	匹配0个或1个由前面的正则表达式定义的片段，非贪婪方式
re{ n}	精确匹配 n 个前面表达式
re{ n,}	匹配 n 个前面表达式
re{ n, m}	匹配 n 到 m 次由前面的正则表达式定义的片段，贪婪方式
a | b	匹配a或b
(re)	对正则表达式分组并记住匹配的文本
(?imx)	正则表达式包含三种可选标志：i, m, 或 x 。只影响括号中的区域
(?-imx)	正则表达式关闭 i, m, 或 x 可选标志。只影响括号中的区域
(?: re)	类似 (…), 但是不表示一个组
(?imx: re)	在括号中使用i, m, 或 x 可选标志
(?-imx: re)	在括号中不使用i, m, 或 x 可选标志
(?#…)	注释.
(?= re)	前向肯定界定符
(?! re)	前向否定界定符。与肯定界定符相反；当所含表达式不能在字符串当前位置匹配时成功
(?> re)	匹配的独立模式，省去回溯
\w	匹配字母数字及下划线
\W	匹配非字母数字及下划线
\s	匹配任意空白字符，等价于 [ \t\n\r\f]
\S	匹配任意非空字符
\d	匹配任意数字，等价于 [0-9]
\D	匹配任意非数字
\A	匹配字符串开始
\Z	匹配字符串结束，如果存在换行，只匹配到换行前的结束字符串
\z	匹配字符串结束
\G	匹配最后匹配完成的位置
\b	匹配一个单词边界，也就是指单词和空格间的位置
\B	匹配非单词边界
\n, \t…	匹配一个换行符，匹配一个制表符等
\1…\9	匹配第n个分组的内容。
\10	匹配第n个分组的内容，如果它经匹配。否则指的是八进制字符码的表达式

实例

字符类

实例	描述
[Pp]ython	匹配 “Python” 或 “python”
rub[ye]	匹配 “ruby” 或 “rube”
[aeiou]	匹配中括号内的任意一个字母
[0-9]	匹配任何数字，类似于 [0123456789]
[a-z]	匹配任何小写字母
[A-Z]	匹配任何大写字母
[a-zA-Z0-9]	匹配任何字母及数字
[^aeiou]	除了aeiou字母以外的所有字符
[^0-9]	匹配除了数字外的字符

特殊字符类

实例	描述
.	匹配除 “\n” 之外的任何单个字符。要匹配包括 ‘\n’ 在内的任何字符使用 ‘[.\n]’
\d	匹配一个数字字符。等价于 [0-9]
\D	匹配一个非数字字符。等价于 [^0-9]
\s	匹配任何空白字符，包括空格、制表符、换页符等等。等价于 [ \f\n\r\t\v]
\S	匹配任何非空白字符。等价于 [^ \f\n\r\t\v]
\w	匹配包括下划线的任何单词字符。等价于’[A-Za-z0-9_]’
\W	匹配任何非单词字符。等价于 ‘[^A-Za-z0-9_]’

相关函数

re.match

re.match

从字符串的起始位置匹配一个模式(pattern)，如果不是起始位置，就返回none

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

pattern:匹配的正则表达式
string:要匹配的字符串
flags:标志位，控制正则表达式的匹配方式(是否区分大小写，多行匹配等)

匹配成功re.match方法返回一个匹配的对象，否则返回None

使用group(num) 或 groups() 匹配对象函数来获取匹配表达式

group(num=0) 匹配的整个表达式的字符串，group() 可以一次输入多个组号，将返回一个包含那些组所对应值的元组

groups() 返回一个包含所有小组字符串的元组，从 1 到所含的小组号

import re

line = "YOU Chan Will YOUChanWill"
matchObj = re.match( r'(.*) Chan (.*?) .*', line, re.M|re.I)
 
if matchObj:
   print("matchObj.group() : ", matchObj.group())
   print("matchObj.group(1) : ", matchObj.group(1))
   print("matchObj.group(2) : ", matchObj.group(2))
else:
   print ("No match!!")

matchObj.group() :  YOU Chan Will YOUChanWill
matchObj.group(1) :  YOU
matchObj.group(2) :  Will

re.search

扫描整个字符串并返回第一个成功的匹配

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

pattern：匹配的正则表达式
string：要匹配的字符串
flags：标志位

匹配成功re.search方法返回一个匹配的对象，否则返回None

使用group(num) 或 groups() 匹配对象函数来获取匹配表达式

group(num=0) 匹配的整个表达式的字符串，group() 可以一次输入多个组号，将返回一个包含那些组所对应值的元组

groups() 返回一个包含所有小组字符串的元组，从 1 到所含的小组号

import re

line = "YOU Chan Will YOUChanWill"
matchObj = re.search( r'(.*) Chan (.*?) .*', line, re.M|re.I)
 
if matchObj:
   print("matchObj.group() : ", matchObj.group())
   print("matchObj.group(1) : ", matchObj.group(1))
   print("matchObj.group(2) : ", matchObj.group(2))
else:
   print ("No match!!")

matchObj.group() :  YOU Chan Will YOUChanWill
matchObj.group(1) :  YOU
matchObj.group(2) :  Will

re.match匹配字符串的开始，如果字符串开始不符合正则表达式，则匹配失败，函数返回None

re.search匹配整个字符串，直到找到一个匹配

检索和替换

re.sub

替换字符串中的匹配项

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

pattern : 正则中的模式字符串
repl : 替换的字符串，也可为一个函数
string : 要被查找替换的原始字符串
count : 模式匹配后替换的最大次数，默认 0 表示替换所有的匹配

import re
 
number = "2000-10-16 # 数字"
 
num = re.sub(r'#.*$', "", number) # 删除字符串中的 Python注释 
print("数字: ", num)
 
num = re.sub(r'\D', "", number) # 删除非数字(-)的字符串 
print("数字: ", num)

数字:  2000-10-16 
数字:  20001016

repl 可为一个函数

import re
def double(matched):# 该函数将匹配的数字乘以 2
    value = int(matched.group('value'))
    return str(value * 2) 
 
s = 'YOU001016'
print(re.sub('(?P<value>\d+)', double, s))

YOU2032

re.compile 
用于编译正则表达式，生成一个正则表达式（ Pattern ）对象，供match() 和 search()使用

re.compile(pattern[, flags])

pattern：匹配的正则表达式
flags：标志位

re.I 忽略大小写
re.L 表示特殊字符集 \w, \W, \b, \B, \s, \S 依赖于当前环境
re.M 多行模式
re.S 即为 . 并且包括换行符在内的任意字符（. 不包括换行符）
re.U 表示特殊字符集 \w, \W, \b, \B, \d, \D, \s, \S 依赖于 Unicode 字符属性数据库
re.X 为了增加可读性，忽略空格和 # 后面的注释

import re
pattern = re.compile(r'\d+')  # 用于匹配至少一个数字
m = pattern.match('one12twothree34four')   # 查找头部
print m
None

group([group1, …]):用于获得一个或多个分组匹配的字符串，当要获得整个匹配的子串时，可直接使用 group() 或 group(0)

start([group]):获取分组匹配的子串在整个字符串中的起始位置（子串第一个字符的索引），参数默认值为 0

end([group]):用于获取分组匹配的子串在整个字符串中的结束位置（子串最后一个字符的索引+1），参数默认值为 0

span([group]):返回 (start(group), end(group))

findall

在字符串中找到正则表达式所匹配的所有子串，并返回一个列表，如果没有找到匹配的，则返回空列表

findall(string[, pos[, endpos]])

string : 待匹配的字符串
pos : 可选参数，指定字符串的起始位置，默认为 0
endpos : 可选参数，指定字符串的结束位置，默认为字符串的长度

match 和 search 是匹配一次 findall 匹配所有

import re

pattern = re.compile(r'\d+')   # 查找数字
result1 = pattern.findall('you 123 chan 456 will')
result2 = pattern.findall('you123chan456will789', 0, 10)
 
print(result1)
print(result2)

['123', '456']
['123']

re.finditer

在字符串中找到正则表达式所匹配的所有子串，并把它们作为一个迭代器返回

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

pattern：匹配的正则表达式
string：要匹配的字符串
flags：标志位

import re
 
it = re.finditer(r"\d+","you123chan456will789") 
for match in it: 
    print (match.group() )

123
456
789

re.split

按照能够匹配的子串将字符串分割后返回列表

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

pattern：匹配的正则表达式
string：要匹配的字符串
maxsplit：分隔次数，maxsplit=1 分隔一次，默认为 0，不限制次数
flags：标志位

对于一个找不到匹配的字符串而言，split 不会对其作出分割

对象

re.RegexObject
re.compile() 返回 RegexObject 对象。

re.MatchObject
group() 返回被 正则表达式（RE ）匹配的字符串
start() 返回匹配开始的位置
end() 返回匹配结束的位置
span() 返回一个元组包含匹配 (开始,结束) 的位置