python叁分析库lxml的安装与主题使用,Python爬虫利器三之Xpath语法与lxml库的用法

By admin in 4858.com on 2019年5月17日

 lxml是python的2个剖析库,协助HTML和XML的分析,帮忙XPath分析方式,而且深入分析功能相当高

前言

前方我们介绍了 BeautifulSoup
的用法,这么些已经是极其强劲的库了,但是还有一对相比流行的分析库,比如lxml,使用的是 Xpath 语法,一样是功效比较高的辨析方法。即使大家对
BeautifulSoup 使用不太习惯的话,能够尝尝下 Xpath。

后面我们介绍了 BeautifulSoup
的用法,那个早已是十二分壮大的库了,不过还有部分相比较盛行的剖判库,譬喻lxml,使用的是 Xpath 语法,同样是功效比较高的辨析方法。假使大家对
BeautifulSoup 使用不太习贯的话,能够尝尝下 Xpath。

XPath,全称XML 帕特h
Language,即XML路线语言,它是1门在XML文档中查找音讯的言语,它最初是用来寻找XML文书档案的,可是它一样适用于HTML文书档案的探究

在爬虫的上学中,我们爬取网页信息之后就是对消息项相配,今年一般是行使正则。不过在选取中发觉正则写的不佳的时候无法纯粹匹配(那其实是自个儿的标题!)所以就找啊找。想到了足以经过标签来张开规范相称岂不是比正则要快。所以找到了lxml。

参谋文书档案:

参谋文档:

XPath的挑选成效10分有力,它提供了丰盛刚烈的门道选取表达式,其余,它还提供了超过九1九个内建函数,用于字符串、数值、时间的相称以及节点、类别的管理等,大概全数我们想要定位的节点,都足以用XPath来挑选

lxml是python的1个分析库,辅助HTML和XML的深入分析,支持XPath剖判格局,而且分析功能极度高

  • lxml python
    官方文书档案
  • XPath语法参谋w三school
  • lxml python
    官方文档
  • XPath语法参照他事他说加以考查w三school

X帕特h于一九97年1二月二八日变为W3C标准,它被规划为供XSLT、XPointer以及别的XML深入分析软件应用,更加的多的文档能够访问其官网:

XPath,全称XML Path
Language,即XML路径语言,它是壹门在XML文书档案中查找音信的言语,它最初是用来搜索XML文书档案的,但是它同样适用于HTML文档的追寻

4858.com ,安装

pip install lxml

运用 pip 安装就能够

安装

pip install lxml

动用 pip 安装就能够

1、python库lxml的安装

windows系统下的装置:

#pip安装
pip3 install lxml

#wheel安装
#下载对应系统版本的wheel文件:http://www.lfd.uci.edu/~gohlke/pythonlibs/#lxml
pip3 install lxml-4.2.1-cp36-cp36m-win_amd64.whl

linux下安装:

yum install -y epel-release libxslt-devel libxml2-devel openssl-devel

pip3 install lxml

表明安装:

$python3
>>>import lxml

XPath的挑3拣肆功能特别有力,它提供了那一个分明的门路选取表明式,别的,它还提供了抢先一百个内建函数,用于字符串、数值、时间的相称以及节点、种类的处理等,差不多全数大家想要定位的节点,都足以用XPath来抉择

XPath语法

XPath 是1门在 XML 文书档案中查找音讯的语言。XPath 可用来在 XML
文书档案中对成分和性格举行遍历。XPath 是 W3C XSLT 规范的重中之首要素,并且
XQuery 和 XPointer 都创设于 X帕特h 表明之上。

XPath语法

XPath 是1门在 XML
文书档案中查找消息的语言。XPath 可用来在 XML
文书档案中对成分和总体性实行遍历。X帕特h 是 W3C XSLT 标准的机要因素,并且
XQuery 和 XPointer 都创设于 XPath 表达之上。

二、XPath常用规则

表达式 描述
nodename 选取此节点的所有子节点
/ 从当前节点选取直接子节点
// 从当前节点选取子孙节点
. 选取当前节点
.. 选取当前节点的父节点
@ 选取属性
* 通配符,选择所有元素节点与元素名
@* 选取所有属性
[@attrib] 选取具有给定属性的所有元素
[@attrib=’value’] 选取给定属性具有给定值的所有元素
[tag] 选取所有具有指定元素的直接子节点
[tag=’text’] 选取所有具有指定元素并且文本内容是text节点

XPath于一九九捌年1月16日变为W3C标准,它被设计为供XSLT、XPointer以及其余XML深入分析软件使用,越多的文档可以访问其官网:

节点关系

  • (1)父(Parent)

各类成分以及品质都有七个父。
在下边包车型地铁例子中,book 成分是 title、author、year 以及 price 成分的父:

<book>
  <title>Harry Potter</title>
  <author>J K. Rowling</author>
  <year>2005</year>
  <price>29.99</price>
</book>
  • (2)子(Children)

要素秋点可有零个、1个或多个子。
在上边包车型客车例子中,title、author、year 以及 price 元素都是 book 成分的子:

<book>
  <title>Harry Potter</title>
  <author>J K. Rowling</author>
  <year>2005</year>
  <price>29.99</price>
</book>
  • (3)同胞(Sibling)

享有同等的父的节点
在底下的事例中,title、author、year 以及 price 成分都以同胞:

<book>
  <title>Harry Potter</title>
  <author>J K. Rowling</author>
  <year>2005</year>
  <price>29.99</price>
</book>
  • (4)先辈(Ancestor)

某节点的父、父的父,等等。
在底下的事例中,title 成分的长辈是 book 成分和 bookstore 成分:

<bookstore>

<book>
  <title>Harry Potter</title>
  <author>J K. Rowling</author>
  <year>2005</year>
  <price>29.99</price>
</book>

</bookstore>
  • (5)后代(Descendant)

某些节点的子,子的子,等等。
在上面包车型客车例证中,bookstore 的儿孙是 book、title、author、year 以及 price
元素:

<bookstore>

<book>
  <title>Harry Potter</title>
  <author>J K. Rowling</author>
  <year>2005</year>
  <price>29.99</price>
</book>

</bookstore>

节点关系

  • (1)父(Parent)

种种元素以及品质都有三个父。
在底下的例子中,book 成分是
title、author、year 以及 price 成分的父:

<book>
  <title>Harry Potter</title>
  <author>J K. Rowling</author>
  <year>2005</year>
  <price>29.99</price>
</book>
  • (2)子(Children)

要白藏点可有零个、2个或四个子。
在底下的事例中,title、author、year 以及
price 成分都是 book 成分的子:

<book>
  <title>Harry Potter</title>
  <author>J K. Rowling</author>
  <year>2005</year>
  <price>29.99</price>
</book>
  • (3)同胞(Sibling)

具有同样的父的节点
在底下的事例中,title、author、year 以及
price 成分都以同胞:

<book>
  <title>Harry Potter</title>
  <author>J K. Rowling</author>
  <year>2005</year>
  <price>29.99</price>
</book>
  • (4)先辈(Ancestor)

某节点的父、父的父,等等。
在下边包车型地铁例证中,title 成分的长辈是 book
成分和 bookstore 成分:

<bookstore>

<book>
  <title>Harry Potter</title>
  <author>J K. Rowling</author>
  <year>2005</year>
  <price>29.99</price>
</book>

</bookstore>
  • (5)后代(Descendant)

某些节点的子,子的子,等等。
在下边包车型大巴例证中,bookstore 的后代是
book、title、author、year 以及 price 成分:

<bookstore>

<book>
  <title>Harry Potter</title>
  <author>J K. Rowling</author>
  <year>2005</year>
  <price>29.99</price>
</book>

</bookstore>

(一)读取文本剖判节点

from lxml import etree

text='''
<div>
    <ul>
         <li class="item-0"><a href="link1.html">第一个</a></li>
         <li class="item-1"><a href="link2.html">second item</a></li>
         <li class="item-0"><a href="link5.html">a属性</a>
     </ul>
 </div>
'''
html=etree.HTML(text) #初始化生成一个XPath解析对象
result=etree.tostring(html,encoding='utf-8')   #解析对象输出代码
print(type(html))
print(type(result))
print(result.decode('utf-8'))

#etree会修复HTML文本节点
<class 'lxml.etree._Element'>
<class 'bytes'>
<html><body><div>
    <ul>
         <li class="item-0"><a href="link1.html">第一个</a></li>
         <li class="item-1"><a href="link2.html">second item</a></li>
         <li class="item-0"><a href="link5.html">a属性</a>
     </li></ul>
 </div>
</body></html>

1、python库lxml的安装

采纳节点

XPath 使用路径表明式在 XML 文书档案中挑选节点。节点是透过沿着马路线只怕 step
来抉择的。
上面列出了最得力的路线表明式:

表达式 描述
nodename 选取此节点的所有子节点
/ 从根节点选取。
// 从匹配选择的当前节点选择文档中的节点,而不考虑它们的位置。
. 选取当前节点。
.. 选取当前节点的父节点。
@ 选取属性。

实例
在下边包车型客车表格中,我们已列出了一部分门路表达式以及表明式的结果:

路径表达式 结果
bookstore 选取 bookstore 元素的所有子节点。
/bookstore 选取根元素 bookstore。注释:假如路径起始于正斜杠( / ),则此路径始终代表到某元素的绝对路径!
bookstore/book 选取属于 bookstore 的子元素的所有 book 元素。
//book 选取所有 book 子元素,而不管它们在文档中的位置。
bookstore//book 选择属于 bookstore 元素的后代的所有 book 元素,而不管它们位于 bookstore 之下的什么位置。
//@lang 选取名为 lang 的所有属性。

选用节点

XPath 使用路线表明式在 XML
文书档案中选取节点。节点是透过沿着路线可能 step 来摘取的。
下边列出了最实用的门路表明式:

表达式 描述
nodename 选取此节点的所有子节点
/ 从根节点选取。
// 从匹配选择的当前节点选择文档中的节点,而不考虑它们的位置。
. 选取当前节点。
.. 选取当前节点的父节点。
@ 选取属性。

实例
在上面包车型大巴报表中,我们已列出了部分门路表明式以及表达式的结果:

路径表达式 结果
bookstore 选取 bookstore 元素的所有子节点。
/bookstore 选取根元素 bookstore。注释:假如路径起始于正斜杠( / ),则此路径始终代表到某元素的绝对路径!
bookstore/book 选取属于 bookstore 的子元素的所有 book 元素。
//book 选取所有 book 子元素,而不管它们在文档中的位置。
bookstore//book 选择属于 bookstore 元素的后代的所有 book 元素,而不管它们位于 bookstore 之下的什么位置。
//@lang 选取名为 lang 的所有属性。

(二)读取HTML文件进行解析

from lxml import etree

html=etree.parse('test.html',etree.HTMLParser()) #指定解析器HTMLParser会根据文件修复HTML文件中缺失的如声明信息
result=etree.tostring(html)   #解析成字节
#result=etree.tostringlist(html) #解析成列表
print(type(html))
print(type(result))
print(result)

#
<class 'lxml.etree._ElementTree'>
<class 'bytes'>
b'<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN" "http://www.w3.org/TR/REC-html40/loose.dtd">\n<html><body><div>&#13;\n    <ul>&#13;\n         <li class="item-0"><a href="link1.html">first item</a></li>&#13;\n         <li class="item-1"><a href="link2.html">second item</a></li>&#13;\n         <li class="item-inactive"><a href="link3.html">third item</a></li>&#13;\n         <li class="item-1"><a href="link4.html">fourth item</a></li>&#13;\n         <li class="item-0"><a href="link5.html">fifth item</a>&#13;\n     </li></ul>&#13;\n </div>&#13;\n</body></html>'

python叁分析库lxml的安装与主题使用,Python爬虫利器三之Xpath语法与lxml库的用法。windows系统下的装置:

谓语(Predicates)

谓语用来搜寻有些特定的节点照旧隐含有些钦定的值的节点。
谓语被嵌在方括号中。
实例
在上面的表格中,大家列出了带有谓语的一些路线表明式,以及表明式的结果:

路径表达式 结果
/bookstore/book[1] 选取属于 bookstore 子元素的第一个 book 元素。
/bookstore/book[last()] 选取属于 bookstore 子元素的最后一个 book 元素。
/bookstore/book[last()-1] 选取属于 bookstore 子元素的倒数第二个 book 元素。
/bookstore/book[position()<3] 选取最前面的两个属于 bookstore 元素的子元素的 book 元素。
//title[@lang] 选取所有拥有名为 lang 的属性的 title 元素。
//title[@lang=’eng’] 选取所有 title 元素,且这些元素拥有值为 eng 的 lang 属性。
/bookstore/book[price>35.00] 选取 bookstore 元素的所有 book 元素,且其中的 price 元素的值须大于 35.00。
/bookstore/book[price>35.00]/title 选取 bookstore 元素中的 book 元素的所有 title 元素,且其中的 price 元素的值须大于 35.00。

谓语(Predicates)

谓语用来查找某些特定的节点依然隐含有些钦赐的值的节点。
谓语被嵌在方括号中。
实例
在上面包车型地铁表格中,我们列出了蕴藏谓语的有些路子表明式,以及表明式的结果:

路径表达式 结果
/bookstore/book[1] 选取属于 bookstore 子元素的第一个 book 元素。
/bookstore/book[last()] 选取属于 bookstore 子元素的最后一个 book 元素。
/bookstore/book[last()-1] 选取属于 bookstore 子元素的倒数第二个 book 元素。
/bookstore/book[position()<3] 选取最前面的两个属于 bookstore 元素的子元素的 book 元素。
//title[@lang] 选取所有拥有名为 lang 的属性的 title 元素。
//title[@lang=’eng’] 选取所有 title 元素,且这些元素拥有值为 eng 的 lang 属性。
/bookstore/book[price>35.00] 选取 bookstore 元素的所有 book 元素,且其中的 price 元素的值须大于 35.00。
/bookstore/book[price>35.00]/title 选取 bookstore 元素中的 book 元素的所有 title 元素,且其中的 price 元素的值须大于 35.00。

(三)获取具备节点

回到二个列表每种成分都以Element类型,全数节点都包括在里边

from lxml import etree

html=etree.parse('test',etree.HTMLParser())
result=html.xpath('//*')  #//代表获取子孙节点,*代表获取所有

print(type(html))
print(type(result))
print(result)

#
<class 'lxml.etree._ElementTree'>
<class 'list'>
[<Element html at 0x754b210048>, <Element body at 0x754b210108>, <Element div at 0x754b210148>, <Element ul at 0x754b210188>, <Element li at 0x754b2101c8>, <Element a at 0x754b210248>, <Element li at 0x754b210288>, <Element a at 0x754b2102c8>, <Element li at 0x754b210308>, <Element a at 0x754b210208>, <Element li at 0x754b210348>, <Element a at 0x754b210388>, <Element li at 0x754b2103c8>, <Element a at 0x754b210408>]

如要获取li节点,能够利用//后边加上节点名称,然后调用xpath()方法

html.xpath('//li')   #获取所有子孙节点的li节点
#pip安装
pip3 install lxml

#wheel安装
#下载对应系统版本的wheel文件:http://www.lfd.uci.edu/~gohlke/pythonlibs/#lxml
pip3 install lxml-4.2.1-cp36-cp36m-win_amd64.whl

选料未知节点

XPath 通配符可用来摘取未知的 XML 成分。

通配符 描述
* 匹配任何元素节点。
@* 匹配任何属性节点。
node() 匹配任何类型的节点。

实例
在上边的表格中,大家列出了有的门路表达式,以及这几个表明式的结果:

路径表达式 结果
/bookstore/* 选取 bookstore 元素的所有子元素。
//* 选取文档中的所有元素。
//title[@*] 选取所有带有属性的 title 元素。

选取未知节点

X帕特h 通配符可用来摘取未知的 XML
成分。

通配符 描述
* 匹配任何元素节点。
@* 匹配任何属性节点。
node() 匹配任何类型的节点。

实例
在上面包车型客车表格中,大家列出了部分路线表达式,以及这个表达式的结果:

路径表达式 结果
/bookstore/* 选取 bookstore 元素的所有子元素。
//* 选取文档中的所有元素。
//title[@*] 选取所有带有属性的 title 元素。

(四)获取子节点

通过/只怕//就可以找寻元素的子节点可能子孙节点,假设想选用li节点的全部直接a节点,能够如此使用

result=html.xpath('//li/a')  #通过追加/a选择所有li节点的所有直接a节点,因为//li用于选中所有li节点,/a用于选中li节点的所有直接子节点a

linux下安装:

慎选若干路径

透过在路径表明式中选拔“|”运算符,您可以选拔若干个渠道。
实例
在上边包车型大巴报表中,大家列出了某些门路表明式,以及那么些表达式的结果:

路径表达式 结果
//book/title //book/price
//title //price
/bookstore/book/title //price

选用若干路子

通过在门路表达式中应用“|”运算符,您能够选用若干个渠道。
实例
在上边包车型大巴表格中,我们列出了有个别门道表明式,以及这个表明式的结果:

路径表达式 结果
//book/title | //book/price 选取 book 元素的所有 title 和 price 元素。
//title | //price 选取文档中的所有 title 和 price 元素。
/bookstore/book/title | //price 选取属于 bookstore 元素的 book 元素的所有 title 元素,以及文档中所有的 price 元素。

(5)获取父节点

小编们清楚通过连接的/或然//能够查找子节点或子孙节点,那么要探究父节点能够运用..来促成也足以行使parent::来获得父节点

from lxml import etree
from lxml.etree import HTMLParser
text='''
<div>
    <ul>
         <li class="item-0"><a href="link1.html">第一个</a></li>
         <li class="item-1"><a href="link2.html">second item</a></li>
     </ul>
 </div>
'''

html=etree.HTML(text,etree.HTMLParser())
result=html.xpath('//a[@href="link2.html"]/../@class')
result1=html.xpath('//a[@href="link2.html"]/parent::*/@class')
print(result)
print(result1)


#
['item-1']
['item-1']
yum install -y epel-release libxslt-devel libxml2-devel openssl-devel

pip3 install lxml

XPath 运算符

上边列出了可用在 XPath 表明式中的运算符:

运算符 描述 实例 返回值
| 计算两个节点集 //book | //cd 返回所有拥有 book 和 cd 元素的节点集
+ 加法 6 + 4 10
减法 6 – 4 2
* 乘法 6 * 4 24
div 除法 8 div 4 2
= 等于 price=9.80 如果 price 是 9.80,则返回 true。如果 price 是 9.90,则返回 false。
!= 不等于 price!=9.80 如果 price 是 9.90,则返回 true。如果 price 是 9.80,则返回 false。
< 小于 price<9.80 如果 price 是 9.00,则返回 true。如果 price 是 9.90,则返回 false。
<= 小于或等于 price<=9.80 如果 price 是 9.00,则返回 true。如果 price 是 9.90,则返回 false。
> 大于 price>9.80 如果 price 是 9.90,则返回 true。如果 price 是 9.80,则返回 false。
>= 大于或等于 price>=9.80 如果 price 是 9.90,则返回 true。如果 price 是 9.70,则返回 false。
or price=9.80 or price=9.70 如果 price 是 9.80,则返回 true。如果 price 是 9.50,则返回 false。
and price>9.00 and price<9.90 如果 price 是 9.80,则返回 true。如果 price 是 8.50,则返回 false。
mod 计算除法的余数 5 mod 2 1

XPath 运算符

上边列出了可用在 X帕特h
表明式中的运算符:

运算符 描述 实例 返回值
| 计算两个节点集 //book | //cd 返回所有拥有 book 和 cd 元素的节点集
+ 加法 6 + 4 10
减法 6 – 4 2
* 乘法 6 * 4 24
div 除法 8 div 4 2
= 等于 price=9.80 如果 price 是 9.80,则返回 true。如果 price 是 9.90,则返回 false。
!= 不等于 price!=9.80 如果 price 是 9.90,则返回 true。如果 price 是 9.80,则返回 false。
< 小于 price<9.80 如果 price 是 9.00,则返回 true。如果 price 是 9.90,则返回 false。
<= 小于或等于 price<=9.80 如果 price 是 9.00,则返回 true。如果 price 是 9.90,则返回 false。
> 大于 price>9.80 如果 price 是 9.90,则返回 true。如果 price 是 9.80,则返回 false。
>= 大于或等于 price>=9.80 如果 price 是 9.90,则返回 true。如果 price 是 9.70,则返回 false。
or price=9.80 or price=9.70 如果 price 是 9.80,则返回 true。如果 price 是 9.50,则返回 false。
and price>9.00 and price<9.90 如果 price 是 9.80,则返回 true。如果 price 是 8.50,则返回 false。
mod 计算除法的余数 5 mod 2 1

(6)属性相称

在增选的时候,大家还足以用@标记实行品质过滤。举例,这里假设要挑选classitem-1li节点,能够如此落成:

from lxml import etree
from lxml.etree import HTMLParser
text='''
<div>
    <ul>
         <li class="item-0"><a href="link1.html">第一个</a></li>
         <li class="item-1"><a href="link2.html">second item</a></li>
     </ul>
 </div>
'''

html=etree.HTML(text,etree.HTMLParser())
result=html.xpath('//li[@class="item-1"]')
print(result)

注脚安装:

lxml用法

开班使用
率先大家应用它来剖判 HTML 代码,先来贰个小例子来感受一下它的主题用法。

from lxml import etree
text = '''
<div>
    <ul>
         <li class="item-0"><a href="link1.html">first item</a></li>
         <li class="item-1"><a href="link2.html">second item</a></li>
         <li class="item-inactive"><a href="link3.html">third item</a></li>
         <li class="item-1"><a href="link4.html">fourth item</a></li>
         <li class="item-0"><a href="link5.html">fifth item</a>
     </ul>
 </div>
'''
html = etree.HTML(text)
result = etree.tostring(html)
print(result)

第2我们使用 lxml 的 etree 库,然后使用 etree.HTML
初叶化,然后大家将其打字与印刷出来。

里面,这里体现了 lxml 的一个非凡实用的意义正是活动改正 html
代码,我们应该专注到了,最后三个 li
标签,其实小编把尾标签删掉了,是不闭合的。可是,lxml 因为再三再四了 libxml二的特点,具备活动勘误 HTML 代码的成效。

于是输出结果是这么的

<html><body>
<div>
    <ul>
         <li class="item-0"><a href="link1.html">first item</a></li>
         <li class="item-1"><a href="link2.html">second item</a></li>
         <li class="item-inactive"><a href="link3.html">third item</a></li>
         <li class="item-1"><a href="link4.html">fourth item</a></li>
         <li class="item-0"><a href="link5.html">fifth item</a></li>
</ul>
 </div>

</body></html>

不光补全了 li 标签,还增加了 body,html 标签。

文本读取
而外直接读取字符串,还扶助从文件读取内容。比方大家新建2个文本叫做
hello.html,内容为

<div>
    <ul>
         <li class="item-0"><a href="link1.html">first item</a></li>
         <li class="item-1"><a href="link2.html">second item</a></li>
         <li class="item-inactive"><a href="link3.html">third item</a></li>
         <li class="item-1"><a href="link4.html">fourth item</a></li>
         <li class="item-0"><a href="link5.html">fifth item</a></li>
     </ul>
 </div>

选拔 parse 方法来读取文件。

from lxml import etree
html = etree.parse('hello.html')
result = etree.tostring(html, pretty_print=True)
print(result)

如出一辙能够获得壹致的结果。

XPath实例测试
依然以上一段程序为例
(一)获取具备的 <li> 标签

from lxml import etree
html = etree.parse('hello.html')
print type(html)
result = html.xpath('//li')
print result
print len(result)
print type(result)
print type(result[0])

运行结果

<type 'lxml.etree._ElementTree'>
[<Element li at 0x1014e0e18>, <Element li at 0x1014e0ef0>, <Element li at 0x1014e0f38>, <Element li at 0x1014e0f80>, <Element li at 0x1014e0fc8>]
5
<type 'list'>
<type 'lxml.etree._Element'>

足见,etree.parse 的种类是 ElementTree,通过调用 xpath
现在,得到了1个列表,包含了 五 个 <li> 成分,各样成分都以 Element
类型
(2)获取 <li> 标签的全数 class

result = html.xpath('//li/@class')
print result

运维结果

['item-0', 'item-1', 'item-inactive', 'item-1', 'item-0']

(3)获取 <li> 标签下 href 为 link1.html 的 <a> 标签

result = html.xpath('//li/a[@href="link1.html"]')
print result

运作结果

[<Element a at 0x10ffaae18>]

(四)获取 <li> 标签下的有所 <span> 标签
在意这样写是非经常的

result = html.xpath('//li/span')

因为 / 是用来博取子元素的,而 <span> 并不是 <li>
的子成分,所以,要用双斜杠

result = html.xpath('//li//span')
print result

运作结果

[<Element span at 0x10d698e18>]

(5)获取 <li> 标签下的有所 class,不包蕴 <li>

result = html.xpath('//li/a//@class')
print result

运维结果

['blod']

(陆)获取最终3个 <li> 的 <a> 的 href

result = html.xpath('//li[last()]/a/@href')
print result

运营结果

['link5.html']

(7)获取尾数第二个成分的原委

result = html.xpath('//li[last()-1]/a')
print result[0].text

运转结果

fourth item

(8)获取 class 为 bold 的标具名

result = html.xpath('//*[@class="bold"]')
print result[0].tag

运维结果

span

经过上述实例的练习,相信我们对 X帕特h
的骨干用法有了骨干的刺探。也能够采纳 text 方法来赢得成分的剧情。

lxml用法

始发使用
首先大家接纳它来深入分析 HTML
代码,先来1个小例子来感受一下它的中坚用法。

from lxml import etree
text = '''
<div>
    <ul>
         <li class="item-0"><a href="link1.html">first item</a></li>
         <li class="item-1"><a href="link2.html">second item</a></li>
         <li class="item-inactive"><a href="link3.html">third item</a></li>
         <li class="item-1"><a href="link4.html">fourth item</a></li>
         <li class="item-0"><a href="link5.html">fifth item</a>
     </ul>
 </div>
'''
html = etree.HTML(text)
result = etree.tostring(html)
print(result)

率先大家应用 lxml 的 etree 库,然后采纳etree.HTML 初步化,然后大家将其打字与印刷出来。

里面,这里反映了 lxml
的2个特别实用的效劳正是自动改良 html 代码,我们应该注意到了,最后叁个li 标签,其实本人把尾标签删掉了,是不闭合的。可是,lxml 因为一连了 libxml2的天性,具备自动校正 HTML 代码的意义。

就此输出结果是那样的

<html><body>
<div>
    <ul>
         <li class="item-0"><a href="link1.html">first item</a></li>
         <li class="item-1"><a href="link2.html">second item</a></li>
         <li class="item-inactive"><a href="link3.html">third item</a></li>
         <li class="item-1"><a href="link4.html">fourth item</a></li>
         <li class="item-0"><a href="link5.html">fifth item</a></li>
</ul>
 </div>

</body></html>

不独补全了 li 标签,还增添了 body,html
标签。

文件读取
除此而外直接读取字符串,还协助从文件读取内容。比方大家新建三个文件叫做
hello.html,内容为

<div>
    <ul>
         <li class="item-0"><a href="link1.html">first item</a></li>
         <li class="item-1"><a href="link2.html">second item</a></li>
         <li class="item-inactive"><a href="link3.html">third item</a></li>
         <li class="item-1"><a href="link4.html">fourth item</a></li>
         <li class="item-0"><a href="link5.html">fifth item</a></li>
     </ul>
 </div>

采纳 parse 方法来读取文件。

from lxml import etree
html = etree.parse('hello.html')
result = etree.tostring(html, pretty_print=True)
print(result)

同壹能够获取平等的结果。

XPath实例测试
照旧以上壹段程序为例
(壹)获取具备的 <li> 标签

from lxml import etree
html = etree.parse('hello.html')
print type(html)
result = html.xpath('//li')
print result
print len(result)
print type(result)
print type(result[0])

运维结果

<type 'lxml.etree._ElementTree'>
[<Element li at 0x1014e0e18>, <Element li at 0x1014e0ef0>, <Element li at 0x1014e0f38>, <Element li at 0x1014e0f80>, <Element li at 0x1014e0fc8>]
5
<type 'list'>
<type 'lxml.etree._Element'>

可知,etree.parse 的连串是
ElementTree,通过调用 xpath 现在,获得了几个列表,包蕴了 5 个 <li>
成分,种种成分都以 Element 类型
(二)获取 <li> 标签的装有
class

result = html.xpath('//li/@class')
print result

运作结果

['item-0', 'item-1', 'item-inactive', 'item-1', 'item-0']

(3)获取 <li> 标签下 href 为
link1.html 的 <a> 标签

result = html.xpath('//li/a[@href="link1.html"]')
print result

运维结果

[<Element a at 0x10ffaae18>]

(四)获取 <li> 标签下的享有
<span> 标签
专注那样写是畸形的

result = html.xpath('//li/span')

因为 / 是用来博取子成分的,而 <span>
并不是 <li> 的子成分,所以,要用双斜杠

result = html.xpath('//li//span')
print result

运维结果

[<Element span at 0x10d698e18>]

(五)获取 <li> 标签下的享有
class,不蕴涵 <li>

result = html.xpath('//li/a//@class')
print result

运维结果

['blod']

(陆)获取最终3个 <li> 的 <a>
的 href

result = html.xpath('//li[last()]/a/@href')
print result

运作结果

['link5.html']

(7)获取尾数第四个要素的剧情

result = html.xpath('//li[last()-1]/a')
print result[0].text

运行结果

fourth item

(八)获取 class 为 bold 的标签字

result = html.xpath('//*[@class="bold"]')
print result[0].tag

运营结果

span

经过上述实例的演练,相信大家对 XPath
的着力用法有了着力的摸底。也足以选拔 text 方法来获取成分的内容。

(7)文本获取

大家用XPath中的text()方法获得节点中的文本

from lxml import etree

text='''
<div>
    <ul>
         <li class="item-0"><a href="link1.html">第一个</a></li>
         <li class="item-1"><a href="link2.html">second item</a></li>
     </ul>
 </div>
'''

html=etree.HTML(text,etree.HTMLParser())
result=html.xpath('//li[@class="item-1"]/a/text()') #获取a节点下的内容
result1=html.xpath('//li[@class="item-1"]//text()') #获取li下所有子孙节点的内容

print(result)
print(result1)
$python3
>>>import lxml

结语

XPath 是2个不行好用的分析方法,同时也作为爬虫学习的根基,在末端的
selenium 以及 scrapy
框架中都会涉及到那部分知识,希望大家能够把它的语法掌握领悟,为前边的深远钻研盘活铺垫。
来源:
Python爬虫利器三之Xpath语法与lxml库的用法

结语

XPath
是1个老大好用的解析方法,同时也作为爬虫学习的底蕴,在前边的 selenium
以及 scrapy
框架中都会涉及到那部分知识,希望大家能够把它的语法通晓精晓,为前边的通透到底钻研盘活铺垫。
来源: Python爬虫利器三之Xpath语法与lxml库的用法

(八)属性获取

行使@符号就可以得到节点的天性,如下:获取具备li节点下有所a节点的href属性

result=html.xpath('//li/a/@href')  #获取a的href属性
result=html.xpath('//li//@href')   #获取所有li子孙节点的href属性

二、XPath常用规则

(9)属性多值非常

假诺某些属性的值有多少个时,大家能够动用contains()函数来博取

from lxml import etree

text1='''
<div>
    <ul>
         <li class="aaa item-0"><a href="link1.html">第一个</a></li>
         <li class="bbb item-1"><a href="link2.html">second item</a></li>
     </ul>
 </div>
'''

html=etree.HTML(text1,etree.HTMLParser())
result=html.xpath('//li[@class="aaa"]/a/text()')
result1=html.xpath('//li[contains(@class,"aaa")]/a/text()')

print(result)
print(result1)

#通过第一种方法没有取到值,通过contains()就能精确匹配到节点了
[]
['第一个']
表达式 描述
nodename 选取此节点的所有子节点
/ 从当前节点选取直接子节点
// 从当前节点选取子孙节点
. 选取当前节点
.. 选取当前节点的父节点
@ 选取属性
* 通配符,选择所有元素节点与元素名
@* 选取所有属性
[@attrib] 选取具有给定属性的所有元素
[@attrib=’value’] 选取给定属性具有给定值的所有元素
[tag] 选取所有具有指定元素的直接子节点
[tag=’text’] 选取所有具有指定元素并且文本内容是text节点

(10)多属性相配

除此以外大家还或然境遇1种情况,那就是凭借八个属性分明叁个节点,那时就需求同时兼容四性格格,此时可用运用and运算符来连接使用:

from lxml import etree

text1='''
<div>
    <ul>
         <li class="aaa" name="item"><a href="link1.html">第一个</a></li>
         <li class="aaa" name="fore"><a href="link2.html">second item</a></li>
     </ul>
 </div>
'''

html=etree.HTML(text1,etree.HTMLParser())
result=html.xpath('//li[@class="aaa" and @name="fore"]/a/text()')
result1=html.xpath('//li[contains(@class,"aaa") and @name="fore"]/a/text()')


print(result)
print(result1)


#
['second item']
['second item']

(一)读取文本剖析节点

(1一)XPath中的运算符

运算符 描述 实例 返回值

or

age=19 or age=20 如果age等于19或者等于20则返回true反正返回false
and age>19 and age<21 如果age等于20则返回true,否则返回false
mod 取余 5 mod 2 1
| 取两个节点的集合 //book | //cd 返回所有拥有book和cd元素的节点集合
+ 6+4 10
6-4 2
* 6*4 24
div 除法 8 div 4 2
= 等于 age=19 true
!= 不等于 age!=19 true
< 小于 age<19 true
<= 小于或等于 age<=19 true
> 大于 age>19 true
>=  大于或等于 age>=19 true

此表仿照效法来源:

from lxml import etree

text='''
<div>
 <ul>
 <li class="item-0"><a href="link1.html">第一个</a></li>
 <li class="item-1"><a href="link2.html">second item</a></li>
 <li class="item-0"><a href="link5.html">a属性</a>
 </ul>
 </div>
'''
html=etree.HTML(text) #初始化生成一个XPath解析对象
result=etree.tostring(html,encoding='utf-8') #解析对象输出代码
print(type(html))
print(type(result))
print(result.decode('utf-8'))

#etree会修复HTML文本节点
<class 'lxml.etree._Element'>
<class 'bytes'>
<html><body><div>
 <ul>
 <li class="item-0"><a href="link1.html">第一个</a></li>
 <li class="item-1"><a href="link2.html">second item</a></li>
 <li class="item-0"><a href="link5.html">a属性</a>
 </li></ul>
 </div>
</body></html>

(1贰)按序采取

神迹,大家在甄选的时候某个品质恐怕同时合营多少个节点,但大家只想要在那之中的某部节点,如第2个节点照旧最后三个节点,那时能够选拔中括号引进索引的点子赢得一定程序的节点:

from lxml import etree

text1='''
<div>
    <ul>
         <li class="aaa" name="item"><a href="link1.html">第一个</a></li>
         <li class="aaa" name="item"><a href="link1.html">第二个</a></li>
         <li class="aaa" name="item"><a href="link1.html">第三个</a></li>
         <li class="aaa" name="item"><a href="link1.html">第四个</a></li> 
     </ul>
 </div>
'''

html=etree.HTML(text1,etree.HTMLParser())

result=html.xpath('//li[contains(@class,"aaa")]/a/text()') #获取所有li节点下a节点的内容
result1=html.xpath('//li[1][contains(@class,"aaa")]/a/text()') #获取第一个
result2=html.xpath('//li[last()][contains(@class,"aaa")]/a/text()') #获取最后一个
result3=html.xpath('//li[position()>2 and position()<4][contains(@class,"aaa")]/a/text()') #获取第一个
result4=html.xpath('//li[last()-2][contains(@class,"aaa")]/a/text()') #获取倒数第三个


print(result)
print(result1)
print(result2)
print(result3)
print(result4)


#
['第一个', '第二个', '第三个', '第四个']
['第一个']
['第四个']
['第三个']
['第二个']

这里运用了last()、position()函数,在XPath中,提供了十0多少个函数,包涵存取、数值、字符串、逻辑、节点、体系等处理效果,它们的具体效果可参照:

(二)读取HTML文件进行剖析

(一三)节点轴选取

XPath提供了不少节点采用方式,包蕴获取子成分、兄弟成分、父元素、祖先成分等,示比如下:

from lxml import etree

text1='''
<div>
    <ul>
         <li class="aaa" name="item"><a href="link1.html">第一个</a></li>
         <li class="aaa" name="item"><a href="link1.html">第二个</a></li>
         <li class="aaa" name="item"><a href="link1.html">第三个</a></li>
         <li class="aaa" name="item"><a href="link1.html">第四个</a></li> 
     </ul>
 </div>
'''

html=etree.HTML(text1,etree.HTMLParser())
result=html.xpath('//li[1]/ancestor::*')  #获取所有祖先节点
result1=html.xpath('//li[1]/ancestor::div')  #获取div祖先节点
result2=html.xpath('//li[1]/attribute::*')  #获取所有属性值
result3=html.xpath('//li[1]/child::*')  #获取所有直接子节点
result4=html.xpath('//li[1]/descendant::a')  #获取所有子孙节点的a节点
result5=html.xpath('//li[1]/following::*')  #获取当前子节之后的所有节点
result6=html.xpath('//li[1]/following-sibling::*')  #获取当前节点的所有同级节点


#
[<Element html at 0x3ca6b960c8>, <Element body at 0x3ca6b96088>, <Element div at 0x3ca6b96188>, <Element ul at 0x3ca6b961c8>]
[<Element div at 0x3ca6b96188>]
['aaa', 'item']
[<Element a at 0x3ca6b96248>]
[<Element a at 0x3ca6b96248>]
[<Element li at 0x3ca6b96308>, <Element a at 0x3ca6b96348>, <Element li at 0x3ca6b96388>, <Element a at 0x3ca6b963c8>, <Element li at 0x3ca6b96408>, <Element a at 0x3ca6b96488>]
[<Element li at 0x3ca6b96308>, <Element li at 0x3ca6b96388>, <Element li at 0x3ca6b96408>]

如上使用的是XPath轴的用法,越来越多轴的用法可参照他事他说加以考察:

from lxml import etree

html=etree.parse('test.html',etree.HTMLParser()) #指定解析器HTMLParser会根据文件修复HTML文件中缺失的如声明信息
result=etree.tostring(html) #解析成字节
#result=etree.tostringlist(html) #解析成列表
print(type(html))
print(type(result))
print(result)

#
<class 'lxml.etree._ElementTree'>
<class 'bytes'>
b'<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN" "http://www.w3.org/TR/REC-html40/loose.dtd">\n<html><body><div>

(1四)案例应用:抓取TIOBE指数前20名排名开辟语言

#!/usr/bin/env python
#coding:utf-8
import requests
from requests.exceptions import RequestException
from lxml import etree
from lxml.etree import ParseError
import json

def one_to_page(html):
    headers={
        'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/67.0.3396.62 Safari/537.36'
    }
    try:
        response=requests.get(html,headers=headers)
        body=response.text  #获取网页内容
    except RequestException as e:
        print('request is error!',e)
    try:
        html=etree.HTML(body,etree.HTMLParser())  #解析HTML文本内容
        result=html.xpath('//table[contains(@class,"table-top20")]/tbody/tr//text()') #获取列表数据
        pos = 0
        for i in range(20):
            if i == 0:
                yield result[i:5]
            else:
                yield result[pos:pos+5]  #返回排名生成器数据
            pos+=5
    except ParseError as e:
         print(e.position)


def write_file(data):   #将数据重新组合成字典写入文件并输出
    for i in data:
        sul={
            '2018年6月排行':i[0],
            '2017年6排行':i[1],
            '开发语言':i[2],
            '评级':i[3],
            '变化率':i[4]
        }
        with open('test.txt','a',encoding='utf-8') as f:
            f.write(json.dumps(sul,ensure_ascii=False) + '\n') #必须格式化数据
            f.close()
        print(sul)
    return None


def main():
    url='https://www.tiobe.com/tiobe-index/'
    data=one_to_page(url)
    revaule=write_file(data)
    if revaule == None:
        print('ok')




if __name__ == '__main__':
    main()



#
{'2018年6月排行': '1', '2017年6排行': '1', '开发语言': 'Java', '评级': '15.368%', '变化率': '+0.88%'}
{'2018年6月排行': '2', '2017年6排行': '2', '开发语言': 'C', '评级': '14.936%', '变化率': '+8.09%'}
{'2018年6月排行': '3', '2017年6排行': '3', '开发语言': 'C++', '评级': '8.337%', '变化率': '+2.61%'}
{'2018年6月排行': '4', '2017年6排行': '4', '开发语言': 'Python', '评级': '5.761%', '变化率': '+1.43%'}
{'2018年6月排行': '5', '2017年6排行': '5', '开发语言': 'C#', '评级': '4.314%', '变化率': '+0.78%'}
{'2018年6月排行': '6', '2017年6排行': '6', '开发语言': 'Visual Basic .NET', '评级': '3.762%', '变化率': '+0.65%'}
{'2018年6月排行': '7', '2017年6排行': '8', '开发语言': 'PHP', '评级': '2.881%', '变化率': '+0.11%'}
{'2018年6月排行': '8', '2017年6排行': '7', '开发语言': 'JavaScript', '评级': '2.495%', '变化率': '-0.53%'}
{'2018年6月排行': '9', '2017年6排行': '-', '开发语言': 'SQL', '评级': '2.339%', '变化率': '+2.34%'}
{'2018年6月排行': '10', '2017年6排行': '14', '开发语言': 'R', '评级': '1.452%', '变化率': '-0.70%'}
{'2018年6月排行': '11', '2017年6排行': '11', '开发语言': 'Ruby', '评级': '1.253%', '变化率': '-0.97%'}
{'2018年6月排行': '12', '2017年6排行': '18', '开发语言': 'Objective-C', '评级': '1.181%', '变化率': '-0.78%'}
{'2018年6月排行': '13', '2017年6排行': '16', '开发语言': 'Visual Basic', '评级': '1.154%', '变化率': '-0.86%'}
{'2018年6月排行': '14', '2017年6排行': '9', '开发语言': 'Perl', '评级': '1.147%', '变化率': '-1.16%'}
{'2018年6月排行': '15', '2017年6排行': '12', '开发语言': 'Swift', '评级': '1.145%', '变化率': '-1.06%'}
{'2018年6月排行': '16', '2017年6排行': '10', '开发语言': 'Assembly language', '评级': '0.915%', '变化率': '-1.34%'}
{'2018年6月排行': '17', '2017年6排行': '17', '开发语言': 'MATLAB', '评级': '0.894%', '变化率': '-1.10%'}
{'2018年6月排行': '18', '2017年6排行': '15', '开发语言': 'Go', '评级': '0.879%', '变化率': '-1.17%'}
{'2018年6月排行': '19', '2017年6排行': '13', '开发语言': 'Delphi/Object Pascal', '评级': '0.875%', '变化率': '-1.28%'}
{'2018年6月排行': '20', '2017年6排行': '20', '开发语言': 'PL/SQL', '评级': '0.848%', '变化率': '-0.72%'}

XPath的更加多用法参照他事他说加以考查:

python lxml库的越来越多用法参谋:

\n

\n

\n‘

(三)获取具有节点

回到二个列表各类成分都以Element类型,全数节点都带有在中间

from lxml import etree

html=etree.parse('test',etree.HTMLParser())
result=html.xpath('//*') #//代表获取子孙节点,*代表获取所有

print(type(html))
print(type(result))
print(result)

#
<class 'lxml.etree._ElementTree'>
<class 'list'>
[<Element html at 0x754b210048>, <Element body at 0x754b210108>, <Element div at 0x754b210148>, <Element ul at 0x754b210188>, <Element li at 0x754b2101c8>, <Element a at 0x754b210248>, <Element li at 0x754b210288>, <Element a at 0x754b2102c8>, <Element li at 0x754b210308>, <Element a at 0x754b210208>, <Element li at 0x754b210348>, <Element a at 0x754b210388>, <Element li at 0x754b2103c8>, <Element a at 0x754b210408>]

如要获取li节点,能够行使//前面加上节点名称,然后调用xpath()方法

html.xpath('//li') #获取所有子孙节点的li节点

(4)获取子节点

透过/或许//就可以寻觅成分的子节点只怕子孙节点,假诺想选用li节点的享有直接a节点,能够这么使用

result=html.xpath('//li/a') #通过追加/a选择所有li节点的所有直接a节点,因为//li用于选中所有li节点,/a用于选中li节点的所有直接子节点a

(五)获取父节点

我们了然通过连接的/也许//能够查找子节点或子孙节点,那么要物色父节点可以选取..来贯彻也足以运用parent::来博取父节点

from lxml import etree
from lxml.etree import HTMLParser
text='''
<div>
 <ul>
 <li class="item-0"><a href="link1.html">第一个</a></li>
 <li class="item-1"><a href="link2.html">second item</a></li>
 </ul>
 </div>
'''

html=etree.HTML(text,etree.HTMLParser())
result=html.xpath('//a[@href="link2.html"]/../@class')
result1=html.xpath('//a[@href="link2.html"]/parent::*/@class')
print(result)
print(result1)


#
['item-1']
['item-1']

(六)属性相配

在选择的时候,大家还足以用@符号实行品质过滤。譬如,这里假如要挑选class为item-一的li节点,能够这么完结:

from lxml import etree
from lxml.etree import HTMLParser
text='''
<div>
 <ul>
 <li class="item-0"><a href="link1.html">第一个</a></li>
 <li class="item-1"><a href="link2.html">second item</a></li>
 </ul>
 </div>
'''

html=etree.HTML(text,etree.HTMLParser())
result=html.xpath('//li[@class="item-1"]')
print(result)

(7)文本获取

咱俩用XPath中的text()方法获得节点中的文本

from lxml import etree

text='''
<div>
 <ul>
 <li class="item-0"><a href="link1.html">第一个</a></li>
 <li class="item-1"><a href="link2.html">second item</a></li>
 </ul>
 </div>
'''

html=etree.HTML(text,etree.HTMLParser())
result=html.xpath('//li[@class="item-1"]/a/text()') #获取a节点下的内容
result1=html.xpath('//li[@class="item-1"]//text()') #获取li下所有子孙节点的内容

print(result)
print(result1)

(八)属性获取

运用@符号就能够获得节点的性质,如下:获取具有li节点下具有a节点的href属性

result=html.xpath('//li/a/@href') #获取a的href属性
result=html.xpath('//li//@href') #获取所有li子孙节点的href属性

(玖)属性多值相当

纵然有个别属性的值有多个时,大家得以选拔contains()函数来获得

from lxml import etree

text1='''
<div>
 <ul>
 <li class="aaa item-0"><a href="link1.html">第一个</a></li>
 <li class="bbb item-1"><a href="link2.html">second item</a></li>
 </ul>
 </div>
'''

html=etree.HTML(text1,etree.HTMLParser())
result=html.xpath('//li[@class="aaa"]/a/text()')
result1=html.xpath('//li[contains(@class,"aaa")]/a/text()')

print(result)
print(result1)

#通过第一种方法没有取到值,通过contains()就能精确匹配到节点了
[]
['第一个']

(10)多属性相称

别的大家还可能遇见一种情形,那正是依据伍本性情分明三个节点,那时就须求同时合营八个属性,此时可用运用and运算符来连接使用:

from lxml import etree

text1='''
<div>
 <ul>
 <li class="aaa" name="item"><a href="link1.html">第一个</a></li>
 <li class="aaa" name="fore"><a href="link2.html">second item</a></li>
 </ul>
 </div>
'''

html=etree.HTML(text1,etree.HTMLParser())
result=html.xpath('//li[@class="aaa" and @name="fore"]/a/text()')
result1=html.xpath('//li[contains(@class,"aaa") and @name="fore"]/a/text()')


print(result)
print(result1)


#
['second item']
['second item']

(11)XPath中的运算符

运算符 描述 实例 返回值

or

age=19 or age=20 如果age等于19或者等于20则返回true反正返回false
and age>19 and age<21 如果age等于20则返回true,否则返回false
mod 取余 5 mod 2 1
| 取两个节点的集合 //book | //cd 返回所有拥有book和cd元素的节点集合
+ 6+4 10
6-4 2
* 6*4 24
div 除法 8 div 4 2
= 等于 age=19 true
!= 不等于 age!=19 true
< 小于 age<19 true
<= 小于或等于 age<=19 true
> 大于 age>19 true
>=  大于或等于 age>=19 true

此表参照他事他说加以考察来源:

(1二)按序选用

不时,大家在挑选的时候有个别品质大概还要合营多个节点,但大家只想要当中的有个别节点,如第3个节点依旧最终2个节点,那时可以应用中括号引进索引的点子得到特定程序的节点:

from lxml import etree

text1='''
<div>
 <ul>
  <li class="aaa" name="item"><a href="link1.html">第一个</a></li>
  <li class="aaa" name="item"><a href="link1.html">第二个</a></li>
  <li class="aaa" name="item"><a href="link1.html">第三个</a></li>
  <li class="aaa" name="item"><a href="link1.html">第四个</a></li> 
 </ul>
 </div>
'''

html=etree.HTML(text1,etree.HTMLParser())

result=html.xpath('//li[contains(@class,"aaa")]/a/text()') #获取所有li节点下a节点的内容
result1=html.xpath('//li[1][contains(@class,"aaa")]/a/text()') #获取第一个
result2=html.xpath('//li[last()][contains(@class,"aaa")]/a/text()') #获取最后一个
result3=html.xpath('//li[position()>2 and position()<4][contains(@class,"aaa")]/a/text()') #获取第一个
result4=html.xpath('//li[last()-2][contains(@class,"aaa")]/a/text()') #获取倒数第三个


print(result)
print(result1)
print(result2)
print(result3)
print(result4)


#
['第一个', '第二个', '第三个', '第四个']
['第一个']
['第四个']
['第三个']
['第二个']

此处运用了last()、position()函数,在XPath中,提供了拾0八个函数,包罗存取、数值、字符串、逻辑、节点、系列等管理效果,它们的求实职能可参看:

(一叁)节点轴采用

XPath提供了广大节点选取格局,包含获取子成分、兄弟成分、父成分、祖先成分等,示比方下:

from lxml import etree

text1='''
<div>
 <ul>
  <li class="aaa" name="item"><a href="link1.html">第一个</a></li>
  <li class="aaa" name="item"><a href="link1.html">第二个</a></li>
  <li class="aaa" name="item"><a href="link1.html">第三个</a></li>
  <li class="aaa" name="item"><a href="link1.html">第四个</a></li> 
 </ul>
 </div>
'''

html=etree.HTML(text1,etree.HTMLParser())
result=html.xpath('//li[1]/ancestor::*') #获取所有祖先节点
result1=html.xpath('//li[1]/ancestor::div') #获取div祖先节点
result2=html.xpath('//li[1]/attribute::*') #获取所有属性值
result3=html.xpath('//li[1]/child::*') #获取所有直接子节点
result4=html.xpath('//li[1]/descendant::a') #获取所有子孙节点的a节点
result5=html.xpath('//li[1]/following::*') #获取当前子节之后的所有节点
result6=html.xpath('//li[1]/following-sibling::*') #获取当前节点的所有同级节点


#
[<Element html at 0x3ca6b960c8>, <Element body at 0x3ca6b96088>, <Element div at 0x3ca6b96188>, <Element ul at 0x3ca6b961c8>]
[<Element div at 0x3ca6b96188>]
['aaa', 'item']
[<Element a at 0x3ca6b96248>]
[<Element a at 0x3ca6b96248>]
[<Element li at 0x3ca6b96308>, <Element a at 0x3ca6b96348>, <Element li at 0x3ca6b96388>, <Element a at 0x3ca6b963c8>, <Element li at 0x3ca6b96408>, <Element a at 0x3ca6b96488>]
[<Element li at 0x3ca6b96308>, <Element li at 0x3ca6b96388>, <Element li at 0x3ca6b96408>]

如上使用的是XPath轴的用法,越多轴的用法可参谋:

(1四)案例应用:抓取TIOBE指数前20名排名开荒语言

#!/usr/bin/env python
#coding:utf-8
import requests
from requests.exceptions import RequestException
from lxml import etree
from lxml.etree import ParseError
import json

def one_to_page(html):
 headers={
 'user-agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/67.0.3396.62 Safari/537.36'
 }
 try:
 response=requests.get(html,headers=headers)
 body=response.text #获取网页内容
 except RequestException as e:
 print('request is error!',e)
 try:
 html=etree.HTML(body,etree.HTMLParser()) #解析HTML文本内容
 result=html.xpath('//table[contains(@class,"table-top20")]/tbody/tr//text()') #获取列表数据
 pos = 0
 for i in range(20):
  if i == 0:
  yield result[i:5]
  else:
  yield result[pos:pos+5] #返回排名生成器数据
  pos+=5
 except ParseError as e:
  print(e.position)


def write_file(data): #将数据重新组合成字典写入文件并输出
 for i in data:
 sul={
  '2018年6月排行':i[0],
  '2017年6排行':i[1],
  '开发语言':i[2],
  '评级':i[3],
  '变化率':i[4]
 }
 with open('test.txt','a',encoding='utf-8') as f:
  f.write(json.dumps(sul,ensure_ascii=False) + '\n') #必须格式化数据
  f.close()
 print(sul)
 return None


def main():
 url='https://www.tiobe.com/tiobe-index/'
 data=one_to_page(url)
 revaule=write_file(data)
 if revaule == None:
 print('ok')




if __name__ == '__main__':
 main()



#
{'2018年6月排行': '1', '2017年6排行': '1', '开发语言': 'Java', '评级': '15.368%', '变化率': '+0.88%'}
{'2018年6月排行': '2', '2017年6排行': '2', '开发语言': 'C', '评级': '14.936%', '变化率': '+8.09%'}
{'2018年6月排行': '3', '2017年6排行': '3', '开发语言': 'C++', '评级': '8.337%', '变化率': '+2.61%'}
{'2018年6月排行': '4', '2017年6排行': '4', '开发语言': 'Python', '评级': '5.761%', '变化率': '+1.43%'}
{'2018年6月排行': '5', '2017年6排行': '5', '开发语言': 'C#', '评级': '4.314%', '变化率': '+0.78%'}
{'2018年6月排行': '6', '2017年6排行': '6', '开发语言': 'Visual Basic .NET', '评级': '3.762%', '变化率': '+0.65%'}
{'2018年6月排行': '7', '2017年6排行': '8', '开发语言': 'PHP', '评级': '2.881%', '变化率': '+0.11%'}
{'2018年6月排行': '8', '2017年6排行': '7', '开发语言': 'JavaScript', '评级': '2.495%', '变化率': '-0.53%'}
{'2018年6月排行': '9', '2017年6排行': '-', '开发语言': 'SQL', '评级': '2.339%', '变化率': '+2.34%'}
{'2018年6月排行': '10', '2017年6排行': '14', '开发语言': 'R', '评级': '1.452%', '变化率': '-0.70%'}
{'2018年6月排行': '11', '2017年6排行': '11', '开发语言': 'Ruby', '评级': '1.253%', '变化率': '-0.97%'}
{'2018年6月排行': '12', '2017年6排行': '18', '开发语言': 'Objective-C', '评级': '1.181%', '变化率': '-0.78%'}
{'2018年6月排行': '13', '2017年6排行': '16', '开发语言': 'Visual Basic', '评级': '1.154%', '变化率': '-0.86%'}
{'2018年6月排行': '14', '2017年6排行': '9', '开发语言': 'Perl', '评级': '1.147%', '变化率': '-1.16%'}
{'2018年6月排行': '15', '2017年6排行': '12', '开发语言': 'Swift', '评级': '1.145%', '变化率': '-1.06%'}
{'2018年6月排行': '16', '2017年6排行': '10', '开发语言': 'Assembly language', '评级': '0.915%', '变化率': '-1.34%'}
{'2018年6月排行': '17', '2017年6排行': '17', '开发语言': 'MATLAB', '评级': '0.894%', '变化率': '-1.10%'}
{'2018年6月排行': '18', '2017年6排行': '15', '开发语言': 'Go', '评级': '0.879%', '变化率': '-1.17%'}
{'2018年6月排行': '19', '2017年6排行': '13', '开发语言': 'Delphi/Object Pascal', '评级': '0.875%', '变化率': '-1.28%'}
{'2018年6月排行': '20', '2017年6排行': '20', '开发语言': 'PL/SQL', '评级': '0.848%', '变化率': '-0.72%'}

XPath的更加多用法参照他事他说加以侦察:

python lxml库的更加多用法参谋:

总结

如上正是那篇小说的全体内容了,希望本文的开始和结果对大家的学习恐怕事业有所自然的参阅学习价值,假设不平常大家能够留言交换,谢谢我们对剧本之家的援救。

您可能感兴趣的小说:

  • Python完结将Excel转变来xml的格局言传身教
  • Python实现将xml导入至excel
  • Python达成的读取/更换/写入xml文件操作示例
  • Python3基于sax剖判xml操作示例
  • 用Python深入分析XML的两种常见情势的介绍
  • python操作xml文件详细介绍
  • Python 解析XML文件
  • python中央银行使xlrd、xlwt操作excel表格详解
  • python高手之路python管理excel文件(方法汇总)
  • 用Python的pandas框架操作Excel文件中的数据教程
  • Python完结提取XML内容并保留到Excel中的方法

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图
Copyright @ 2010-2019 美高梅手机版4858 版权所有