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事件，然后进行处理。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 |
# <?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) |
更多参考：https://docs.python.org/2/library/xml.dom.html
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
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 |
# <?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") |
更多参考：https://docs.python.org/2/library/xml.sax.html
xml.parser.expat
xml.parser.expat提供了对C语言编写的expat解析器的一个直接的、底层API接口。expat接口与SAX类似，也是基于事件回调机制，但是这个接口并不是标准化的，只适用于expat库。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 |
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 |
更多参考：https://docs.python.org/2/library/pyexpat.html
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 语言实现的那种，因为它速度更快，而且消耗的内存更少。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 |
# <?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对象
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 |
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对象
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 |
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") |
模块方法
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 |
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到其自身。 |
更多参考：
- http://eli.thegreenplace.net/2012/03/15/processing-xml-in-python-with-elementtree/
- http://pycoders-weekly-chinese.readthedocs.io/en/latest/issue6/processing-xml-in-python-with-element-tree.html
xmltodict
xmltodict是一个可以让你在处理XML时感觉像在处理JSON一样的Python模块。
对于一个像这样的XML文件：
|
1 2 3 4 5 6 7 8 9 |
<mydocument has="an attribute"> <and> <many>elements</many> <many>more elements</many> </and> <plus a="complex"> element as well </plus> </mydocument> |
可以装载进一个Python字典里，像这样：
|
1 2 3 4 |
import xmltodict with open('path/to/file.xml') as fd: obj = xmltodict.parse(fd.read()) |
你可以访问元素，属性以及值，像这样：
|
1 2 3 4 |
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模式适合用来 处理不能放入内存的文件，它还支持命名空间。
更多信息：https://github.com/martinblech/xmltodict
untangle
untangle 库可以将XML文档映射为一个Python 对象，该对象于其结构中包含了原文档的节点与属性信息。
作为例子，一个像这样的XML文件：
|
1 2 3 4 |
<?xml version="1.0"?> <root> <child name="child1"> </root> |
可以被这样载入：
|
1 2 |
import untangle obj = untangle.parse('path/to/file.xml') |
然后你可以像这样获取child元素名称：
|
1 |
obj.root.child['name'] |
untangle也支持从字符串或URL中载入XML。
更多信息：https://github.com/stchris/untangle
lxml
具体参看：数据提取工具lxml及xpath
BeautifulSoup
具体参看：Python数据解析工具：Beautiful Soup
总结：在不考虑性能的情况下，我选择的是xmltodict，方便易用。如果考虑性能，建议使用ElementTree。
打赏作者微信支付
支付宝