Python - XML 处理

XML 是一种可移植的开源语言，允许程序员开发其他应用程序可以读取的应用程序，无论作系统和/或开发语言为何。

什么是XML？

可扩展标记语言（XML）是一种类似于HTML或SGML的标记语言。这是万维网联盟推荐的，并作为开放标准提供。

XML对于跟踪中小数据量非常有用，无需基于SQL的骨干网。

XML 解析器架构和 API。

Python 标准库提供了一套极简但实用的接口，用于处理 XML。所有用于XML处理的子模块都包含在xml包中。

xml.etree.ElementTree − ElementTree API，一个简单且轻量级的XML 处理器
xml.dom - DOM API 定义。
xml.dom.minidom − 一种最小DOM实现。
xml.dom.pulldom − 支持构建部分DOM树。
xml.sax − SAX2 基类和便利函数。
xml.parsers.expat − Expat 解析器绑定。

XML数据最基本且广泛使用的两种API是SAX和DOM接口。

简单 XML API（SAX）------ 在这里，你注册感兴趣事件的回调，然后让解析器继续处理文档。当文档很大或内存有限时，它会在读取文件时解析文件，且整个文件从不存储在内存中。
文档对象模型（DOM）− 这是万维网联盟的一项建议，将整个文件读入内存并以层级（基于树状）的形式存储，以表示XML文档的所有特征。

在处理大文件时，SAX 显然无法像 DOM 那样快速处理信息。另一方面，单纯使用DOM可能会严重消耗资源，尤其是大量小文件时。

SAX 是只读的，而 DOM 允许对 XML 文件进行修改。既然这两个不同的 API 实际上是互补的，没有理由不能同时用它们来做大型项目。

对于我们所有的XML代码示例，我们使用一个简单的XML文件movies.xml作为输入------

复制代码

<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>

使用 SAX API 解析 XML

SAX 是事件驱动 XML 解析的标准接口。用 SAX 解析 XML 通常需要你通过将 xml.sax.ContentHandler 子分类来创建自己的 ContentHandler。

你的 ContentHandler 负责处理你版本 XML 的标签和属性。ContentHandler 对象提供了处理各种解析事件的方法。其拥有的解析器在解析XML文件时调用ContentHandler的方法。

startDocument 和 endDocument 这两个方法在 XML 文件的开头和结尾被调用。方法字符（文本）通过参数文本传递XML文件的字符数据。

ContentHandler 在每个元素的开头和结尾被调用。如果解析器不在命名空间模式中，调用 startElement（tag， attributes）和 endElement（tag）这两个方法;否则，调用相应的方法startElementNS和endElementNS。这里，tag 是元素标签，attributes 是属性对象。

以下是其他重要方法，在继续前需要了解------

make_parser方法

以下方法创建一个新的解析器对象并返回它。系统发现，创建的解析器对象将属于第一个解析器类型。

复制代码

xml.sax.make_parser( [parser_list] )

以下是参数的详细情况 −

parser_list − 可选参数，包含一组解析器列表，其中必须全部实现make_parser方法。

解析法

以下方法创建一个 SAX 解析器，并用它解析文档。

复制代码

xml.sax.parse( xmlfile, contenthandler[, errorhandler])

以下是参数的详细信息 −

xmlfile − 这是要读取的XML文件名称。
contenthandler − 这必须是一个 ContentHandler 对象。
errorhandler − 如果指定，errorhandler 必须是 SAX ErrorHandler 对象。

解析字符串方法

还有一种方法可以创建 SAX 解析器和解析指定的 XML 字符串。

复制代码

xml.sax.parseString(xmlstring, contenthandler[, errorhandler])

以下是参数的详细信息 −

xmlstring − 这是要读取的XML字符串名称。
contenthandler − 这必须是一个 ContentHandler 对象。
errorhandler − 如果指定，errorhandler 必须是 SAX ErrorHandler 对象。

示例

复制代码

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 = ""

   # Call when an element starts
   def startElement(self, tag, attributes):
      self.CurrentData = tag
      if tag == "movie":
         print ("*****Movie*****")
         title = attributes["title"]
         print ("Title:", title)

   # Call when an elements ends
   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 = ""

   # Call when a character is read
   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__"):

   # create an XMLReader
   parser = xml.sax.make_parser()
   
   # turn off namepsaces
   parser.setFeature(xml.sax.handler.feature_namespaces, 0)
   
   # override the default ContextHandler
   Handler = MovieHandler()
   parser.setContentHandler( Handler )
   
   parser.parse("movies.xml")

这会得到以下结果 −

复制代码

*****Movie*****
Title: Enemy Behind
Type: War, Thriller
Format: DVD
Year: 2003
Rating: PG
Stars: 10
Description: Talk about a US-Japan war
*****Movie*****
Title: Transformers
Type: Anime, Science Fiction
Format: DVD
Year: 1989
Rating: R
Stars: 8
Description: A schientific fiction
*****Movie*****
Title: Trigun
Type: Anime, Action
Format: DVD
Rating: PG
Stars: 10
Description: Vash the Stampede!
*****Movie*****
Title: Ishtar
Type: Comedy
Format: VHS
Rating: PG
Stars: 2
Description: Viewable boredom

有关 SAX API 文档的完整细节，请参阅标准的 Python SAX API。

使用 DOM API 解析 XML

文档对象模型（"DOM"）是万维网联盟（W3C）提出的一种跨语言API，用于访问和修改XML文档。

DOM对于随机访问应用非常有用。SAX 一次只能让你查看文档的一个比特。如果你只关注一个SAX元素，你就无法访问另一个。

以下是快速加载XML文档和使用xml.dom模块创建minidom对象的最简单方法。minidom对象提供了一个简单的解析器方法，可以快速从XML文件创建DOM树。

示例短语调用 minidom 对象的 parse（ file [，parser] ）函数，将 XML 文件（由文件指定）解析为 DOM 树对象。

复制代码

from xml.dom.minidom import parse
import xml.dom.minidom

# Open XML document using minidom parser
DOMTree = xml.dom.minidom.parse("movies.xml")
collection = DOMTree.documentElement
if collection.hasAttribute("shelf"):
   print ("Root element : %s" % collection.getAttribute("shelf"))

# Get all the movies in the collection
movies = collection.getElementsByTagName("movie")

# Print detail of each movie.
for movie in movies:
   print ("*****Movie*****")
   if movie.hasAttribute("title"):
      print ("Title: %s" % movie.getAttribute("title"))

   type = movie.getElementsByTagName('type')[0]
   print ("Type: %s" % type.childNodes[0].data)
   format = movie.getElementsByTagName('format')[0]
   print ("Format: %s" % format.childNodes[0].data)
   rating = movie.getElementsByTagName('rating')[0]
   print ("Rating: %s" % rating.childNodes[0].data)
   description = movie.getElementsByTagName('description')[0]
   print ("Description: %s" % description.childNodes[0].data)

这会产生以下输出 −

复制代码

Root element : New Arrivals
*****Movie*****
Title: Enemy Behind
Type: War, Thriller
Format: DVD
Rating: PG
Description: Talk about a US-Japan war
*****Movie*****
Title: Transformers
Type: Anime, Science Fiction
Format: DVD
Rating: R
Description: A schientific fiction
*****Movie*****
Title: Trigun
Type: Anime, Action
Format: DVD
Rating: PG
Description: Vash the Stampede!
*****Movie*****
Title: Ishtar
Type: Comedy
Format: VHS
Rating: PG
Description: Viewable boredom

有关 DOM API 文档的完整细节，请参阅标准 Python DOM API。

ElementTree XML API

xml 包包含一个 ElementTree 模块。这是一个简单且轻量级的XML处理器API。

XML 是一种树状的层级数据格式。该模块中的"ElementTree"将整个XML文档视为树。"Element"类代表该树中的单个节点。XML 文件的读写作在 ElementTree 层面进行。与单个XML元素及其子元素的交互是在元素层面进行的。

创建XML文件

树是一个层级结构，由根节点开始，随后是其他元素。每个元素都是通过该模块的 Element（）函数创建的。

复制代码

import xml.etree.ElementTree as et
e=et.Element('name')

每个元素都由标签和归因属性（dict对象）来刻画。对于树的起始元素，归因是一个空字典。

复制代码

>>> root=xml.Element('employees')
>>> root.tag
'employees'
>>> root.attrib
{}

你现在可以设置一个或多个子元素，在根元素下添加。每个子节点可以有一个或多个子元素。使用SubElement（）函数添加它们，并定义其文本属性。

复制代码

child=xml.Element("employee")
nm = xml.SubElement(child, "name")
nm.text = student.get('name')
age = xml.SubElement(child, "salary")
age.text = str(student.get('salary'))

每个子节点通过附加（ append（）函数加到根节点，作为 −

复制代码

root.append(child)

添加所需子元素后，通过 elementTree（）函数 − 构造树对象

复制代码

tree = et.ElementTree(root)

整个树结构由树对象的write（）函数 − 写入二进制文件

复制代码

f=open('employees.xml', "wb")
tree.write(f)

示例

在这个例子中，树是由词典条目列表构建而成的。每个词典项目包含描述学生数据结构的键值对。这样构建的树被写成"myfile.xml"

复制代码

import xml.etree.ElementTree as et
employees=[{'name':'aaa','age':21,'sal':5000},{'name':xyz,'age':22,'sal':6000}]
root = et.Element("employees")
for employee in employees:
   child=xml.Element("employee")
   root.append(child)
   nm = xml.SubElement(child, "name")
   nm.text = student.get('name')
   age = xml.SubElement(child, "age")
   age.text = str(student.get('age'))
   sal=xml.SubElement(child, "sal")
   sal.text=str(student.get('sal'))
tree = et.ElementTree(root)
with open('employees.xml', "wb") as fh:
   tree.write(fh)

"myfile.xml"存储在当前工作目录中。

复制代码

<employees><employee><name>aaa</name><age>21</age><sal>5000</sal></employee><employee><name>xyz</name><age>22</age><sal>60</sal></employee></employee>

解析 XML 文件

现在让我们回顾上面例子中产生的"myfile.xml"。为此，ElementTree 模块中的以下函数将被使用 −

ElementTree（） − 该函数被超载，用于读取元素的层级结构到树对象中。

复制代码

tree = et.ElementTree(file='students.xml')

getroot（） − 该函数返回树的根元素。

复制代码

root = tree.getroot()

你可以获得元素下一级的子元素列表。

复制代码

children = list(root)

在以下示例中，"myfile.xml"的元素和子元素被解析成词典项列表。

示例

复制代码

import xml.etree.ElementTree as et
tree = et.ElementTree(file='employees.xml')
root = tree.getroot()
employees=[]
   children = list(root)
for child in children:
   employee={}
   pairs = list(child)
   for pair in pairs:
      employee[pair.tag]=pair.text
   employees.append(employee)
print (employees)

它将产生以下输出 −

复制代码

[{'name': 'aaa', 'age': '21', 'sal': '5000'}, {'name': 'xyz', 'age':'22', 'sal': '6000'}]

修改XML文件

我们将使用 Element 的 iter（）函数。它为给定标签创建一个树状迭代器，以当前元素为根节点。迭代器按文档（深度优先）顺序遍历该元素及其下的所有元素。

让我们为所有"标记"子元素构建迭代器，并将每个 sal 标签的文本逐一增加 100。

复制代码

import xml.etree.ElementTree as et
tree = et.ElementTree(file='students.xml')
root = tree.getroot()
for x in root.iter('sal'):
   s=int (x.text)
   s=s+100
   x.text=str(s)
with open("employees.xml", "wb") as fh:
   tree.write(fh)

我们的"employees.xml"将相应调整。我们也可以用 set（）来更新某个键的值。

复制代码

x.set(marks, str(mark))