Python解析XML的几种方法

Python 有非常非常多的工具来处理 XML。哪个工具易用性更好，性能更加？一起来探索下。

xml.dom.* 模块

xml.dom实现的是W3C制定的DOM API。如果你习惯于使用DOM API，可以使用这个包。xml.dom将XML数据在内存中解析成一个树，通过对树的操作来操作XML。一个 DOM 的解析器在解析一个 XML 文档时，一次性读取整个文档，把文档中所有元素保存在内存中的一个树结构里，之后你可以利用DOM 提供的不同的函数来读取或修改文档的内容和结构，也可以把修改过的内容写入xml文件。

注意：在 xml.dom 包里面有许多模块，注意它们之间的不同。

dom.minidom是DOM API的极简化实现，比完整版的DOM要简单的多，而且这个包也小的多。
dom.pulldom模块提供的是一个“pull解析器”，其背后的基本概念指的是从XML流中pull事件，然后进行处理。

# <?xml version="1.0" encoding="UTF-8"?>

# <employees>

# <employee>

# <name>linux</name>

# <age>30</age>

# </employee>

# <employee>

# <name>windows</name>

# <age>20</age>

# </employee>

# </employees>

from xml.dom import minidom

doc = minidom.parse("employees.xml")

root = doc.documentElement

employees = root.getElementsByTagName("employee")

for employee in employees:

print (employee.nodeName)

print (employee.toxml())

nameNode = employee.getElementsByTagName("name")[0]

print (nameNode.childNodes)

print (nameNode.nodeName + ":" + nameNode.childNodes[0].nodeValue)

ageNode = employee.getElementsByTagName("age")[0]

print (ageNode.childNodes)

print (ageNode.nodeName + ":" + ageNode.childNodes[0].nodeValue)

for n in employee.childNodes:

print (n)

xml.sax.* 模块

xml.sax.* 模块是 SAX API 的实现。这个模块牺牲了便捷性来换取速度和内存占用。SAX（simple API for XML），是基于事件处理的，当XML文档顺序地读入时，每次遇到一个元素会触发相应的事件处理函数来处理。

SAX的特点：

是基于事件的 API
在一个比 DOM 低的级别上操作
为您提供比 DOM 更多的控制
几乎总是比 DOM 更有效率
但不幸的是，需要比 DOM 更多的工作

使用Python解析XML的时候，需要 import xml.sax 和 xml.sax.handler

# <?xml version="1.0"?>

# <collection shelf="New Arrivals">

# <movie title="Enemy Behind">

# <type>War, Thriller</type>

# <format>DVD</format>

# <year>2003</year>

# <rating>PG</rating>

# <stars>10</stars>

# <description>Talk about a US-Japan war</description>

# </movie>

# <movie title="Transformers">

# <type>Anime, Science Fiction</type>

# <format>DVD</format>

# <year>1989</year>

# <rating>R</rating>

# <stars>8</stars>

# <description>A schientific fiction</description>

# </movie>

# <movie title="Trigun">

# <type>Anime, Action</type>

# <format>DVD</format>

# <episodes>4</episodes>

# <rating>PG</rating>

# <stars>10</stars>

# <description>Vash the Stampede!</description>

# </movie>

# <movie title="Ishtar">

# <type>Comedy</type>

# <format>VHS</format>

# <rating>PG</rating>

# <stars>2</stars>

# <description>Viewable boredom</description>

# </movie>

# </collection>

import xml.sax

class MovieHandler( xml.sax.ContentHandler):

def __init__(self):

self.CurrentData = ""

self.type = ""

self.format = ""

self.year = ""

self.rating = ""

self.stars = ""

self.description = ""

# 元素开始事件处理

def startElement(self, tag, attributes):

self.CurrentData = tag

if tag == "movie":

print "*****Movie*****"

title = attributes["title"]

print "Title:", title

# 元素结束事件处理

def endElement(self, tag):

if self.CurrentData == "type":

print "Type:", self.type

elif self.CurrentData == "format":

print "Format:", self.format

elif self.CurrentData == "year":

print "Year:", self.year

elif self.CurrentData == "rating":

print "Rating:", self.rating

elif self.CurrentData == "stars":

print "Stars:", self.stars

elif self.CurrentData == "description":

print "Description:", self.description

self.CurrentData = ""

# 内容事件处理

def characters(self, content):

if self.CurrentData == "type":

self.type = content

elif self.CurrentData == "format":

self.format = content

elif self.CurrentData == "year":

self.year = content

elif self.CurrentData == "rating":

self.rating = content

elif self.CurrentData == "stars":

self.stars = content

elif self.CurrentData == "description":

self.description = content

if ( __name__ == "__main__"):

# 创建一个 XMLReader

parser = xml.sax.make_parser()

# turn off namepsaces

parser.setFeature(xml.sax.handler.feature_namespaces, 0)

# 重写 ContextHandler

Handler = MovieHandler()

parser.setContentHandler( Handler )

parser.parse("movies.xml")

xml.parser.expat

xml.parser.expat提供了对C语言编写的expat解析器的一个直接的、底层API接口。expat接口与SAX类似，也是基于事件回调机制，但是这个接口并不是标准化的，只适用于expat库。

import xml.parsers.expat

class ExParser(object):

'''Parse roster xml'''

def __init__(self, xml_raw):

'''init parser and setup handlers'''

self.parser = xml.parsers.expat.ParserCreate()

#connect handlers

self.parser.StartElementHandler = self.start_element

self.parser.EndElementHandler = self.end_element

self.parser.CharacterDataHandler = self.char_data

self.parser.Parse(xml_raw)

del(xml_raw)

def start_element(self, name, attrs):

'''Start xml element handler'''

print 'start:'+name

def end_element(self, name):

'''End xml element handler'''

print 'end:'+name

def char_data(self, data):

'''Char xml element handler'''

print 'data is '+data

ElementTree

xml.etree.ElementTree模块提供了一个轻量级、Pythonic的API，同时还有一个高效的C语言实现，即xml.etree.cElementTree。与DOM相比，ET的速度更快，API使用更直接、方便。与SAX相比，ET.iterparse函数同样提供了按需解析的功能，不会一次性在内存中读入整个文档。ET的性能与SAX模块大致相仿，但是它的API更加高层次，用户使用起来更加便捷。

ElementTree在 Python 标准库中有两种实现。一种是纯 Python 实现例如 xml.etree.ElementTree ，另外一种是速度快一点的 xml.etree.cElementTree 。你要记住：尽量使用 C 语言实现的那种，因为它速度更快，而且消耗的内存更少。

# <?xml version="1.0"?>

# <doc>

# <branch name="testing" hash="1cdf045c">

# text,source

# </branch>

# <branch name="release01" hash="f200013e">

# <sub-branch name="subrelease01">

# xml,sgml

# </sub-branch>

# </branch>

# <branch name="invalid">

# </branch>

# </doc>

try:

import xml.etree.cElementTree as ET

except ImportError:

import xml.etree.ElementTree as ET

tree = ET.ElementTree(file='doc1.xml')

root = tree.getroot()

print root.tag, root.attrib

for child_of_root in root:

print child_of_root.tag, child_of_root.attrib

for elem in tree.iter():

print elem.tag, elem.attrib

for elem in tree.iter(tag='branch'):

print elem.tag, elem.attrib

for elem in tree.iterfind('branch/sub-branch'):

print elem.tag, elem.attrib

for elem in tree.iterfind('branch[@name="release01"]'):

print elem.tag, elem.attrib

Element对象

class xml.etree.ElementTree.Element(tag, attrib={}, **extra)

　　tag：string，元素代表的数据种类。

　　text：string，元素的内容。

　　tail：string，元素的尾形。

　　attrib：dictionary，元素的属性字典。

　　#针对属性的操作

　　clear()：清空元素的后代、属性、text和tail也设置为None。

　　get(key, default=None)：获取key对应的属性值，如该属性不存在则返回default值。

　　items()：根据属性字典返回一个列表，列表元素为(key, value）。

　　keys()：返回包含所有元素属性键的列表。

　　set(key, value)：设置新的属性键与值。

　　#针对后代的操作

　　append(subelement)：添加直系子元素。

　　extend(subelements)：增加一串元素对象作为子元素。＃python2.7新特性

　　find(match)：寻找第一个匹配子元素，匹配对象可以为tag或path。

　　findall(match)：寻找所有匹配子元素，匹配对象可以为tag或path。

　　findtext(match)：寻找第一个匹配子元素，返回其text值。匹配对象可以为tag或path。

　　insert(index, element)：在指定位置插入子元素。

　　iter(tag=None)：生成遍历当前元素所有后代或者给定tag的后代的迭代器。＃python2.7新特性

　　iterfind(match)：根据tag或path查找所有的后代。

　　itertext()：遍历所有后代并返回text值。

　　remove(subelement)：删除子元素。

ElementTree对象

class xml.etree.ElementTree.ElementTree(element=None, file=None)

　　element如果给定，则为新的ElementTree的根节点。

　　_setroot(element)：用给定的element替换当前的根节点。慎用。

　　# 以下方法与Element类中同名方法近似，区别在于它们指定以根节点作为操作对象。

　　find(match)

　　findall(match)

　　findtext(match, default=None)

　　getroot()：获取根节点.

　　iter(tag=None)

　　iterfind(match)

　　parse(source, parser=None)：装载xml对象，source可以为文件名或文件类型对象.

　　write(file, encoding="us-ascii", xml_declaration=None, default_namespace=None,method="xml")

模块方法

xml.etree.ElementTree.Comment(text=None)

创建一个特别的element，通过标准序列化使其代表了一个comment。comment可以为bytestring或unicode。

xml.etree.ElementTree.dump(elem)

生成一个element tree，通过sys.stdout输出，elem可以是元素树或单个元素。这个方法最好只用于debug。

xml.etree.ElementTree.fromstring(text)

text是一个包含XML数据的字符串，与XML()方法类似，返回一个Element实例。

xml.etree.ElementTree.fromstringlist(sequence, parser=None)

从字符串的序列对象中解析xml文档。缺省parser为XMLParser，返回Element实例。

xml.etree.ElementTree.iselement(element)

检查是否是一个element对象。

xml.etree.ElementTree.iterparse(source, events=None, parser=None)

将文件或包含xml数据的文件对象递增解析为element tree，并且报告进度。events是一个汇报列表，如果忽略，将只有end事件会汇报出来。

注意，iterparse()只会在看见开始标签的">"符号时才会抛出start事件，因此届时属性是已经定义了，但是text和tail属性在那时还没有定义，同样子元素也没有定义，因此他们可能不能被显示出来。如果你想要完整的元素，请查找end事件。

xml.etree.ElementTree.parse(source, parser=None)

将一个文件或者字符串解析为element tree。

xml.etree.ElementTree.ProcessingInstruction(target, text=None)

这个方法会创建一个特别的element，该element被序列化为一个xml处理命令。

xml.etree.ElementTree.register_namespace(prefix, uri)

注册命名空间前缀。这个注册是全局有效，任何已经给出的前缀或者命名空间uri的映射关系会被删除。

xml.etree.ElementTree.SubElement(parent, tag, attrib={}, **extra)

子元素工厂，创建一个Element实例并追加到已知的节点。

xml.etree.ElementTree.tostring(element, encoding="us-ascii", method="xml")

生成一个字符串来表示表示xml的element，包括所有子元素。element是Element实例，method为"xml","html","text"。返回包含了xml数据的字符串。

xml.etree.ElementTree.tostringlist(element, encoding="us-ascii", method="xml")

生成一个字符串来表示表示xml的element，包括所有子元素。element是Element实例，method为"xml","html","text"。返回包含了xml数据的字符串列表。

xml.etree.ElementTree.XML(text, parser=None)

从一个字符串常量中解析出xml片段。返回Element实例。

xml.etree.ElementTree.XMLID(text, parser=None)

从字符串常量解析出xml片段，同时返回一个字典，用以映射element的id到其自身。

更多参考：

xmltodict

xmltodict是一个可以让你在处理XML时感觉像在处理JSON一样的Python模块。

对于一个像这样的XML文件：

<and>

<many>elements</many>

<many>more elements</many>

</and>

element as well

</plus>

</mydocument>

可以装载进一个Python字典里，像这样：

import xmltodict

with open('path/to/file.xml') as fd:

obj = xmltodict.parse(fd.read())

你可以访问元素，属性以及值，像这样：

doc['mydocument']['@has'] # == u'an attribute'

doc['mydocument']['and']['many'] # == [u'elements', u'more elements']

doc['mydocument']['plus']['@a'] # == u'complex'

doc['mydocument']['plus']['#text'] # == u'element as well'

xmltodict 也有unparse函数让你可以转回XML。该函数有一个streaming模式适合用来处理不能放入内存的文件，它还支持命名空间。

untangle

untangle 库可以将XML文档映射为一个Python 对象，该对象于其结构中包含了原文档的节点与属性信息。

作为例子，一个像这样的XML文件：

<?xml version="1.0"?>

<root>

</root>

可以被这样载入：

1 2	import untangle obj = untangle.parse('path/to/file.xml')

然后你可以像这样获取child元素名称：

1	obj.root.child['name']

untangle也支持从字符串或URL中载入XML。

lxml

具体参看：数据提取工具lxml及xpath

BeautifulSoup

具体参看：Python数据解析工具：Beautiful Soup

总结：在不考虑性能的情况下，我选择的是xmltodict，方便易用。如果考虑性能，建议使用ElementTree。

打赏作者

微信支付

支付宝

Python解析XML的几种方法

xml.dom.* 模块

xml.sax.* 模块

xml.parser.expat

ElementTree

xmltodict

untangle

lxml

BeautifulSoup

复合事件处理CEP简介

C语言学习：size_t

C语言学习：main()函数的正确写法

发表评论取消回复

Python解析XML的几种方法

xml.dom.* 模块

xml.sax.* 模块

xml.parser.expat

ElementTree

xmltodict

untangle

lxml

BeautifulSoup

复合事件处理CEP简介

C语言学习：size_t

C语言学习：main()函数的正确写法

发表评论 取消回复

发表评论取消回复