Python XML文件格式的解析

XML指可扩展标记语言，标准通用标记语言的子集，是一种用于标记电子文件使其具有结构性的标记语言。XML被设计用来传输和存储数据。

Python有三种常见的XML解析方式：SAX（simple API for XML）、DOM（Document Object Model）、ElementTree。

• DOM方式：DOM中文译为文档对象模型，是W3C组织推荐的标准编程接口，它将XML数据在内存中解析成一个树，通过对树的操作来操作XML。
• SAX方式：SAX是一个用于处理XML事件驱动的模型，它逐行扫描文档，一边扫描一边解析，对于大型文档的解析拥有巨大优势，尽管不是W3C标准，但它却得到了广泛认可。
• ElementTree方式：ElementTree相对于DOM来说拥有更好的性能，与SAX性能差不多，API使用也很方便。

Python除了内建的xml解析器外，还要非常多其他的解析工具。哪个工具易用性更好，性能更佳？一起来探索下。

xml.dom.*模块

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

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

• minidom是DOM API的极简化实现，比完整版的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

#
#
#
#War, Thriller
#DVD
#2003
#PG
#10
#Talk about a US-Japan war
#
#
#Anime, Science Fiction
#DVD
#1989
#R
#8
#A schientific fiction
#
#
#Anime, Action
#DVD
#4
#PG
#10
#Vash the Stampede!
#
#
#Comedy
#VHS
#PG
#2
#Viewable boredom
#
#

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):
    '''Parseroster 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语言实现的那种，因为它速度更快，而且消耗的内存更少。

#
#
#
#text, source
#
#
#
#xml, sgml
#
#
#
#
#

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 文件：

<mydocument has="anattribute">
<and>
<many>elements</many>
<many>moreelements</many>
</and>
<plus a="complex">
elementaswell
</plus>
</mydocument>

可以装载进一个 Python 字典里：

import xmltodict

with open('path/to/file.xml') as fd:
    obj = xmltodict.parse(fd.read())

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

doc['mydocument']['@has'] # == u'anattribute'
doc['mydocument']['and']['many'] # == [u'elements', u'moreelements']
doc['mydocument']['plus']['@a'] # == u'complex'
doc['mydocument']['plus']['#text'] # == u'elementaswell'

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

dicttoxml是一个将字典转化为 xml 的工具，感兴趣的可以研究下。

untangle

untangle 是一个用于将 XML 文档转换为 Python 对象的轻量级库。它的主要特点是简单易用，通过将 XML 数据映射为 Python 对象，使得访问 XML 节点和属性的操作变得直观和直接。

untangle 的使用非常简单，主要包括加载 XML 文档并将其转换为 Python 对象，以及访问这些对象的属性和子节点。以下是一些常见的用法示例：

解析 XML

可以从字符串、文件或 URL 加载 XML 数据。

import untangle

# 从字符串加载 XML
xml_string = '''
<library>
<book>
<title>Python 101</title>
<author>John Doe</author>
<year>2020</year>
</book>
<book>
<title>Advanced Python</title>
<author>Jane Smith</author>
<year>2021</year>
</book>
</library>
'''

obj = untangle.parse(xml_string)

# 从文件加载 XML
obj = untangle.parse('path/to/file.xml')

# 从 URL 加载 XML
obj = untangle.parse('http://example.com/data.xml')

访问节点和属性

一旦 XML 被解析为 Python 对象，就可以通过对象属性访问 XML 节点和属性。

# 访问第一个书籍的标题
title = obj.library.book[0].title.cdata
print(title) # 输出: Python 101

# 访问作者
author = obj.library.book[0].author.cdata
print(author) # 输出: John Doe

# 访问出版年份
year = obj.library.book[0].year.cdata
print(year) # 输出: 2020

处理多个节点当XML中有多个同名节点时，可以将其视为一个列表。

# 遍历所有书籍
for book in obj.library.book:
    print(f"Title: {book.title.cdata}, Author: {book.author.cdata}, Year: {book.year.cdata}")

处理XML属性

XML节点的属性可以通过_attributes访问。

<book id="1">
    <title>Python 101</title>
    <author>John Doe</author>
    <year>2020</year>
</book>

# 访问book节点的id属性
book_id = obj.library.book[0]._attributes['id']
print(book_id)  # 输出: 1

错误处理

untangle提供了一些基本的错误处理功能。例如，当访问不存在的节点时，它会抛出AttributeError。

try:
    non_existent = obj.library.non_existent_node
except AttributeError as e:
    print("Node does not exist:", e)

untangle通过将XML数据直接映射为Python对象，极大地简化了XML数据的处理过程。它适合那些需要快速和简单地访问XML数据的开发者。

xmldataset

xmldataset是一个用于解析XML数据并将其转换为Python数据结构的库。它的设计目标是简化从XML文档中提取数据的过程，尤其是在处理复杂或层次化的XML数据时。

xmldataset的基本用法包括定义数据提取模板、解析XML数据，以及将数据转换为Python数据结构。以下是一些常见的用法示例：

定义数据提取模板

在xmldataset中，你需要定义一个模板来描述你想从XML中提取的数据结构。模板通常是一个Python字典，键是数据路径，值是数据标签。

import xmldataset

# 定义数据提取模板
template = {
    'books': {
        'book': {
            'title': 'title',
            'author': 'author',
            'year': 'year'
        }
    }
}

解析XML数据

使用定义的模板来解析XML数据。

# 示例XML数据
xml_data = '''
<library>
    <books>
        <book>
            <title>Python 101</title>
            <author>John Doe</author>
            <year>2020</year>
        </book>
        <book>
            <title>Advanced Python</title>
            <author>Jane Smith</author>
            <year>2021</year>
        </book>
    </books>
</library>
'''

# 解析XML数据
dataset = xmldataset.parse_using_template(xml_data, template)

# 输出解析结果
print(dataset)

结果

解析结果将是一个嵌套的Python字典，结构与模板中定义的相匹配。

{
    'books': [
        {
            'title': 'Python 101',
            'author': 'John Doe',
            'year': '2020'
        },
        {
            'title': 'Advanced Python',
            'author': 'Jane Smith',
            'year': '2021'
        }
    ]
}

处理复杂的XML结构

xmldataset可以处理更复杂的XML结构，包括嵌套和重复的元素。通过精心设计的模板，可以灵活地提取所需的数据。

自定义标签和属性提取

你可以在模板中指定要提取的XML元素的属性和标签。

template = {
    'books': {
        'book': {
            'title': 'title',
            'author': 'author',
            'year': 'year',
            '@id': 'id'  # 提取book元素的id属性
        }
    }
}

xmldataset提供了一种简洁的方法来处理XML数据，特别适合那些需要快速从XML文档中提取数据的场景。它的模板驱动方法使得定义和解析数据结构变得直观和高效。

其他工具

• lxml：数据提取工具lxml及xpath
• BeautifulSoup：Python数据解析工具：BeautifulSoup
• Parsel：Scrapy自带的HTML、XML解析工具，可以使用XPath、CSS选择器或正则表达式进行数据提取。