Python网络爬虫案例实战：解析网页：PyQuery 解析库

andyyah晓波

于 2024-08-13 12:05:08 发布

阅读量742

点赞数 31

分类专栏： Python网络爬虫案例实战文章标签： python 爬虫开发语言

本文链接：https://blog.csdn.net/andyyah/article/details/141151320

版权

Python网络爬虫案例实战专栏收录该内容

29 篇文章 0 订阅

订阅专栏

Python网络爬虫案例实战：解析网页：PyQuery 解析库

前面介绍了BeautifulSoup 的用法，它是一个非常强大的网页解析库，你是否觉得它的一些方法用起来有点不适用？有没有觉得它的CSS选择器的功能没有那么强大？
下面来介绍一个更适合的解析库—PyQuery。PyQuery库是jQuery的Python实现，能够以jQuery的语法来操作解析HTML 文档，易用性和解析速度都很好，使用起来还是可以的，有些地方用起来很方便简洁。

5.4.1使用PyQuery

如果之前没有安装PyQuery，可在命令窗口中直接使用pip install PyQuery进行安装。
1.初始化
像 BeautifulSoup 一样，初始化PyQuery的时候，也需要传人HTML 文本来初始化一个PyQuery对象，它的初始化方式有多种，比如直接传入字符串、传入URL、传人文件名，等等。下面详细介绍。
1）字符串初始化
首先，通过一个实例来感受一下：

from pyquery import PyQuery as pq

# 定义 HTML 字符串
html = """
<html lang="en">
<head>
简单好用的
    <title>PyQuery</title>
</head>
<body>
    <ul id="container">
        <li class="object-1">Python</li>
        <li class="object-2">爬虫</li>
        <li class="object-3">好</li>
    </ul>
</body>
</html>
"""

# 初始化为 PyQuery 对象
doc = pq(html)

# 打印对象的类型
print(type(doc))

# 打印 PyQuery 对象的内容
print(doc)

运行程序，输出如下：

<class 'pyquery.pyquery.PyQuery'>
<html lang="en">
<head>
简单好用的
    <title>PyQuery</title>
</head>
<body>
    <ul id="container">
        <li class="object-1">Python</li>
        <li class="object-2">爬虫</li>
        <li class="object-3">好</li>
    </ul>
</body>
</html>

这里首先引入PyQuery这个对象，取别名为pq，然后声明了一个长HTML字符串，并将其当作参数传递给PyQuery类，这样就成功完成了初始化。接下来，将初始化的对象传入 CSS选择器。在这个实例中，传入li节点，这样就可以选择所有的1i节点。
2）对网址响应进行初始化
初始化的参数不仅可以以字符串的形式传递，还可以传入网页的URL，此时只需要指定参数为url 即可：

from pyquery import PyQuery as pq
#初始化为 PyQuery对象
response = pq(url ='https://www.baidu.com')
print(type(response))
print(response)

运行程序，输出如下：

<class 'pyquery.pyquery.PyQuery'>
<html> <head><meta http-equiv="content-type" content="text/html;charset=utf-8"/><meta http-equiv="X-UA-Compatible" content="IE=Edge"/><meta content="always" name="referrer"/><link rel="stylesheet" type="text/css" href="https://ss1.bdstatic.com/5eN1bjq8AAUYm2zgoY3K/r/www/cache/bdorz/baidu.min.css"/><title>ç¾åº¦ä¸ä¸ï¼ä½ å°±ç¥é</title></head> <body link="#0000cc"> <div id="wrapper">

2.CSS 选择器
首先，用一个实例来感受PyQuery的 CSS选择器的用法：

# 定义 HTML 字符串
html = """
<html lang="en">
<head>
简单好用的
    <title>PyQuery</title>
</head>
<body>
    <ul id="container">
        <li class="object-1">Python</li>
        <li class="object-2">爬虫</li>
        <li class="object-3">好</li>
    </ul>
</body>
</html>
"""
from pyquery import PyQuery as pq
doc = pq(html)

print(doc('#container'))
print(type(doc('#container')))

运行程序，输出如下：

<ul id="container">
        <li class="object-1">Python</li>
        <li class="object-2">爬虫</li>
        <li class="object-3">好</li>
    </ul>

<class 'pyquery.pyquery.PyQuery'>

这里初始化 PyQuery对象之后，传入了一个CSS选择器井container.list li，它的意思为选取id为 container的节点，然后再选取其内部的class为list的节点内部的所有li节点。然后，打印输出，可以看到，成功获取了符合条件的节点。最后，将它的类型打印输出，可以看到，它的类型依然是PyQuery类型。
再例如，打印 class为object-l的标签：

print(doc('.object-1'))

输出如下：

<li class="object-1">Python</li>

打印标签名为body的标签：

print(doc('body'))

输出如下：

<body>
    <ul id="container">
        <li class="object-1">Python</li>
        <li class="object-2">爬虫</li>
        <li class="object-3">好</li>
    </ul>
</body>

3.查找节点
下面介绍一些常用的查询函数。
1）子节点
查找子节点时，需要用到find（）方法，此时传入的参数是CSS选择器。

from pyquery import PyQuery as pq

# 定义 HTML 字符串
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>
"""

# 初始化为 PyQuery 对象
doc = pq(html)

# 查询所有 <li> 元素
items = doc('li')
print(type(items))  # 输出 items 的类型
print(items)  # 输出 items

# 查找所有 <li> 元素的子元素
lis = items.find('li')
print(type(lis))  # 输出 lis 的类型
print(lis)  # 输出 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 'pyquery.pyquery.PyQuery'>

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

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

输出如下：

<class 'pyquery.pyquery.PyQuery'>
<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为 active的节点，可以向children（）方法传入CSS选择器.active：

active_items = items.filter('.active')
print(type(active_items))  # 输出 active_items 的类型
print(active_items)  # 输出 active_items

输出如下：

<class 'pyquery.pyquery.PyQuery'>
<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的节点。
2）父节点
在Python 中，可以用 parent（）方法来获取某个节点的父节点，例如：

from pyquery import PyQuery as pq

# 定义修正后的 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>
"""

# 初始化为 PyQuery 对象
doc = pq(html)

# 查询具有 class="list" 的 <ul> 元素
items = doc('.list')

# 获取父元素，即 <div id="container">
container = items.parent()

# 打印结果
print(type(container))  # 输出 container 的类型
print(container)       # 输出 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（）方法：

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的节点。
3）兄弟节点
除了前面介绍的子节点、父节点外，还有一种节点，那就是兄弟节点。如果要获取兄弟节点，可以使用siblings（）方法。例如：

# 查询具有 class="item-0" 且同时具有 class="active" 的 <li> 元素
li = doc('.list .item-0.active')

# 打印该 <li> 元素的同级元素（即它的兄弟元素）
print(li.siblings())

输出如下：

<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选择器，这样就会从所有兄弟节点中挑选出符合条件的节点了：

print(li.siblings('.active'))

输出如下：

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

这里筛选了class为active的节点，通过刚才的结果可以观察到，class为 active的兄弟节点只有第四个li节点，所以结果应该是一个。
4.遍历
由刚才可观察到，PyQuery的选择结果可能是多少节点，也可能是单个节点，类型都是PyQuery，并没有返回像 BeautifulSoup 那样的列表。
对于单个节点来说，可以直接打印输出，也可以直接转成字符串：

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（）方法：

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（）方法后，会得到一个生成器，遍历一下，就可以逐个得到1i节点对象了，它的类型也是PyQuery类型。每个li节点还可以调用前面所说的方法进行选择，比如继续查询子节点，寻找某个祖先节点等，非常灵活。
5.获取信息
提取到节点之后，最终目的是提取节点所包含的信息。比较重要的信息有两类：一是获取属性，二是获取文本。下面具体说明。
1）获取属性
提取到某个PyQuery 类型的节点后，就可以调用attr（）方法来获取属性：

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节点的属性，就要用到前面所说的遍历了：

for item in a.items():
    print(item.attr('href'))

输出：

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

因此，在进行属性获取时，可以观察返回节点是一个还是多个。如果是多个，则需要遍历才能依次获取每个节点的属性。
2）获取文本
获取节点之后的另一个主要操作就是获取其内部的文本了，此时可以调用 text（）方法来实现：

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（）方法了：

li = doc('.item-0.active')
print(li) 
print(li. html())

输出：

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

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

在程序中选中了第三个li节点，然后调用了html（）方法，它返回的结果应该是li节点内的所有HTML 文本。
这里同样有一个问题，如果选中的结果是多个节点，text（）或html（）会返回什么内容？用实例来测试下：

from pyquery import PyQuery as pq

# 初始化为 PyQuery 对象
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>
"""

doc = pq(html)
li = doc('li')

# 输出所有 <li> 元素的 HTML 内容
print(li.html())

# 输出所有 <li> 元素的文本内容
print(li.text())

# 输出 text 的类型（应为 <class 'str'>）
print(type(li.text()))

输出：

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

结果可能比较出人意料，html（）方法返回的是第一个li节点的内部 HTML 文本，而text（）返回了所有的li节点内部的纯文本，中间用一个空格分隔开，即返回结果是一个字符串。
值得注意的是，如果得到的结果是多个节点，并且想要获取每个节点的内部 HTML 文本，则需要遍历每个节点；而使用 text（）方法不需要遍历就可以获取，它对所有节点取文本之后合并成一个字符串。
6.节点操作
PyQuery提供了一系列方法来对节点进行动态修改，比如为某个节点添加一个class，移除某个节点等，这些操作有时会为提取信息带来极大的便利。
由于节点操作的方法太多，下面举几个典型的例子来说明它的用法。
1）addClass 和removeClass
下面先体会实例演示：

from pyquery import PyQuery as pq

# 定义修正后的 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>
"""

# 初始化为 PyQuery 对象
doc = pq(html)

# 查询具有 class="item-0 active" 的 <li> 元素
li = doc('.item-0.active')

# 打印选中的 <li> 元素
print(li)

# 从选中的 <li> 元素中移除 class="active"
li.removeClass('active')

# 打印修改后的 <li> 元素
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次。第二次输出时，i节点的active这个class被移除了，第三次 class又添加回来了。
所以，addClass（）和removeClass（）这些方法可以动态改变节点的class属性。
2）attr、text 和html
当然，除了操作 class这个属性外，也可以用attr（）方法对属性进行操作。此外，还可以用 text（）和html（）方法来改变节点内部的内容。例如：

from pyquery import PyQuery as pq

# 定义修正后的 HTML 字符串
html = """
<ul class="list">
    <li class="item-0 active">
        <a href="link3.html">
            <span class="bold">third item</span>
        </a>
    </li>
</ul>
"""

# 初始化为 PyQuery 对象
doc = pq(html)

# 选择具有 class="item-0 active" 的 <li> 元素
li = doc('.item-0.active')

# 打印选中的 <li> 元素
print(li)

# 为 <li> 元素添加一个名为 'name' 的属性，值为 'link'
li.attr('name', 'link')
print(li)

# 修改 <li> 元素的文本内容（注意，这会替换整个文本内容）
li.text('changed item')
print(li)

# 修改 <li> 元素的 HTML 内容
li.html('<span>changed item</span>')
print(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>

这里首先选中1i节点，然后调用attr（）方法来修改属性，其中该方法的第一个参数为属性名，第二个参数为属性值。接着，调用 text（）和html（）方法来改变节点内部的内容。两次操作后，分别打印输出当前的li节点。
由结果可发现，调用attr（）方法后，Ii节点多了一个原本不存在的属性name，其值为link。接着调用 text（）方法，传人文本之后，li节点内部的文本全部被改为传人的字符串文本了。最后，调用html（）方法传人HTML 文本后，li节点内部又变为传入的HTML 文本了。
所以，如果attr（）方法只传入第一个参数的属性名，则是获取这个属性值；如果传入第二个参数，则可以用来修改属性值。text（）和html（）方法如果不传参数，则是获取节点内纯文本和HTML 文本；如果传入参数，则进行赋值。
3）remove（）
remove（）的方法即为移除，它有时会为信息的提取带来非常大的便利。下面有一段HTML 文本：

from pyquery import PyQuery as pq

# 定义修正后的 HTML 字符串
html = """
<div class="wrap">
    Hello, World
    <p>This is a paragraph.</p>
</div>
"""

# 初始化为 PyQuery 对象
doc = pq(html)

# 选择具有 class="wrap" 的 <div> 元素
wrap = doc('.wrap')

# 打印 <div class="wrap"> 元素的文本内容
print(wrap.text())

输出：

Hello, World
This is a paragraph.

我们想提取的是“Hello，World”这个字符串，而这个结果还包含了内部的p节点的内容，也就是说，text（）把所有的纯文本全提取出来了。如果想去掉p节点内部的文本，可以选择再把p节点内的文本提取一遍，然后从整个结果中移除这个子串，但这个做法明显比较烦琐。而remove（）方法就可以实现该功能，例如：

# 查找 <div class="wrap"> 内的 <p> 元素并将其移除
wrap.find('p').remove()

# 打印更新后的 <div class="wrap"> 元素的文本内容
print(wrap.text())

输出：

Hello, World

以上代码的思路是：首先选中p节点，然后调用remove（）方法将其移除，这时wrap内部就只剩下“Hello，World”了，再利用 text（）方法提取即可。
7.伪类选择器
CSS选择器之所以强大，有一个重要的原因，那就是它支持多种多样的伪类选择器，例如，选择第一个节点、最后一个节点、奇偶数节点、包含某一文本的节点等等。实例如下：

from pyquery import PyQuery as pq

# 定义修正后的 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>
"""

# 初始化为 PyQuery 对象
doc = pq(html)

# 选择第一个 <li> 元素
li = doc('li:first-child')
print(li)

# 选择最后一个 <li> 元素
li = doc('li:last-child')
print(li)

# 选择第二个 <li> 元素
li = doc('li:nth-child(2)')
print(li)

# 选择所有第 3 个及其之后的 <li> 元素
li = doc('li:gt(2)')
print(li)

# 选择所有偶数索引的 <li> 元素（从 0 开始）
li = doc('li:nth-child(2n)')
print(li)

# 选择包含文本 "second" 的 <li> 元素
li = doc('li:contains("second")')
print(li)

输出：

<li class="item-0">first item</li>

<li class="item-0"><a href="link5.html">fifth item</a></li>

<li class="item-1"><a href="link2.html">second item</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>       

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

<li class="item-1"><a href="link2.html">second item</a></li>

在代码中，使用了CSS的伪类选择器，依次选择了第一个li节点、最后一个li节点、第二个i节点、第三个li之后的1i节点、偶数位置的1i节点、包含 second 文本的1节点。

5.4.2PyQuery爬取煎蛋网商品图片

图片一般都是以链接的形式出现在HTML文本中，因此只需要找到图片连接即可（一般是在img src中），这时再把图片url 打开，利用content保存成具体的文件。这里使用的hashlib是一个编码库，为了使得每一个图片的名字不一样，就用md5这个方法把图片的内容进行了编码。爬取煎蛋网加入了一定的反爬取措施，即并不是直接将图片的url列出来，而是利用一个.js文件，在每一次加载图片的时候都要加载这个.js文件，进而把图片的url解析出来。实现代码为：

import requests
from pyquery import PyQuery as pq
import hashlib
import base64
from hashlib import md5
def ty(body):
    print(type(body))
 
# 处理md5编码问题
def handle_md5(hd_object):
    return hashlib.md5(hd_object.encode('utf-8')).hexdigest()
 
# 处理base64编码问题
def handle_base64(hd_object):
	return str(base64.b64decode(hd_object))[2:-1]
 
# 解密图片链接
def parse(ig_hs, ct):
    count = 4
    contains = handle_md5(ct)
    ig_hs_copy = ig_hs
    p = handle_md5(contains[0:16])
    m = ig_hs[0:count]
    c = p + handle_md5(p + m)
    n = ig_hs[count:]
    l = handle_base64(n)
    k = []
    for h in range(256):
        k.append(h)
    b = []
    for h in range(256):
        b.append(ord(c[h % len(c)]))
    g = 0
    for h in range(256):
        g = (g + k[h] + b[h]) % 256
        tmp = k[h]
        k[h] = k[g]
        k[g] = tmp
    u = ''
    q = 0
    z = 0
    for h in range(len(l)):
        q = (q + 1) % 256
        z = (z + k[q]) % 256
        tmp = k[q]
        k[q] = k[z]
        k[z] = tmp
        u += chr(ord(l[h]) ^ (k[(k[q] + k[g]) % 256]))
    u = u[26:]
    u = handle_base64(ig_hs_copy)
    return u
for i in range(1,10):
    url = 'http://jandan.net/ooxx/'+str(i)+'#comments'
    response = requests.get(url)
    doc = pq(response.text)
    links = doc('#wrapper #body #content #comments .commentlist .row .text .img-hash')
    print(links)
    arg = '5HTs9vFpTZjaGnG2M473PomLAGtI37M8'
    for link in links:
        l=link.text
        print(type(l))
        u=parse(l,arg)
        #print(u)
        u1='http:'+u
        print(u1)
        r=requests.get(u1)
        with open('D:/image/'+md5(r.content).hexdigest()+'.jpg','wb') as f:
            f.write(r.content)
            f.close()

在这里插入图片描述

andyyah晓波

关注

31
点赞
踩
11

收藏

觉得还不错? 一键收藏
0
评论
Python网络爬虫案例实战：解析网页：PyQuery 解析库

前面介绍了BeautifulSoup 的用法，它是一个非常强大的网页解析库，你是否觉得它的一些方法用起来有点不适用？有没有觉得它的CSS选择器的功能没有那么强大？下面来介绍一个更适合的解析库—PyQuery。PyQuery库是jQuery的Python实现，能够以jQuery的语法来操作解析HTML 文档，易用性和解析速度都很好，使用起来还是可以的，有些地方用起来很方便简洁。
复制链接

扫一扫

专栏目录