当前位置：极客教程 > Python > Python 精品教程 > Python XML处理

Python XML处理

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接口。

  • Simple API for XML (SAX) - 在这里，您注册感兴趣的事件的回调，然后让解析器继续处理文档。当您的文档很大或存在内存限制时，这是非常有用的，它会在从磁盘读取文件时解析文件，整个文件不会存储在内存中。

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

使用SAX API解析XML

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对象。

在继续之前，还有其他重要的方法需要了解−

make_parser方法

下面的方法创建一个新的解析器对象并返回它。创建的解析器对象将是系统找到的第一个解析器类型。

xml.sax.make_parser( [parser_list] )

这里是参数的详细信息 –

  • parser_list - 可选参数，包含要使用的解析器的列表，它们都必须实现make_parser方法。

parse方法

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

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

以下是参数的详细信息：

  • xmlfile − 这是要从中读取的XML文件的名称。

  • contenthandler − 必须是ContentHandler对象。

  • errorhandler − 如果指定了，errorhandler必须是一个SAX ErrorHandler对象。

parseString方法

还有一种方法可以创建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 APIs 。

使用DOM APIs解析XML

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

DOM对于随机访问应用非常有用。SAX只允许您一次查看文档的一部分。如果您正在查看一个SAX元素，您无法访问另一个元素。

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

示例片段调用minidom对象的parse（file [, parser]）函数来解析XML文件，该文件指定为file，然后将其转换为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 APIs 。

ElementTree XML API

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

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

创建XML文件

树是由根元素和其他元素组成的层次结构。每个元素都是使用这个模块的Element()函数创建的。

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

每个元素由标签和attrib属性组成，attrib是一个字典对象。对于树的起始元素，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)

示例

在这个示例中，树是从字典项列表构建的。每个字典项都包含描述学生数据结构的键值对。构建的树被写入到’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()函数。它会为给定的标签创建一个树迭代器，当前元素为根元素。迭代器按照文档（深度优先）顺序遍历该元素和其下所有元素。

让我们为所有’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))

Python教程

Python 教程

Python 教程
Tkinter 教程

Tkinter 教程
Pandas 教程

Pandas 教程
NumPy 教程

NumPy 教程
Flask 教程

Flask 教程
Django 教程

Django 教程
PySpark 教程

PySpark 教程
wxPython 教程

wxPython 教程
SymPy 教程

SymPy 教程
Seaborn 教程

Seaborn 教程
SciPy 教程

SciPy 教程
RxPY 教程

RxPY 教程
Pycharm 教程

Pycharm 教程
Pygame 教程

Pygame 教程
PyGTK 教程

PyGTK 教程
PyQt 教程

PyQt 教程
PyQt5 教程

PyQt5 教程
PyTorch 教程

PyTorch 教程
Matplotlib 教程

Matplotlib 教程
Web2py 教程

Web2py 教程
BeautifulSoup 教程

BeautifulSoup 教程

Java教程

Java 教程

Java 教程

Web教程

HTML 教程

HTML 教程
CSS 教程

CSS 教程
CSS3 教程

CSS3 教程
jQuery 教程

jQuery 教程
Ajax 教程

Ajax 教程
AngularJS 教程

AngularJS 教程
TypeScript 教程

TypeScript 教程
WordPress 教程

WordPress 教程
Laravel 教程

Laravel 教程
Next.js 教程

Next.js 教程
PhantomJS 教程

PhantomJS 教程
Three.js 教程

Three.js 教程
Underscore.JS 教程

Underscore.JS 教程
WebGL 教程

WebGL 教程
WebRTC 教程

WebRTC 教程
VueJS 教程

VueJS 教程

数据库教程

SQL 教程

SQL 教程
MySQL 教程

MySQL 教程
MongoDB 教程

MongoDB 教程
PostgreSQL 教程

PostgreSQL 教程
SQLite 教程

SQLite 教程
Redis 教程

Redis 教程
MariaDB 教程

MariaDB 教程

图形图像教程

Vulkan 教程

Vulkan 教程
OpenCV 教程

OpenCV 教程

大数据教程

R语言 教程

R语言 教程

开发工具教程

Git 教程

Git 教程
VSCode 教程

VSCode 教程
Docker 教程

Docker 教程
Gerrit 教程

Gerrit 教程
Excel 教程

Excel 教程

计算机教程

Go语言 教程

Go语言 教程
C++ 教程

C++ 教程

Python 精品教程