devbox
AllinToyou
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

python爬虫解析库（Xpath、beautiful soup、Jsonpath）_beautiful soup xpath

作者：AllinToyou | 2024-02-18 16:29:01

赞

踩

beautiful soup xpath

1. HTML解析

HTML的内容返回给浏览器，浏览器就会解析它，并对它渲染。 HTML 超文本表示语言，设计的初衷就是为了超越普通文本，让文本表现力更强。 XML 扩展标记语言，不是为了代替HTML，而是觉得HTML的设计中包含了过多的格式，承担了一部分数据之外的 任务，所以才设计了XML只用来描述数据。HTML和XML都有结构，使用标记形成树型的嵌套结构。DOM（Document Object Model）来解析这种嵌套树型 结构，浏览器往往都提供了对DOM操作的API，可以用面向对象的方式来操作DOM。

2. Xpath

XPath 是一门在 XML 文档中查找信息的语言。XPath 可用来在 XML 文档中对元素和属性进行遍历。工具 XMLQuire win7+需要.NET框架4.0-4.5。 测试XML、XPath

2.1 节点

在 XPath 中，有七种类型的节点：元素、属性、文本、命名空间、处理指令、注释以及文档（根）节点。

  • / 根结点
  • <bookstore> 元素节点
  • <author>Corets, Eva</author> 元素节点，
  • id="bk104" 是属性节点，id是元素节点book的属性
  • 节点之间的嵌套形成父子(parent、children)关系。
  • 具有同一个父节点的不同节点是兄弟(sibling)关系。

节点选择：

 谓语：谓语用来查找某个特定的节点或者包含某个指定的值的节点。 谓语被嵌在方括号中。 谓语就是查询的条件。 即在路径选择时，在中括号内指定查询条件。

XPath（轴节点）：轴的意思是相对于当前节点的节点集

 步step：步的语法 轴名称::节点测试[谓语]

XPATH实例 ：以斜杠开始的称为绝对路径，表示从根开始。 不以斜杆开始的称为相对路径，一般都是依照当前节点来计算。当前节点在上下文环境中，当前节点很可能已经不 是根节点了。 一般为了方便，往往xml如果层次很深，都会使用//来查找节点。

2.2. lxml

lxml安装：$ pip install lxml 

  1. from lxml import etree
  2.  
  3.  
  4. with open('./books.xml') as f:
  5.     # print(f.read())
  6.     text = f.read()
  7.     html = etree.HTML(text.encode())
  8.     # print(html)
  9.     print(html.tag)
  10.  
  11.     print(html.xpath('//title'))  # 从根节点向下找任意层中title的节点
  12.     print(html.xpath('//book//title'))
  13.     print(html.xpath('//book[@id="bk102"]'))
  14.     print(html.xpath('//book[@id]'))
  15.     print(html.xpath('//@id'))  # 取回的是属性
  16.     print(html.xpath('//*[@id]'))
  17.     print(html.xpath('//bookstore/book[1]'))
  18.     print(html.xpath('//bookstore/book[1]/@id'))  # ['bk101']
  19.     print(html.xpath('//bookstore/book[last()]/@id'))  # last()为最后一个节点
  20.     print(html.xpath('//*[contains(local-name(), "store")]'))  # [<Element bookstore at 0x2ce5648>]
  21.     # local-name()为当前标签名字
  22.     print(html.xpath('//bookstore/*'))  # 匹配根节点bookstore下的所有子节点，不递归；
  23.     print(html.xpath('//*[@*]'))  # 匹配所有有属性的节点
  24.     print(html.xpath('//@*'))  # 匹配所有属性
  25.     print(html.xpath('//book/title|//book/price'))  # 匹配book节点下title标签或prices标签
  26.     print(html.xpath('//book[position()=2]/@id'))  # ['bk102']
  27.     print(html.xpath('//book[price > 40]/@id'))
  28.     print(html.xpath('//book[1]/text()'))  # 匹配第一个book节点下所有文本子节点
  29.     print(html.xpath('//book[1]//text()'))  # 匹配第一个book节点下所有文本节点
  30.     print(html.xpath('//*[contains(@class,"even")]'))  # 匹配属性class中包含even字符串的节点
  31.

从豆瓣电影中提取“本周口碑榜”：

  1. import requests
  2. from lxml import etree  # lxml 是c语言的库，效率非常高
  3. from bs4 import BeautifulSoup
  4.  
  5. url = 'http://movie.douban.com'
  6. headers = {'User-agent': "Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) \
  7.             Chrome/55.0.2883.75 Safari/537.36"}
  8. response = requests.get(url, headers=headers)
  9.  
  10. with response:
  11.     if response.status_code == 200:
  12.         text = response.text
  13.         html = etree.HTML(text)
  14.         print(html.tag)
  15.  
  16.         titles = html.xpath('//div[@class="billboard-bd"]//a/text()')
  17.         for title in titles:
  18.             print(title)
  19.  
  20.         print("*********************")

2.3  Beautiful Soup4

BeautifulSoup可以从HTML、XML中提取数据。目前BS4在持续开发。

官方中文文档https://www.crummy.com/software/BeautifulSoup/bs4/doc.zh/

安装：$ pip install beautifulsoup4

BeautifulSoup(markup, "html.parser") 使用Python标准库，容错差且性能一般。BeautifulSoup(markup, "lxml") 容错能力强，速度快。需要安装系统C库。 推荐使用lxml作为解析器，效率高。 请手动指定解析器，以保证代码在所有运行环境中解析器一致。

四种对象

BeautifulSoup将HTML文档解析成复杂的树型结构，每个节点都是Python的对象，可分为4种：

BeautifulSoup、Tag、NavigableString、Comment

BeautifulSoup：代表整个文档。

Tag：它对应着HTML中的标签。有2个常用的属性：

  • name：Tag对象的名称，就是标签名称
  • attrs：标签的属性字典

多值属性，对于class属性可能是下面的形式， <h3 class="title highlight">python高级班</h3> ，这 个属性就是多值（{'class': ['title', 'highlight']}）属性可以被修改、删除

  1. from lxml import etree  # lxml 是c语言的库，效率非常高
  2. from bs4 import BeautifulSoup
  3. # from bs4 import Tag
  4.  
  5.  
  6. # features推荐写清楚
  7. with open('E:/马哥教育培训资料/slides/chapter16爬虫/test.html', encoding='utf-8') as f:
  8.     soup = BeautifulSoup(f, 'lxml')  # str 就是html内容；file-like obj open：'lxml'
  9.     print(0, soup.builder)
  10.     print(1, soup.name)
  11.     print(2, soup.img)  # 返回第一个，
  12.     print(3, soup.p)  # 深度优先遍历，取第一个
  13.     print(4, soup.p.attrs)  # 结果是字典
  14.     print(5, soup.h3.attrs)  # 字典
  15.     print(6, soup.h3['class'])
  16.     print(7, soup.h3.get('class'))
  17.     soup.h3['class'] = 'new_class'
  18.     print(8, soup.h3.get('class'))
  19.     print(000, soup.div.name, soup.div.attrs)
  20.     print(9, soup.p.string)  # p标签的内容
  21.     print(10, soup.div.contents)  # 直接子，包括文本
  22.     print(11, list(soup.div.children))  # 返回子节点的迭代器
  23.  
  24.     print(12, list(soup.div.descendants))  # 返回所有子孙节点的迭代器
  25.     print(list(map(lambda x: x.name if x.name else x, soup.div.descendants)))  # 子孙节点
  26.  
  27.     print('************************')
  28.     print(13, "".join(soup.div.strings))  # 拼接，但是换行符还在
  29.     print(14, "".join(soup.div.stripped_strings))  # 连接在一起了
  30.  
  31.     print(15, soup.p.next_sibling)
  32.     print(16, soup.img.get('src'))
  33.     print(17, soup.img['src'])
  34.     print(18, soup.a)  # 找不到返回None
  35.     del soup.h3['class']  # 删除属性
  36.     print(19, soup.h3.get('class'))

注意，我们一般不使用上面这种方式来操作HTML，此代码是为了熟悉对象类型

NavigableString：如果只想输出标记内的文本，而不关心标记的话，就要使用NavigableString。

print(soup.div.p.string) # 第一个div下第一个p的字符串；print(soup.p.string) # 同上

Comment ：注释对象，这就是HTML中的注释，它被Beautiful Soup解析后对应Comment对象。

遍历字符串 ：在前面的例子中，soup.div.string返回None，是因为string要求soup.div只能有一个NavigableString类型子节点， 也就是如这样 <div>only string</div> 。 如果div有很多子孙节点，如何提取字符串？

  1. print(soup.div.string)  # 返回None，因为多于1个子节点
  2. print("".join(soup.div.strings))  # 返回迭代器，带多余的空白字符
  3. print("".join(soup.div.stripped_strings))  # 返回迭代器，去除多余空白符

遍历祖先节点：

  1. print(soup.parent)  # None 根节点没有父节点
  2. print(soup.div.parent.name)  # body，第一个div的父节点
  3. print(soup.p.parent.parent.get('id'))  # 取id属性，main
  4. print(list(map(lambda x: x.name, soup.p.parents)))  # 父迭代器，由近及远

遍历兄弟节点：

  1. print('{} [{}]'.format(1, soup.p.next_sibling))  # 第一个p元素的下一个兄弟节点，注意可能是一个文本节
  2. 点
  3. print('{} [{}]'.format(2, soup.p.previous_sibling))
  4. print(list(soup.p.next_siblings))  # previous_siblings

遍历其他元素 ：next_element是下一个可被解析的对象（字符串或tag），和下一个兄弟节点next_sibling不一样

  1. print(soup.p.next_element)  # 返回"字典"2个字
  2. print(soup.p.next_element.next_element.next_element)
  3. print(list(soup.p.next_elements))
  1. from lxml import etree  # lxml 是c语言的库，效率非常高
  2. from bs4 import BeautifulSoup
  3. # from bs4 import Tag
  4.  
  5.  
  6. # features推荐写清楚
  7. with open('E:/马哥教育培训资料/slides/chapter16爬虫/test.html', encoding='utf-8') as f:
  8.     soup = BeautifulSoup(f, 'lxml')  # str 就是html内容；file-like obj open：'lxml'
  9.     print(soup.p.next_element)  # 返回字典两个字
  10.     print(soup.p.next_element.next_element)
  11.     print(soup.p.next_element.next_element.next_element)
  12.     print(list(soup.p.next_elements))
  13.     print(list(soup.p.next_siblings))

搜索文档树：

name：官方称为filter过滤器，这个参数可以是以下类型：

i.字符串：一个标签名称的字符串，会按照这个字符串全长匹配标签名

print(soup.find_all('p'))

ii.正则表达式对象：按照正则表达式对象的模式匹配标签名 

print(soup.find_all(re.compile(r'^h\d')))  # 标签名一h开头后接数字

iii.列表

  1.  print(soup.find_all(['p', 'h1', 'h3']))
  2.  print(soup.find_all(['p', re.compile(r'h\d')]))

IV.True或None：True或None，则find_all返回全部非字符串节点、非注释节点，接胡思Tag标签类型。

  1.    print(soup.list(map(lambda x: x.name, soup.find_all(True))))
  2.    print(soup.list(map(lambda x: x.name, soup.find_all(None))))
  3.    print(soup.list(map(lambda x: x.name, soup.find_all())))

 

  1. from lxml import etree  # lxml 是c语言的库，效率非常高
  2. from bs4 import BeautifulSoup
  3. import re
  4. from bs4 import Tag
  5.  
  6.  
  7. # features推荐写清楚
  8. with open('E:/马哥教育培训资料/slides/chapter16爬虫/test.html', encoding='utf-8') as f:
  9.     soup = BeautifulSoup(f, 'lxml')  # str 就是html内容；file-like obj open：'lxml'
  10.  
  11.     values = [True, None, False]
  12.     for value in values:
  13.         all = soup.find_all(value)
  14.         print(type(all[0]))
  15.         print(len(all))
  16.     count = 0
  17.     for i, t in enumerate(soup.descendants):
  18.         print(i, type(t), t.name)
  19.         if isinstance(t, Tag):
  20.             count += 1
  21.     print(count)

V.函数：如果使用以上过滤器还不能提取出想要的节点，可以使用函数，此函数仅只能接收一个参数。 如果这个函数返回True，表示当前节点匹配；返回False则是不匹配。

  1. from lxml import etree  # lxml 是c语言的库，效率非常高
  2. from bs4 import BeautifulSoup
  3. import re
  4. import bs4
  5.  
  6.  
  7. def many_class(tag: bs4.Tag):
  8.     # print(type(tag))
  9.     # print(tag.attrs)
  10.     return len(tag.attrs.get('class', [])) > 1
  11.  
  12.  
  13. # features推荐写清楚
  14. with open('E:/马哥教育培训资料/slides/chapter16爬虫/test.html', encoding='utf-8') as f:
  15.     soup = BeautifulSoup(f, 'lxml')  # str 就是html内容；file-like obj open：'lxml'
  16.  
  17.     print(soup.find_all(many_class))
  18.     # [<h3 class="title highlight">python高级班</h3>]

keyword传参：使用关键字传参，如果参数名不是find系函数已定义的位置参数名，参数会被kwargs收集并被当做标签的属性来搜索。属性的传参可以是字符串、正则表达式对象、True、列表。

  1. print(soup.find_all(id='first'))  # id为first的所有节点列表
  2. print(soup.find_all(id=re.compile('\w+')))  # 相当于找有id的所有节点
  3. print(soup.find_all(id=True))  # 所有有id的节点
  4. print(list(map(lambda x:x['id'], soup.find_all(id=True))))
  5. print(soup.find_all(id=['first', re.compile(r'^sec')]))  # 指定id的名称列表
  6. print(soup.find_all(id=True, src=True))  # 相当于条件and，既有id又有src属性的节点列表

css的class的特殊处理：class是Python关键字，所以使用 class_ 。class是多值属性，可以匹配其中任意一个，也可以完全匹配。

  1. print(soup.find_all(class_="content"))
  2. print(soup.find_all(class_="title"))  # 可以使用任意一个css类
  3. print(soup.find_all(class_="highlight"))  # 可以使用任意一个css类
  4. print(soup.find_all(class_="highlight title"))  # 顺序错了，找不到
  5. print(soup.find_all(class_="title highlight"))  # 顺序一致，找到，就是字符串完全匹配

attrs参数：attrs接收一个字典，字典的key为属性名，value可以是字符串、正则表达式对象、True、列表。可以多个属性

  1. print(soup.find_all(attrs={'class':'title'}))
  2. print(soup.find_all(attrs={'class':'highlight'}))
  3. print(soup.find_all(attrs={'class':'title highlight'}))
  4. print(soup.find_all(attrs={'id':True}))
  5. print(soup.find_all(attrs={'id':re.compile(r'\d$')}))
  6. print(list(map(lambda x:x.name, soup.find_all(attrs={
  7. 'id':True, 'src':True
  8. }))))

text参数：可以通过text参数搜索文档中的字符串内容，接受字符串、正则表达式对象、True、列表

  1. print(list(map(lambda x: (type(x), x), soup.find_all(text=re.compile('\w+')))))  # 返回文本类节点
  2. print(list(map(lambda x: (type(x), x), soup.find_all(text=re.compile('[a-z]+')))))
  3. print(soup.find_all(re.compile(r'^(h|p)'), text=re.compile('[a-z]+')))  # 相当于过滤出Tag对象，并看
  4. 它的string是否符合text参数的要求，返回Tag对象

limit参数：限制返回结果的数量

print(soup.find_all(id=True, limit=3))  # 返回列表中有3个结果

find_all()是非常常用的方法，可以简化省略掉：

  1. print(soup('img'))  # 所有img标签对象的列表，不等价于soup.img
  2. print(soup.img)  # 深度优先第一个img
  3. print(soup.a.find_all(text=True))  # 返回文本
  4. print(soup.a(text=True))  # 返回文本，和上面等价
  5. print(soup('a', text=True))  # 返回a标签对象
  6. print(soup.find_all('img', attrs={'id':'bg1'}))
  7. print(soup('img', attrs={'id':'bg1'}))  # find_all的省略
  8. print(soup('img', attrs={'id':re.compile('1')}))

find方法：find( name , attrs , recursive , text , **kwargs ) 参数几乎和fifind_all一样。 找到了，fifind_all返回一个列表，而fifind返回一个单值，元素对象。 找不到，fifind_all返回一个空列表，而fifind返回一个None。

  1. print(soup.find('img', attrs={'id':'bg1'}).attrs.get('src', 'magedu'))
  2. print(soup.find('img', attrs={'id':'bg1'}).get('src'))  # 简化了attrs
  3. print(soup.find('img', attrs={'id':'bg1'})['src'])

CSS选择器 ***

和JQuery一样，可以使用CSS选择器来查找节点，使用soup.select()方法，select方法支持大部分CSS选择器，返回列表。CSS中，标签名直接使用，类名前加.点号，id名前加#井号。

  1.  
  2. from bs4 import BeautifulSoup
  3.  
  4.  
  5. # features推荐写清楚
  6. with open('E:/马哥教育培训资料/slides/chapter16爬虫/test.html', encoding='utf-8') as f:
  7.     soup = BeautifulSoup(f, 'lxml')  # str 就是html内容；file-like obj open：'lxml'
  8.     
  9.     # 元素选择器
  10.     print(1, soup.select('p'))  # 所有的p标签
  11.     # 类选择器
  12.     print(2, soup.select('.title'))
  13.     # 使用了伪类
  14.     # 直接子标签是p的同类型的所有p标签中的第二个
  15.     # （同类型）同标签名p的第2个，伪类只实现了nth-of-type，且要求是数字
  16.     print(3, soup.select('div.content > p:nth-of-type(2)'))  # 只实现了这个伪类
  17.     # id选择器
  18.     print(4, soup.select('p#second'))
  19.     print(5, soup.select('#bg1'))
  20.     # 后代选择器
  21.     print(6, soup.select('div p'))  # div下逐层找p
  22.     print(7, soup.select('div div p'))  # div下逐层找div下逐层找p
  23.     # 子选择器，直接后代
  24.     print(8, soup.select('div > p'))  # div下直接子标签的p，有2个
  25.     # 相邻兄弟选择器
  26.     print(9, soup.select('div p:nth-of-type(1) + [src]'))  # 返回[]
  27.     print(9, soup.select('div p:nth-of-type(1) + p'))  # 返回[]
  28.     print(9, soup.select('div > p:nth-of-type(2) + input'))  # 返回input Tag
  29.     print(9, soup.select('div > p:nth-of-type(2) + [type]'))  # 同上
  30.     # 普通兄弟选择器
  31.     print(10, soup.select('div p:nth-of-type(1) ~ [src]'))  # 返回2个img
  32.     # 属性选择器
  33.     print(11, soup.select('[src]'))  # 有属性src
  34.     print(12, soup.select('[src="/"]'))  # 属性src等于/
  35.     print(13, soup.select('[src="http://www.magedu.com/"]'))  # 完全匹配
  36.     print(14, soup.select('[src^="http://www"]'))  # 以http://www开头
  37.     print(15, soup.select('[src$="com/"]'))  # 以com/结尾
  38.     print(16, soup.select('img[src*="magedu"]'))  # 包含magedu
  39.     print(17, soup.select('img[src*=".com"]'))  # 包含.com
  40.     print(18, soup.select('[class="title highlight"]'))
  41.     print(19, soup.select('[class~=title]'))  # 多值属性中有一个title

获取文本内容:

  1. from bs4 import BeautifulSoup
  2.  
  3.  
  4. # features推荐写清楚
  5. with open('E:/马哥教育培训资料/slides/chapter16爬虫/test.html', encoding='utf-8') as f:
  6.     soup = BeautifulSoup(f, 'lxml')  # str 就是html内容；file-like obj open：'lxml'
  7.     ele = soup.select('div')  # 所有的div标签
  8.     print(ele[0].string, end='\n------------\n')  # 内容仅仅只能是文本类型，否则返回None
  9.     print(list(ele[0].strings), end='\n------------\n')  # 迭代保留空白字符
  10.     print(list(ele[0].stripped_strings), end='\n------------\n')  # 迭代不保留空白字符
  11.     print(ele[0], end='\n------------\n')
  12.     print(ele[0].text, end='\n------------\n')  # 本质上就是get_text()，保留空白字符的strings
  13.     print(ele[0].get_text(), end='\n------------\n')  # 迭代并join，保留空白字符，strip默认为False
  14.     print(ele[0].get_text(strip=True))  # 迭代并join，不保留空白字符

2.4 Json解析

拿到一个Json字符串，如果想提取其中的部分内容，就需要遍历了。在遍历过程中进行判断。还有一种方式，类似于XPath，叫做JsonPath。安装：$ pip install jsonpath

  1. import requests
  2. import simplejson
  3. from jsonpath import jsonpath
  4.  
  5.  
  6. url = "https://movie.douban.com/j/search_subjects?type=movie&tag=%E7%83%AD%E9%97%A8&page_limit=50&page_start=0"
  7.  
  8. headers = {'User-agent': "Mozilla/5.0 (Windows NT 6.1) AppleWebKit/537.36 (KHTML, like Gecko) \
  9.             Chrome/55.0.2883.75 Safari/537.36"}
  10. response = requests.get(url, headers=headers)
  11.  
  12. with response:
  13.     text = response.text
  14.     print(type(text), text)
  15.  
  16.     data = simplejson.loads(text)
  17.     print(data)
  18.  
  19.     # //subjects
  20.     # subjects = jsonpath(data, '$..subjects')  # 找不到就返回bool的False
  21.     # if isinstance(subjects, list) and len(subjects) == 1:
  22.     #     print(subjects)
  23.     #     for subject in subjects[0]:
  24.     #         print(subject.get['title'])
  25.  
  26.     # //subjects[rate > 8]/title  $.subjects[?(@.rate >8)]
  27.     subjects = jsonpath(data, '$.subjects[?(@.rate > "8")].title')  # 找不到就返回bool的False
  28.     # if isinstance(subjects, list) and len(subjects) == 1:
  29.     print(subjects)

 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/AllinToyou/article/detail/109124
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号