爬虫 - BeautifulSoup4 模块 - 数据解析

目录

一、BS4 简单介绍

1-0 指定文档解析器

1-1 BS4解析器

 二、BeautifulSoup 类解析

2-1 基本使用方式 - 遍历文档树

三、Tag 对象介绍

3-1 Tag 常用属性

3-1-1 Name - Tag.name

3-1-2 Attributes - Tag.attrs

3-1-3 Text、String - Tag.text、Tag.string

3-2 操作文档树 

3-2-1 获取Tag - 获取单个or批量获取

3-2-2 获取Tag子孙节点 - .contents 和 .children

3-2-3 获取Tag父祖节点

3-2-4 获取Tag兄弟节点

3-2-5 获取标签内文本

四、 搜索文档树

4-1 五种过滤方式

4-2 find_all方法详解

4-3 find 方法详解

五、CSS选择器

5-1 通过tag标签逐层查找

5-2 找到某个tag标签下的直接子标签 

5-3 找到兄弟节点标签:

5-4 通过CSS的类名查找:

5-5 通过tag的id查找:

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

5-7 通过属性的值来查找

5-8 通过语言设置来查找

六、文档树修改

---

一、BS4 简单介绍

官方中文文档

Beautiful Soup 是一个可以从HTML或XML文件中提取数据的Python库.它能够通过你喜欢的转换器实现惯用的文档导航,查找,修改文档的方式.Beautiful Soup会帮你节省数小时甚至数天的工作时间.你可能在寻找 Beautiful Soup3 的文档,Beautiful Soup 3 目前已经停止开发,官网推荐在现在的项目中使用Beautiful Soup 4, 移植到BS4

1-0 指定文档解析器

如果仅是想要解析HTML文档,只要用文档创建 BeautifulSoup 对象就可以了.Beautiful Soup会自动选择一个解析器来解析文档.但是还可以通过参数指定使用那种解析器来解析当前文档.

BeautifulSoup 第一个参数应该是要被解析的文档字符串或是文件句柄,第二个参数用来标识怎样解析文档.如果第二个参数为空,那么Beautiful Soup根据当前系统安装的库自动选择解析器,解析器的优先数序: lxml, html5lib, Python标准库.在下面两种条件下解析器优先顺序会变化:

• 要解析的文档是什么类型: 目前支持, “html”, “xml”, 和 “html5”
• 指定使用哪种解析器: 目前支持, “lxml”, “html5lib”, 和 “html.parser”

如果指定的解析器没有安装,Beautiful Soup会自动选择其它方案.目前只有 lxml 解析器支持XML文档的解析,在没有安装lxml库的情况下,创建 beautifulsoup 对象时无论是否指定使用lxml,都无法得到解析后的对象

1-1 BS4解析器

解析器之间的区别 - 官方文档

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解析方法不够稳定.

 

解析器	使用方法	优势	劣势
Python标准库	BeautifulSoup(markup, "html.parser")	Python的内置标准库 执行速度适中 文档容错能力强	Python 2.7.3 or 3.2.2)前 的版本中文档容错能力差
lxml HTML 解析器	BeautifulSoup(markup, "lxml")	速度快 文档容错能力强	需要安装C语言库
lxml XML 解析器	BeautifulSoup(markup, ["lxml", "xml"]) BeautifulSoup(markup, "xml")	速度快 唯一支持XML的解析器	需要安装C语言库
html5lib	BeautifulSoup(markup, "html5lib")	最好的容错性 以浏览器的方式解析文档 生成HTML5格式的文档	速度慢 不依赖外部扩展

 二、BeautifulSoup 类解析

BeautifulSoup 对象表示的是一个文档的全部内容.大部分时候,可以把它当作 Tag 对象,它支持 遍历文档树 和 搜索文档树 中描述的大部分的方法.

因为 BeautifulSoup 对象并不是真正的HTML或XML的tag,所以它没有name和attribute属性.但有时查看它的 .name 属性是很方便的,所以 BeautifulSoup 对象包含了一个值为 “[document]” 的特殊属性 .name

2-1 基本使用方式 - 遍历文档树

通过这段例子来演示怎样从文档的一段内容找到另一段内容

html_doc = """


The Dormouse's story

Once upon a time there were three little sisters; and their names were
Elsie,
Lacie and
Tillie;
and they lived at the bottom of a well.

...
"""

# 基本使用：容错处理,文档的容错能力指的是在html代码不完整的情况下,使用该模块可以识别该错误。
# 使用BeautifulSoup解析上述代码,能够得到一个 BeautifulSoup 的对象,并能按照标准的缩进格式的结构输出

from bs4 import BeautifulSoup

soup=BeautifulSoup(html_doc,'lxml') # 实例化对象，具有容错功能
res=soup.prettify() # 处理好缩进，结构化显示
print(res)

三、Tag 对象介绍

Tag 对象与XML或HTML原生文档中的tag相同 - BeautifulSoup对象指定获取文件内的标签，即为Tag对象

soup = BeautifulSoup('Extremely bold')
tag = soup.b
type(tag)
# 

3-1 Tag 常用属性

3-1-1 Name - Tag.name

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

tag.name
# u'b'

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

tag.name = "blockquote"
tag
# 
Extremely bold

3-1-2 Attributes - Tag.attrs

一个tag可能有很多个属性.

tag  有一个 “class” 的属性,值为 “boldest” . tag的属性的操作方法与字典相同:

tag['class']
# u'boldest'

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

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

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

tag['class'] = 'verybold'
tag['id'] = 1
tag
# 
Extremely bold

del tag['class']
del tag['id']
tag
# 
Extremely bold

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

3-1-3 Text、String - Tag.text、Tag.string

from bs4 import BeautifulSoup


html_doc = """


Elsie,
Lacie and
Tillie;
and they lived at the bottom of a well.

...

"""
soup = BeautifulSoup(html_doc,"lxml")
tag = soup.a
print(tag)
# Elsie

print(tag.text) # 获取标签内文本内容
# Elsie

print(tag.string)
# Elsie

3-2 操作文档树 

3-2-1 获取Tag - 获取单个or批量获取

操作文档树最简单的方法就是告诉它你想获取的tag的name.

如果想获取 标签,只要用 soup.head  - 存在相同多个标签，仅返回第一个

soup.head
# 

soup.title
# 

获取指定标签内的指定标签 - 存在相同多个标签，仅返回第一个

# 获取标签中的第一个标签:
soup.body.b
# The Dormouse's story

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

soup.a
# Elsie

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

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

3-2-2 获取Tag子孙节点 - .contents 和 .children

soup.p.contents
# p下所有子节点

soup.p.children
# 得到一个迭代器,包含p下所有子节点
for i,child in enumerate(soup.p.children):
    print(i,child)

soup.p.descendants
# 获取子孙节点,p下所有的标签都会选择出来
for i,child in enumerate(soup.p.descendants):
    print(i,child)

BeautifulSoup 对象本身一定会包含子节点,也就是说标签也是 BeautifulSoup 对象的子节点

len(soup.contents)
# 1
soup.contents[0].name
# u'html'

3-2-3 获取Tag父祖节点

soup.a.parent
# 获取a标签的父节点

soup.a.parents
# 找到a标签所有的祖先节点，父亲的父亲，父亲的父亲的父亲

3-2-4 获取Tag兄弟节点

soup.a.next_sibling
# 下一个兄弟

soup.a.previous_sibling
# 上一个兄弟

list(soup.a.next_siblings)
# soup.a.next_siblings 下面的兄弟们=>生成器对象

soup.a.previous_siblings
# 上面的兄弟们=>生成器对象

3-2-5 获取标签内文本

from bs4 import BeautifulSoup

html_doc = """


The Dormouse's story
Once upon a time there were three little sisters; and their names were
Elsie,
Lacie and
Tillie;
and they lived at the bottom of a well.
...

"""
soup = BeautifulSoup(html_doc,"lxml")


# 获取这个标签自己的文本
print(soup.html.text)
print(soup.html.string)

# 获取这个标签包含所有文本 一个生成器
print(list(soup.html.strings))
# 获取这个标签包含所有文本 一个生成器 
# 自动去除空白字符
print(list(soup.stripped_strings))

四、 搜索文档树

4-1 五种过滤方式

• 标签名过滤 - soup.find_all('b')
• 正则表达式过滤 - soup.find_all(re.compile('^b')) - 找出b开头的标签，结果有body和b标签
• 列表方式过滤 - soup.find_all(['a','b']) - 找到文档中所有标签和标签
  • 如果传入列表参数,Beautiful Soup会将与列表中任一元素匹配的内容返回
• True方式过滤 - soup.find_all(True) - 匹配任何值

• # 找到所有的tag,但是不会返回字符串节点
  print(soup.find_all(True))
  for tag in soup.find_all(True):
      print(tag.name)

• 方法过滤  - 如果没有合适过滤器,那么还可以定义一个方法,方法只接受一个元素参数 ,如果这个方法返回 True 表示当前元素匹配并且被找到,如果不是则反回 False

• def has_class_but_no_id(tag):
      return tag.has_attr('class') and not tag.has_attr('id')
  
  print(soup.find_all(has_class_but_no_id))

4-2 find_all方法详解

    def find_all(self, name=None, attrs={}, recursive=True, text=None,
                 limit=None, **kwargs):
        """Extracts a list of Tag objects that match the given
        criteria.  You can specify the name of the Tag and any
        attributes you want the Tag to have.

        The value of a key-value pair in the 'attrs' map can be a
        string, a list of strings, a regular expression object, or a
        callable that takes a string and returns whether or not the
        string matches for some custom definition of 'matches'. The
        same is true of the tag name."""

        generator = self.descendants
        if not recursive:
            generator = self.children
        return self._find_all(name, attrs, text, limit, generator, **kwargs)
    findAll = find_all       # BS3
    findChildren = find_all  # BS2

''' ------------------------------------------------------------------------------ '''

'''
参数解析  
def find_all(self, name=None, attrs={}, recursive=True, text=None,limit=None, **kwargs)
'''
# name
# 搜索name参数的值;可以是任一类型的 过滤器 ,字符窜,正则表达式,列表,方法或是 True .
print(soup.find_all(name=re.compile('^t')))

# keyword
# key=value的形式；value可以是过滤器：字符串 , 正则表达式 , 列表, True .
print(soup.find_all(id=re.compile('my')))
print(soup.find_all(href=re.compile('lacie'),id=re.compile('\d'))) # 注意类要用class_
print(soup.find_all(id=True)) # 查找有id属性的标签

# 按照类名查找，注意关键字是class_，class_=value,value可以是五种选择器之一
print(soup.find_all('a',class_='sister')) # 查找类为sister的a标签
print(soup.find_all('a',class_='sister ssss')) # 查找类为sister和sss的a标签，顺序错误也匹配不成功
print(soup.find_all(class_=re.compile('^sis'))) # 查找类为sister的所有标签

# attrs
print(soup.find_all('p',attrs={'class':'story'}))

# 有些tag属性在搜索不能使用,比如HTML5中的 data-* 属性:
data_soup = BeautifulSoup('
foo!
','lxml')
data_soup.find_all(data-foo="value") 
# 报错：SyntaxError: keyword can't be an expression
# 但是可以通过 find_all() 方法的 attrs 参数定义一个字典参数来搜索包含特殊属性的tag:
print(data_soup.find_all(attrs={"data-foo": "value"}))
# [
foo!
]

# text 
# 值可以是：字符，列表，True，正则
print(soup.find_all(text='Elsie'))
print(soup.find_all('a',text='Elsie'))

# limit
# 如果文档树很大那么搜索会很慢.如果我们不需要全部结果,可以使用 limit 参数限制返回结果的数量.
# 效果与SQL中的limit关键字类似,当搜索到的结果数量达到 limit 的限制时,就停止搜索返回结果
print(soup.find_all('a',limit=2))

# recursive
# 调用tag的 find_all() 方法时,Beautiful Soup会检索当前tag的所有子孙节点,如果只想搜索tag的直接子节点,可以使用参数 recursive=False .
print(soup.html.find_all('a'))
print(soup.html.find_all('a',recursive=False))

'''
像调用 find_all() 一样调用tag
find_all() 几乎是Beautiful Soup中最常用的搜索方法,所以我们定义了它的简写方法.
BeautifulSoup 对象和 tag 对象可以被当作一个方法来使用,这个方法的执行结果与调用这个对象的 
find_all() 方法相同

下面两行代码是等价的:
soup.find_all("a")
soup("a")

这两行代码也是等价的:
soup.title.find_all(text=True)
soup.title(text=True)
'''

4-3 find 方法详解

    def find(self, name=None, attrs={}, recursive=True, text=None,
             **kwargs):
        """Return only the first child of this Tag matching the given
        criteria."""
        r = None
        l = self.find_all(name, attrs, recursive, text, 1, **kwargs)
        if l:
            r = l[0]
        return r
    findChild = find


''' ---------------------------------------------------------------------  '''

'''
find( name , attrs , recursive , text , **kwargs )
find_all() 方法将返回文档中符合条件的所有tag,尽管有时候我们只想得到一个结果.
比如文档中只有一个标签,那么使用 find_all() 方法来查找标签就不太合适, 使用 find_all 方法并设置 limit=1 参数不如直接使用 find() 方法.
'''
# 下面两行代码是等价的 - 仅查找第一个匹配到的标签
soup.find_all('title', limit=1)
# []
soup.find('title')
# 


# 区别
# find_all() 方法的返回结果是值包含一个元素的列表,而 find() 方法直接返回结果.
# find_all() 方法没有找到目标是返回空列表, find() 方法找不到目标时,返回 None .
print(soup.find("nosuchtag"))
# None

# soup.head.title - tag的名字、方法的简写.
# 这个简写的原理就是多次调用当前tag的 find() 方法
soup.head.title
# 
soup.find("head").find("title")
# 

五、CSS选择器

Beautiful Soup支持大部分的CSS选择器；对于熟悉CSS选择器语法的人来说这是个非常方便的方法.Beautiful Soup也支持CSS选择器API,如果你仅仅需要CSS选择器的功能,那么直接使用 lxml 也可以,而且速度更快,支持更多的CSS选择器语法,但Beautiful Soup整合了CSS选择器的语法和自身方便使用API.

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

soup.select("title")
# []

soup.select("p nth-of-type(3)")
# [
...
]

5-1 通过tag标签逐层查找

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

soup.select("html head title")
# []

5-2 找到某个tag标签下的直接子标签 

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")
# []

5-3 找到兄弟节点标签:

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

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

5-4 通过CSS的类名查找:

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

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

5-5 通过tag的id查找:

soup.select("#link1")
# [Elsie]

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

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

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

5-7 通过属性的值来查找

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]

5-8 通过语言设置来查找

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
]

六、文档树修改

文档树修改 -官方文档