2.4 使用Python的解析库爬取Web数据

通过Requests发起网络请求，通过re库构造一个正则表达式，就可以完成一个简单的爬虫爬取web数据，但是同时也可以发行正则表达式还是有一些不太便利，尤其是一旦其中一个写错了后续便不能匹配了。

注意到每个网页节点(标签)，都可以定义id,class等等属性，且标签直接还有层级关系，我们完全可以通过XPath或者CSS选择器来定位节点，常用的方法就是使用XPath, Beautifulsoup,PyQuery库。本文为学习崔庆才的教程总结输出。

1. XPath 库

我们现用表格列举一下几个常用规则：

表达式

描述

nodename

选取此节点的所有子节点

从当前节点选取直接子节点

从当前节点选取子孙节点

选取当前节点

选取当前节点的父节点

选取属性

如：

//title[@lang=’eng’]

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

常见的Xpath使用方法：

//li/a表示所有 li 节点的所有直接 a 子节点
//ul//a表示所有ul节点的所有a子孙节点
//a[@href="link4.html"]/../@class表示所有属性为href="link4.html"的a节点的父节点的class
//li[@class="item-0"]/text()前半段为XPath表达式，后面的text()为获取匹配表达式的文本
//li[contains(@class, "li")]/a/text()中使用contains()函数进行多个属性匹配，此次表示如果一个li标签有一个class为li就可以匹配上了。如：
```
<li class="li li-first"><a href="link.html">first item</a></li>
```
这个li标签有多个属性，其中一个属性为li，所以它可以匹配得上。
使用[ A and B ]方法进行多属性匹配，如//li[contains(@class, "li") and @name="item"]/a/text(),表示元素li包含了一个class属性li,同时还有一个name属性item。可以匹配上下面的节点：
```
<li class="li li-first" name="item"><a href="link.html">first item</a></li>
```

2. BeautifulSoup 库

BeautifulSoup提供一些简单的、Python式的函数用来处理导航、搜索、修改分析树等功能。BeautifulSoup 自动将输入文档转换为 Unicode 编码，输出文档转换为 utf-8 编码。不需要考虑编码方式，除非文档没有指定一个编码方式，这时你仅仅需要说明一下原始编码方式就可以了。 BeautifulSoup 已成为和 lxml、html6lib 一样出色的 Python 解释器，为用户灵活地提供不同的解析策略或强劲的速度。

相比于Xpath，BeautifulSoup可以更便捷地获取节点，如：

from bs4 import BeautifulSoup
soup = BeautifulSoup('<p>Hello</p>', 'lxml') #配合lxml解析前面的html
print(soup.p.string) #直接指定soup的p节点

在调用BeautifulSoup解析HTML以后，可以直接指定节点名字来获取，如上面的例子指定soup的p节点，然后通过.string来获取节点的字符串。

2.1 BeautifulSoup获取节点属性

可以调用 attrs 获取选择节点的所有属性，包括id,class和name等属性。

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) #提取title节点
print(type(soup.title))
print(soup.title.string) #提取title节点的内容
print(soup.head)  #提取head节点
print(soup.p) #提取p节点

print(soup.p.attrs) #提取p节点的属性
print(soup.p.attrs['name']) #提取p节点的name属性

运行结果：

$ python bs_test.py
<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>
{'class': ['title'], 'name': 'dromouse'}
dromouse

除了使用attrs[]属性以外，还可以直接使用element[]的方式调用，如：

print(soup.p['name'])
print(soup.p['class'])

运行结果：

dromouse
['title']

2.2 BeautifulSoup获取节点内容

可以利用 string 属性获取节点元素包含的文本内容，比如上面的文本我们获取第一个 p 节点的文本：

print(soup.p.string)

运行结果：

The Dormouse's story

再次注意一下这里选择到的 p 节点是第一个 p 节点，获取的文本也就是第一个 p 节点里面的文本。

使用get_text()函数获取节点的内容

如：

print(soup.p.get_text())

运行结果：

The Dormouse's story

2.3 BeautifulSoup使用方法选择器

使用上面的这些节点选择器，复杂但是速度快，但是如果要进行比较复杂的选择的话则会比较繁琐，不够灵活。所以 BeautifulSoup 还为我们提供了一些查询的方法，比如 find_all()、find()等方法，我们可以调用方法然后传入相应等参数就可以灵活地进行查询了。

2.4 find_all()函数

就是查询所有符合条件的元素，可以给它传入一些属性或文本来得到符合条件的元素，功能十分强大。

它的API如下：

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

name参数：节点名(标签)，是一个字符串值
attrs参数：属性值(如name,id,class等属性)，参数类型是字典类型

如要查询 id 为 list-1 的节点，那就可以传入attrs={'id': 'list-1'} 的查询条件，得到的结果是列表形式，包含的内容就是符合 id 为 list-1 的所有节点。如：soup.find_all(attrs={'id': 'list-1'})

另外，对于一些常用的属性比如 id、class 等，我们可以不用 attrs 来传递，比如我们要查询 id 为 list-1 的节点，我们可以直接传入id 这个参数。如：soup.find_all(id='list-1')

而对于 class 来说，由于 class 在 python 里是一个关键字，所以在这里后面需要加一个下划线，class_='element'，返回的结果依然还是列表。如：soup.find_all(class_='list-1')

text参数：匹配节点中的文本，传入的形式可以是字符串，也可以是正则表达式对象。

看一个例子：

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
import re
soup = BeautifulSoup(html, 'lxml')

# Name参数示例
print("Name参数示例")
print(soup.find_all(name='ul'))
print(type(soup.find_all(name='ul')[0]))

for ul in soup.find_all(name='ul'):
    print(ul.find_all(name='li'))
    for li in ul.find_all(name='li'):
        print(li.string)
print("*********************************")

#attrs参数示例
print("Attrs参数示例")
print(soup.find_all(attrs={'id': 'list-1'}))
print(soup.find_all(attrs={'class': 'element'}))    
print("*********************************")

#id示例
print("id参数示例")
print(soup.find_all(id='list-1'))
print("*********************************")

#class示例
print("class参数示例")
print(soup.find_all(class_='element'))
print("*********************************")

#text示例
print("text参数示例")
print(soup.find_all(text=re.compile('Foo')))

运行结果：

$ python bs_test.py
Name参数示例
[<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'>
[<li class="element">Foo</li>, <li class="element">Bar</li>, <li class="element">Jay</li>]
Foo
Bar
Jay
[<li class="element">Foo</li>, <li class="element">Bar</li>]
Foo
Bar
*********************************
Attrs参数示例
[<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参数示例
[<ul class="list" id="list-1">
<li class="element">Foo</li>
<li class="element">Bar</li>
<li class="element">Jay</li>
</ul>]
*********************************
class参数示例
[<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>]
*********************************
text参数示例
['Foo', 'Foo']

2.5 其他选择函数

除了常用的find_all()函数以外，还有一下几个函数。

find()函数

find()函数的用法与find_all()完全一致，只不过查询范围不同，前者查询一个元素，后者查询所有。

find_parents() 与find_parent()

find_parents() 返回所有祖先节点，find_parent() 返回直接父节点。

find_next_siblings()与 find_next_sibling()

find_next_siblings() 返回后面所有兄弟节点，find_next_sibling() 返回后面第一个兄弟节点。

find_previous_siblings()与 find_previous_sibling()

find_previous_siblings() 返回前面所有兄弟节点，find_previous_sibling() 返回前面第一个兄弟节点。

find_all_next()与 find_next()

find_all_next() 返回节点后所有符合条件的节点, find_next() 返回第一个符合条件的节点。

find_all_previous() 与 find_previous()

find_all_previous() 返回节点后所有符合条件的节点, find_previous() 返回第一个符合条件的节点

BeautifulSoup使用CSS选择器

在 CSS 中，选择器是一种模式，用于选择需要添加样式的元素。BeautifulSoup使用 CSS 选择器，只需要调用 select() 方法，传入相应的 CSS 选择器，即可返回一个列表。

以下是CSS选择器以及示例，最后一列指示CSS1，CSS2还是CSS3中支持该选择器。

选择器

例子

例子描述

CSS

.class

.intro

选择 class="intro" 的所有元素。

#id

#firstname

选择 id="firstname" 的所有元素。

选择所有元素。

element

选择所有元素。

element,element

div,p

选择所有元素和所有元素。

element element

div p

选择元素内部的所有元素。

element>element

div>p

选择父元素为元素的所有元素。

element+element

div+p

选择紧接在元素之后的所有元素。

[attribute]

[target]

选择带有 target 属性所有元素。

[attribute=value]

[target=_blank]

选择 target="_blank" 的所有元素。

[attribute~=value]

[title~=flower]

选择 title 属性包含单词 "flower" 的所有元素。

[attribute|=value]

[lang|=en]

选择 lang 属性值以 "en" 开头的所有元素。

:link

a:link

选择所有未被访问的链接。

:visited

a:visited

选择所有已被访问的链接。

:active

a:active

选择活动链接。

:hover

a:hover

选择鼠标指针位于其上的链接。

:focus

input:focus

选择获得焦点的 input 元素。

:first-letter

p:first-letter

选择每个元素的首字母。

:first-line

p:first-line

选择每个元素的首行。

:first-child

p:first-child

选择属于父元素的第一个子元素的每个元素。

:before

p:before

在每个元素的内容之前插入内容。

:after

p:after

在每个元素的内容之后插入内容。

:lang(language)

p:lang(it)

选择带有以 "it" 开头的 lang 属性值的每个元素。

element1~element2

p~ul

选择前面有元素的每个元素。

[attribute^=value]

a[src^="https"]

选择其 src 属性值以 "https" 开头的每个元素。

[attribute$=value]

a[src$=".pdf"]

选择其 src 属性以 ".pdf" 结尾的所有元素。

[attribute**=value*]

a[src*="abc"]

选择其 src 属性中包含 "abc" 子串的每个元素。

:first-of-type

p:first-of-type

选择属于其父元素的首个元素的每个元素。

:last-of-type

p:last-of-type

选择属于其父元素的最后元素的每个元素。

:only-of-type

p:only-of-type

选择属于其父元素唯一的元素的每个元素。

:only-child

p:only-child

选择属于其父元素的唯一子元素的每个元素。

:nth-child(n)

p:nth-child(2)

选择属于其父元素的第二个子元素的每个元素。

:nth-last-child(n)

p:nth-last-child(2)

同上，从最后一个子元素开始计数。

:nth-of-type(n)

p:nth-of-type(2)

选择属于其父元素第二个元素的每个元素。

:nth-last-of-type(n)

p:nth-last-of-type(2)

同上，但是从最后一个子元素开始计数。

:last-child

p:last-child

选择属于其父元素最后一个子元素每个元素。

:root

选择文档的根元素。

:empty

p:empty

选择没有子元素的每个元素（包括文本节点）。

:target

#news:target

选择当前活动的 #news 元素。

:enabled

input:enabled

选择每个启用的元素。

:disabled

input:disabled

选择每个禁用的元素

:checked

input:checked

选择每个被选中的元素。

:not(selector)

:not(p)

选择非元素的每个元素。

::selection

选择被用户选取的元素部分。

示例：

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
import re
soup = BeautifulSoup(html, 'lxml')

#CSS选择器示例
print("CSS选择器参数示例")
print(soup.select('.panel .panel-heading'))
print(soup.select('ul li'))
print(soup.select('#list-2 .element'))
print(type(soup.select('ul')[0]))

运行结果：

$ python bs_test.py
CSS选择器参数示例
[<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. PyQuery 库

前面的BeautifulSoup是一个非常强大的网页解析库，但是CSS 选择器功能相对于PyQuery来说稍微更逊色一筹。如果对Web比较熟悉，肯定对jquery不会陌生，而PyQuery就是类似于jquery的Python库，非常强大。

3.1 PyQuery初始化

像 BeautifulSoup 一样，PyQuery 初始化的时候也需要传入 HTML 数据源来初始化一个操作对象，它的初始化方式有多种，比如直接传入字符串，传入 URL，传文件名。下面我们来详细介绍一下。

3.1.1 字符串初始化

首先我们用一个实例来感受一下：

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'))

运行结果：

<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 节点，打印输出可以看到所有的 li 节点的 HTML 文本。

3.1.2 URL初始化

初始化的参数不仅可以以字符串的形式传递，还可以传入网页的 URL，在这里只需要指定参数为 url 即可：

from pyquery import PyQuery as pq
doc = pq(url='http://www.baidu.com')
print(doc('title'))

PyQuery 会首先请求这个 URL，然后用得到的 HTML 内容完成初始化，其实就相当于我们用网页的源代码以字符串的形式传递给 PyQuery 来初始化。

它与下面的功能是相同的：

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

3.1.3 文件初始化

当然除了传递一个 URL，还可以传递本地的文件名，参数指定为 filename 即可：

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

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

以上三种初始化方式均可，当然最常用的初始化方式还是以字符串形式传递。

3.2 PyQuery的基本CSS选择器

我们首先用一个实例来感受一下 PyQuery 的 CSS 选择器的用法：

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')))

在doc('#container .list li')中与jquery类似，选择的是id为container下面层级的类为list的下面层级为li标签，返回一个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 'pyquery.pyquery.PyQuery'>

3.3 查找节点

下面我们介绍一些常用的查询函数，这些函数和 jQuery 中的函数用法也完全相同。

3.3.1 子节点

查找子节点需要用到 find() 方法，传入的参数是 CSS 选择器，我们还是以上面的 HTML 为例：

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)

运行结果：

<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() 方法：

lis = items.children()
print(type(lis))
print(lis)

运行结果：

<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：

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

运行结果：

<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 的节点。

总结一下即：

find()查找所有子孙节点
children()查找直接对应的子节点

3.3.2 父节点

我们可以用 parent()方法来获取某个节点的父节点，我们用一个实例来感受一下：

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)

运行结果：

<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() 方法：

from pyquery import PyQuery as pq
doc = pq(html)
items = doc('.list')
parents = items.parents()
print(type(parents))
print(parents)

运行结果：

<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>

在这里我们调用了 parents() 方法，可以看到输出结果有两个，一个是 class 为 wrap 的节点，一个是 id 为 container 的节点，也就是说，parents() 方法会返回所有的祖先节点。

如果我们想要筛选某个祖先节点的话可以向 parents() 方法传入 CSS 选择器，这样就会返回祖先节点中符合 CSS 选择器的节点：

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

运行结果：

<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 的节点。

总结一下：

parent()查找直接子节点
parents()查找所有祖先节点
parents('CSS选择器')查找所有匹配CSS选择器条件的所有祖先节点

3.3.3 兄弟节点

除了子节点和父节点的用法，还有一种节点那就是兄弟节点，如果要获取兄弟节点可以使用siblings()方法。我们还是以上面的 HTML 代码为例来感受一下：

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 节点。那么很明显它的兄弟节点有四个，那就是第一、二、四、五个 li 节点。

运行结果：

<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>

可以看到运行结果也正是我们刚才所说的四个兄弟节点。

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

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

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

运行结果：

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

3.4 遍历

我们刚才可以观察到，PyQuery 的选择结果可能是多个节点，可能是单个节点，类型都是 PyQuery 类型，并没有返回像 BeautifulSoup 一样的列表。

对于单个节点来说，我们可以直接打印输出，也可直接转成字符串：

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

运行结果：

<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() 方法：

from pyquery import PyQuery as pq
doc = pq(html)
lis = doc('li').items()
print(type(lis))
for li in lis:
    print(li, type(li))

运行结果：

<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 节点还可以调用前面所说的方法进行选择，比如继续查询子节点，寻找某个祖先节点等等，非常灵活。

3.5 获取信息

提取到节点之后，我们的最终目的当然是提取节点所包含的信息了，比较重要的信息有两类，一是获取属性，二是获取文本，下面我们分别进行说明。

3.5.1 获取属性

提取到某个 PyQuery 类型的节点之后，我们可以调用 attr() 方法来获取属性：

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'))

运行结果：

<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 属性，然后再调用属性名，同样可以得到属性值。

如果我们选中的是多个元素，然后调用 attr() 方法会出现怎样的结果？我们用一个实例来测试一下：

a = doc('a')
print(a, type(a))
print(a.attr('href'))
print(a.attr.href)

运行结果：

<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 节点应该有四个，而且打印结果也是四个，但是当我们调用 attr()方法或者直接调用attr属性时，返回的结果却只有第一个。那么遇到这种情况如果我们想获取所有的 a 节点的属性，就需要用到前面所说的遍历了：

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

运行结果：

link2.html
link3.html
link4.html
link5.html

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

3.5.2 获取文本

获取节点之后的另一个主要的操作就是获取其内部的文本了，我们可以调用text() 方法来获取：

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())

运行结果：

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

我们首先选中了一个 a 节点，然后调用了 text() 方法，就可以获取其内部的文本信息了，它会忽略掉节点内部包含的所有 HTML，只返回纯文字内容。

但如果我们想要获取这个节点内部的 HTML 文本，就可以用 html() 方法：

from pyquery import PyQuery as pq
doc = pq(html)
li = doc('.item-0.active')
print(li)
print(li.html())

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

运行结果：

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

这里同样有一个问题，如果我们选中的结果是多个节点，text() 或html() 会返回什么内容？

我们用一个实例来看一下：

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())

运行结果：

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

结果出乎意料，我们选中的是所有的li 节点，但是 html() 方法返回的是第一个 li 节点的内部 HTML 文本，而 text()则返回了所有的li节点内部纯文本，中间用一个空格分割开，实际上是一个字符串。

所以这个地方值得注意，如果我们得到的结果是多个节点，如果要获取每个节点的内部 HTML 文本，则需要遍历每个节点，而 text() 方法不需要遍历就可以获取，它是将所有节点取文本之后合并成一个字符串。

3.6 节点操作

PyQuery 提供了一系列方法来对节点进行动态修改操作，比如为某个节点添加一个 class，移除某个节点等等，这些操作有时候会为提取信息带来极大的便利。

由于节点操作的方法太多，下面举几个典型的例子来说明它的用法。

3.6.1 addClass、removeClass

我们先用一个实例来感受一下：

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 节点的内容。

运行结果：

<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>

可以看到一共进行了三次输出，第二次输出 li 节点的 active 这个 class 被移除了，第三次 class 又添加回来了。

所以说我们 addClass()、removeClass() 这些方法可以动态地改变节点的 class 属性。

3.6.2 attr、text、html

当然除了操作 class 这个属性，也有 attr() 方法来专门针对属性进行操作，也可以用 text()、html()方法来改变节点内部的内容。

我们用实例感受一下：

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 节点。

运行结果：

<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 文本，如果传入参数则是进行赋值。

3.6.3 remove

remove 顾名思义移除，remove() 方法有时会为信息的提取带来非常大的便利。下面我们看一个实例：

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())

在这里有一段 HTML 文本，我们现在想提取 Hello, World 这个字符串，而不要 p 节点内部的字符串，这个怎样来提取？

在这里我们直接先尝试提取 class 为 wrap 的节点的内容，看看是不是我们想要的，运行结果如下：

Hello, World This is a paragraph.

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

那这是 remove() 方法就可以派上用场了，我们可以接着这么做:

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

我们首先选中了 p 节点，然后调用了 remove() 方法将其移除，然后这时 wrap 内部就只剩下 Hello, World 这句话了，然后再利用 text()方法提取即可。

所以说，remove() 方法可以删除某些冗余内容，来方便我们的提取。在适当的时候使用可以极大地提高效率。

另外其实还有很多节点操作的方法，比如 append()、empty()、prepend() 等方法，他们和 jQuery 的用法是完全一致的，详细的用法可以参考官方文档：http://pyquery.readthedocs.io/en/latest/api.html

3.7 伪类选择器

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

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)
li = doc('li:contains(second)')
print(li)

在这里我们使用了 CSS3 的伪类选择器，依次选择了第一个 li 节点、最后一个 li 节点、第二个 li 节点、第三个 li 之后的 li 节点、偶数位置的 li 节点、包含 second 文本的 li 节点，功能十分强大。

更多的 CSS 选择器的用法可以参考：http://www.w3school.com.cn/css/index.asp

Previous2.3 使用Requests和正则表达式爬取猫眼电影Top 100排行榜 Next2.5 使用Requests和PyQuery爬取猫眼电影Top 100排行榜

Last updated 7 years ago