前面的内容我们都是用正则的方式获取想要的内容，每次写正则匹配时候都要测试好多次，是不是能够获取我们想要的结果，感觉很烦是不是，下面我们就介绍一下更好的方式，通过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

下表列出了主要的解析器,以及它们的优缺点:

推荐使用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.htmlsoup = BeautifulSoup(open("index.html"))# 打开字符串soup = BeautifulSoup("data")

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

BeautifulSoup("Sacré bleu!")Sacré bleu!

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

2.2 对象的种类

Beautiful Soup将复杂HTML文档转换成一个复杂的树形结构,每个节点都是Python对象,所有对象可以归纳为4种: Tag , NavigableString , BeautifulSoup , Comment .

TagTag其实就是html中的标签，下面我们用代码来说明一下：

# -*- coding: utf-8 -*-# 导入模块from bs4 import BeautifulSoup# 定义htmlhtml_doc = """
The Dormouse's story
Once upon a time there were three little sisters; and their names wereElsie,Lacie andTillie;and they lived at the bottom of a well.
...
"""# 创建对象，通过lxml解析soup = BeautifulSoup(html_doc, 'lxml')# 打印标签print(soup.title)print(soup.p)print(soup.a)# 输出结果：# # 
The Dormouse's story
# Elsie

Tag有两个重要的属性 name 和 attrs:

name每个tag都有自己的名字,通过 .name 来获取:

tag.name# u'b'

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

tag.name = "blockquote"tag# 
    
     Extremely bold
    

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'] = 1tag# 
    
     Extremely bold
    
del tag['class']del tag['id']tag# 
    
     Extremely bold
    
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]# {}# 
    

Comment

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

markup = "
     "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?# 
     # 
    

2.3 遍历子节点

一个Tag可能包含多个字符串或其它的Tag,这些都是这个Tag的子节点.Beautiful Soup提供了许多操作和遍历子节点的属性.

注意: Beautiful Soup中字符串节点不支持这些属性,因为字符串没有子节点操作文档树最简单的方法就是告诉它你想获取的tag的name.如果想获取 <head> 标签,只要用 soup.head :

soup.head# soup.title# 

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

soup.body.b# The Dormouse's story

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

soup.a# Elsie

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

soup.find_all('a')# [Elsie,#  Lacie,#  Tillie]

2.4 tag的 .contents 属性

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

head_tag = soup.headhead_tag# head_tag.contents[]title_tag = head_tag.contents[0]title_tag# 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)    #     # 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# []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.titletitle_tag# title_tag.parent# 

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

title_tag.string.parent# 

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

html_tag = soup.htmltype(html_tag.parent)# 
    

BeautifulSoup 对象的 .parent 是None:

print(soup.parent)# None

.parents

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

link = soup.alink# Elsiefor 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文档:

ElsieLacieTillie

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

link = soup.alink# Elsielink.next_sibling# u',\n'

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

link.next_sibling.next_sibling# Lacie

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

for sibling in soup.a.next_siblings:    print(repr(sibling))    # u',\n'    # Lacie    # u' and\n'    # Tillie    # u'; and they lived at the bottom of a well.'    # Nonefor sibling in soup.find(id="link3").previous_siblings:    print(repr(sibling))    # ' and\n'    # Lacie    # u',\n'    # Elsie    # 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# # 定义htmlhtml_doc = """
The Dormouse's story
Once upon a time there were three little sisters; and their names wereElsie,Lacie andTillie;and they lived at the bottom of a well.
...
"""# 创建对象，通过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)#  Tillie# ;# and they lived at the bottom of a well.# 这是我们想要的结果# Tillie

从上面可以看出，其实.next_element的意思不是按分层来的，是按照标签或字符串来进行的，就如：<a class="sister" href="" 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")# []soup.find_all("p", "title")# [
The Dormouse's story
]soup.find_all("a")# [Elsie,#  Lacie,#  Tillie]soup.find_all(id="link2")# [Lacie]import resoup.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)# []soup.find('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")# []soup.select("p nth-of-type(3)")# [
...
]

通过tag标签逐层查找:

soup.select("body a")# [Elsie,#  Lacie,#  Tillie]soup.select("html head title")# []

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

soup.select("head > title")# []soup.select("p > a")# [Elsie,#  Lacie,#  Tillie]soup.select("p > a:nth-of-type(2)")# [Lacie]soup.select("p > #link1")# [Elsie]soup.select("body > a")# []

找到兄弟节点标签:

soup.select("#link1 ~ .sister")# [Lacie,#  Tillie]soup.select("#link1 + .sister")# [Lacie]

通过CSS的类名查找:

soup.select(".sister")# [Elsie,#  Lacie,#  Tillie]soup.select("[class~=sister]")# [Elsie,#  Lacie,#  Tillie]

通过tag的id查找:

soup.select("#link1")# [Elsie]soup.select("a#link2")# [Lacie]

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

soup.select('a[href]')# [Elsie,#  Lacie,#  Tillie]

通过属性的值来查找:

soup.select('a[href="http://example.com/elsie"]')# [Elsie]soup.select('a[href^="http://example.com/"]')# [Elsie,#  Lacie,#  Tillie]soup.select('a[href$="tillie"]')# [Tillie]soup.select('a[href*=".com/el"]')# [Elsie]

通过语言设置来查找:

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

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

5 实例

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

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

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

import requests

from urllib import requestfrom bs4 import BeautifulSoup

class DB:

"""爬取豆瓣妹子图片"""

def __init__(self, baseurl):    """    初始化baseurl    """    self.baseurl = baseurldef 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 urllistdef 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 = ''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=)