Python이 Beautiful Soup(BS4) 라이브러리를 사용하여 HTML과 XML을 구문 분석하는 방법
- 王林앞으로
- 2023-05-13 21:55:041736검색
1. Beautiful Soup 개요:
Beautiful Soup은 HTML 또는 XML 파일에서 데이터를 추출하는 Python 라이브러리를 지원합니다.
Python 표준 라이브러리의 HTML 파서를 지원하며 일부 타사 파서 lxml도 지원합니다.
Beautiful Soup은 자동으로 입력 문서를 유니코드 인코딩으로 변환하고 출력 문서를 UTF-8 인코딩으로 변환합니다.
설치:
pip install beautifulsoup4pip install beautifulsoup4
可选择安装解析器
pip install lxmlpip install html5lib
二、BeautifulSoup4简单使用
假设有这样一个Html，具体内容如下：
<!DOCTYPE html>
<html>
<head>
<meta content="text/html;charset=utf-8" http-equiv="content-type" />
<meta content="IE=Edge" http-equiv="X-UA-Compatible" />
<meta content="always" name="referrer" />
<link href="https://ss1.bdstatic.com/5eN1bjq8AAUYm2zgoY3K/r/www/cache/bdorz/baidu.min.css" rel="external nofollow" rel="stylesheet" type="text/css" />
<title>百度一下，你就知道 </title>
</head>
<body link="#0000cc">
<div id="wrapper">
<div id="head">
<div class="head_wrapper">
<div id="u1">
<a class="mnav" href="http://news.baidu.com" rel="external nofollow" name="tj_trnews">新闻 </a>
<a class="mnav" href="https://www.hao123.com" rel="external nofollow" name="tj_trhao123">hao123 </a>
<a class="mnav" href="http://map.baidu.com" rel="external nofollow" name="tj_trmap">地图 </a>
<a class="mnav" href="http://v.baidu.com" rel="external nofollow" name="tj_trvideo">视频 </a>
<a class="mnav" href="http://tieba.baidu.com" rel="external nofollow" rel="external nofollow" name="tj_trtieba">贴吧 </a>
<a class="bri" href="//www.baidu.com/more/" rel="external nofollow" name="tj_briicon" >更多产品 </a>
</div>
</div>
</div>
</div>
</body>
</html>创建beautifulsoup4对象：
from bs4 import BeautifulSoup
file = open('./aa.html', 'rb')
html = file.read()
bs = BeautifulSoup(html, "html.parser") # 缩进格式
print(bs.prettify()) # 格式化html结构
print(bs.title) #
print(bs.title.name) # 获取title标签的名称 :title
print(bs.title.string) # 获取title标签的文本内容 : 百度一下，你就知道
print(bs.head) # 获取head标签的所有内容 :
print(bs.div) # 获取第一个div标签中的所有内容 :
print(bs.div["id"]) # 获取第一个div标签的id的值 : wrapper
print(bs.a) # 获取第一个a标签中的所有内容 : <a href="http://news.baidu.com/" rel="external nofollow" target="_blank">新闻 </a>
print(bs.find_all("a")) # 获取所有的a标签中的所有内容 : [....]
print(bs.find(id="u1")) # 获取id="u1"的所有内容 :
for item in bs.find_all("a"): # 获取所有的a标签，并遍历打印a标签中的href的值 :
print(item.get("href"))
for item in bs.find_all("a"): # 获取所有的a标签，并遍历打印a标签的文本值:
print(item.get_text())三、BeautifulSoup4四大对象种类
BeautifulSoup4将复杂HTML文档转换成一个复杂的树形结构,每个节点都是Python对象,所有对象可以归纳为4种:Tag 、NavigableString 、BeautifulSoup 、Comment、
1、Tag：标签
Tag通俗点讲就是HTML中的一个个标签，例如：
print(bs.title) # 获取title标签的所有内容 print(bs.head) # 获取head标签的所有内容 print(bs.a) # 获取第一个a标签的所有内容 print(type(bs.a))# 类型
我们可以利用 soup 加标签名轻松地获取这些标签的内容，这些对象的类型是bs4.element.Tag。但是注意，它查找的是在所有内容中的第一个符合要求的标签。
对于 Tag，它有两个重要的属性，是 name 和 attrs：
print(bs.name) # [document] #bs 对象本身比较特殊，它的 name 即为 [document] print(bs.head.name) # head #对于其他内部标签，输出的值便为标签本身的名称 print(bs.a.attrs) # 在这里，我们把 a 标签的所有属性打印输出了出来，得到的类型是一个字典。 print(bs.a['class']) ##还可以利用get方法，传入属性的名称，二者是等价的，等价 bs.a.get('class') bs.a['class'] = "newClass"# 可以对这些属性和内容等等进行修改 print(bs.a) del bs.a['class'] # 还可以对这个属性进行删除 print(bs.a)
2、NavigableString：标签内部的文字
既然我们已经得到了标签的内容，那么问题来了，我们要想获取标签内部的文字怎么办呢？很简单，用 .string 即可，例如：
print(bs.title.string) # 百度一下，你就知道 print(type(bs.title.string)) #
3、BeautifulSoup：文档的内容
BeautifulSoup对象表示的是一个文档的内容。大部分时候，可以把它当作 Tag 对象，是一个特殊的 Tag，我们可以分别获取它的类型，名称，以及属性，例如：
print(type(bs.name)) #
print(bs.name) # [document]
print(bs.attrs) # {}4、Comment：注释
Comment 对象是一个特殊类型的 NavigableString 对象，其输出的内容不包括注释符号。
print(bs.a) # 此时不能出现空格和换行符，a标签如下： # print(bs.a.string) # 新闻 print(type(bs.a.string)) #
四、遍历文档树所用属性
.contents：获取Tag的所有子节点，返回一个list
print(bs.head.contents) # tag的.contents属性可以将tag的子节点以列表的方式输出:[...] print(bs.head.contents[1]) # 用列表索引来获取它的某一个元素:
.children：获取Tag的所有子节点，返回一个生成器
for child in bs.body.children:
print(child).descendants：获取Tag的所有子孙节点
.parent：获取Tag的父节点
.parents：递归得到父辈元素的所有节点，返回一个生成器
.previous_sibling：获取当前Tag的上一个节点，属性通常是字符串或空白，真实结果是当前标签与上一个标签之间的顿号和换行符
.next_sibling：获取当前Tag的下一个节点，属性通常是字符串或空白，真是结果是当前标签与下一个标签之间的顿号与换行符
.previous_siblings：获取当前Tag的上面所有的兄弟节点，返回一个生成器
.next_siblings：获取当前Tag的下面所有的兄弟节点，返回一个生成器
.previous_element：获取解析过程中上一个被解析的对象(字符串或tag)，可能与previous_sibling相同，但通常是不一样的
.next_element：获取解析过程中下一个被解析的对象(字符串或tag)，可能与next_sibling相同，但通常是不一样的
.previous_elements：返回一个生成器，可以向前访问文档的解析内容
.next_elements：返回一个生成器，可以向后访问文档的解析内容
.strings：如果Tag包含多个字符串，即在子孙节点中有内容，可以用此获取，而后进行遍历
.stripped_strings：与strings用法一致，只不过可以去除掉那些多余的空白内容
.has_attr：判断Tag是否包含属性
五、搜索文档树
1、find_all()：过滤器
find_all(name, attrs, recursive, text, **kwargs)：
파서 설치 선택 사항
pip install lxml code><p></p>
<li><strong><code>pip install html5lib2. BeautifulSoup4의 간단한 사용이러한 HTML이 있다고 가정하면, 구체적인 내용은 다음과 같습니다.
a_list = bs.find_all("a")
print(a_list) Beautifulsoup4 개체 만들기: import re
t_list = bs.find_all(re.compile("a"))
for item in t_list:
print(item) 3. BeautifulSoup4 개체의 네 가지 주요 유형 BeautifulSoup4는 복잡한 HTML 문서를 복잡한 트리 구조로 변환합니다. 모든 개체는 4가지 유형으로 요약될 수 있습니다. Tag, NavigableString , BeautifulSoup , Comment, 1. 태그: 태그
Tag는 단순히 HTML의 태그입니다. 예: 🎜t_list = bs.find_all(["meta","link"])
for item in t_list:
print(item)🎜 수프를 사용하여 태그 이름을 추가하면 이러한 태그의 내용을 쉽게 얻을 수 있습니다. 이러한 객체의 유형은 bs4.element.Tag입니다. 그러나 모든 콘텐츠에서 첫 번째로 일치하는 태그를 찾습니다. 🎜🎜태그의 경우 🎜이름과 속성이라는 두 가지 중요한 속성이 있습니다. 🎜🎜def name_is_exists(tag):
return tag.has_attr("name")
t_list = bs.find_all(name_is_exists)
for item in t_list:
print(item)🎜2. NavigableString: 태그 내부의 텍스트🎜🎜이제 태그의 내용을 얻었으니 문제는 무엇을 해야 하는가입니다. 우리가 원하는 것은? 라벨 내부에 텍스트를 가져오는 방법은 무엇입니까? 매우 간단합니다. .string을 사용하세요(예: 🎜t_list = bs.find_all(id="head") # 查询id=head的Tag
t_list = bs.find_all(href=re.compile(http://news.baidu.com)) # 查询href属性包含ss1.bdstatic.com的Tag
t_list = bs.find_all(class_=True) # 查询所有包含class的Tag(注意：class在Python中属于关键字，所以加_以示区别)
for item in t_list:
print(item)🎜3). BeautifulSoup: 문서의 내용🎜🎜 BeautifulSoup 개체는 문서의 내용을 나타냅니다. 대부분의 경우 특별한 태그인 태그 개체로 간주할 수 있습니다. 예를 들어 🎜t_list = bs.find_all(data-foo="value")🎜4와 같이 각각 해당 개체의 유형, 이름 및 속성을 얻을 수 있습니다. 출력에 주석 기호가 포함되지 않은 NavigableString 개체를 입력합니다. 🎜
t_list = bs.find_all(attrs={"data-foo":"value"})
for item in t_list:
print(item)🎜4. 문서 트리를 순회하는 데 사용되는 속성🎜- 🎜🎜.contents: 🎜태그의 모든 하위 노드를 가져오고 목록을 반환🎜
t_list = bs.find_all(text="hao123")
t_list = bs.find_all(text=["hao123", "地图", "贴吧"])
t_list = bs.find_all(text=re.compile("\d"))- 🎜.🎜children: 🎜Tag의 모든 하위 노드를 가져오고 생성기를 반환🎜
def length_is_two(text):
return text and len(text) == 2
t_list = bs.find_all(text=length_is_two)- 🎜🎜.descendants🎜: Tag🎜의 모든 하위 노드 가져오기
- 🎜🎜.parent🎜: Tag🎜의 상위 노드 가져오기
- 🎜🎜 .parents🎜: 상위 요소의 모든 노드를 재귀적으로 가져오고 생성기를 반환합니다🎜
- 🎜🎜.previous_sibling🎜: 현재 태그의 이전 노드를 가져옵니다. 속성은 일반적으로 문자열이거나 공백입니다. 실제 결과는 현재 태그와 이전 태그 사이의 쉼표 및 개행 문자🎜
- 🎜🎜.next_sibling🎜: 현재 태그의 다음 노드를 가져옵니다. 속성은 일반적으로 문자열 또는 공백입니다. 결과는 현재 태그와 다음 태그 사이의 쉼표와 개행 문자🎜
- 🎜🎜.previous_siblings🎜: 현재 태그 위의 모든 형제 노드를 가져오고 생성기를 반환합니다🎜
- 🎜🎜.next_siblings 🎜: 현재 태그 아래의 모든 형제 노드를 가져오고 생성기를 반환🎜
- 🎜🎜.previous_element🎜: 구문 분석 프로세스 중에 마지막으로 구문 분석된 개체(문자열 또는 태그)를 가져옵니다. , Previous_sibling과 관련될 수 있음 동일하지만 일반적으로 다릅니다🎜
- 🎜🎜.next_element🎜: 구문 분석 프로세스 중에 next_sibling과 동일할 수 있는 다음 구문 분석된 개체(문자열 또는 태그)를 가져옵니다. 하지만 일반적으로 다릅니다. 🎜
- 🎜🎜.previous_elements🎜: 문서의 구문 분석된 콘텐츠에 앞으로 액세스할 수 있는 생성기를 반환합니다. 🎜
- 🎜🎜.next_elements🎜: 액세스할 수 있는 생성기를 반환합니다. 문서의 역방향 구문 분석된 내용 문서의 구문 분석된 내용🎜
- 🎜🎜.strings🎜: 태그에 여러 문자열이 포함된 경우, 즉 하위 노드에 내용이 있는 경우 이를 사용하여 얻을 수 있습니다. 그런 다음 통과🎜
- 🎜🎜.stripped_strings🎜: 사용법은 문자열과 동일합니다. 단, 여분의 공백 내용을 제거할 수 있다는 점만 다릅니다🎜
- 🎜🎜.has_attr: 🎜태그에 속성이 포함되어 있는지 확인🎜
find_all(name, attrs, recursive, text, **kwargs) :🎜🎜find_all 필터는 태그 이름, 노드 속성 등에 사용할 수 있습니다. 🎜🎜(1) 이름 매개변수: 🎜🎜🎜문자열 필터링🎜: 문자열과 정확히 일치하는 콘텐츠를 찾습니다🎜t_list = bs.find_all("a",limit=2)🎜🎜정규식 필터링:🎜정규식이 전달되면 BeautifulSoup4는 콘텐츠와 일치하는 검색( )을 수행합니다🎜 # 下面两者是相等的
t_list = bs.find_all("a")
t_list = bs("a")
# 下面两者是相等的
t_list = bs.a.find_all(text="新闻")
t_list = bs.a(text="新闻")🎜🎜List🎜: 목록이 전달되면 BeautifulSoup4는 목록의 모든 요소와 일치하는 노드를 반환합니다🎜t_list = bs.find_all("title",limit=1) # 返回只有一个结果的列表
t = bs.find("title") # 返回唯一值
t = bs.find("abc") # 如果没有找到，则返回None🎜🎜Method🎜: 메서드를 전달하고 메서드에 따라 일치합니다🎜def name_is_exists(tag):
return tag.has_attr("name")
t_list = bs.find_all(name_is_exists)
for item in t_list:
print(item)（2）kwargs参数：
t_list = bs.find_all(id="head") # 查询id=head的Tag
t_list = bs.find_all(href=re.compile(http://news.baidu.com)) # 查询href属性包含ss1.bdstatic.com的Tag
t_list = bs.find_all(class_=True) # 查询所有包含class的Tag(注意：class在Python中属于关键字，所以加_以示区别)
for item in t_list:
print(item)（3）attrs参数：
并不是所有的属性都可以使用上面这种方式进行搜索，比如HTML的data-*属性：
t_list = bs.find_all(data-foo="value")
如果执行这段代码，将会报错。我们可以使用attrs参数，定义一个字典来搜索包含特殊属性的tag：
t_list = bs.find_all(attrs={"data-foo":"value"})
for item in t_list:
print(item)（4）text参数：
通过text参数可以搜索文档中的字符串内容，与name参数的可选值一样，text参数接受 字符串，正则表达式，列表
t_list = bs.find_all(text="hao123")
t_list = bs.find_all(text=["hao123", "地图", "贴吧"])
t_list = bs.find_all(text=re.compile("\d"))当我们搜索text中的一些特殊属性时，同样也可以传入一个方法来达到我们的目的：
def length_is_two(text):
return text and len(text) == 2
t_list = bs.find_all(text=length_is_two)（5）limit参数：
可以传入一个limit参数来限制返回的数量，当搜索出的数据量为5，而设置了limit=2时，此时只会返回前2个数据
t_list = bs.find_all("a",limit=2)find_all除了上面一些常规的写法，还可以对其进行一些简写：
# 下面两者是相等的
t_list = bs.find_all("a")
t_list = bs("a")
# 下面两者是相等的
t_list = bs.a.find_all(text="新闻")
t_list = bs.a(text="新闻")2、find()
find()将返回符合条件的第一个Tag，有时我们只需要或一个Tag时，我们就可以用到find()方法了。当然了，也可以使用find_all()方法，传入一个limit=1，然后再取出第一个值也是可以的，不过未免繁琐。
t_list = bs.find_all("title",limit=1) # 返回只有一个结果的列表
t = bs.find("title") # 返回唯一值
t = bs.find("abc") # 如果没有找到，则返回None从结果可以看出find_all，尽管传入了limit=1，但是返回值仍然为一个列表，当我们只需要取一个值时，远不如find方法方便。但是如果未搜索到值时，将返回一个None。
在上面介绍BeautifulSoup4的时候，我们知道可以通过bs.div来获取第一个div标签，如果我们需要获取第一个div下的第一个div，我们可以这样：
t = bs.div.div
# 等价于
t = bs.find("div").find("div")六、CSS选择器：select()方法
BeautifulSoup支持部分的CSS选择器，在Tag获取BeautifulSoup对象的.select()方法中传入字符串参数，即可使用CSS选择器的语法找到Tag:
print(bs.select('title')) # 1、通过标签名查找
print(bs.select('a'))
print(bs.select('.mnav')) # 2、通过类名查找
print(bs.select('#u1')) # 3、通过id查找
print(bs.select('div .bri')) # 4、组合查找
print(bs.select('a[class="bri"]')) # 5、属性查找
print(bs.select('a[href="http://tieba.baidu.com" rel="external nofollow" rel="external nofollow" ]'))
print(bs.select("head > title")) # 6、直接子标签查找
print(bs.select(".mnav ~ .bri")) # 7、兄弟节点标签查找
print(bs.select('title')[0].get_text()) # 8、获取内容七、综合实例：
from bs4 import BeautifulSoup
import requests,re
req_obj = requests.get('https://www.baidu.com')
soup = BeautifulSoup(req_obj.text,'lxml')
'''标签查找'''
print(soup.title) #只是查找出第一个
print(soup.find('title')) #效果和上面一样
print(soup.find_all('div')) #查出所有的div标签
'''获取标签里的属性'''
tag = soup.div
print(tag['class']) #多属性的话，会返回一个列表
print(tag['id']) #查找标签的id属性
print(tag.attrs) #查找标签所有的属性，返回一个字典（属性名：属性值）
'''标签包的字符串'''
tag = soup.title
print(tag.string) #获取标签里的字符串
tag.string.replace_with("哈哈") #字符串不能直接编辑，可以替换
'''子节点的操作'''
tag = soup.head
print(tag.title) #获取head标签后再获取它包含的子标签
'''contents 和 .children'''
tag = soup.body
print(tag.contents) #将标签的子节点以列表返回
print([child for child in tag.children]) #输出和上面一样
'''descendants'''
tag = soup.body
[print(child_tag) for child_tag in tag.descendants] #获取所有子节点和子子节点
'''strings和.stripped_strings'''
tag = soup.body
[print(str) for str in tag.strings] #输出所有所有文本内容
[print(str) for str in tag.stripped_strings] #输出所有所有文本内容，去除空格或空行
'''.parent和.parents'''
tag = soup.title
print(tag.parent) #输出便签的父标签
[print(parent) for parent in tag.parents] #输出所有的父标签
'''.next_siblings 和 .previous_siblings
查出所有的兄弟节点
'''
'''.next_element 和 .previous_element
下一个兄弟节点
'''
'''find_all的keyword 参数'''
soup.find_all(id='link2') #查找所有包含 id 属性的标签
soup.find_all(href=re.compile("elsie")) #href 参数,Beautiful Soup会搜索每个标签的href属性:
soup.find_all(id=True) #找出所有的有id属性的标签
soup.find_all(href=re.compile("elsie"), id='link1') #也可以组合查找
soup.find_all(attrs={"属性名": "属性值"}) #也可以通过字典的方式查找八、BeautifulSoup 和lxml（Xpath）对比
# test.py
# -*- coding: utf-8 -*-
import requests
from bs4 import BeautifulSoup, SoupStrainer
import traceback
import json
from lxml import etree
import re
import time
def getHtmlText(url):
try:
r = requests.get(url, headers=headers)
r.raise_for_status()
if r.encoding == 'ISO-8859-1':
r.encoding = r.apparent_encoding
return r.text
except:
traceback.print_exc()
# ----------使用BeautifulSoup解析------------------------
def parseWithBeautifulSoup(html_text):
soup = BeautifulSoup(html_text, 'lxml')
content = []
for mulu in soup.find_all(class_='mulu'): # 先找到所有的 div class=mulu 标记
# 找到div_h3 标记
h3 = mulu.find('h3')
if h3 != None:
h3_title = h3.string # 获取标题
lst = []
for a in mulu.select('div.box a'):
href = a.get('href') # 找到 href 属性
box_title = a.get('title') # 找到 title 属性
pattern = re.compile(r'\s*\[(.*)\]\s+(.*)') # (re) 匹配括号内的表达式，也表示一个组
match = pattern.search(box_title)
if match != None:
date = match.group(1)
real_title = match.group(2)
lst.append({'href':href,'title':real_title,'date':date})
content.append({'title':h3_title,'content':lst})
with open('dmbj_bs.json', 'w') as fp:
json.dump(content, fp=fp, indent=4)
# ----------使用Xpath解析------------------------
def parseWithXpath(html_text):
html = etree.HTML(html_text)
content = []
for div_mulu in html.xpath('.//*[@class="mulu"]')： # 先找到所有的 div class=mulu 标记
# 找到所有的 div_h3 标记
div_h3 = div_mulu.xpath('./div[@class="mulu-title"]/center/h3/text()')
if len(div_h3) > 0:
h3_title = div_h3[0] # 获取标题
a_s = div_mulu.xpath('./div[@class="box"]/ul/li/a')
lst = []
for a in a_s:
href = a.xpath('./@href')[0] # 找到 href 属性
box_title = a.xpath('./@title')[0] # 找到 title 属性
pattern = re.compile(r'\s*\[(.*)\]\s+(.*)') # (re) 匹配括号内的表达式，也表示一个组
match = pattern.search(box_title)
if match != None:
date = match.group(1)
real_title = match.group(2)
lst.append({'href':href,'title':real_title,'date':date})
content.append({'title':h3_title,'content':lst})
with open('dmbj_xp.json', 'w') as fp:
json.dump(content, fp=fp, indent=4)
def main():
html_text = getHtmlText('http://www.seputu.com')
print(len(html_text))
start = time.clock()
parseWithBeautifulSoup(html_text)
print('BSoup cost:', time.clock()-start)
start = time.clock()
parseWithXpath(html_text)
print('Xpath cost:', time.clock()-start)
if __name__ == '__main__':
user_agent = 'Mozilla/5.0 (Windows NT 10.0; WOW64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/66.0.3359.117 Safari/537.36'
headers={'User-Agent': user_agent}
main()위 내용은 Python이 Beautiful Soup(BS4) 라이브러리를 사용하여 HTML과 XML을 구문 분석하는 방법의 상세 내용입니다. 자세한 내용은 PHP 중국어 웹사이트의 기타 관련 기사를 참조하세요!
성명：
이 기사는 yisu.com에서 복제됩니다. 침해가 있는 경우 admin@php.cn으로 문의하시기 바랍니다. 삭제