pyquery的使用

3.2 节介绍了 Beautiful Soup 的用法，这是一个非常强大的网页解析库，你是否觉得它的一些方法用起来有点不适应？有没有觉得它的 CSS 选择器的功能没那么强大？

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

接下来，一起感受一下 pyquery 的强大之处。

准备工作

同样，在本节开始之前请确保已经安装好了 pyquery 库，如没有安装，可以使用 pip3 安装：

pip3 install pyquery

更加详细的安装说明可以参考： https://setup.scrape.center/pyquery 。

安装完成之后，我们便可以开始接下来的学习了。

初始化

在用 pyquery 库解析 HTML 文本的时候，需要先将其初始化为一个 PyQuery 对象。

初始化方式有很多种，例如直接传入字符串、传入 URL、传入文件名，等等。下面我们详细介绍下这方式。

字符串初始化

这种方式是直接把 HTML 的内容当作初始化参数，来初始化 PyQuery 对象。可以用一个实例来感受一下：

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

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

URL 初始化

初始化的参数除了能以字符串形式传递，还能是网页的 URL，此时只需要指定 PyQuery 对象的参数为 url 即可：

from pyquery import PyQuery as pq

doc = pq(url='https://cuiqingcai.com')
print(doc('title'))

运行结果如下：

<title>静觅丨崔庆才的个人站点 - Python爬虫教程</title>

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

下面代码实现的功能是相同的：

from pyquery import PyQuery as pq
import requests

doc = pq(requests.get('https://cuiqingcai.com').text)
print(doc('title'))

文件初始化

除了上面两种，还可以传递本地的文件名，此时将参数指定为 filename 即可：

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

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

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

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

运行结果如下：

<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 对象之后，传入了一个 CSS 选择器 #container .list li，它的意思是先选取 id 为 container 的节点，再选取其内部 class 为 list 的节点内部的所有 li 节点，然后打印输出。从运行结果可以看到，我们成功获取了符合条件的节点。

最后，将符合条件的节点的类型打印输出，可以看到依然是 PyQuery 类型。

下面，我们直接遍历获取的节点，然后调用 text 方法，就可以直接获取节点的文本内容了，代码如下：

for item in doc('#container .list li').items():
    print(item.text())

运行结果如下：

first item
second item
third item
fourth item
fifth item

怎么样？我们这里没有写正则表达式，直接通过选择器和 text 方法，就得到了想要提取的文本信息，是不是方便多了？

下面我们再来详细了解一下 pyquery 库的用法，包括如何查找节点、遍历节点，并获取各种信息等。掌握了这些，我们才能更高效地提取数据。

查找节点

下面是一些常用的查询方法。

子节点

查找子节点时，需要用到 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>

这里我们先通过 .list 参数选取 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 的节点。

父节点

我们可以用 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。

这里的父节点是指直接父节点，也就是说，parent 方法不会继续查找父节点的父节点，即祖先节点。

但是如果就想获取某个祖先节点，要怎么办呢？这时可以用 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>

可以看到，输出结果有两个：一个是 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 的节点。

兄弟节点

前面我们说明了子节点和父节点的用法，还有一种节点就是兄弟节点。获取兄弟节点可以使用 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 节点。那么，很明显，其兄弟节点有 4 个，就是第一个、第二个、第四个、第五个 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>

可以看到，结果正是我们刚才说的那 4 个节点。

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

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

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

我们再看一下运行结果：

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

结果确实符合我们的预期。

遍历节点

可以观察到，pyquery 库的选择结果可能是多个节点，也可能是单个节点，类型都是 PyQuery 类型，并没有像 Beautiful Soup 那样返回列表。

如果结果是单个节点，既可以直接打印输出，也可以直接转成字符串：

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>

如果结果是多个节点，就需要遍历获取了。需要调用 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))

这单把所有 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 节点进行选择，例如继续查询子节点、寻找某个祖先节点等非常灵活。

获取信息

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

获取属性

提取到某个 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 方法，会出现怎样的结果呢？我们用实例来测试一下：

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 节点应该有 4 个，所以打印结果也应该是 4 个。但是当我们调用 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

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

获取文本

获取节点之后的另一个主要操作就是获取其内部的文本，此时可以调用 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 方法，就可以获取其内部的文本信息。此时 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-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')
print(li.html())
print(li.text())
print(type(li.text()))

运行结果如下：

first item
first item second item third item fourth item fifth item
<class 'str'>

结果可能比较出乎意料，html 方法返回的是第一个 li 节点内部的 HTML 文本，而 text 返回了所有的 li 节点内部的纯文本，各节点内容中间用一个空格分割开，即返回结果是一个字符串。

所以这个地方值得注意，如果得到的结果是多个节点，并且想获取所有节点的内部 HTML 文本，就需要遍历这些节点。而 text 方法不需要遍历即可获取，会对所有节点取文本之后合并成一个字符串。

节点操作

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

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

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

当然，除了 addClass 和 removeClass 方法，也可以用 attr 方法对属性进行操作。此外，text 和 htm 方法可以用来改变节点内部的内容。实例如下：

html = '''
<ul class="list">
    <li class="item-0 active"><a href="link3.html"><span>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 节点。

运行结果如下：

<li class="item-0 active"><a href="link3.html"><span>third item</span></a></li>
<li class="item-0 active" name="link"><a href="link3.html"><span>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 文本：

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 的节点中的内容，看看是不是我们想要的。运行结果如下：

Hello,World This is a paragraph.

这个结果中包含着 p 节点的内容，也就是说 text 方法把所有纯文本全提取出来了。要想去掉 p 节点内部的文本，可以再把 p 节点内的文本提取一遍，然后从整个结果中移除这个子串，显然这个做法比较烦琐。

这时 remove 方法就派上用场了，可以这么做

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

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

其实还有很多操作节点的方法，例如 append、empty 和 prepend 等。

伪类选择器

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

这里我们使用的是 CSS 3 的伪类选择器，依次选择了文本中的第一个 li 节点，最后一个 li 节点，第二个 li 节点，第三个 li 之后的 li 节点，偶数位置的 li 节点，包含 second 文本的 li 节点。

总结

到此为止，pyquery 库的常用用法就介绍完了，如果想查看更多内容，可以参考 pyquery 的官方文档： http://pyquery.readthedocs.io 。

本节代码参考： https://github.com/Python3WebSpider/PyQueryTest 。