python爬虫(5)

对于网页的节点来说,它可以定义id、class或其他属性,而且节点之间还有层次关系,在网页中可以通过XPath或CSS选择器来定位一个或多个节点。那么,在页面解析时,利用XPath或CSS选择器来提取某个节点,然后再调用相应方法获取它的正文内容或者属性,就可以提取我们想要的任意信息。在Python中,lxml、Beautiful Soup、pyquery等解析库能帮助我们完成上述操作。

使用XPath

XPath,全程XML Path Language,即XML路径语言,它是一门在XML文档中查找信息的语言。它最初是用来搜寻XML文档的,但是它同样适用于HTML文档的搜索。

XPath概览

XPath的选择功能十分强大,它提供了非常简洁明了的路径选择表达式。另外,它还提供了超过100个内建函数,用于字符串、数值、时间的匹配以及节点、序列的处理等。XPath于1999年11月16日成为W3C标准,它被设计为供XSLT、XPointer以及其他XML解析软件使用,更多的文档可以访问其官方网站:https://www.w3.org/TR/xpath/

XPath常用规则

下表列举了XPath的几个常用规则。

表达式 描述
nodename 选取此节点的所有子节点
/ 从当前节点选取直接子节点
// 从当前节点选取子孙节点
. 选取当前节点
.. 选取当前节点的父节点
@ 选取属性

这里列出了XPath的常用匹配规则,示例如下:

//title[@lang=’eng’]

这就是一个XPath规则,它代表选择所有名称为title,同时属性lang的值为eng的节点。

示例代码:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
from lxml import etree
text = '''
<div>
<ul>
<li class="item-0"><a href="link1.html">first item</a></li>
<li class="item-1"><a href="link2.html">second item</a></li>
<li class="item-inactive"><a href="link3.html">third item</a></li>
<li class="item-1"><a href="link4.html">fourth item</a></li>
<li class="item-0"><a href="link5.html">fifth item</a>
</ul>
</div>
'''
html = etree.HTML(text)
result = etree.tostring(html)
print(result.decode('utf-8'))

运行结果:

1
2
3
4
5
6
7
8
9
10
<html><body><div>
<ul>
<li class="item-0"><a href="link1.html">first item</a></li>
<li class="item-1"><a href="link2.html">second item</a></li>
<li class="item-inactive"><a href="link3.html">third item</a></li>
<li class="item-1"><a href="link4.html">fourth item</a></li>
<li class="item-0"><a href="link5.html">fifth item</a>
</li></ul>
</div>
</body></html>

这里首先导入lxml库的etree模块,然后声明了一段HTML文本,调用HTML类进行初始化,这样就成功构造了一个XPath解析对象。需要注意的是,HTML文本中的最后一个li节点是没有闭合的,但是etree模块可以自动修正HTML文本。然后调用tostring()方法即可输出修正后的HTML代码,但是结果是bytes类型。这里利用decode()方法将其转成str类型。
另外,也可以直接读取文本进行解析。例如:

html = etree.parse(‘./test.html’, etree.HTMLParser())

选取所有节点

一般会用//开头的XPath规则来选取所有符合要求的节点。
以前面的HTML文本为例,如果要选取所有节点,可以这样实现:

1
2
3
4
from lxml import etree
html = etree.parse('./test.html', etree.HTMLParser())
result = html.xpath('//*')
print(result)

运行结果:

1
[<Element html at 0x10510d9c8>, <Element body at 0x10510da08>, <Element div at 0x10510da48>, <Element ul at 0x10510da88>, <Element li at 0x10510dac8>, <Element a at 0x10510db48>, <Element li at 0x10510db88>, <Element a at 0x10510dbc8>, <Element li at 0x10510dc08>, <Element a at 0x10510db08>, <Element li at 0x10510dc48>, <Element a at 0x10510dc88>, <Element li at 0x10510dcc8>, <Element a at 0x10510dd08>]

这里使用*代表匹配所有节点,也就是整个HTML文本中的所有节点都会被获取。可以看到,返回形式是一个列表,每个元素是Element类型,其后跟了节点的名称,如html、body、div、ul、li、a等,所有节点都包含在列表中了。如果要取出其中一个对象,可以直接用中括号加索引,如[0]。

子节点

通过/或者//即可查找元素的子节点或子孙节点。假如现在想选择li节点的所有直接a子节点,可以这样实现:

1
2
3
4
5
from lxml import etree

html = etree.parse('./test.html', etree.HTMLParser())
result = html.xpath('//li/a')
print(result)

运行结果:

1
[<Element a at 0x106ee8688>, <Element a at 0x106ee86c8>, <Element a at 0x106ee8708>, <Element a at 0x106ee8748>, <Element a at 0x106ee8788>]

这里通过追加/a即选择了所有li节点的所有直接a子节点。因为//li用于选中所有li节点,/a用于选中li节点的所有直接子节点a,二者结合在一起即获取所有li节点的所有直接a子节点。此处的/用于选取直接子节点,如果要获取所有子孙节点,就可以使用//。

父节点

如果我们知道了子节点,可以用..来查找父节点。比如,现在首先选中href属性为link4.html的a节点,然后再获取其父节点,然后再获取其class属性,相关代码如下:

1
2
3
4
5
from lxml import etree

html = etree.parse('./test.html', etree.HTMLParser())
result = html.xpath('//a[@href="link4.html"]/../@class')
print(result)

运行结果:

1
['item-1']

同时,我们也可以通过parent::来获取父节点,代码如下:

1
2
3
4
5
from lxml import etree

html = etree.parse('./test.html', etree.HTMLParser())
result = html.xpath('//a[@href="link4.html"]/parent::*/@class')
print(result)

属性匹配

在选取的时候,我们还可以用@符号进行属性过滤。比如,这里如果要选取class为item-1的li节点,可以这样实现:

1
2
3
4
from lxml import etree
html = etree.parse('./test.html', etree.HTMLParser())
result = html.xpath('//li[@class="item-0"]')
print(result)

在这里我们通过加入[@class=”item-0”],限制了节点的class属性为item-0,而HTML文本中符合条件的li节点有两个,所以结果应该返回两个匹配到的元素。结果如下:

1
[<Element li at 0x10a399288>, <Element li at 0x10a3992c8>]

文本获取

我们用XPath中的text()方法获取节点中的文本,接下来尝试获取前面li节点中的文本。代码如下:

1
2
3
4
5
from lxml import etree

html = etree.parse('./test.html', etree.HTMLParser())
result = html.xpath('//li[@class="item-0"]/a/text()')
print(result)

运行结果:

1
['\n     ']

如果想获取li节点内部的文本,就有两种方式,一种是先获取a节点再获取文本,另一种就是使用//。
下面再看一下使用//选取的结果,代码如下:

1
2
3
4
5
from lxml import etree

html = etree.parse('./test.html', etree.HTMLParser())
result = html.xpath('//li[@class="item-0"]//text()')
print(result)

运行结果如下:

1
['first item', 'fifth item', '\n     ']

可想而知,这里是选取的所有子孙节点的文本,其中前两个是li的子节点a节点内部的文本,另外一个就是最后一个li节点内部的文本,即换行符。
如果想获取子孙节点内部的所有文本,可以直接用//加text()的方式,这样可以保证获取到最全面的文本信息,但是可能会夹杂一些换行符等特殊字符。如果想获取某些特定子孙节点下的所有文本,可以先选取到特定的子孙节点,然后再调用text()方法获取其内部文本,这样可以保证获取的结果是整洁的。

属性获取

上面用text()可以获取节点的内部文本,用@符号可以获取节点属性。例如,我们想获取所有li节点下所有a节点的href属性,代码如下:

1
2
3
4
5
from lxml import etree

html = etree.parse('./test.html', etree.HTMLParser())
result = html.xpath('//li/a/@href')
print(result)

运行结果如下:

1
['link1.html', 'link2.html', 'link3.html', 'link4.html', 'link5.html']

这里通过@href即可获取节点的href属性。注意,此处和属性匹配的方法不同,属性匹配是中括号加属性名和值来限定某个属性,如[@href=”link.html”],而此处的@href指的是获取节点的某个属性,二者需要做好区分。

属性多值匹配

有时候,某些节点的某个属性可能有多个值,这时候就需要contains()函数了。代码如下:

1
2
3
4
5
6
7
from lxml import etree
text = '''
<li class="li li-first"><a href="link.html">first item</a></li>
'''
html = etree.HTML(text)
result = html.xpath('//li[contains(@class, "li")]/a/text()')
print(result)

运行结果:

1
['first item']

通过contains()方法,第一个参数传入属性名称,第二个参数传入属性值,只要此属性包含所传入的属性值,就可以完成匹配。此种方式在某个节点的某个属性有多个值时经常用到,如某个节点的class属性通常有多个。

多属性匹配

有时候需要根据多个属性确定一个节点,这时就需要同时匹配多个属性,此时可以用运算符and来连接。代码如下:

1
2
3
4
5
6
7
from lxml import etree
text = '''
<li class="li li-first" name="item"><a href="link.html">first item</a></li>
'''
html = etree.HTML(text)
result = html.xpath('//li[contains(@class, "li") and @name="item"]/a/text()')
print(result)

运行结果:

1
['first item']

这里的li节点又增加了一个属性name,要确定这个节点,需要同时根据class和name属性来选择,一个条件是class属性里面包含li字符串,另一个条件是name属性为item字符串,二者需要同时满足,需要用and操作符相连,相连之后置于中括号进行条件筛选。
这里的and其实是XPath中的运算符。另外,还有很多运算符,如or、mod等,总结为下表。

运算符 描述 实例 返回值
or age=19 or age=20 如果age是19,则返回true。如果age是21,则返回false
and age>19 and age<21 如果age是20,则返回true。如果age18,则返回false
mod 计算除法的余数 5 mod 2 1
计算两个节点集 //book //cd 返回所有拥有bookcd元素的节点集
+ 加法 6 + 4 10
- 减法 6 - 4 2
* 乘法 6 * 4 24
div 除法 8 div 4 2
= 等于 age=19 如果age是19,则返回true。如果age是20,则返回false
!= 不等于 age!=19 如果age是18,则返回true。如果age是19,则返回false
< 小于 age<19 如果age是18,则返回true。如果age是19,则返回false
<= 小于或等于 age<=19 如果age是19,则返回true。如果age是20,则返回false
> 大于 age>19 如果age是20,则返回true。如果age是19,则返回false
>= 大于或等于 age>=19 如果age是19,则返回true。如果age是18,则返回false

按序选择

有时候,我们在选定的时候某些属性可能同时匹配了多个节点,但是只想要其中的某个节点,如第二个节点或者最后一个节点,这时可以利用中括号传入索引的方法获取特定次序的节点。代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
from lxml import etree

text = '''
<div>
<ul>
<li class="item-0"><a href="link1.html">first item</a></li>
<li class="item-1"><a href="link2.html">second item</a></li>
<li class="item-inactive"><a href="link3.html">third item</a></li>
<li class="item-1"><a href="link4.html">fourth item</a></li>
<li class="item-0"><a href="link5.html">fifth item</a>
</ul>
</div>
'''
html = etree.HTML(text)
result = html.xpath('//li[1]/a/text()')
print(result)
result = html.xpath('//li[last()]/a/text()')
print(result)
result = html.xpath('//li[position()<3]/a/text()')
print(result)
result = html.xpath('//li[last()-2]/a/text()')
print(result)

运行结果如下:

1
2
3
4
['first item']
['fifth item']
['first item', 'second item']
['third item']

第一次选择时,我们选取了第一个li节点,中括号中传入数字1即可。注意,这里和代码中的不同,序号是以1开头的,不是0开头。
第二次选择时,我们选取了最后一个li节点,中括号中传入last()即可,返回的便是最后一个li节点。
第三次选择时,我们选取了位置小于3的li节点,也就是位置序号为1和2的节点,得到的结果就是前两个li节点。
第四次选择时,我们选取了倒数第三个li节点,中括号中传入last()-2即可。因为last()是最后一个,所以last()-2就是倒数第三个。
这里我们使用了last()、position()等函数。在XPath中,提供了100多个函数,包括存取、数值、字符串、逻辑、节点、序列等处理功能。它们的具体作用参考:http://www.w3school.com.cn/xpath/xpath_functions.asp

节点轴选择

XPath提供了很多节点轴选择方法,包括获取子元素、兄弟元素、父元素、祖先元素等,示例如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
from lxml import etree

text = '''
<div>
<ul>
<li class="item-0"><a href="link1.html"><span>first item</span></a></li>
<li class="item-1"><a href="link2.html">second item</a></li>
<li class="item-inactive"><a href="link3.html">third item</a></li>
<li class="item-1"><a href="link4.html">fourth item</a></li>
<li class="item-0"><a href="link5.html">fifth item</a>
</ul>
</div>
'''
html = etree.HTML(text)
result = html.xpath('//li[1]/ancestor::*')
print(result)
result = html.xpath('//li[1]/ancestor::div')
print(result)
result = html.xpath('//li[1]/attribute::*')
print(result)
result = html.xpath('//li[1]/child::a[@href="link1.html"]')
print(result)
result = html.xpath('//li[1]/descendant::span')
print(result)
result = html.xpath('//li[1]/following::*[2]')
print(result)
result = html.xpath('//li[1]/following-sibling::*')<code class="lang-python">
<span class="kwd">print</span><span class="pun">(</span><span class="pln">result</span><span class="pun">)</span>

运行结果:

1
2
3
4
5
6
7
[<Element html at 0x107941808>, <Element body at 0x1079418c8>, <Element div at 0x107941908>, <Element ul at 0x107941948>]
[<Element div at 0x107941908>]
['item-0']
[<Element a at 0x1079418c8>]
[<Element span at 0x107941948>]
[<Element a at 0x1079418c8>]
[<Element li at 0x107941948>, <Element li at 0x107941988>, <Element li at 0x1079419c8>, <Element li at 0x107941a08>]

第一次选择时,我们调用了ancestor轴,可以获取所有祖先节点。其后需要跟两个冒号,然后是节点的选择器,这里我们直接使用,表示匹配所有节点,因此返回结果是第一个li节点的所有祖先节点,包括html、body、div和ul。
第二次选择时,我们又加了限定条件,这次在冒号后面加了div,这样得到的结果就只有div这个祖先节点了。
第三次选择时,我们调用了attribute轴,可以获取所有属性值,其后跟的选择器还是
,这代表获取节点的所有属性,返回值就是li节点的所有属性值。
第四次选择时,我们调用了child轴,可以获取所有直接子节点。这里我们又加了限定条件,选取href属性为link1.html的a节点。
第五次选择时,我们调用了descendant轴,可以获取所有子孙节点。这里我们又加了限定条件获取span节点,所以返回的结果只包含span节点而不包含a节点。
第六次选择时,我们调用了following轴,可以获取当前节点之后的所有节点。这里我们虽然使用的是匹配,但又加了索引选择,所以只获取了第二个后续节点。
第七次选择时,我们调用了following-sibling轴,可以获取当前节点之后的所有同级节点。这里我们使用
匹配,所以获取了所有后续同级节点。

使用Beautiful Soup

Beautiful Soup就是Python的一个HTML或XML的解析库,可以用它来方便地从网页中提取数据。
Beautiful Soup提供一些简单的、Python式的函数来处理导航、搜索、修改分析树等功能。它是一个工具箱,通过解析文档为用户提供需要抓取的数据,因为简单,所以不需要多少代码就可以写出一个完整的应用程序。
Beautiful Soup自动将输入文档转换为Unicode编码,输出文档转换为UTF-8编码。你不需要考虑编码方式,除非文档没有指定一个编码方式,这时你仅仅需要说明一下原始编码方式就可以了。
Beautiful Soup已成为和lxml、html6lib一样出色的Python解释器,为用户灵活地提供不同的解析策略或强劲的速度。

解析器

Beautiful Soup在解析时实际上依赖解析器,它除了支持Python标准库中的HTML解析器外,还支持一些第三方解析器(比如lxml)。下表列出了Beautiful Soup支持的解析器。

解析器 使用方法 优势 劣势
Python标准库 BeautifulSoup(markup, “html.parser”) Python的内置标准库、执行速度适中、文档容错能力强 Python 2.7.3及Python 3.2.2之前的版本文档容错能力差
lxml HTML解析器 BeautifulSoup(markup, “lxml”) 速度快、文档容错能力强 需要安装C语言库
lxml XML解析器 BeautifulSoup(markup, “xml”) 速度快、唯一支持XML的解析器 需要安装C语言库
html5lib BeautifulSoup(markup, “html5lib”) 最好的容错性、以浏览器的方式解析文档、生成HTML5格式的文档 速度慢、不依赖外部扩展

通过以上对比可以看出,lxml解析器有解析HTML和XML的功能,而且速度快、容错能力强,所以推荐使用它。
如果使用lxml,那么在初始化Beautiful Soup是,可以把第二个参数改为lxml即可:

1
2
3
from bs4 import BeautifulSoup
soup = BeautifulSoup('<p>Hello</p>', 'lxml')
print(soup.p.string)

基本用法

下面通过实例来看看Beautiful Soup的基本用法:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
html = """
<html><head><title>The Dormouse's story</title></head>
<body>
<p class="title" name="dromouse"><b>The Dormouse's story</b></p>
<p class="story">Once upon a time there were three little sisters; and their names were
<a href="http://example.com/elsie" class="sister" id="link1"><!-- Elsie --></a>,
<a href="http://example.com/lacie" class="sister" id="link2">Lacie</a> and
<a href="http://example.com/tillie" class="sister" id="link3">Tillie</a>;
and they lived at the bottom of a well.</p>
<p class="story">...</p>
"""
from bs4 import BeautifulSoup
soup = BeautifulSoup(html, 'lxml')
print(soup.prettify())
print(soup.title.string)

运行结果:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
<html>
<head>
<title>
The Dormouse's story
</title>
</head>
<body>
<p class="title" name="dromouse">
<b>
The Dormouse's story
</b>
</p>
<p class="story">
Once upon a time there were three little sisters; and their names were
<a class="sister" href="http://example.com/elsie" id="link1">
<!-- Elsie -->
</a>
,
<a class="sister" href="http://example.com/lacie" id="link2">
Lacie
</a>
and
<a class="sister" href="http://example.com/tillie" id="link3">
Tillie
</a>
;
and they lived at the bottom of a well.
</p>
<p class="story">
...
</p>
</body>
</html>
The Dormouse's story

首先声明变量html,它是一个HTML字符串。但是需要注意的是,它并不是一个完整的HTML字符串,因为body和html节点都没有闭合。接着,我们将它当作第一个参数传给Beautiful Soup对象,该对象的第二个参数为解析器的类型(这里使用lxml),此时就完成了BeautifulSoup对象的初始化。然后,将这个值赋值给soup对象。
接下来,就可以调用soup的各个方法和属性解析这串HTML代码了。
首先,调用prettify()方法。这个方法可以把要解析的字符串以标准的缩进格式输出。这里需要注意的是,输出结果里面包含body和html节点,也就是说对于不标准的HTML字符串,BeautifulSoup可以自动更正格式。这一步不是由prettify()方法做的,而是在初始化BeautifulSoup时就完成了。
然后调用soup.title.string,这实际上是输出HTML中title节点的文本内容。所以,soup.title可以选出HTML中的title节点,再调用string属性就可以得到里面的文本了,所以我们可以通过简单调用几个属性完成文本提取。

节点选择器

直接调用节点的名称就可以选择节点元素,再调用string属性就可以得到节点内的文本了,这种选择方式速度非常快。如果单个节点结构层次非常清晰,可以选用这种方式来解析。
选择元素
下面用一段代码来说明:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
html = """
<html><head><title>The Dormouse's story</title></head>
<body>
<p class="title" name="dromouse"><b>The Dormouse's story</b></p>
<p class="story">Once upon a time there were three little sisters; and their names were
<a href="http://example.com/elsie" class="sister" id="link1"><!-- Elsie --></a>,
<a href="http://example.com/lacie" class="sister" id="link2">Lacie</a> and
<a href="http://example.com/tillie" class="sister" id="link3">Tillie</a>;
and they lived at the bottom of a well.</p>
<p class="story">...</p>
"""
from bs4 import BeautifulSoup
soup = BeautifulSoup(html, 'lxml')
print(soup.title)
print(type(soup.title))
print(soup.title.string)
print(soup.head)
print(soup.p)

运行结果:

1
2
3
4
5
<title>The Dormouse's story</title>
<class 'bs4.element.Tag'>
The Dormouse's story
<head><title>The Dormouse's story</title></head>
<p class="title" name="dromouse"><b>The Dormouse's story</b></p>

首选打印输出title节点的选择结果,输出结果正是title节点加里面的文字内容。接下来,输出它的类型,是bs4.element.Tag类型,这是Beautiful Soup中一个重要的数据结构。经过选择器选择后,选择结果都是这种Tag类型。Tag具有一些属性,比如string属性,调用该属性,可以得到节点的文本内容,所以接下来的输出结果正是节点的文本内容。
接下里,我们又尝试选择了head节点,结果也是节点加其内容的所有内容。最后,选择了q节点。不过,这次情况比较特殊,我们发现结果是第一个p节点的内容,后面的几个p节点并没有选到。也就是说,当有多个节点时,这种选择方式只会选择到第一个匹配的节点,其他后面节点都会忽略。

提取信息
(1)获取名称
可以利用name属性获取节点的名称。例如,选取title节点,然后调用name属性就可以得到节点名称:

print(soup.title.name)

运行结果:

title

(2)获取属性
可以利用attrs获取节点的所有属性。每个节点可能有多个属性,你如id和class等。

print(soup.p.attrs)
print(soup.p.attrs[‘name’])

运行结果:

{‘class’: [‘title’], ‘name’: ‘dromouse’}
dromouse

可以看到,attrs的返回结果是字典形式,它把选择的节点的所有属性和属性值组合成一个字典。接下来,如果要获取name属性,就相当于从字典中获取某个键值,只需要用中括号加属性名就可以了。比如,要获取name属性,就可以通过attrs[‘name’]来得到。
其实这样有点烦琐,还有一种简单的获取方式,可以不用写attrs,直接在节点元素后面加中括号,传入属性名就可以获取属性值了。样例如下:

print(soup.p[‘name’])
print(soup.p[‘class’])

运行结果如下:

dromouse
[‘title’]

这里需要注意的是,有的返回结果是字符串,有的返回结果是字符串组成的列表,比如,name属性的值是唯一的,返回的结果就是单个字符串。而对于class,一个节点元素可能有多个class,所以返回的是列表。在实际处理过程中,要注意判断类型。
(3)获取内容
可以利用string属性获取节点元素包含的文本内容,比如要获取第一个p节点的文本:

print(soup.p.string)

运行结果如下:

The Dormouse’s story

注意的是,这里选择到的p节点是第一个p节点,获取的文本也是第一个p节点里面的文本。

嵌套选择
上面可知,每一个返回结果都是bs4.element.Tag类型,它同样可以继续调用节点进行下一步的选择。比如,我们获取了head节点元素,我们可以继续调用head来选取其内容的head节点元素:

1
2
3
4
5
6
7
8
9
html = """
<html><head><title>The Dormouse's story</title></head>
<body>
"""
from bs4 import BeautifulSoup
soup = BeautifulSoup(html, 'lxml')
print(soup.head.title)
print(type(soup.head.title))
print(soup.head.title.string)

运行结果如下:

1
2
3
<title>The Dormouse's story</title>
<class 'bs4.element.Tag'>
The Dormouse's story

第一行结果是调用head之后再次调用title而选择的title节点元素。然后打印输出了它的类型,可以看到,它仍然是bs4.element.Tag类型。也就是说,我们在Tag类型的基础上再次选择得到的依然还是Tag类型,每次返回的结果都相同,所以这样就可以做嵌套选择了。最后输出它的string属性,也就是节点里的文本内容。

关联选择
在做选择的时候,有时候不能做到一步就选到想要的节点元素,需要先选中某一个节点元素,然后以它为基准再选择它的子节点、父节点、兄弟节点等。
(1)子节点和子孙节点
选取节点元素之后,如果想要获取它的直接子节点,可以调用contents属性,示例如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
from bs4 import BeautifulSoup

html = """
<html>
<head>
<title>The Dormouse's story</title>
</head>
<body>
<p class="story">
Once upon a time there were three little sisters; and their names were
<a href="http://example.com/elsie" class="sister" id="link1">
<span>Elsie</span>
</a>
<a href="http://example.com/lacie" class="sister" id="link2">Lacie</a>
and
<a href="http://example.com/tillie" class="sister" id="link3">Tillie</a>
and they lived at the bottom of a well.
</p>
<p class="story">...</p>
"""

soup = BeautifulSoup(html, 'lxml')
print(soup.p.contents)

运行结果如下:

1
2
3
['\n            Once upon a time there were three little sisters; and their names were\n            ', <a class="sister" href="http://example.com/elsie" id="link1">
<span>Elsie</span>
</a>, '\n', <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>, ' \n and\n ', <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>, '\n and they lived at the bottom of a well.\n ']

返回结果是列表形式,p节点里既包含文本,又包含节点,最后会将它们以列表形式统一返回。列表中的每个元素都是p节点的直接子节点。比如第一个a节点里面包含一层span节点,这相当于孙子节点了,但是返回结果并没有单独把span节点选出来。所以说,contents属性得到的结果是直接子节点的列表。
同样,我们可以调用children属性得到相应的结果:

1
2
3
4
5
from bs4 import BeautifulSoup
soup = BeautifulSoup(html, 'lxml')
print(soup.p.children)
for i, child in enumerate(soup.p.children):
print(i, child)

运行结果:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<list_iterator object at 0x1064f7dd8>
0
Once upon a time there were three little sisters; and their names were

1 <a class="sister" href="http://example.com/elsie" id="link1">
<span>Elsie</span>
</a>
2

3 <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>
4
and

5 <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>
6
and they lived at the bottom of a well.

返回结果是生成器类型。然后用for循环输出相应的内容。
如果要得到所有的子孙节点的话,可以调用descendants属性:

1
2
3
4
5
from bs4 import BeautifulSoup
soup = BeautifulSoup(html, 'lxml')
print(soup.p.descendants)
for i, child in enumerate(soup.p.descendants):
print(i, child)

运行结果:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
<generator object descendants at 0x10650e678>
0
Once upon a time there were three little sisters; and their names were

1 <a class="sister" href="http://example.com/elsie" id="link1">
<span>Elsie</span>
</a>
2

3 <span>Elsie</span>
4 Elsie
5

6

7 <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>
8 Lacie
9
and

10 <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>
11 Tillie
12
and they lived at the bottom of a well.

返回结果是生成器,遍历输出可以看到,结果包含span节点。descendants会递归查询所有子节点,得到所有的子孙节点。
(2)父节点和祖先节点
如果要获取某个节点元素的父节点,可以调用parent属性:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
html = """
<html>
<head>
<title>The Dormouse's story</title>
</head>
<body>
<p class="story">
Once upon a time there were three little sisters; and their names were
<a href="http://example.com/elsie" class="sister" id="link1">
<span>Elsie</span>
</a>
</p>
<p class="story">...</p>
"""
from bs4 import BeautifulSoup
soup = BeautifulSoup(html, 'lxml')
print(soup.a.parent)

运行结果如下:

1
2
3
4
5
6
<p class="story">
Once upon a time there were three little sisters; and their names were
<a class="sister" href="http://example.com/elsie" id="link1">
<span>Elsie</span>
</a>
</p>

这里选择的是第一个a节点的父节点元素。很明显,它的父节点是p节点,输出结果便是p节点及其内部的内容。
需要注意的是,这里输出的仅仅是a节点的直接父节点,而没有再向外寻找父节点的祖先节点。如果想要获取所有的祖先节点,可以调用parents属性:

1
2
3
4
5
6
7
8
9
10
11
12
13
html = """
<html>
<body>
<p class="story">
<a href="http://example.com/elsie" class="sister" id="link1">
<span>Elsie</span>
</a>
</p>
"""
from bs4 import BeautifulSoup
soup = BeautifulSoup(html, 'lxml')
print(type(soup.a.parents))
print(list(enumerate(soup.a.parents)))

运行结果如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
<class 'generator'>
[(0, <p class="story">
<a class="sister" href="http://example.com/elsie" id="link1">
<span>Elsie</span>
</a>
</p>), (1, <body>
<p class="story">
<a class="sister" href="http://example.com/elsie" id="link1">
<span>Elsie</span>
</a>
</p>
</body>), (2, <html>
<body>
<p class="story">
<a class="sister" href="http://example.com/elsie" id="link1">
<span>Elsie</span>
</a>
</p>
</body></html>), (3, <html>
<body>
<p class="story">
<a class="sister" href="http://example.com/elsie" id="link1">
<span>Elsie</span>
</a>
</p>
</body></html>)]

返回结果是生成器类型,用列表输出了它的索引和内容,而列表中的元素就是a节点的祖先节点。
(3)兄弟节点
上面说明了子节点和父节点的获取方式,下面介绍同级的节点(也就是兄弟节点)的获取方式:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
html = """
<html>
<body>
<p class="story">
Once upon a time there were three little sisters; and their names were
<a href="http://example.com/elsie" class="sister" id="link1">
<span>Elsie</span>
</a>
Hello
<a href="http://example.com/lacie" class="sister" id="link2">Lacie</a>
and
<a href="http://example.com/tillie" class="sister" id="link3">Tillie</a>
and they lived at the bottom of a well.
</p>
"""
from bs4 import BeautifulSoup
soup = BeautifulSoup(html, 'lxml')
print('Next Sibling', soup.a.next_sibling)
print('Prev Sibling', soup.a.previous_sibling)
print('Next Siblings', list(enumerate(soup.a.next_siblings)))
print('Prev Siblings', list(enumerate(soup.a.previous_siblings)))

运行结果如下:

1
2
3
4
5
6
7
8
Next Sibling 
Hello

Prev Sibling
Once upon a time there were three little sisters; and their names were

Next Siblings [(0, '\n Hello\n '), (1, <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>), (2, ' \n and\n '), (3, <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>), (4, '\n and they lived at the bottom of a well.\n ')]
Prev Siblings [(0, '\n Once upon a time there were three little sisters; and their names were\n ')]

这里调用了四个属性,其中next_sibling和previous_sibling分别获取节点的下一个和上一个兄弟元素,next_siblings和previous_siblings则分别返回所有前面和后面的兄弟节点的生成器。
(4)提取信息
前面介绍了关联元素节点的选择方法,如果想要获取它们的一些信息,比如文本、属性等,也用同样的方法,示例如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
html = """
<html>
<body>
<p class="story">
Once upon a time there were three little sisters; and their names were
<a href="http://example.com/elsie" class="sister" id="link1">Bob</a><a href="http://example.com/lacie" class="sister" id="link2">Lacie</a>
</p>
"""
from bs4 import BeautifulSoup
soup = BeautifulSoup(html, 'lxml')
print('Next Sibling:')
print(type(soup.a.next_sibling))
print(soup.a.next_sibling)
print(soup.a.next_sibling.string)
print('Parent:')
print(type(soup.a.parents))
print(list(soup.a.parents)[0])
print(list(soup.a.parents)[0].attrs['class'])

运行结果如下:

1
2
3
4
5
6
7
8
9
10
11
Next Sibling:
<class 'bs4.element.Tag'>
<a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>
Lacie
Parent:
<class 'generator'>
<p class="story">
Once upon a time there were three little sisters; and their names were
<a class="sister" href="http://example.com/elsie" id="link1">Bob</a><a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>
</p>
['story']

如果返回的是单个节点,那么可以直接调用string、attrs等属性获得其文本和属性;如果返回的是多个节点的生成器,则可以转为列表后取出单个元素,然后再调用string、attrs等属性获取其对应节点的文本和属性。

方法选择器

前面所讲的选择方法都是通过属性来选择的,这种方法非常快,但是如果进行比较复杂的选择的话,它就比较烦琐,不够灵活了。幸好,Beautiful Soup还为我们提供了一些查询方法,比如find_all()和find()等,调用它们,然后传入相应的参数,就可以灵活查询了。
find_all()
find_all,顾名思义,就是查询所有符合条件的元素。给它传入一些属性和文本,就可以得到符合条件的元素,它的功能十分强大。
它的API如下:

find_all(name, attrs, recursive, text, **kwargs)

(1)name
我们可以根据节点名来查询元素,示例如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
html='''
<div class="panel">
<div class="panel-heading">
<h4>Hello</h4>
</div>
<div class="panel-body">
<ul class="list" id="list-1">
<li class="element">Foo</li>
<li class="element">Bar</li>
<li class="element">Jay</li>
</ul>
<ul class="list list-small" id="list-2">
<li class="element">Foo</li>
<li class="element">Bar</li>
</ul>
</div>
</div>
'''
from bs4 import BeautifulSoup
soup = BeautifulSoup(html, 'lxml')
print(soup.find_all(name='ul'))
print(type(soup.find_all(name='ul')[0]))

运行结果如下:

1
2
3
4
5
6
7
8
9
[<ul class="list" id="list-1">
<li class="element">Foo</li>
<li class="element">Bar</li>
<li class="element">Jay</li>
</ul>, <ul class="list list-small" id="list-2">
<li class="element">Foo</li>
<li class="element">Bar</li>
</ul>]
<class 'bs4.element.Tag'>

这里调用了find_all()方法,传入name参数,其参数值为ul,也就是说,要查询所有ul节点,返回结果是列表类型,长度为2,每个元素依然都是bs4.element.Tag类型。
因为是Tag类型,所以可以进行嵌套查询。还是同样的文本,这里查询处所有的ul节点后,再继续查询其内部的li节点:

1
2
for ul in soup.find_all(name='ul'):
print(ul.find_all(name='li'))

运行结果如下:

1
2
[<li class="element">Foo</li>, <li class="element">Bar</li>, <li class="element">Jay</li>]
[<li class="element">Foo</li>, <li class="element">Bar</li>]

返回结果是列表类型,列表中每个元素依然还是Tag类型。然后就可以遍历每个li,获取它的文本了。
(2)attrs
除了根据节点名查询,还可以传入一些属性来查询。示例如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
html='''
<div class="panel">
<div class="panel-heading">
<h4>Hello</h4>
</div>
<div class="panel-body">
<ul class="list" id="list-1" name="elements">
<li class="element">Foo</li>
<li class="element">Bar</li>
<li class="element">Jay</li>
</ul>
<ul class="list list-small" id="list-2">
<li class="element">Foo</li>
<li class="element">Bar</li>
</ul>
</div>
</div>
'''
from bs4 import BeautifulSoup
soup = BeautifulSoup(html, 'lxml')
print(soup.find_all(attrs={'id': 'list-1'}))
print(soup.find_all(attrs={'name': 'elements'}))

运行结果如下:

1
2
3
4
5
6
7
8
9
10
[<ul class="list" id="list-1" name="elements">
<li class="element">Foo</li>
<li class="element">Bar</li>
<li class="element">Jay</li>
</ul>]
[<ul class="list" id="list-1" name="elements">
<li class="element">Foo</li>
<li class="element">Bar</li>
<li class="element">Jay</li>
</ul>]

查询的时候传入的是attrs参数,参数的类型是字典类型。比如,要查询id为list-1的节点,可以传入attrs={‘id’: ‘list-1’}的查询条件,得到的结果是列表形式,包含的内容就是符合id为list-1的所有节点。在上面的例子中,符合条件的元素个数是1,所以结果是长度为1的列表。
对于一些常用的属性,比如id和class等,我们可以不用attrs来传递,比如,要查询id为list-1的节点,可以直接传入id这个参数。还是上面的文本,换一种方式来查询:

1
2
3
4
from bs4 import BeautifulSoup
soup = BeautifulSoup(html, 'lxml')
print(soup.find_all(id='list-1'))
print(soup.find_all(class_='element'))

运行结果如下:

1
2
3
4
5
6
[<ul class="list" id="list-1">
<li class="element">Foo</li>
<li class="element">Bar</li>
<li class="element">Jay</li>
</ul>]
[<li class="element">Foo</li>, <li class="element">Bar</li>, <li class="element">Jay</li>, <li class="element">Foo</li>, <li class="element">Bar</li>]

这里直接传入id=’list-1’,就可以查询id为list-1的节点元素了。而对于class来说,由于class在Python里是一个关键字,所以后面需要加一个下划线,即class_=’element’,返回的结果依然还是Tag组成的列表。
(3)text
text参数可用来匹配节点的文本、传入的形式可以是字符串,可以是正则表达式对象,示例如下:

1
2
3
4
5
6
7
8
9
10
11
12
import re
html='''
<div class="panel">
<div class="panel-body">
<a>Hello, this is a link</a>
<a>Hello, this is a link, too</a>
</div>
</div>
'''
from bs4 import BeautifulSoup
soup = BeautifulSoup(html, 'lxml')
print(soup.find_all(text=re.compile('link')))

运行结果如下:

1
['Hello, this is a link', 'Hello, this is a link, too']

这里有两个a节点,其内容包含文本信息。这里在find_all()方法中传入text参数,该参数为正则表达式对象,结果返回所有匹配正则表达式的节点文本组成的列表。

find()
除了find_all()方法,还有find()方法,只不过后者返回的是单个元素,也就是第一个匹配的元素,而前者返回的是所有匹配的元素组成的列表。示例如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
html='''
<div class="panel">
<div class="panel-heading">
<h4>Hello</h4>
</div>
<div class="panel-body">
<ul class="list" id="list-1">
<li class="element">Foo</li>
<li class="element">Bar</li>
<li class="element">Jay</li>
</ul>
<ul class="list list-small" id="list-2">
<li class="element">Foo</li>
<li class="element">Bar</li>
</ul>
</div>
</div>
'''
from bs4 import BeautifulSoup
soup = BeautifulSoup(html, 'lxml')
print(soup.find(name='ul'))
print(type(soup.find(name='ul')))
print(soup.find(class_='list'))

运行结果如下:

1
2
3
4
5
6
7
8
9
10
11
<ul class="list" id="list-1">
<li class="element">Foo</li>
<li class="element">Bar</li>
<li class="element">Jay</li>
</ul>
<class 'bs4.element.Tag'>
<ul class="list" id="list-1">
<li class="element">Foo</li>
<li class="element">Bar</li>
<li class="element">Jay</li>
</ul>

这里返回的结果不再是列表形式,而是第一个匹配的节点元素,类型依然是Tag类型。
另外,还有很多查询办法,其用法与前面介绍的find_all()、find()方法完全相同,只不过查询范围不同,简单说明如下:

  • find_parents()和find_parent():前者返回所有祖先节点,后者返回直接父节点。
  • find_next_siblings()和find_next_sibling():前者返回后面所有的兄弟节点,后者返回后面第一个兄弟节点。
  • find_previous_siblings()和find_previous_sibling():前者返回前面所有的兄弟节点,后者返回前面第一个兄弟节点。
  • find_all_next()和find_next():前者返回节点后所有符合条件的节点,后者返回第一个符合条件的节点。
  • find_all_previous()和find_previous():前者返回节点后所有符合条件的节点,后者返回第一个符合条件的节点。

CSS选择器

Beautiful Soup还提供了另外一种选择器,那就是CSS选择器。使用CSS选择器时,只需要使用select()方法,传入相应的CSS选择器即可。示例如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
html='''
<div class="panel">
<div class="panel-heading">
<h4>Hello</h4>
</div>
<div class="panel-body">
<ul class="list" id="list-1">
<li class="element">Foo</li>
<li class="element">Bar</li>
<li class="element">Jay</li>
</ul>
<ul class="list list-small" id="list-2">
<li class="element">Foo</li>
<li class="element">Bar</li>
</ul>
</div>
</div>
'''
from bs4 import BeautifulSoup
soup = BeautifulSoup(html, 'lxml')
print(soup.select('.panel .panel-heading'))
print(soup.select('ul li'))
print(soup.select('#list-2 .element'))
print(type(soup.select('ul')[0]))

运行结果如下:

1
2
3
4
5
6
[<div class="panel-heading">
<h4>Hello</h4>
</div>]
[<li class="element">Foo</li>, <li class="element">Bar</li>, <li class="element">Jay</li>, <li class="element">Foo</li>, <li class="element">Bar</li>]
[<li class="element">Foo</li>, <li class="element">Bar</li>]
<class 'bs4.element.Tag'>

这里用了3次CSS选择器,返回的结果均是符合CSS选择器的节点组成的列表。例如,select(‘ul li’)则是选择所有ul节点下面的所有li节点,结果便是所有的li节点组成的列表。最后一句打印输出了列表中元素的类型。可以看到,类型依然是Tag类型。

嵌套选择
select()方法同样支持嵌套选择。例如,先选择所有ul节点,再遍历每个ul节点,选择其li节点,样例如下:

1
2
3
4
from bs4 import BeautifulSoup
soup = BeautifulSoup(html, 'lxml')
for ul in soup.select('ul'):
print(ul.select('li'))

运行结果如下:

1
2
[<li class="element">Foo</li>, <li class="element">Bar</li>, <li class="element">Jay</li>]
[<li class="element">Foo</li>, <li class="element">Bar</li>]

结果输出了所有ul节点下所有li节点组成的列表。

获取属性
我们知道节点类型是Tag类型,所以获取属性还可以用原来的方法。仍然是上面的HTML文本,这里尝试获取每个ul节点的id属性:

1
2
3
4
5
from bs4 import BeautifulSoup
soup = BeautifulSoup(html, 'lxml')
for ul in soup.select('ul'):
print(ul['id'])
print(ul.attrs['id'])

运行结果如下:

1
2
3
4
list-1
list-1
list-2
list-2

直接传入中括号和属性名,以及通过attrs属性获取属性值,都可以。

获取文本
要获取文本,当然也可以用前面所讲的string属性。此外,还有一个方法,那就是get_text(),示例如下:

1
2
3
4
5
from bs4 import BeautifulSoup
soup = BeautifulSoup(html, 'lxml')
for li in soup.select('li'):
print('Get Text:', li.get_text())
print('String:', li.string)

运行结果如下:

1
2
3
4
5
6
7
8
9
10
Get Text: Foo
String: Foo
Get Text: Bar
String: Bar
Get Text: Jay
String: Jay
Get Text: Foo
String: Foo
Get Text: Bar
String: Bar

可以看到,二者的效果完全一样。

总结:

  1. 推荐使用lxml解析,必要时使用html.parser
  2. 节点选择筛选功能弱但是速度快
  3. 建议使用find()或者find_all()查询匹配单个结果或者多个结果
  4. 如果对CSS选择器比较熟,可以使用select()方法选择

使用pyquery

如果你对Web有所涉及,如果你比较喜欢用CSS选择器,如果你对jQuery有所了解,那么这里有一个更适合你的解析库——pyquery。

初始化

像Beautiful Soup一样,初始化pyquery的时候,也需要传入HTML文本来初始化一个pyquery对象。它的初始化方式有多种,比如直接传入字符串、URL、文件名等。

字符串初始化
示例如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
html = '''
<div>
<ul>
<li class="item-0">first item</li>
<li class="item-1"><a href="link2.html">second item</a></li>
<li class="item-0 active"><a href="link3.html"><span class="bold">third item</span></a></li>
<li class="item-1 active"><a href="link4.html">fourth item</a></li>
<li class="item-0"><a href="link5.html">fifth item</a></li>
</ul>
</div>
'''
from pyquery import PyQuery as pq
doc = pq(html)
print(doc('li'))

运行结果如下:

1
2
3
4
5
<li class="item-0">first item</li>
<li class="item-1"><a href="link2.html">second item</a></li>
<li class="item-0 active"><a href="link3.html"><span class="bold">third item</span></a></li>
<li class="item-1 active"><a href="link4.html">fourth item</a></li>
<li class="item-0"><a href="link5.html">fifth item</a></li>

首先引入PyQuery这个对象,取别名为pq,然后声明了一个长HTML字符串,并将其当作参数传递给PyQuery类,这样就完成了初始化。接下来,将初始化的对象传入CSS选择器。在这个实例中,我们传入li节点,这样就可以选择所有的li节点。

URL初始化
初始化的参数不仅可以以字符串的形式传递,还可以传入网页的URL,此时需要指定参数为url即可:

1
2
3
from pyquery import PyQuery as pq
doc = pq(url='http://cuiqingcai.com')
print(doc('title'))

运行结果如下:

1
<title>静觅丨崔庆才的个人博客</title>

PyQuery对象会首先请求这个URL,然后得到的HTML内容完成初始化,这其实就相当于用网页源码以字符串的形式传递给PyQuery类来初始化。
它与下面的功能是相同的:

1
2
3
4
from pyquery import PyQuery as pq
import requests
doc = pq(requests.get('http://cuiqingcai.com').text)
print(doc('title'))

文件初始化
除了传递URL,还可以传递本地的文件名,此时将参数指定为filename即可:

1
2
3
from pyquery import PyQuery as pq
doc = pq(filename='demo.html')
print(doc('li'))

当然,这里需要有一个本地HTML文件的demo.html,其内容是待解析的HTML字符串。这样它会首先读取本地的文件内容,然后用文件内容以字符串的形式传递给PyQuery类来初始化。

基本CSS选择器

示例如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
html = '''
<div id="container">
<ul class="list">
<li class="item-0">first item</li>
<li class="item-1"><a href="link2.html">second item</a></li>
<li class="item-0 active"><a href="link3.html"><span class="bold">third item</span></a></li>
<li class="item-1 active"><a href="link4.html">fourth item</a></li>
<li class="item-0"><a href="link5.html">fifth item</a></li>
</ul>
</div>
'''
from pyquery import PyQuery as pq
doc = pq(html)
print(doc('#container .list li'))
print(type(doc('#container .list li')))

运行结果如下:

1
2
3
4
5
6
<li class="item-0">first item</li>
<li class="item-1"><a href="link2.html">second item</a></li>
<li class="item-0 active"><a href="link3.html"><span class="bold">third item</span></a></li>
<li class="item-1 active"><a href="link4.html">fourth item</a></li>
<li class="item-0"><a href="link5.html">fifth item</a></li>
<class 'pyquery.pyquery.PyQuery'>

这里初始化PyQuery对象后,传入了一个CSS选择器#container .list li,它的意思是先选取id为container的节点,然后再选取其内部的class为list的节点内部的所有li节点。然后,打印输出。最后将它的类型打印输出。类型依然是PyQuery类型 。

查找节点

下面介绍常用的查询函数,这些函数和jQuery函数的用法完全相同。
子节点
查找子节点时,需要用到find()方法,此时传入的参数是CSS选择器。这里还是以前面的HTML为例:

1
2
3
4
5
6
7
8
from pyquery import PyQuery as pq
doc = pq(html)
items = doc('.list')
print(type(items))
print(items)
lis = items.find('li')
print(type(lis))
print(lis)

运行结果如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
<class 'pyquery.pyquery.PyQuery'>
<ul class="list">
<li class="item-0">first item</li>
<li class="item-1"><a href="link2.html">second item</a></li>
<li class="item-0 active"><a href="link3.html"><span class="bold">third item</span></a></li>
<li class="item-1 active"><a href="link4.html">fourth item</a></li>
<li class="item-0"><a href="link5.html">fifth item</a></li>
</ul>
<class 'pyquery.pyquery.PyQuery'>
<li class="item-0">first item</li>
<li class="item-1"><a href="link2.html">second item</a></li>
<li class="item-0 active"><a href="link3.html"><span class="bold">third item</span></a></li>
<li class="item-1 active"><a href="link4.html">fourth item</a></li>
<li class="item-0"><a href="link5.html">fifth item</a></li>

首先选取了class为list的节点,然后调用了find()方法,传入CSS选择器,选取其内部的li节点,最后打印输出。可以发现,find()方法会将符合条件的所有节点选择出来,结果的类型是PyQuery类型。
其实find()方法的查找范围是节点的所有子孙节点,而如果我们只想查找子节点,那么可以用children()方法:

1
2
3
lis = items.children()
print(type(lis))
print(lis)

运行结果如下:

1
2
3
4
5
6
<class 'pyquery.pyquery.PyQuery'>
<li class="item-0">first item</li>
<li class="item-1"><a href="link2.html">second item</a></li>
<li class="item-0 active"><a href="link3.html"><span class="bold">third item</span></a></li>
<li class="item-1 active"><a href="link4.html">fourth item</a></li>
<li class="item-0"><a href="link5.html">fifth item</a></li>

如果要筛选所有子节点中符合条件的节点,比如想筛选出子节点中class为active的节点,可以向children()方法传入CSS选择器.active:

1
2
lis = items.children('.active')
print(lis)

运行结果如下:

1
2
<li class="item-0 active"><a href="link3.html"><span class="bold">third item</span></a></li>
<li class="item-1 active"><a href="link4.html">fourth item</a></li>

可以看到,输出结果已经做了筛选,留下了class为active的节点。

父节点
我们可以用parent()方法来获取某个节点的父节点,示例如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
html = '''
<div class="wrap">
<div id="container">
<ul class="list">
<li class="item-0">first item</li>
<li class="item-1"><a href="link2.html">second item</a></li>
<li class="item-0 active"><a href="link3.html"><span class="bold">third item</span></a></li>
<li class="item-1 active"><a href="link4.html">fourth item</a></li>
<li class="item-0"><a href="link5.html">fifth item</a></li>
</ul>
</div>
</div>
'''
from pyquery import PyQuery as pq
doc = pq(html)
items = doc('.list')
container = items.parent()
print(type(container))
print(container)

运行结果如下:

1
2
3
4
5
6
7
8
9
10
<class 'pyquery.pyquery.PyQuery'>
<div id="container">
<ul class="list">
<li class="item-0">first item</li>
<li class="item-1"><a href="link2.html">second item</a></li>
<li class="item-0 active"><a href="link3.html"><span class="bold">third item</span></a></li>
<li class="item-1 active"><a href="link4.html">fourth item</a></li>
<li class="item-0"><a href="link5.html">fifth item</a></li>
</ul>
</div>

这里我们首先用.list选取class为list的节点,然后调用parent()方法得到其父节点,其类型依然是PyQuery类型。
这里的父节点是该节点的直接父节点,也就是说,它不会再去查找父节点的父节点,即祖先节点。
但是如果想获取某个祖先节点,该怎么办呢?这时可以用parents()方法:

1
2
3
4
5
6
from pyquery import PyQuery as pq
doc = pq(html)
items = doc('.list')
parents = items.parents()
print(type(parents))
print(parents)

运行结果如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
<class 'pyquery.pyquery.PyQuery'>
<div class="wrap">
<div id="container">
<ul class="list">
<li class="item-0">first item</li>
<li class="item-1"><a href="link2.html">second item</a></li>
<li class="item-0 active"><a href="link3.html"><span class="bold">third item</span></a></li>
<li class="item-1 active"><a href="link4.html">fourth item</a></li>
<li class="item-0"><a href="link5.html">fifth item</a></li>
</ul>
</div>
</div>
<div id="container">
<ul class="list">
<li class="item-0">first item</li>
<li class="item-1"><a href="link2.html">second item</a></li>
<li class="item-0 active"><a href="link3.html"><span class="bold">third item</span></a></li>
<li class="item-1 active"><a href="link4.html">fourth item</a></li>
<li class="item-0"><a href="link5.html">fifth item</a></li>
</ul>
</div>

可以看到,输出结果有两个:一个是class为wrap的节点,一个是id为container的节点。也就是说,parents()方法会返回所有的祖先节点。
如果想要筛选某个祖先节点的话,可以向parents()方法传入CSS选择器,这样就会返回祖先节点中符合CSS选择器的节点:

1
2
parent = items.parents('.wrap')
print(parent)

运行结果如下:

1
2
3
4
5
6
7
8
9
10
11
<div class="wrap">
<div id="container">
<ul class="list">
<li class="item-0">first item</li>
<li class="item-1"><a href="link2.html">second item</a></li>
<li class="item-0 active"><a href="link3.html"><span class="bold">third item</span></a></li>
<li class="item-1 active"><a href="link4.html">fourth item</a></li>
<li class="item-0"><a href="link5.html">fifth item</a></li>
</ul>
</div>
</div>

可以看到,输出结果少了一个节点,只保留了class为wrap的节点。

兄弟节点
前面说了子节点和父节点的用法,还有一种节点——兄弟节点。如果要获取兄弟节点,可以使用siblings()方法。这里还是以上面的HTML代码为例:

1
2
3
4
from pyquery import PyQuery as pq
doc = pq(html)
li = doc('.list .item-0.active')
print(li.siblings())

首先选择了class为list的节点内部class为item-0和active的节点,也就是第三个li节点。那么。很明显,它的兄弟节点有4个,那就是第一、二、四、五个li节点。
运行结果如下:

1
2
3
4
<li class="item-1"><a href="link2.html">second item</a></li>
<li class="item-0">first item</li>
<li class="item-1 active"><a href="link4.html">fourth item</a></li>
<li class="item-0"><a href="link5.html">fifth item</a></li>

如果要筛选某个兄弟节点,我们依然可以向siblings方法传入CSS选择器,这样就会从所有兄弟节点中挑选出符合条件的节点了:

1
2
3
4
from pyquery import PyQuery as pq
doc = pq(html)
li = doc('.list .item-0.active')
print(li.siblings('.active'))

这里筛选了class为active的节点,通过刚才的结果可以观察到,class为active的兄弟节点只有第四个li节点,所以结果应该是一个。
我们再看一下运行结果:

1
<li class="item-1 active"><a href="link4.html">fourth item</a></li>

遍历

刚才可以观察到,pyquery的选择结果可能是多个节点,也可能是单个节点,类型都是PyQuery类型,并没有返回像Beautiful Soup那样的列表。
对于单个节点来说,可以直接打印输出,也可以直接转成字符串:

1
2
3
4
5
from pyquery import PyQuery as pq
doc = pq(html)
li = doc('.item-0.active')
print(li)
print(str(li))

运行结果如下:

1
2
<li class="item-0 active"><a href="link3.html"><span class="bold">third item</span></a></li>
<li class="item-0 active"><a href="link3.html"><span class="bold">third item</span></a></li>

对于多个节点的结果,我们就需要遍历来获取了。例如,这里把每一个li节点进行遍历,需要调用items()方法:

1
2
3
4
5
6
from pyquery import PyQuery as pq
doc = pq(html)
lis = doc('li').items()
print(type(lis))
for li in lis:
print(li, type(li))

运行结果如下:

1
2
3
4
5
6
7
8
9
10
11
<class 'generator'>
<li class="item-0">first item</li>
<class 'pyquery.pyquery.PyQuery'>
<li class="item-1"><a href="link2.html">second item</a></li>
<class 'pyquery.pyquery.PyQuery'>
<li class="item-0 active"><a href="link3.html"><span class="bold">third item</span></a></li>
<class 'pyquery.pyquery.PyQuery'>
<li class="item-1 active"><a href="link4.html">fourth item</a></li>
<class 'pyquery.pyquery.PyQuery'>
<li class="item-0"><a href="link5.html">fifth item</a></li>
<class 'pyquery.pyquery.PyQuery'>

可以发现,调用items()方法后,会得到一个生成器,遍历一下,就可以逐个得到li节点对象了,它的类型也是PyQuery类型,每个li节点还可以调用前面所说的方法进行选择,比如继续查询子节点,寻找某个祖先节点等,非常灵活。

获取信息

提取到节点之后,我们的最终目的当然是提取节点所包含的信息了。比较重要的信息有两类,一是获取属性,二是获取文本。
获取属性
提取到某个PyQuery类型的节点之后,就可以调用attr()方法来获取属性。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
html = '''
<div class="wrap">
<div id="container">
<ul class="list">
<li class="item-0">first item</li>
<li class="item-1"><a href="link2.html">second item</a></li>
<li class="item-0 active"><a href="link3.html"><span class="bold">third item</span></a></li>
<li class="item-1 active"><a href="link4.html">fourth item</a></li>
<li class="item-0"><a href="link5.html">fifth item</a></li>
</ul>
</div>
</div>
'''
from pyquery import PyQuery as pq
doc = pq(html)
a = doc('.item-0.active a')
print(a, type(a))
print(a.attr('href'))

运行结果如下:

1
2
<a href="link3.html"><span class="bold">third item</span></a> <class 'pyquery.pyquery.PyQuery'>
link3.html

这里首先选中class为item-0和active的li节点内的a节点,它的类型是PyQuery类型。
然后调用attr()方法,在这个方法中传入属性的名称,就可以得到这个属性值了。
此外,也可以通过调用attr属性来获取属性,用法如下:

print(a.attr.href)

结果如下:

link3.html

这两种方法的结果完全一样。
如果选中的是多个元素,然后调用attr()方法,会出现怎样的结果呢?我们用实例来测试一下:

1
2
3
4
a = doc('a')
print(a, type(a))
print(a.attr('href'))
print(a.attr.href)

运行结果如下:

1
2
3
<a href="link2.html">second item</a><a href="link3.html"><span class="bold">third item</span></a><a href="link4.html">fourth item</a><a href="link5.html">fifth item</a> <class 'pyquery.pyquery.PyQuery'>
link2.html
link2.html

照理来说,我们选中的a节点应该有4个,而且打印结果也应该是四个,但是当我们调用attr()方法时,返回结果却只是第一个。这是因为,当返回结果包含多个节点时,调用attr()方法,只会得到第一个节点的属性。
那么,遇到这种情况时,如果想获取所有的a节点的属性,就要用到前面所说的遍历了:

1
2
3
4
5
from pyquery import PyQuery as pq
doc = pq(html)
a = doc('a')
for item in a.items():
print(item.attr('href'))

运行结果如下:

1
2
3
4
link2.html
link3.html
link4.html
link5.html

因此,在进行属性获取时,可以观察返回节点是一个还是多个,如果是多个,则需要遍历才能依次获取每个节点的属性。

获取文本
获取节点之后的另一个主要操作就是获取其内部的文本了,此时可以调用text()方法来实现:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
html = '''
<div class="wrap">
<div id="container">
<ul class="list">
<li class="item-0">first item</li>
<li class="item-1"><a href="link2.html">second item</a></li>
<li class="item-0 active"><a href="link3.html"><span class="bold">third item</span></a></li>
<li class="item-1 active"><a href="link4.html">fourth item</a></li>
<li class="item-0"><a href="link5.html">fifth item</a></li>
</ul>
</div>
</div>
'''
from pyquery import PyQuery as pq
doc = pq(html)
a = doc('.item-0.active a')
print(a)
print(a.text())

运行结果如下:

1
2
<a href="link3.html"><span class="bold">third item</span></a>
third item

这里首先选中一个a节点,然后调用text()方法,就可以获取其内部的文本信息。此时它会忽略掉节点内部包含的所有HTML,只返回纯文字内容。
但如果想要获取这个节点内部的HTML文本,就要用html()方法了:

1
2
3
4
5
from pyquery import PyQuery as pq
doc = pq(html)
li = doc('.item-0.active')
print(li)
print(li.html())

这里我们选中了第三个li节点,然后调用了html()方法,它返回的结果应该是li节点内的所有HTML文本。
运行结果如下:

1
<a href="link3.html"><span class="bold">third item</span></a>

这里同样有一个问题,如果我们选中的结果是多个节点,text()或html()会返回什么内容?我们用实例来看一下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
html = '''
<div class="wrap">
<div id="container">
<ul class="list">
<li class="item-1"><a href="link2.html">second item</a></li>
<li class="item-0 active"><a href="link3.html"><span class="bold">third item</span></a></li>
<li class="item-1 active"><a href="link4.html">fourth item</a></li>
<li class="item-0"><a href="link5.html">fifth item</a></li>
</ul>
</div>
</div>
'''
from pyquery import PyQuery as pq
doc = pq(html)
li = doc('li')
print(li.html())
print(li.text())
print(type(li.text())

运行结果如下:

1
2
3
<a href="link2.html">second item</a>
second item third item fourth item fifth item
<class 'str'>

结果可能比较出乎意料,html()方法返回的是第一个li节点的内部HTML文本,而text()则返回了所有的li节点内部的纯文本,中间用一个空格分割开,即返回结果是一个字符串。
所以这个地方值得注意,如果得到的结果是多个节点,并且想要获取每个节点的内部HTML文本,则需要遍历每个节点。而text()方法不需要遍历就可以获取,它将所有节点取文本之后合并成一个字符串。

节点操作

pyquery提供了一系列方法来对节点进行动态修改,比如为某个节点添加一个class,移除某个节点等,这些操作有时候会为提取信息带来极大的便利。
由于节点操作的方法太多,下面举几个典型的例子来说明它的用法。
addClass和removeClass
我们先用实例来感受一下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
html = '''
<div class="wrap">
<div id="container">
<ul class="list">
<li class="item-0">first item</li>
<li class="item-1"><a href="link2.html">second item</a></li>
<li class="item-0 active"><a href="link3.html"><span class="bold">third item</span></a></li>
<li class="item-1 active"><a href="link4.html">fourth item</a></li>
<li class="item-0"><a href="link5.html">fifth item</a></li>
</ul>
</div>
</div>
'''
from pyquery import PyQuery as pq
doc = pq(html)
li = doc('.item-0.active')
print(li)
li.removeClass('active')
print(li)
li.addClass('active')
print(li)

首先选中了第三个li节点,然后调用removeClass()方法,将li节点的active这个class移除,后来又调用addClass()方法,将class添加回来。每执行一次操作,就打印输出当前li节点的内容。
运行结果如下:

1
2
3
<li class="item-0 active"><a href="link3.html"><span class="bold">third item</span></a></li>
<li class="item-0"><a href="link3.html"><span class="bold">third item</span></a></li>
<li class="item-0 active"><a href="link3.html"><span class="bold">third item</span></a></li>

可以看到,一共输出了3次。第二次输出时,li节点的active这个class被移除了,第三次class又添加回来了。
所以说,addClass()和removeClass()这些方法可以动态改变节点的class属性。
attr、text和html
当然,除了操作class这个属性外,也可以用attr()方法对属性进行操作。此外,还可以用text()和html()方法来改变节点内部的内容。示例如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
html = '''
<ul class="list">
<li class="item-0 active"><a href="link3.html"><span class="bold">third item</span></a></li>
</ul>
'''
from pyquery import PyQuery as pq
doc = pq(html)
li = doc('.item-0.active')
print(li)
li.attr('name', 'link')
print(li)
li.text('changed item')
print(li)
li.html('<span>changed item</span>')
print(li)

这里我们首先选中li节点,然后调用attr()方法来修改属性,其中该方法的第一个参数为属性名,第二个参数为属性值。接着,调用text()和html()方法来改变节点内部的内容。三次操作后,分别打印输出当前的li节点。
运行结果如下:

1
2
3
4
<li class="item-0 active"><a href="link3.html"><span class="bold">third item</span></a></li>
<li class="item-0 active" name="link"><a href="link3.html"><span class="bold">third item</span></a></li>
<li class="item-0 active" name="link">changed item</li>
<li class="item-0 active" name="link"><span>changed item</span></li>

可以发现,调用attr()方法后,li节点多了一个原本不存在的属性name,其值为link。接着调用text()方法,传入文本之后,li节点内部的文本全被改为传入的字符串文本了。最后,调用html()方法传入HTML文本后,li节点内部又变为传入的HTML文本了。
所以说,如果attr()方法只传入第一个参数的属性名,则是获取这个属性值;如果传入第二个参数,可以用来修改属性值。text()和html()方法如果不传参数,则是获取节点内纯文本和HTML文本;如果传入参数,则进行赋值。
remove()
顾名思义,remove()方法就是移除,它有时会为信息的提取带来非常大的便利。下面有一段HTML文本:

1
2
3
4
5
6
7
8
9
10
html = '''
<div class="wrap">
Hello, World
<p>This is a paragraph.</p>
</div>
'''
from pyquery import PyQuery as pq
doc = pq(html)
wrap = doc('.wrap')
print(wrap.text())

现在想提取Hello, World这个字符串,而不要p节点内部的字符串,需要怎样操作呢?
这里直接先尝试提取class为wrap的节点的内容,看看是不是我们想要的。运行结果如下:

1
Hello, World This is a paragraph.

这个结果还包含了内部的p节点的内容,也就是说text()把所有的纯文本全提取出来了。如果我们想去掉p节点内部的文本,可以选择再把p节点内的文本提取一遍,然后从整个结果中移除这个子串,但这个做法明显比较烦琐。
这时remove()方法就可以派上用场了,我们可以接着这么做:

1
2
wrap.find('p').remove()
print(wrap.text())

首先选中p节点,然后调用了remove()方法将其移除,然后这时wrap内部就只剩下Hello, World这句话了,然后再利用text()方法提取即可。
另外,其实还有很多节点操作的方法,比如append()、empty()和prepend()等方法,它们和jQuery的用法完全一致,详细的用法可以参考官方文档:http://pyquery.readthedocs.io/en/latest/api.html

伪类选择器

CSS选择器之所以强大,还有一个很重要的原因,那就是它支持多种多样的伪类选择器,例如选择第一个节点,最后一个节点、奇偶数节点、包含某一文本的节点等。示例如下

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
html = '''
<div class="wrap">
<div id="container">
<ul class="list">
<li class="item-0">first item</li>
<li class="item-1"><a href="link2.html">second item</a></li>
<li class="item-0 active"><a href="link3.html"><span class="bold">third item</span></a></li>
<li class="item-1 active"><a href="link4.html">fourth item</a></li>
<li class="item-0"><a href="link5.html">fifth item</a></li>
</ul>
</div>
</div>
'''
from pyquery import PyQuery as pq
doc = pq(html)
li = doc('li:first-child')
print(li)
li = doc('li:last-child')
print(li)
li = doc('li:nth-child(2)')
print(li)
li = doc('li:gt(2)')
print(li)
li = doc('li:nth-child(2n)')
print(li)<code class="lang-python"><span class="pln">
li </span><span class="pun">=</span><span class="pln"> doc</span><span class="pun">(</span><span class="str">'li:contains(second)'</span><span class="pun">)</span>
<span class="kwd">print</span><span class="pun">(</span><span class="pln">li</span><span class="pun">)</span>

这里我们使用了CSS3的伪类选择器,依次选择了第一个li节点、最后一个li节点、第二个li节点、第三个li之后的li节点、偶数位置的li节点、包含second文本的li节点。
关于CSS选择器的更多用法,可以参考http://www.w3school.com.cn/css/index.asp。
到此为止,pyquery的常用用法就介绍完了。如果想查看更多的内容,可以参考pyquery的官方文档:http://pyquery.readthedocs.io。我们相信有了它,解析网页不再是难事。