Python 简明教程

Python - XML Processing

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

What is XML?

可扩展标记语言 (XML) 是一种类似 HTML 或 SGML 的标记语言。它由万维网联盟推荐，并作为一个开放标准提供。

XML 对于跟踪少量的中型数据非常有用，而不需要基于 SQL 的支柱。

XML Parser Architectures and APIs.

Python 标准库提供了最少但有用的接口集，供与 XML 一起使用。用于 XML 处理的所有子模块都可以在 xml 包中找到。

  1. xml.etree.ElementTree − ElementTree API，一个简单轻量的 XML 处理器

  2. xml.dom − DOM API 定义。

  3. xml.dom.minidom − 最小 DOM 实现。

  4. xml.dom.pulldom − 用于构建部分 DOM 树的支持。

  5. xml.sax − SAX2 基类和便捷功能。

  6. xml.parsers.expat − Expat 解析器绑定。

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

  1. Simple API for XML (SAX) − 在这里，您可以为关注的事件注册回调，然后让解析器继续处理文档。当您的文档较大或存在内存限制时，这非常有用，它在从磁盘读取文件时对文件进行解析，整个文件永远不会存储在内存中。

  2. Document Object Model (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>

Parsing XML with SAX APIs

SAX 是用于事件驱动的 XML 解析的标准接口。使用 SAX 解析 XML 通常需要您通过对 xml.sax.ContentHandler 进行子类化来创建自己的 ContentHandler。

您的 ContentHandler 处理您想要解析的 XML 的特定标记和属性。ContentHandler 对象提供了处理各种解析事件的方法。它的所有解析器在解析 XML 文件时调用 ContentHandler 方法。

方法 startDocument 和 endDocument 在 XML 文件的开始和结尾调用。方法 characters(text) 通过参数 text 传递 XML 文件的字符数据。

ContentHandler 在每个元素的开始和结尾调用。如果解析器不处于命名空间模式，则调用方法 startElement(tag, attributes) 和 endElement(tag); 否则，调用相应的方法 startElementNS 和 endElementNS。在此，tag 是元素标记，而 attributes 是 Attributes 对象。

在继续之前，这还有一些需要了解的重要方法 −

The make_parser Method

下一个方法创建一个新的解析器对象并返回。创建的解析器对象将属于系统查找的第一个解析器类型。

xml.sax.make_parser( [parser_list] )

以下是参数的说明：

  1. parser_list − 由一系列解析器列表组成的可选参数，所有这些解析器都必须实现make_parser方法。

The parse Method

以下方法创建SAX解析器并使用此解析器解析文档。

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

以下是参数的详细信息−

  1. xmlfile − 这是要从中读取的XML文件的文件名。

  2. contenthandler − 必须为ContentHandler对象。

  3. errorhandler − 如果已指定，则errorhandler必须为SAX ErrorHandler对象。

The parseString Method

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

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

以下是参数的详细信息−

  1. xmlstring − 这是要从中读取的XML字符串的文件名。

  2. contenthandler − 必须为ContentHandler对象。

  3. errorhandler − 如果已指定，则errorhandler必须为SAX ErrorHandler对象。

Example

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

Parsing XML with DOM APIs

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

DOM对随机访问应用程序非常有用。SAX一次只允许查看文档的一个位。如果您正在查看某个SAX元素，则无权访问另一个元素。

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

示例短语调用minidom对象的parse(file [,parser])函数来解析由file指定的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)

这将产生以下 output −

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

ElementTree XML API

xml程序包有一个ElementTree模块。这是一个简单轻便的XML解析器API。

XML是一种类似树形的层次数据格式。此模块中的“ElementTree”将整个XML文档视为一棵树。“Element”类表示此树中的一个节点。在ElementTree级别进行XML文件上的读写操作。与单个XML元素及其子元素的交互在Element级别进行。

Create an XML File

该树是元素的层次结构，从根部开始，后跟其他元素。使用此模块的Element()函数创建每个元素。

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

每个元素的特征是标签和attrib属性，attrib属性是一个dict对象。对于树的起始元素，attrib是空字典。

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

现在您可以设置一个或多个子元素以添加到根元素下。每个子元素可以有一个或多个子元素。使用 SubElement() 函数添加它们并定义其 text 属性。

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)

Example

在此示例中，树是从字典项的列表构建的。每个字典项持有描述学生数据结构的键值对。这样构造的树将写入“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>

Parse an XML File

现在，我们从上面示例中创建的“myfile.xml”中读出内容。为此，将使用 ElementTree 模块中的以下函数：

ElementTree() - 此函数被重载为将元素的层次结构读到树对象中。

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

getroot() - 此函数返回树的根元素。

root = tree.getroot()

您可以获取某个元素下一层的子元素列表。

children = list(root)

在以下示例中，“myfile.xml”的元素和子元素被解析成一个字典项列表。

Example

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)

它将生成以下 output −

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

Modify an XML file

我们将使用 Element 的 iter() 函数。它创建一个以当前元素为根的给定标记的树迭代器。迭代器对其所在的元素和它之下的所有元素按从上到下的顺序进行迭代。

让我们为所有“marks”子元素构建一个迭代器，并使每个 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))