摘要
Beautiful Soup 是一个可以从 html 或 xml 格式文件中提取数据的 Python 库, 他可以将 HTML 或 xml 数据解析为 Python 对象, 以方便通过 Python 代码进行处理.
文档环境
本文档中代码的测试环境
Beautifu Soup 使用说明
Beautiful Soup 的基本功能就是对 HTML 的标签进行查找及编辑.
基本概念 - 对象类型
Beautiful Soup 将复杂 HTML 文档转换成一个复杂的树形结构, 每个节点都被转换成一个 Python 对象, Beautiful Soup 将这些对象定义了 4 种类型: Tag,NavigableString,BeautifulSoup,Comment .
对象类型 | 描述 |
---|---|
BeautifulSoup | 文档的全部内容 |
Tag | HTML 的标签 |
NavigableString | 标签包含的文字 |
Comment | 是一种特殊的 NavigableString 类型,当标签中的 NavigableString 被注释时,则定义为该类型 |
安装及引用
- # Beautiful Soup
- pip install bs4
- # 解析器
- pip install lxml
- pip install html5lib
- # 初始化
- from bs4 import BeautifulSoup
- # 方法一, 直接打开文件
- soup = BeautifulSoup(open("index.html"))
- # 方法二, 指定数据
- resp = "<html>data</html>"
- soup = BeautifulSoup(resp, 'lxml')
- # soup 为 BeautifulSoup 类型对象
- print(type(soup))
标签搜索及过滤
基本方法
标签搜索有 find_all() 和 find() 两个基本的搜索方法, find_all() 方法会返回所有匹配关键字的标签列表, find() 方法则只返回一个匹配结果.
- soup = BeautifulSoup(resp, 'lxml')
- # 返回一个标签名为 "a" 的 Tag
- soup.find("a")
- # 返回所有 tag 列表
- soup.find_all("a")
- ## find_all 方法可被简写
- soup("a")
- # 找出所有以 b 开头的标签
- for tag in soup.find_all(re.compile("^b")):
- print(tag.name)
- # 找出列表中的所有标签
- soup.find_all(["a", "p"])
- # 查找标签名为 p,class 属性为 "title"
- soup.find_all("p", "title")
- # 查找属性 id 为 "link2"
- soup.find_all(id="link2")
- # 查找存在属性 id 的
- soup.find_all(id=True)
- #
- soup.find_all(href=re.compile("elsie"), id='link1')
- #
- soup.find_all(attrs={
- "data-foo": "value"
- })
- # 查找标签文字包含 "sisters"
- soup.find(string=re.compile("sisters"))
- # 获取指定数量的结果
- soup.find_all("a", limit=2)
- # 自定义匹配方法
- def has_class_but_no_id(tag):
- return tag.has_attr('class') and not tag.has_attr('id')
- soup.find_all(has_class_but_no_id)
- # 仅对属性使用自定义匹配方法
- def not_lacie(href):
- return href and not re.compile("lacie").search(href)
- soup.find_all(href=not_lacie)
- # 调用 tag 的 find_all() 方法时, Beautiful Soup 会检索当前 tag 的所有子孙节点, 如果只想搜索 tag 的直接子节点, 可以使用参数 recursive=False
- soup.find_all("title", recursive=False)
扩展方法
find_parents() | 所有父辈节点 |
find_parent() | 第一个父辈节点 |
find_next_siblings() | 之后的所有兄弟节点 |
find_next_sibling() | 之后的第一个兄弟节点 |
find_previous_siblings() | 之前的所有兄弟节点 |
find_previous_sibling() | 之前的第一个兄弟节点 |
find_all_next() | 之后的所有元素 |
find_next() | 之后的第一个元素 |
find_all_previous() | 之前的所有元素 |
find_previous() | 之前的第一个元素 |
CSS 选择器
Beautiful Soup 支持大部分的 CSS 选择器 http://www.w3.org/TR/CSS2/selector.html , 在 Tag 或 BeautifulSoup 对象的 .select() 方法中传入字符串参数, 即可使用 CSS 选择器的语法找到 tag.
- html_doc = """
- <html>
- <head>
- <title>The Dormouse's story</title>
- </head>
- <body>
- <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>
- """
- soup = BeautifulSoup(html_doc)
- # 所有 a 标签
- soup.select("a")
- # 逐层查找
- soup.select("body a")
- soup.select("html head title")
- # tag 标签下的直接子标签
- soup.select("head> title")
- soup.select("p> #link1")
- # 所有匹配标签之后的兄弟标签
- soup.select("#link1 ~ .sister")
- # 匹配标签之后的第一个兄弟标签
- soup.select("#link1 + .sister")
- # 根据 calss 类名
- soup.select(".sister")
- soup.select("[class~=sister]")
- # 根据 ID 查找
- soup.select("#link1")
- soup.select("a#link1")
- # 根据多个 ID 查找
- soup.select("#link1,#link2")
- # 根据属性查找
- soup.select('a[href]')
- # 根据属性值查找
- soup.select('a[href^="http://example.com/"]')
- soup.select('a[href$="tillie"]')
- soup.select('a[href*=".com/el"]')
- # 只获取一个匹配结果
- soup.select(".sister", limit=1)
- # 只获取一个匹配结果
- soup.select_one(".sister")
标签对象方法
标签属性
- soup = BeautifulSoup('<p class="body strikeout"id="1">Extremely bold</p><p class="body strikeout"id="2">Extremely bold2</p>')
- # 获取所有的 p 标签对象
- tags = soup.find_all("p")
- # 获取第一个 p 标签对象
- tag = soup.p
- # 输出标签类型
- type(tag)
- # 标签名
- tag.name
- # 标签属性
- tag.attrs
- # 标签属性 class 的值
- tag['class']
- # 标签包含的文字内容, 对象 NavigableString 的内容
- tag.string
- # 返回标签内所有的文字内容
- for string in tag.strings:
- print(repr(string))
- # 返回标签内所有的文字内容, 并去掉空行
- for string in tag.stripped_strings:
- print(repr(string))
- # 获取到 tag 中包含的所有及包括子孙 tag 中的 NavigableString 内容, 并以 Unicode 字符串格式输出
- tag.get_text()
- ## 以 "|" 分隔
- tag.get_text("|")
- ## 以 "|" 分隔, 不输出空字符
- tag.get_text("|", strip=True)
获取子节点
- tag.contents # 返回第一层子节点的列表
- tag.children # 返回第一层子节点的 listiterator 对象
- for child in tag.children:
- print(child)
- tag.descendants # 递归返回所有子节点
- for child in tag.descendants:
- print(child)
获取父节点
- tag.parent # 返回第一层父节点标签
- tag.parents # 递归得到元素的所有父辈节点
- for parent in tag.parents:
- if parent is None:
- print(parent)
- else:
- print(parent.name)
获取兄弟节点
- # 下一个兄弟元素
- tag.next_sibling
- # 当前标签之后的所有兄弟元素
- tag.next_siblings
- for sibling in tag.next_siblings:
- print(repr(sibling))
- # 上一个兄弟元素
- tag.previous_sibling
- # 当前标签之前的所有兄弟元素
- tag.previous_siblings
- for sibling in tag.previous_siblings:
- print(repr(sibling))
元素的遍历
Beautiful Soup 中把每个 tag 定义为一个 "element", 每个 "element", 被自上而下的在 HTML 中排列, 可以通过遍历命令逐个显示标签
- # 当前标签的下一个元素
- tag.next_element
- # 当前标签之后的所有元素
- for element in tag.next_elements:
- print(repr(element))
- # 当前标签的前一个元素
- tag.previous_element
- # 当前标签之前的所有元素
- for element in tag.previous_elements:
- print(repr(element))
修改标签属性
- soup = BeautifulSoup('<b class="boldest">Extremely bold</b>')
- tag = soup.b
- tag.name = "blockquote"
- tag['class'] = 'verybold'
- tag['id'] = 1
- tag.string = "New link text."
- print(tag)
修改标签内容 (NavigableString)
- soup = BeautifulSoup('<b class="boldest">Extremely bold</b>')
- tag = soup.b
- tag.string = "New link text."
添加标签内容 (NavigableString)
- soup = BeautifulSoup("<a>Foo</a>")
- tag = soup.a
- tag.append("Bar")
- tag.contents
- # 或者
- new_string = NavigableString("Bar")
- tag.append(new_string)
- print(tag)
添加注释 (Comment)
注释是一个特殊的 NavigableString 对象, 所以同样可以通过 append() 方法进行添加.
- from bs4 import Comment
- soup = BeautifulSoup("<a>Foo</a>")
- new_comment = soup.new_string("Nice to see you.", Comment)
- tag.append(new_comment)
- print(tag)
添加标签 (Tag)
添加标签方法有两种, 一种是在指定标签的内部添加 (append 方法), 另一种是在指定位置添加 (insert,insert_before,insert_after 方法)
append 方法
- soup = BeautifulSoup("<b></b>")
- tag = soup.b
- new_tag = soup.new_tag("a", href="http://www.example.com")
- new_tag.string = "Link text."
- tag.append(new_tag)
- print(tag)
* insert 方法, 是指在当前标签子节点列表的指定位置插入对象 (Tag 或 NavigableString)
- ```python
- HTML = '<b><a href="http://example.com/">I linked to <i>example.com</i></a></b>'
- soup = BeautifulSoup(HTML)
- tag = soup.a
- tag.contents
- tag.insert(1, "but did not endorse")
- tag.contents
insert_before() 和 insert_after() 方法则在当前标签之前或之后的兄弟节点添加元素
- HTML = '<b><a href="http://example.com/">I linked to <i>example.com</i></a></b>'
- soup = BeautifulSoup(HTML)
- tag = soup.new_tag("i")
- tag.string = "Don't"
- soup.b.insert_before(tag)
- soup.b
* wrap() 和 unwrap() 可以对指定的 tag 元素进行包装或解包, 并返回包装后的结果.
- ```python
- # 添加包装
- soup = BeautifulSoup("<p>I wish I was bold.</p>")
- soup.p.string.wrap(soup.new_tag("b"))
- # 输出 <b>I wish I was bold.</b>
- soup.p.wrap(soup.new_tag("div"))
- # 输出 <div><p><b>I wish I was bold.</b></p></div>
- # 拆解包装
- markup = '<a href="http://example.com/">I linked to <i>example.com</i></a>'
- soup = BeautifulSoup(markup)
- a_tag = soup.a
- a_tag.i.unwrap()
- a_tag
- # 输出 <a href="http://example.com/">I linked to example.com</a>
删除标签
- HTML = '<b><a href="http://example.com/">I linked to <i>example.com</i></a></b>'
- soup = BeautifulSoup(HTML)
- # 清楚当前标签的所有子节点
- soup.b.clear()
- # 将当前标签及所有子节点从 soup 中移除, 返回当前标签.
- b_tag=soup.b.extract()
- b_tag
- soup
- # 将当前标签及所有子节点从 soup 中移除, 无返回.
- soup.b.decompose()
- # 将当前标签替换为指定的元素
- tag=soup.i
- new_tag = soup.new_tag("p")
- new_tag.string = "Don't"
- tag.replace_with(new_tag)
其他方法
输出
- # 格式化输出
- tag.prettify()
- tag.prettify("latin-1")
使用 Beautiful Soup 解析后, 文档都被转换成了 Unicode, 特殊字符也被转换为 Unicode, 如果将文档转换成字符串, Unicode 编码会被编码成 UTF-8. 这样就无法正确显示 HTML 特殊字符了
使用 Unicode 时, Beautiful Soup 还会智能的把 "引号" 转换成 HTML 或 xml 中的特殊字符
文档编码
使用 Beautiful Soup 解析后, 文档都被转换成了 Unicode, 其使用了 "编码自动检测" 子库来识别当前文档编码并转换成 Unicode 编码.
- soup = BeautifulSoup(HTML)
- soup.original_encoding
- # 也可以手动指定文档的编码
- soup = BeautifulSoup(HTML, from_encoding="iso-8859-8")
- soup.original_encoding
- # 为提高 "编码自动检测" 的检测效率, 也可以预先排除一些编码
- soup = BeautifulSoup(markup, exclude_encodings=["ISO-8859-7"])
通过 Beautiful Soup 输出文档时, 不管输入文档是什么编码方式, 默认输出编码均为 UTF-8 编码
文档解析器
Beautiful Soup 目前支持, "lxml", "html5lib", 和 "html.parser"
- soup=BeautifulSoup("<a><b /></a>")
- soup
- # 输出: <HTML><body><a><b></b></a></body></HTML>
- soup=BeautifulSoup("<a></p>", "lxml")
- soup
- # 输出: <HTML><body><a></a></body></HTML>
- soup=BeautifulSoup("<a></p>", "html5lib")
- soup
- # 输出: <HTML><head></head><body><a><p></p></a></body></HTML>
- soup=BeautifulSoup("<a></p>", "html.parser")
- soup
- # 输出: <a></a>
参考文档
来源: http://blog.51cto.com/13673090/2466801