python开发—教你如何使用lxml.etree

是一个关于使用lxml.etree进行XML处理的教程。它简要概述了ElementTree API的主要概念，以及一些简单的增强功能，使您作为程序员的生活更轻松。

有关API的完整参考，请参阅生成的API文档。

内容

本文章主要介绍的是元素将属性作为dict和元素包含文本

元素将属性作为dict

XML元素支持属性。您可以直接在Element工厂中创建它们：

>>> root=etree 。元素（“root” ， 有趣=“完全” ）
>>> etree 。tostring （root ）
b'<root interesting=“完全”/>'

属性只是无序的名称 - 值对，因此处理它们的一种非常方便的方法是通过Elements的类字典界面：

>>> 打印（根。获得（“有趣” ））
完全
>>> 打印（根。获得（“你好” ））
无
>>> 根。集（“你好” ， “忽忽” ）
>>> 打印（根。获得（“你好” ））
忽忽
>>> etree 。tostring （root ）
b'<root interesting=“完全”hello=“Huhu”/>'
>>> 排序（根。键（））
[ '你好'， '有趣']
>>> 为 名称， 值 中的 排序（根。项目（））：
... 打印（' ％S=％R ' ％ （名称， 值））
你好='忽忽' 
有趣='完全'

对于您想要进行项目查找或有其他理由获取“真正的”类字典对象的情况，例如传递它，您可以使用attrib属性：

>>> attributes=root 。ATTRIB
>>> 打印（属性[ “有趣” ]）
完全
>>> 打印（属性，获得（“无此类属性” ））
无
>>> 属性[ “你好” ]=“Guten变量” 
>>> 打印（属性[ “你好” ]）
Guten标签
>>> 打印（根。获得（“你好” ））
Guten标签

请注意，attrib是一个由Element本身支持的类似dict的对象。这意味着元素的任何更改都会反映在属性中，反之亦然。这也意味着，XML树在内存中保持活着，只要ATTRIB其要素之一是在使用中。要获取不依赖于XML树的属性的独立快照，请将其复制到dict中：

>>> d=字典（根。ATTRIB ）
>>> 排序（d 。项目（））
[（ '你好'， 'Guten标签'），（ '有趣'， '完全'）]
>>> root=etree 。元素（“root” ）
>>> root 。text=“TEXT”
>>> 打印（根。文本）
TEXT
>>> etree 。tostring （root ）
b'<root> TEXT </ root>'

在许多XML文档（以数据为中心的文档）中，这是唯一可以找到文本的地方。它由树层次结构最底部的叶标记封装。

但是，如果XML用于标记文本文档（如（X）HTML），则文本也可以出现在树的中间的不同

欢迎大家加入小编的技术交流全

元素之间：

< HTML > < 体>你好< BR />世界</ 身体> </ HTML >

这里，<br/>标签被文本包围。这通常被称为 文档样式或混合内容 XML。Elements通过它们的tail属性来支持它。它包含直接跟在元素后面的文本，直到XML树中的下一个元素：

>>> html=etree 。元素（“html” ）
>>> body=etree 。SubElement （html ， “body” ）
>>> body 。text=“TEXT”
>>> etree 。tostring （html ）
b'<html> <body> TEXT </ body> </ html>'
>>> br=etree 。子元素（正文， “br” ）
>>> etree 。tostring （html ）
b'<html> <body> TEXT <br/> </ body> </ html>'
>>> br 。tail=“TAIL” 
>>> etree 。tostring （html ）
b'<html> <body> TEXT <br/> TAIL </ body> </ html>'

两个属性.text和.tail足以表示XML文档中的任何文本内容。这样，除了Element类之外，ElementTree API不需要任何特殊的文本节点，这些节点往往会相当频繁（正如您可能从经典DOMAPI中获知）。

但是，有些情况下尾部文本也会妨碍。例如，当您从树中序列化元素时，您并不总是希望在结果中使用尾部文本（尽管您仍然需要其子项的尾部文本）。为此， tostring（）函数接受关键字参数with_tail：

>>> etree 。tostring （br ）
b'<br/> TAIL' 
>>> etree 。tostring （br ， with_tail=False ） ＃lxml.etree only！
B '<BR/>'

如果你想读的只有文字，即没有任何中间变量，你必须递归串联所有文字和尾部以正确的顺序属性。同样，tostring（）函数来拯救，这次使用method关键字：

>>> etree 。tostring （html ， method=“text” ）
b'TEXTTAIL'

如果大家没有找到一个好的技术交流群或者需要关于python的资料的如1.爬虫库--requests，bs4，lxml，scrapy，pyspider2.python开发---Django，Tornado，flask框架3.linux，shell脚本4.selenium自动化测试5.自动化运维Zabbix6.数据库 MySql，NoSql，redis正则表达式re，网络编程，面向对象，lambda，IO并发编程，GUI图形

可以加入小编的群418775537

是一个关于使用lxml.etree进行XML处理的教程。它简要概述了ElementTree API的主要概念，以及一些简单的增强功能，使您作为程序员的生活更轻松。

关注小编后续次序更新

本文章主要介绍的是，ElementTree类
从字符串和文件中解析
fromstring（）函数
XML（）函数
parse（）函数
解析器对象
增量解析

ElementTree类

一个ElementTree的主要文档包裹一个树根节点。它提供了两种序列化和一般文档处理方法。

>>> root=etree 。XML （''' \ 
... <？xml version=“1.0”？> 
... <！DOCTYPE root SYSTEM“test”[<！ENTITY tasty“parsnips”>]> 
... <root> 
... <a>＆tasty; </a> 
... </ root> 
... '''' ）
>>> tree=etree 。ElementTree的（根）
>>> 打印（树。DOCINFO 。xml_version ）
1.0 
>>> 打印（树。DOCINFO 。DOCTYPE ）
<！DOCTYPE根SYSTEM “测试”>
>>> 树。docinfo 。public_id=' - // W3C // DTD XHTML 1.0 Transitional // EN' 
>>> 树。docinfo 。system_url='文件：//local.dtd' 
>>> 打印（树。DOCINFO 。DOCTYPE ）
<DOCTYPE根PUBLIC “ - // W3C // DTD XHTML 1.0过渡// EN”“文件：//local.dtd “>

一个ElementTree的也是你得到什么，当你调用解析（）函数来解析文件或类似文件的对象（见下面的分析部）。

其中一个重要区别是ElementTree类序列化为完整文档，而不是单个元素。这包括顶级处理说明和注释，以及文档中的DOCTYPE和其他DTD内容：

>>> 打印（etree 。的toString （树）） ＃LXML 1.3.4和后
<！DOCTYPE根PUBLIC “ - // W3C // DTD XHTML 1.0过渡// EN” “文件：//local.dtd”[ 
< ！ENTITY美味的“parsnips”> 
]> 
<root> 
 <a> parsnips </a> 
</ root>

在原始的xml.etree.ElementTree实现中，在lxml中最高为1.3.3，输出看起来与仅序列化根元素时的输出相同：

>>> 打印（etree 。的toString （树。getroot （）））
<根> 
 <A>防风草</A> 
</根>

此序列化行为在lxml 1.3.4中已更改。之前，树被序列化而没有DTD内容，这使得lxml在输入 - 输出周期中丢失了DTD信息。

从字符串和文件中解析

lxml.etree支持以多种方式从所有重要来源解析XML，即字符串，文件，URL（http / ftp）和类文件对象。主要的解析函数是fromstring（）和 parse（），它们都以source作为第一个参数调用。默认情况下，它们使用标准解析器，但您始终可以将不同的解析器作为第二个参数传递。

fromstring（）函数

该fromstring（）函数解析字符串的最简单的方法：

>>> some_xml_data=“<root> data </ root>”
>>> root=etree 。fromstring （some_xml_data ）
>>> 打印（根。标签）
根
>>> etree 。tostring （root ）
b'<root> data </ root>'

XML（）函数

的XML（）函数的行为类似于fromstring（）函数，但常用于XML文本写右到源：

>>> root=etree 。XML （“<根>数据</根>” ）
>>> 打印（根。标签）
根
>>> etree 。tostring （root ）
b'<root> data </ root>'

HTML文字还有一个相应的函数HTML（）。

>>> root=etree 。HTML （“<p>数据</ p>” ）
>>> etree 。tostring （root ）
b'<html> <body> <p> data </ p> </ body> </ html>'

parse（）函数

的解析（）函数是用来从文件和类文件对象进行解析。

作为此类文件对象的示例，以下代码使用 BytesIO类从字符串而不是外部文件中读取。该类来自Python 2.6及更高版本中的io模块。在较旧的Python版本中，您必须使用StringIO模块中的StringIO类。但是，在现实生活中，你显然会避免这样做，并使用上面的字符串解析函数。

>>> from io import BytesIO 
>>> some_file_or_file_like_object=BytesIO （b “<root> data </ root>” ）
>>> tree=etree 。解析（some_file_or_file_like_object ）
>>> etree 。tostring （tree ）
b'<root> data </ root>'

请注意，parse（）返回ElementTree对象，而不是Element对象，因为字符串解析器函数：

>>> root=tree 。getroot （）
>>> 打印（根。标签）
根
>>> etree 。tostring （root ）
b'<root> data </ root>'

这种差异背后的原因是parse（）从文件返回一个完整的文档，而字符串解析函数通常用于解析XML片段。

的解析（）函数支持任何以下来源：

打开文件对象（确保以二进制模式打开）
一个类文件对象，它有一个.read（byte_count）方法，在每次调用时返回一个字节字符串
文件名字符串
HTTP或FTP URL字符串

请注意，传递文件名或URL通常比传递打开的文件或类文件对象更快。但是，libxml2中的HTTP / FTP客户端非常简单，因此HTTP身份验证等需要专用的URL请求库，例如urllib2或requests。这些库通常为结果提供类似文件的对象，您可以在响应流入时解析该结果。

解析器对象

默认情况下，lxml.etree使用具有默认设置的标准解析器。如果要配置解析器，可以创建新实例：

>>> parser=etree 。XMLParser （remove_blank_text=True ） 仅限＃lxml.etree！

这将创建一个解析器，在解析时删除标记之间的空文本，这可以减少树的大小，并避免悬空尾文本，如果您知道仅空白内容对您的数据没有意义。一个例子：

>>> root=etree 。XML （“<root> <a/> <b> </ b> </ root>” ， 解析器）
>>> etree 。tostring （root ）
b'<root> <a/> <b> </ b> </ root>'

请注意，<b>标记内的空白内容未被删除，因为叶元素的内容往往是数据内容（即使是空白）。您可以通过遍历树轻松地在其他步骤中删除它：

>>> 为 元件 在 根。iter （“*” ）：
... if element 。文字 是 不 无 和 不 元素。文字。strip （）：
... 元素。text=无
>>> etree 。tostring （root ）
b'<root> <a/> <b /> </ root>'

请参阅帮助（etree.XMLParser）以了解可用的解析器选项。

增量解析

lxml.etree提供了两种渐进式逐步解析方法。一种是通过类似文件的对象，它重复调用read（）方法。这最适用于数据来自urllib之类的源或任何其他类似文件的对象，可以根据请求提供数据。请注意，在这种情况下，解析器将阻塞并等待数据可用：

>>> class DataSource ：
... data=[ b “<roo” ， b “t> <” ， b “a /” ， b “> <” ， b “/ root>” ] 
... def read （self ， requested_size ）：
... 尝试：
... 返回 自我。数据。pop （0 ）
... 除了 IndexError ：
... return b '
>>> tree=etree 。解析（DataSource （））
>>> etree 。tostring （tree ）
b'<root> <a/> </ root>'

第二种方式是通过feed（数据）和close（）方法给出的feed解析器接口：

>>> parser=etree 。XMLParser （）
>>> 解析器。feed （“<roo” ）
>>> 解析器。feed （“t> <” ）
>>> 解析器。feed （“a /” ）
>>> 解析器。feed （“> <” ）
>>> 解析器。feed （“/ root>” ）
>>> root=parser 。关闭（）
>>> etree 。tostring （root ）
b'<root> <a/> </ root>'

在这里，您可以随时中断解析过程，稍后再继续调用feed（）方法。如果你想避免阻塞对解析器的调用，例如在Twisted等框架中，或者数据进入缓慢或块状，并且你想在等待下一个块时做其他事情，这就派上用场了。

在调用close（）方法之后（或者当解析器引发异常时），您可以通过再次调用其feed（）方法来重用解析器：

>>> 解析器。feed （“<root />” ）
>>> root=parser 。close （）
>>> etree 。tostring （root ）
b'<root />'

ElementTree类

一个ElementTree的主要文档包裹一个树根节点。它提供了两种序列化和一般文档处理方法。

>>> root=etree 。XML （''' \ 
... <？xml version=“1.0”？> 
... <！DOCTYPE root SYSTEM“test”[<！ENTITY tasty“parsnips”>]> 
... <root> 
... <a>＆tasty; </a> 
... </ root> 
... '''' ）
>>> tree=etree 。ElementTree的（根）
>>> 打印（树。DOCINFO 。xml_version ）
1.0 
>>> 打印（树。DOCINFO 。DOCTYPE ）
<！DOCTYPE根SYSTEM “测试”>
>>> 树。docinfo 。public_id=' - // W3C // DTD XHTML 1.0 Transitional // EN' 
>>> 树。docinfo 。system_url='文件：//local.dtd' 
>>> 打印（树。DOCINFO 。DOCTYPE ）
<DOCTYPE根PUBLIC “ - // W3C // DTD XHTML 1.0过渡// EN”“文件：//local.dtd “>

一个ElementTree的也是你得到什么，当你调用解析（）函数来解析文件或类似文件的对象（见下面的分析部）。

其中一个重要区别是ElementTree类序列化为完整文档，而不是单个元素。这包括顶级处理说明和注释，以及文档中的DOCTYPE和其他DTD内容：

>>> 打印（etree 。的toString （树）） ＃LXML 1.3.4和后
<！DOCTYPE根PUBLIC “ - // W3C // DTD XHTML 1.0过渡// EN” “文件：//local.dtd”[ 
< ！ENTITY美味的“parsnips”> 
]> 
<root> 
 <a> parsnips </a> 
</ root>

在原始的xml.etree.ElementTree实现中，在lxml中最高为1.3.3，输出看起来与仅序列化根元素时的输出相同：

>>> 打印（etree 。的toString （树。getroot （）））
<根> 
 <A>防风草</A> 
</根>

此序列化行为在lxml 1.3.4中已更改。之前，树被序列化而没有DTD内容，这使得lxml在输入 - 输出周期中丢失了DTD信息。

欢迎大家加入小编的技术交流群

从字符串和文件中解析

fromstring（）函数

该fromstring（）函数解析字符串的最简单的方法：

>>> some_xml_data=“<root> data </ root>”
>>> root=etree 。fromstring （some_xml_data ）
>>> 打印（根。标签）
根
>>> etree 。tostring （root ）
b'<root> data </ root>'

XML（）函数

的XML（）函数的行为类似于fromstring（）函数，但常用于XML文本写右到源：

>>> root=etree 。XML （“<根>数据</根>” ）
>>> 打印（根。标签）
根
>>> etree 。tostring （root ）
b'<root> data </ root>'

HTML文字还有一个相应的函数HTML（）。

>>> root=etree 。HTML （“<p>数据</ p>” ）
>>> etree 。tostring （root ）
b'<html> <body> <p> data </ p> </ body> </ html>'

parse（）函数

的解析（）函数是用来从文件和类文件对象进行解析。

>>> from io import BytesIO 
>>> some_file_or_file_like_object=BytesIO （b “<root> data </ root>” ）
>>> tree=etree 。解析（some_file_or_file_like_object ）
>>> etree 。tostring （tree ）
b'<root> data </ root>'

请注意，parse（）返回ElementTree对象，而不是Element对象，因为字符串解析器函数：

>>> root=tree 。getroot （）
>>> 打印（根。标签）
根
>>> etree 。tostring （root ）
b'<root> data </ root>'

这种差异背后的原因是parse（）从文件返回一个完整的文档，而字符串解析函数通常用于解析XML片段。

的解析（）函数支持任何以下来源：

打开文件对象（确保以二进制模式打开）
一个类文件对象，它有一个.read（byte_count）方法，在每次调用时返回一个字节字符串
文件名字符串
HTTP或FTP URL字符串

解析器对象

默认情况下，lxml.etree使用具有默认设置的标准解析器。如果要配置解析器，可以创建新实例：

>>> parser=etree 。XMLParser （remove_blank_text=True ） 仅限＃lxml.etree！

>>> root=etree 。XML （“<root> <a/> <b> </ b> </ root>” ， 解析器）
>>> etree 。tostring （root ）
b'<root> <a/> <b> </ b> </ root>'

请注意，<b>标记内的空白内容未被删除，因为叶元素的内容往往是数据内容（即使是空白）。您可以通过遍历树轻松地在其他步骤中删除它：

>>> 为 元件 在 根。iter （“*” ）：
... if element 。文字 是 不 无 和 不 元素。文字。strip （）：
... 元素。text=无
>>> etree 。tostring （root ）
b'<root> <a/> <b /> </ root>'

请参阅帮助（etree.XMLParser）以了解可用的解析器选项。

增量解析

>>> class DataSource ：
... data=[ b “<roo” ， b “t> <” ， b “a /” ， b “> <” ， b “/ root>” ] 
... def read （self ， requested_size ）：
... 尝试：
... 返回 自我。数据。pop （0 ）
... 除了 IndexError ：
... return b '
>>> tree=etree 。解析（DataSource （））
>>> etree 。tostring （tree ）
b'<root> <a/> </ root>'

第二种方式是通过feed（数据）和close（）方法给出的feed解析器接口：

>>> parser=etree 。XMLParser （）
>>> 解析器。feed （“<roo” ）
>>> 解析器。feed （“t> <” ）
>>> 解析器。feed （“a /” ）
>>> 解析器。feed （“> <” ）
>>> 解析器。feed （“/ root>” ）
>>> root=parser 。关闭（）
>>> etree 。tostring （root ）
b'<root> <a/> </ root>'

在调用close（）方法之后（或者当解析器引发异常时），您可以通过再次调用其feed（）方法来重用解析器：

>>> 解析器。feed （“<root />” ）
>>> root=parser 。close （）
>>> etree 。tostring （root ）
b'<root />'

可以加入小编的群418775537

equests库

Requests :唯一的一个非转基因的 Python HTTP 库，人类可以安全享用。

发送get请求

直接调用requests.get

import requests

response=requests.get('https://www.baidu.com')

response的属性

import requests

params={'wd': 'python'}
headers={'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/83.0.4090.0 Safari/537.36 Edg/83.0.467.0'}
# params: 接受一个字典或者字符串的查询参数，字典类型自动转换为url编码，不需要urlencode()
response=requests.get('https://www.baidu.com', params=params, headers=headers)
# 查看响应内容，response.text返回的是Unicode格式的数据
print(response.text)
# 查看响应内容，response.content返回的是字节流数据
print(response.content.decode('utf-8'))
# 查看完整url地址
print(response.url)
# 查看响应头部字符编码
print(response.encoding)
# 查看响应码
print(response.status_code)

response.text和response.content的区别

response.content:直接从网络上面抓取的数据，没有经过任何解码，所以是bytes类型（硬盘上和网络上传输的字符串都是bytes类型）
response.text:将response.content进行解码的字符串，数据类型为str,解码需要指定一个编码方式，requests会根据自己的猜测来判断编码的方式，所以有时会猜测错误，就会导致解码产生乱码。这时候应该使用response.content.decode('utf-8')进行手动解码

发送POST请求

直接调用requests.post，如果返回的是json数据，可以调用response.json()来将json字符串转为字典或列表

下面是爬取拉勾网的一个示例，记得请求头添加Cookie，才能成功爬取到

import requests

data={'first': 'true',
        'pn': '1',
        'kd': 'python'}
headers={'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) '
                         'Chrome/83.0.4090.0 Safari/537.36 Edg/83.0.467.0',
           'Referer': 'https://www.lagou.com/jobs/list_python?labelWords=&fromSearch=true&suginput=',
           'Cookie': 'user_trace_token=20200331183800-0c1f510a-ae9a-4f04-b70d-e17f9edec031; '
                     'LGUID=20200331183800-b8eca414-b7b2-479d-8100-71fff41d8087; _ga=GA1.2.17010052.1585651081; '
                     'index_location_city=%E5%85%A8%E5%9B%BD; lagou_utm_source=B; _gid=GA1.2.807051168.1585805257; '
                     'sensorsdata2015jssdkcross=%7B%22distinct_id%22%3A%22171302b7caa67e-0dedc0121b2532-255e0c45'
                     '-2073600-171302b7cabb9c%22%2C%22%24device_id%22%3A%22171302b7caa67e-0dedc0121b2532-255e0c45'
                     '-2073600-171302b7cabb9c%22%2C%22props%22%3A%7B%22%24latest_traffic_source_type%22%3A%22%E7%9B'
                     '%B4%E6%8E%A5%E6%B5%81%E9%87%8F%22%2C%22%24latest_referrer%22%3A%22%22%2C%22'
                     '%24latest_referrer_host%22%3A%22%22%2C%22%24latest_search_keyword%22%3A%22%E6%9C%AA%E5%8F%96%E5'
                     '%88%B0%E5%80%BC_%E7%9B%B4%E6%8E%A5%E6%89%93%E5%BC%80%22%7D%7D; '
                     'JSESSIONID=ABAAABAABFIAAAC7D7CECCAFCFFA1FCBF3CB10D8EA6A189; '
                     'WEBTJ-ID=20200403095906-1713dc35e58a75-0b564b9cba1732-23580c45-2073600-1713dc35e598e; PRE_UTM=; '
                     'PRE_HOST=; PRE_LAND=https%3A%2F%2Fwww.lagou.com%2F; '
                     'LGSID=20200403095905-8201da05-4bb8-4e93-97bf-724ea6f758af; '
                     'PRE_SITE=https%3A%2F%2Fwww.lagou.com; _gat=1; '
                     'Hm_lvt_4233e74dff0ae5bd0a3d81c6ccf756e6=1585651082,1585879146; TG-TRACK-CODE=index_search; '
                     'X_HTTP_TOKEN=0b356dc3463713117419785851e40fa7a09468f3f0; '
                     'Hm_lpvt_4233e74dff0ae5bd0a3d81c6ccf756e6=1585879149; '
                     'LGRID=20200403095908-4f1711b9-3e7e-4d54-a400-20c76b57f327; '
                     'SEARCH_ID=b875e8b91a764d63a2dc98d822ca1f85'}
response=requests.post('https://www.lagou.com/jobs/positionAjax.json?needAddtionalResult=false',
                         headers=headers,
                         data=data)
print(response.json())

使用代理ip

这里在基础中已经讲到过，使用requests只需要两行代码，非常方便

import requests

proxy={'http': '59.44.78.30:54069'}
response=requests.get('http://httpbin.org/ip', proxies=proxy)
print(response.text)

cookie

使用session在多次请求中共享cookie，可以发现相比使用urllib代码变得特别简洁

import requests

headers={'User-Agent': ''}
data={'email': '',
        'password': ''}
login_url='http://www.renren.com/PLogin.do'
profile_url='http://www.renren.com/880151247/profile'
session=requests.Session()
session.post(login_url, data=data, headers=headers)
response=session.get(profile_url)
with open('renren.html', 'w', encoding='utf-8') as f:
    f.write(response.text)

处理不信任的SSL证书

对于那些没有被信任的SSL证书的网站，可以在requests.get和requests.post中设置参数verify=False来进行访问

XPath语法和lxml模块

XPath

xpath(XML Path Language)是一门在XML和HTML文档中查找信息的语言，可用来在XML和HTML文档中对元素和属性进行访问。

XPath开发工具

Chrome插件XPath Helper
Firefox插件Xpath Checker

XPath语法

XPath使用路径表达式来选取XML文档中的节点或者节点集，这些路径表达式和我们在常规的电脑文件系统中的表示式非常类似。

表达式	描述	示例	结果
nodename	选取此节点的所有子节点	bookstore	选取bookstore下所有的子节点
/	如果在最前面，代表从根节点选取，否则选择某节点下的某个节点	/bookstore	选取根元素下所有的bookstore节点
//	从全局节点中选择节点，随便在哪个位置	//book	从全局节点中找到所有的book节点
@	选取某个节点的属性	//book[@price]	选择所有拥有price属性的book节点

谓语

谓语用来查找某个特定的节点或者包含某个指定节点的值的节点，被嵌在方括号中。

路径表达式	描述
/bookstore/book[1]	选取bookstore下的第一个book元素
/booksotre/book[last()]	选取bookstore下的最后一个book元素
/bookstore/book[position()??]	选取bookstore下前面两个book元素
//book[@price]	选择所有拥有price属性的book节点
//book[@price=10]	选取所有属性price=10的book元素

通配符

通配符	描述	示例	结果
*	匹配任意节点	/bookstore/*	选取bookstore下的所有子元素
@*	匹配节点中的任何属性	//book[@*]	选取所有带有属性的book元素

选取多个路径

通过在路径表达式中使用|运算符，可以选取若干个路径

//bookstore/book | //book/title
# 选取多个book元素以及book元素下的title元素

运算符

运算符	描述	实例	返回值
\|	计算两个节点集	//book \| //cd	返回所有拥有book和cd元素的节点集
+，-，*，div	加，减，乘，除	6+1， 6-1， 6 * 1， 6 div 1	7, 5, 6, 6
=, !=, <, <=, >, >=	-	-	返回false或true
or, and	或，与	-	返回false或true
mod	计算除法的余数	5 mod 2	1

注意事项

/和//的区别，/代表只获取直接子节点，//代表获取子孙节点。
contains:有时候某个属性中包含了多个值，那么可以使用contains函数

//div[contains(@class, 'job_detail')]

3.谓词中的下标从1开始。

lxml库

lxml是一个HTML/XML的解析器，主要功能是如何解析和提取HTML/XML数据。

基本使用

1，解析html字符串：使用lxml.etree.HTML进行解析

from lxml import etree
htmlElement=etree.HTML(text)
print(etree.tostring(htmlElement, encoding='utf-8').decode('utf-8'))

2，解析html文件：使用lxml.etree.parse进行解析

htmlElement=etree.parse('tencent.xml')
print(etree.tostring(htmlElement, encoding='utf-8').decode('utf-8'))

这个函数默认使用XML解析器，所以如果碰到不规范的HTML代码的时候就会解析错误，这时候要创建HTML解析器

parser=etree.HTMLParser(encoding='utf-8')
htmlElement=etree.parse('tencent.xml', parser=parser)
print(etree.tostring(htmlElement, encoding='utf-8').decode('utf-8'))

XPath和lxml结合使用

使用xpath语法，应该使用Element.xpath方法，xpath返回列表。
获取标签属性
获取文本使用xpath中的text()函数
如果想在某个标签下，再执行xpath，获取这个标签下的子孙元素，那么应该在斜杠之前加点，代表在当前元素下获取。

from lxml import etree

parser=etree.HTMLParser(encoding='utf-8')
html=etree.parse('tencent.html', parser=parser)

获取所有tr标签

trs=html.xpath('//tr')
for tr in trs:
    print(etree.tostring(tr, encoding='utf-8').decode('utf-8'))

获取第2个tr标签

tr=html.xpath('//tr[2]')[0]
print(etree.tostring(tr, encoding='utf-8').decode('utf-8'))

获取所有class等于even的tr标签

trs=html.xpath("//tr[@class='even']")
for tr in trs:
    print(etree.tostring(tr, encoding='utf-8').decode('utf-8'))

获取所有a标签的href属性

aList=html.xpath('//a/@href')
for a in aList:
    print('http://hr.tencent.com/' + a)

获取所有职位信息

在线咨询

上一篇：价值1000万的EOS账户，你要不要注册一个？
下一篇：Safari现支持NFC、USB和Lightning

您的项目需求

*请认真填写需求信息，我们会在24小时内与您取得联系。

整合营销服务商

python开发—教你如何使用lxml.etree

ElementTree类

从字符串和文件中解析

ElementTree类

从字符串和文件中解析

equests库

发送get请求

response的属性

response.text和response.content的区别

发送POST请求

使用代理ip

cookie

处理不信任的SSL证书

XPath语法和lxml模块

XPath

XPath开发工具

XPath语法

谓语

通配符

选取多个路径

运算符

注意事项

lxml库

基本使用

XPath和lxml结合使用

获取所有tr标签

获取第2个tr标签

获取所有class等于even的tr标签

获取所有a标签的href属性

获取所有职位信息

您的项目需求