运维学python之爬虫工具篇（二）Beautiful Soup的用法

原創 578384 2019-07-05 13:17

前面的内容我们都是用正则的方式获取想要的内容，每次写正则匹配时候都要测试好多次，是不是能够获取我们想要的结果，感觉很烦是不是，下面我们就介绍一下更好的方式，通过Beautiful Soup
来获取，let's go！

1 Beautiful Soup安装

1.1 介绍

Beautiful Soup是一个可以从HTML或XML文件中提取数据的Python库.它能够通过你喜欢的转换器实现惯用的文档导航,查找,修改文档的方式.Beautiful Soup会帮你节省数小时甚至数天的工作时间.

1.2 安装Beautiful Soup

如果你用的是新版的Debain或ubuntu,那么可以通过系统的软件包管理来安装:

$ apt-get install Python-bs4

Beautiful Soup 4 通过PyPi发布,所以如果你无法使用系统包管理安装,那么也可以通过 easy_install 或 pip 来安装.包的名字是 beautifulsoup4 ,这个包兼容Python2和Python3.

$ easy_install beautifulsoup4
$ pip install beautifulsoup4

(在PyPi中还有一个名字是 BeautifulSoup 的包,但那可能不是你想要的,那是 Beautiful Soup3 的发布版本,因为很多项目还在使用BS3, 所以 BeautifulSoup 包依然有效.但是如果你在编写新项目,那么你应该安装的 beautifulsoup4 )
如果你没有安装 easy_install 或 pip ,那你也可以 下载BS4的源码 ,然后通过setup.py来安装.

$ Python setup.py install

如果上述安装方法都行不通,Beautiful Soup的发布协议允许你将BS4的代码打包在你的项目中,这样无须安装即可使用.
Pycharm中如何安装，上一节已经介绍，大家按照相同方式安装即可。

1.3 安装完成后的问题

Beautiful Soup发布时打包成Python2版本的代码,在Python3环境下安装时,会自动转换成Python3的代码,如果没有一个安装的过程,那么代码就不会被转换.
如果代码抛出了 ImportError 的异常: “No module named HTMLParser”, 这是因为你在Python3版本中执行Python2版本的代码.
如果代码抛出了 ImportError 的异常: “No module named html.parser”, 这是因为你在Python2版本中执行Python3版本的代码.
如果遇到上述2种情况,最好的解决方法是重新安装BeautifulSoup4.
如果在ROOT_TAG_NAME = u’[document]’代码处遇到 SyntaxError “Invalid syntax”错误,需要将把BS4的Python代码版本从Python2转换到Python3. 可以重新安装BS4:

$ Python3 setup.py install

或在bs4的目录中执行Python代码版本转换脚本

$ 2to3-3.2 -w bs4

1.4 安装解析器

Beautiful Soup支持Python标准库中的HTML解析器,还支持一些第三方的解析器,其中一个是 lxml .根据操作系统不同,可以选择下列方法来安装lxml:

$ apt-get install Python-lxml
$ easy_install lxml
$ pip install lxml

另一个可供选择的解析器是纯Python实现的 html5lib , html5lib的解析方式与浏览器相同,可以选择下列方法来安装html5lib:

$ apt-get install Python-html5lib
$ easy_install html5lib
$ pip install html5lib

下表列出了主要的解析器,以及它们的优缺点:
运维学python之爬虫工具篇（二）Beautiful Soup的用法

推荐使用lxml作为解析器,因为效率更高. 在Python2.7.3之前的版本和Python3中3.2.2之前的版本,必须安装lxml或html5lib, 因为那些Python版本的标准库中内置的HTML解析方法不够稳定.
提示: 如果一段HTML或XML文档格式不正确的话,那么在不同的解析器中返回的结果可能是不一样的。

2 使用Beautiful Soup

官方文档

2.1 如何使用

将一段文档传入BeautifulSoup 的构造方法,就能得到一个文档的对象, 可以传入一段字符串或一个文件句柄.

# 导入模块
from bs4 import BeautifulSoup
#  打开本地文件index.html
soup = BeautifulSoup(open("index.html"))
# 打开字符串
soup = BeautifulSoup("<html>data</html>")

首先,文档被转换成Unicode,并且HTML的实例都被转换成Unicode编码

BeautifulSoup("Sacré bleu!")
<html><head></head><body>Sacré bleu!</body></html>

然后,Beautiful Soup选择最合适的解析器来解析这段文档,如果手动指定解析器那么Beautiful Soup会选择指定的解析器来解析文档.

2.2 对象的种类

Beautiful Soup将复杂HTML文档转换成一个复杂的树形结构,每个节点都是Python对象,所有对象可以归纳为4种: Tag , NavigableString , BeautifulSoup , Comment .
Tag
Tag其实就是html中的标签，下面我们用代码来说明一下：

# -*- coding: utf-8 -*-
# 导入模块
from bs4 import BeautifulSoup

# 定义html
html_doc = """
<html><head><title>The Dormouse's story</title></head>
<p class="title"><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>
"""
# 创建对象，通过lxml解析
soup = BeautifulSoup(html_doc, 'lxml')
# 打印标签
print(soup.title)
print(soup.p)
print(soup.a)

# 输出结果：
# <title>The Dormouse's story</title>
# <p class="title"><b>The Dormouse's story</b></p>
# <a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>

Tag有两个重要的属性 name 和 attrs:
name
每个tag都有自己的名字,通过 .name 来获取:

tag.name
# u'b'

如果改变了tag的name,那将影响所有通过当前Beautiful Soup对象生成的HTML文档:

tag.name = "blockquote"
tag
# <blockquote class="boldest">Extremely bold</blockquote>

attrs
一个tag可能有很多个属性. tag <b class="boldest"> 有一个 “class” 的属性,值为 “boldest” . tag的属性的操作方法与字典相同:

tag['class']
# u'boldest'

也可以直接”点”取属性, 比如: .attrs :

tag.attrs
# {u'class': u'boldest'}

tag的属性可以被添加,删除或修改. 再说一次, tag的属性操作方法与字典一样

tag['class'] = 'verybold'
tag['id'] = 1
tag
# <blockquote class="verybold" id="1">Extremely bold</blockquote>

del tag['class']
del tag['id']
tag
# <blockquote>Extremely bold</blockquote>

tag['class']
# KeyError: 'class'
print(tag.get('class'))
# None

NavigableString
标签中字符串，也就是我们想要得到的结果如何获取？Beautiful Soup用 NavigableString 类来包装tag中的字符串，直接通过string就可以获得内容:

略（与上面代码相同）
print(soup.title.string)
# The Dormouse's story

BeautifulSoup
BeautifulSoup 对象表示的是一个文档的全部内容.大部分时候,可以把它当作 Tag 对象，因为 BeautifulSoup 对象并不是真正的HTML或XML的tag,所以它没有name和attribute属性.但有时查看它的 .name 属性是很方便的,所以 BeautifulSoup 对象包含了一个值为 “[document]” 的特殊属性 .name

相同代码略
print(soup.name)
print(soup.attrs)
print(type(soup.name))
# [document]
# {}
# <class 'str'>

Comment
Tag , NavigableString , BeautifulSoup 几乎覆盖了html和xml中的所有内容,但是还有一些特殊对象.容易让人担心的内容是文档的注释部分

markup = "<b><!--Hey, buddy. Want to buy a used parser?--></b>"
soup = BeautifulSoup(markup, 'lxml')
print(soup.b.string)
print(soup.b.prettify())
print(type(soup.b.string))
# 如果用sting打印出来，我们发现它已经把注释符号去掉了，容易引起不必要的麻烦
# Hey, buddy. Want to buy a used parser?
# <b><!--Hey, buddy. Want to buy a used parser?--></b>
# <class 'bs4.element.Comment'>

2.3 遍历子节点

一个Tag可能包含多个字符串或其它的Tag,这些都是这个Tag的子节点.Beautiful Soup提供了许多操作和遍历子节点的属性.
注意: Beautiful Soup中字符串节点不支持这些属性,因为字符串没有子节点
操作文档树最简单的方法就是告诉它你想获取的tag的name.如果想获取 <head> 标签,只要用 soup.head :

soup.head
# <head><title>The Dormouse's story</title></head>
soup.title
# <title>The Dormouse's story</title>

这是个获取tag的小窍门,可以在文档树的tag中多次调用这个方法.下面的代码可以获取<body>标签中的第一个<b>标签:

soup.body.b
# <b>The Dormouse's story</b>

通过点取属性的方式只能获得当前名字的第一个tag:

soup.a
# <a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>

如果想要得到所有的<a>标签,或是通过名字得到比一个tag更多的内容的时候,就需要用到 Searching the tree 中描述的方法,比如: find_all()

soup.find_all('a')
# [<a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>,
#  <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>,
#  <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>]

2.4 tag的 .contents 属性

tag的 .contents 属性可以将tag的子节点以列表的方式输出:

head_tag = soup.head
head_tag
# <head><title>The Dormouse's story</title></head>

head_tag.contents
[<title>The Dormouse's story</title>]

title_tag = head_tag.contents[0]
title_tag
# <title>The Dormouse's story</title>
title_tag.contents
# [u'The Dormouse's story']

2.5 tag的 .children 生成器

通过tag的 .children 生成器可以对tag的子节点进行循环:

for child in title_tag.children:
    print(child)
    # The Dormouse's story

2.6 .descendants

.contents 和 .children 属性仅包含tag的直接子节点.例如,<head>标签只有一个直接子节点<title>
但是<title>标签也包含一个子节点:字符串 “The Dormouse’s story”,这种情况下字符串 “The Dormouse’s story”也属于<head>标签的子孙节点. .descendants 属性可以对所有tag的子孙节点进行递归循环 :

for child in head_tag.descendants:
    print(child)
    # <title>The Dormouse's story</title>
    # The Dormouse's story

2.7 .string

如果tag只有一个 NavigableString 类型子节点,那么这个tag可以使用 .string 得到子节点:

title_tag.string
# u'The Dormouse's story'

如果一个tag仅有一个子节点,那么这个tag也可以使用 .string 方法,输出结果与当前唯一子节点的 .string 结果相同:

head_tag.contents
# [<title>The Dormouse's story</title>]
head_tag.string
# u'The Dormouse's story'

如果tag包含了多个子节点,tag就无法确定 .string 方法应该调用哪个子节点的内容, .string 的输出结果是 None :

print(soup.html.string)
# None

2.8 .strings 和 stripped_strings

如果tag中包含多个字符串 ,可以使用 .strings 来循环获取:

for string in soup.strings:
    print(repr(string))
    # u"The Dormouse's story"
    # u'\n\n'
    # u"The Dormouse's story"
    # u'\n\n'
    # u'Once upon a time there were three little sisters; and their names were\n'
    # u'Elsie'
    # u',\n'
    # u'Lacie'
    # u' and\n'
    # u'Tillie'
    # u';\nand they lived at the bottom of a well.'
    # u'\n\n'
    # u'...'
    # u'\n'

输出的字符串中可能包含了很多空格或空行,使用 .stripped_strings 可以去除多余空白内容:

for string in soup.stripped_strings:
    print(repr(string))
    # u"The Dormouse's story"
    # u"The Dormouse's story"
    # u'Once upon a time there were three little sisters; and their names were'
    # u'Elsie'
    # u','
    # u'Lacie'
    # u'and'
    # u'Tillie'
    # u';\nand they lived at the bottom of a well.'
    # u'...'

全部是空格的行会被忽略掉,段首和段末的空白会被删除

2.9 父节点

.parent
通过 .parent 属性来获取某个元素的父节点.在上面例子html_doc的文档中,<head>标签是<title>标签的父节点:

title_tag = soup.title
title_tag
# <title>The Dormouse's story</title>
title_tag.parent
# <head><title>The Dormouse's story</title></head>

文档title的字符串也有父节点:<title>标签

title_tag.string.parent
# <title>The Dormouse's story</title>

文档的顶层节点比如<html>的父节点是 BeautifulSoup 对象:

html_tag = soup.html
type(html_tag.parent)
# <class 'bs4.BeautifulSoup'>

BeautifulSoup 对象的 .parent 是None:

print(soup.parent)
# None

.parents
通过元素的 .parents 属性可以递归得到元素的所有父辈节点,下面的例子使用了 .parents 方法遍历了<a>标签到根节点的所有节点.

link = soup.a
link
# <a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>
for parent in link.parents:
    if parent is None:
        print(parent)
    else:
        print(parent.name)
# p
# body
# html
# [document]
# None

2.10 兄弟节点

在文档树中,使用 .next_sibling 和 .previous_sibling 属性来查询兄弟节点:
实际文档中的tag的 .next_sibling 和 .previous_sibling 属性通常是字符串或空白. 看看html_doc文档:

<a href="http://example.com/elsie" class="sister" id="link1">Elsie</a>
<a href="http://example.com/lacie" class="sister" id="link2">Lacie</a>
<a href="http://example.com/tillie" class="sister" id="link3">Tillie</a>

如果以为第一个<a>标签的 .next_sibling 结果是第二个<a>标签,那就错了,真实结果是第一个<a>标签和第二个<a>标签之间的顿号和换行符:

link = soup.a
link
# <a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>

link.next_sibling
# u',\n'

第二个<a>标签是顿号的 .next_sibling 属性:

link.next_sibling.next_sibling
# <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>

通过 .next_siblings 和 .previous_siblings 属性可以对当前节点的兄弟节点迭代输出:

for sibling in soup.a.next_siblings:
    print(repr(sibling))
    # u',\n'
    # <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>
    # u' and\n'
    # <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>
    # u'; and they lived at the bottom of a well.'
    # None

for sibling in soup.find(id="link3").previous_siblings:
    print(repr(sibling))
    # ' and\n'
    # <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>
    # u',\n'
    # <a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>
    # u'Once upon a time there were three little sisters; and their names were\n'
    # None

2.11 .next_element 和 .previous_element

.next_element 属性指向解析过程中下一个被解析的对象(字符串或tag),我们可能认为结果与 .next_sibling 相同,但通常是不一样的.

# -*- coding: utf-8 -*-
# 导入模块
from bs4 import BeautifulSoup

# # 定义html
html_doc = """
<html><head><title>The Dormouse's story</title></head>
<p class="title"><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>
"""
# 创建对象，通过lxml解析
soup = BeautifulSoup(html_doc, 'lxml')
last_a_tag = soup.find('a', id='link3')
print(last_a_tag)

print(last_a_tag.next_sibling)
print('这是我们想要的结果')
print(last_a_tag.next_element)

#  <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>
# ;
# and they lived at the bottom of a well.
# 这是我们想要的结果
# Tillie

从上面可以看出，其实.next_element的意思不是按分层来的，是按照标签或字符串来进行的，就如：<a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>。a的next_element是字符串‘Tillie’
通过 .next_elements 和 .previous_elements 的迭代器就可以向前或向后访问文档的解析内容,就好像文档正在被解析一样:

3 搜索文档树（常用功能）

3.2 find_all

Beautiful Soup定义了很多搜索方法,这里着重介绍2个: find() 和 find_all() .其它方法的参数和用法类似,请读者举一反三.
find_all( name , attrs , recursive , text , **kwargs )

  • name:name 参数可以查找所有名字为 name 的tag,字符串对象会被自动忽略掉.
  • attrs:调用tag的attrs
  • recursive:调用tag的 find_all() 方法时,Beautiful Soup会检索当前tag的所有子孙节点,如果只想搜索tag的直接子节点,可以使用参数 recursive=False .
  • text:通过 text 参数可以搜搜文档中的字符串内容.与 name 参数的可选值一样, text 参数接受 字符串 , 正则表达式 , 列表, True .
  • **kwargs:如果一个指定名字的参数不是搜索内置的参数名,搜索时会把该参数当作指定名字tag的属性来搜索,如果包含一个名字为 id 的参数,Beautiful Soup会搜索每个tag的”id”属性.

find_all() 方法搜索当前tag的所有tag子节点,并判断是否符合过滤器的条件.这里有几个例子:

soup.find_all("title")
# [<title>The Dormouse's story</title>]

soup.find_all("p", "title")
# [<p class="title"><b>The Dormouse's story</b></p>]

soup.find_all("a")
# [<a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>,
#  <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>,
#  <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>]

soup.find_all(id="link2")
# [<a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>]

import re
soup.find(text=re.compile("sisters"))
# u'Once upon a time there were three little sisters; and their names were\n'

3.3 find

find_all() 方法将返回文档中符合条件的所有tag,尽管有时候我们只想得到一个结果.比如文档中只有一个<body>标签,那么使用 find_all() 方法来查找<body>标签就不太合适, 使用 find_all 方法并设置 limit=1 参数不如直接使用 find() 方法.
唯一的区别是 find_all() 方法的返回结果是值包含一个元素的列表,而 find() 方法直接返回结果.find_all() 方法没有找到目标是返回空列表, find() 方法找不到目标时,返回 None .

soup.find_all('title', limit=1)
# [<title>The Dormouse's story</title>]

soup.find('title')
# <title>The Dormouse's story</title>
print(soup.find("nosuchtag"))
# None

我们已经用了很大篇幅来介绍 find_all() 和 find() 方法,Beautiful Soup中还有10个用于搜索的API.它们中的五个用的是与 find_all() 相同的搜索参数,另外5个与 find() 方法的搜索参数类似.区别仅是它们搜索文档的不同部分.这里就不作详细介绍了。其它方法

4 CSS选择器

eautiful Soup支持大部分的CSS选择器 ,在 Tag 或 BeautifulSoup 对象的 .select() 方法中传入字符串参数,即可使用CSS选择器的语法找到tag:

soup.select("title")
# [<title>The Dormouse's story</title>]

soup.select("p nth-of-type(3)")
# [<p class="story">...</p>]

通过tag标签逐层查找:

soup.select("body a")
# [<a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>,
#  <a class="sister" href="http://example.com/lacie"  id="link2">Lacie</a>,
#  <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>]

soup.select("html head title")
# [<title>The Dormouse's story</title>]

找到某个tag标签下的直接子标签 [6] :

soup.select("head > title")
# [<title>The Dormouse's story</title>]

soup.select("p > a")
# [<a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>,
#  <a class="sister" href="http://example.com/lacie"  id="link2">Lacie</a>,
#  <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>]

soup.select("p > a:nth-of-type(2)")
# [<a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>]

soup.select("p > #link1")
# [<a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>]

soup.select("body > a")
# []

找到兄弟节点标签:

soup.select("#link1 ~ .sister")
# [<a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>,
#  <a class="sister" href="http://example.com/tillie"  id="link3">Tillie</a>]

soup.select("#link1 + .sister")
# [<a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>]

通过CSS的类名查找:

soup.select(".sister")
# [<a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>,
#  <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>,
#  <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>]

soup.select("[class~=sister]")
# [<a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>,
#  <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>,
#  <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>]

通过tag的id查找:

soup.select("#link1")
# [<a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>]

soup.select("a#link2")
# [<a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>]

通过是否存在某个属性来查找:

soup.select('a[href]')
# [<a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>,
#  <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>,
#  <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>]

通过属性的值来查找:

soup.select('a[href="http://example.com/elsie"]')
# [<a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>]

soup.select('a[href^="http://example.com/"]')
# [<a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>,
#  <a class="sister" href="http://example.com/lacie" id="link2">Lacie</a>,
#  <a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>]

soup.select('a[href$="tillie"]')
# [<a class="sister" href="http://example.com/tillie" id="link3">Tillie</a>]

soup.select('a[href*=".com/el"]')
# [<a class="sister" href="http://example.com/elsie" id="link1">Elsie</a>]

通过语言设置来查找:

multilingual_markup = """
 <p lang="en">Hello</p>
 <p lang="en-us">Howdy, y'all</p>
 <p lang="en-gb">Pip-pip, old fruit</p>
 <p lang="fr">Bonjour mes amis</p>
"""
multilingual_soup = BeautifulSoup(multilingual_markup)
multilingual_soup.select('p[lang|=en]')
# [<p lang="en">Hello</p>,
#  <p lang="en-us">Howdy, y'all</p>,
#  <p lang="en-gb">Pip-pip, old fruit</p>]

具体的使用方法可以参考官方文档，我只是整理了常用的一些。

5 实例

是不是都看完感觉很枯燥，好吧，来个例子提提神儿

例子只是让大家熟悉用法，请勿给他人网站造成影响，具体都再注释里，就不多写了


# -*- coding: utf-8 -*-

import requests
from urllib import request
from bs4 import BeautifulSoup

class DB:
"""
爬取豆瓣妹子图片
"""

def __init__(self, baseurl):
    """
    初始化baseurl
    """
    self.baseurl = baseurl

def geturl(self, pn):
    """
    获取图片的url，pn为当前的页码
    """
    # 组成完整的url
    url = self.baseurl + "?pager_offset=" + str(pn)
    # 通过requests打开url
    req = requests.get(url)
    # 建立soup对象
    soup = BeautifulSoup(req.text, 'lxml')
    # 通过find_all方法获取img标签，class为height_min的内容，注意class后有'_'下划线
    imgurls = soup.find_all('img', class_='height_min')
    # 定义一个空url列表，用来存放图片url
    urllist = []
    # 通过for循环，用.get('src')获取图片url
    for imgurl in imgurls:
        # 添加的列表中
        urllist.append(imgurl.get('src'))
    return urllist

def getimage(self, url):
    """
    下载图片,url为获取的图片url
    """
    # 定义图片名称，通过split分割，取最后一个区间作为图片名称
    filename = url.split('/')[-1]
    # 图片保存的路径，其中文件夹aaa需要先创建，其实也可以直接加一个类的方法来自动创建文件夹
    # 我这类偷懒了，没写，留给你们添加吧
    path = 'E:\\' + 'aaa\\' + filename
    print("正在保存 %s" % filename)
    # 用request.urlretrieve保存图片
    request.urlretrieve(url, path)

def start(self, pn):
    """
    主方法，通过调用start方法来执行程序
    """
    urls = self.geturl(pn)
    for url in urls:
        self.getimage(url)

if name == "main":
baseurl = 'https://www.dbmeinv.com/'
db = DB(baseurl)
db.start(1)


结果图：
![](https://s1.51cto.com/images/blog/201712/24/1d064a6f7f2d45f2eadfb66198c05714.png?x-oss-process=image/watermark,size_16,text_QDUxQ1RP5Y2a5a6i,color_FFFFFF,t_100,g_se,x_10,y_10,shadow_90,type_ZmFuZ3poZW5naGVpdGk=)
發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

pyppeteer初次运行需要下载Chrome无法下载或者下载慢的解决方案

目前網上最多的其實都是自己手動下載，這裏說一下最簡單的、最方便的解決方案。 這裏進行替換就好了，這裏是不需要修改源碼的。 只要在我們引用之前設置下環境變量就好了。 import os DEFAULT_DOWNLOAD_HOST

成小新 2020-07-08 05:42:09

爬虫入门--糗百

文章目錄1.爬蟲基本概念2.Requests 庫基本介紹3.Beautiful Soup 庫介紹 本文目標： 掌握爬蟲的基本概念 Requests 及 Beautiful Soup 兩個 Python 庫的基本使用 通過以上知識完

shelley__huang 2020-07-08 05:17:04

爬虫知识梳理

爬蟲知識簡單梳理 文章目錄爬蟲知識簡單梳理1.分類2.模擬瀏覽器請求數據（常用）3.數據提取XML和HTML區別a. 正則（re模塊）b. Beautiful Soup4模塊[API鏈接](http://beautifulsoup

AggressionStorm 2020-07-08 04:15:54

爬取高清站长之家美图（想爬多少爬多少）

方方面面總是會需要使用一些圖片做封面或背景。圖片有兩種來源：一是通過創可貼自己動手修改下就可以用了，還一種就是在網上下載圖片。 那如何下載高清並且可以供使用的圖片了？我是使用的站長之家網站下載來的圖片（http://sc.chin

iplaypy(蟒蛇师) 2020-07-08 10:43:01

爬虫-获取指定城市所有企业信息

之前寫過一個博客：python爬蟲從企查查獲取企業信息-手工繞開企查查的登錄驗證 https://blog.csdn.net/rock4you/article/details/88254612 但只能獲取指定公司的信息，這篇博客的目的是獲

rock4you 2020-07-08 08:24:13

学习爬虫基础6-HTTP响应状态码参考：

HTTP響應狀態碼參考： 1xx:信息 100 Continue 服務器僅接收到部分請求，但是一旦服務器並沒有拒絕該請求，客戶端應該繼續發送其餘的請求。 101 Switching Protocols 服務器轉換協議：服務器

疯狂打码中 2020-07-08 07:56:24

【Python成长之路】Boss直聘爬虫第2弹：selenium找不到元素的常见问题

哈嘍大家好，我是鵬哥。   今天繼續上週的主題是 —— boss直聘網站的爬蟲。   ~~~上課鈴~~~   盜墓筆記·十年人間李常超（Lao乾媽） - 盜墓筆記·十年人間 1 寫在前面 上一篇文章講的如何破解boss直聘網站的滑塊

鹏哥贼优秀 2020-07-08 06:35:40

【Python成长之路】破解Boss直聘网站滑块验证

  哈嘍大家好，我是鵬哥。   今天要記錄的內容是 —— 破解Boss直聘網站的滑塊驗證。     …… 上 課 鈴…… TuesdayBurak Yeter;Danelle Sandoval - Tuesday 1 寫在前面 最近

鹏哥贼优秀 2020-07-08 06:35:38

4.8实验记录（爬取so问答）

只爬取指定的類的div from bs4 import BeautifulSoup soup=BeautifulSoup(h,'html.parser') a=soup.find_all('div',class_="post-te

Rbdash 2020-07-08 06:12:59

爬虫MOOC 第二周 入门

首先下載Beautiful Soup 4，然後解壓安裝，記得安裝代碼是 python setup.py install 這裏要說明一點！！！很重要，我吃了一個多小時的虧。 我把文件命名爲 bs4.py 這時候如果要from bs4 im

Dr_David_S 2020-07-08 03:09:02

Wireshark抓包工具介绍

      在編寫爬蟲抓取app數據的時候，往往需要通過抓包工具對app進行抓包分析，例如：Fiddler、Charles等，但是在偶爾的情況下，你會發現通過這些工具抓包抓取失敗，一啓用抓包工具，就會顯示網絡錯誤。爲什麼會這樣了？ 我個人

刘延林 | 梦陆 2020-07-08 02:38:37

Python根据地名获取经纬度

以下是通過訪問高德地圖接口獲取指定地名的經緯度信息代碼： import requests import re import json '''獲取地址座標''' def get_get_location_m(name): url

刘延林 | 梦陆 2020-07-08 02:38:27

【python】解决网页gb2312编码中文乱码问题

在寫爬蟲的時候，有時候會遇到非utf-8的網頁，可能會造成中文亂碼問題，比如說遇到的是gb2312的編碼。直接打印中文就會變成亂碼 1.查看網頁編碼 document.characterSet 2.正確解碼 網頁使用的是gb23

冰冷的希望 2020-07-08 01:22:12

Scrapy 架构分析(一)

Scrapy（/ˈskreɪpi/) 是一個Python編寫的開源網絡爬蟲框架。它是一個被設計用於爬取網絡數據、提取結構性數據的程序框架。 使用Scrapy框架可以很方便地爬取網站。 一、Scrapy入門 菜鳥教程Scrapy入門

Tawn0000 2020-07-08 00:37:36

菜鸟爬虫——获取安居客二手房信息

以安居客二手房爲例前言瞭解爬蟲爬蟲目錄結構爬蟲主體代碼items.py反反爬蟲策略運行爬蟲 前言 因爲需要一些二手房數據，菜鳥開啓了爬蟲之路！不過需要注意的是，在爬取數據時，要遵守《中華人民共和國網絡安全法》以及《規範互聯網信息服

温柔小静 2020-07-08 00:33:51