Python实现XML文件解析的示例代码,pythonxml

1. XML简介

XML(eXtensible Markup
Language)指可扩展标记语言,被设计用来传输和存储数据,已经日趋成为当前许多新生技术的核心,在不同的领域都有着不同的应用。它是web发展到一定阶段的必然产物,既具有SGML的核心特征,又有着HTML的简单特性,还具有明确和结构良好等许多新的特性。

test.XML文件

<?xml version="1.0" encoding="utf-8"?>
<catalog>
  <maxid>4</maxid>
  <login username="pytest" passwd='123456'>
    <caption>Python</caption>
    <item id="4">
      <caption>测试</caption>
    </item>
  </login>
  <item id="2">
    <caption>Zope</caption>
  </item>
</catalog>

XML详细介绍可以参考:

2. XML文件解析

python解析XML常见的有三种方法:一是xml.dom.*模块,它是W3C DOM
API的实现,若需要处理DOM API则该模块很适合;二是xml.sax.*模块,它是SAX
API的实现,这个模块牺牲了便捷性来换取速度和内存占用,SAX是一个基于事件的API,这就意味着它可以“在空中”处理庞大数量的的文档,不用完全加载进内存;三是xml.etree.ElementTree模块(简称
ET),它提供了轻量级的Python式的API,相对于DOM来说ET
快了很多,而且有很多令人愉悦的API可以使用,相对于SAX来说ET的ET.iterparse也提供了
“在空中”
的处理方式,没有必要加载整个文档到内存,ET的性能的平均值和SAX差不多,但是API的效率更高一点而且使用起来很方便。

2.1 xml.dom.*

文件对象模型(Document Object
Model,简称DOM),是W3C组织推荐的处理可扩展置标语言的标准编程接口。一个
DOM
的解析器在解析一个XML文档时,一次性读取整个文档,把文档中所有元素保存在内存中的一个树结构里,之后你可以利用DOM
提供的不同的函数来读取或修改文档的内容和结构,也可以把修改过的内容写入xml文件。python中用xml.dom.minidom来解析xml文件。

a. 获得子标签

b. 区分相同标签名的标签

c. 获取标签属性值

d. 获取标签对之间的数据

#coding=utf-8

#通过minidom解析xml文件
import xml.dom.minidom as xmldom
import os
''' 
XML文件读取 
<?xml version="1.0" encoding="utf-8"?>
<catalog>
  <maxid>4</maxid>
  <login username="pytest" passwd='123456'>dasdas
    <caption>Python</caption>
    <item id="4">
      <caption>测试</caption>
    </item>
  </login>
  <item id="2">
    <caption>Zope</caption>
  </item>
</catalog>

'''

xmlfilepath = os.path.abspath("test.xml")
print ("xml文件路径:", xmlfilepath)

# 得到文档对象
domobj = xmldom.parse(xmlfilepath)
print("xmldom.parse:", type(domobj))
# 得到元素对象
elementobj = domobj.documentElement
print ("domobj.documentElement:", type(elementobj))

#获得子标签
subElementObj = elementobj.getElementsByTagName("login")
print ("getElementsByTagName:", type(subElementObj))

print (len(subElementObj))
# 获得标签属性值
print (subElementObj[0].getAttribute("username"))
print (subElementObj[0].getAttribute("passwd"))

#区分相同标签名的标签
subElementObj1 = elementobj.getElementsByTagName("caption")
for i in range(len(subElementObj1)):
  print ("subElementObj1[i]:", type(subElementObj1[i]))
  print (subElementObj1[i].firstChild.data) #显示标签对之间的数据

输出结果:

>>> D:\Pystu>python xml_instance.py
>>> xml文件路径: D:\Pystu\test.xml
>>> xmldom.parse: <class ‘xml.dom.minidom.Document’>
>>> domobj.documentElement: <class
‘xml.dom.minidom.Element’>
>>> getElementsByTagName: <class
‘xml.dom.minicompat.NodeList’>
>>> username: pytest
>>> passwd: 123456
>>> subElementObj1[i]: <class
‘xml.dom.minidom.Element’>
>>> Python
>>> subElementObj1[i]: <class
‘xml.dom.minidom.Element’>
>>> 测试
>>> subElementObj1[i]: <class
‘xml.dom.minidom.Element’>
>>> Zope

2.2 xml.etree.ElementTree

ElementTree生来就是为了处理XML,它在Python标准库中有两种实现:一种是纯Python实现的,如xml.etree.ElementTree,另一种是速度快一点的xml.etree.cElementTree。注意:尽量使用C语言实现的那种,因为它速度更快,而且消耗的内存更少。

a. 遍历根节点的下一层

b. 下标访问各个标签、属性、文本

c. 查找root下的指定标签

d. 遍历XML文件

e. 修改XML文件

#coding=utf-8

#通过解析xml文件
'''
try:
  import xml.etree.CElementTree as ET
except:
  import xml.etree.ElementTree as ET

从Python3.3开始ElementTree模块会自动寻找可用的C库来加快速度  
'''
import xml.etree.ElementTree as ET
import os
import sys
''' 
XML文件读取 
<?xml version="1.0" encoding="utf-8"?>
<catalog>
  <maxid>4</maxid>
  <login username="pytest" passwd='123456'>dasdas
    <caption>Python</caption>
    <item id="4">
      <caption>测试</caption>
    </item>
  </login>
  <item id="2">
    <caption>Zope</caption>
  </item>
</catalog>
'''

#遍历xml文件
def traverseXml(element):
  #print (len(element))
  if len(element)>0:
    for child in element:
      print (child.tag, "----", child.attrib)
      traverseXml(child)
  #else:
    #print (element.tag, "----", element.attrib)


if __name__ == "__main__":
  xmlFilePath = os.path.abspath("test.xml")
  print(xmlFilePath)
  try:
    tree = ET.parse(xmlFilePath)
    print ("tree type:", type(tree))

    # 获得根节点
    root = tree.getroot()
  except Exception as e: #捕获除与程序退出sys.exit()相关之外的所有异常
    print ("parse test.xml fail!")
    sys.exit()
  print ("root type:", type(root))  
  print (root.tag, "----", root.attrib)

  #遍历root的下一层
  for child in root:
    print ("遍历root的下一层", child.tag, "----", child.attrib)

  #使用下标访问
  print (root[0].text)
  print (root[1][1][0].text)

  print (20 * "*")
  #遍历xml文件
  traverseXml(root)
  print (20 * "*")

  #根据标签名查找root下的所有标签
  captionList = root.findall("item") #在当前指定目录下遍历
  print (len(captionList))
  for caption in captionList:
    print (caption.tag, "----", caption.attrib, "----", caption.text)

  #修改xml文件,将passwd修改为999999
  login = root.find("login")
  passwdValue = login.get("passwd")
  print ("not modify passwd:", passwdValue)
  login.set("passwd", "999999")  #修改,若修改text则表示为login.text
  print ("modify passwd:", login.get("passwd"))

输出结果:

>>> D:\Pystu\test.xml
>>> tree type: <class
‘xml.etree.ElementTree.ElementTree’>
>>> root type: <class
‘xml.etree.ElementTree.Element’>
>>> catalog —- {}
>>> 遍历root的下一层 maxid —- {}
>>> 遍历root的下一层 login —- {‘username’: ‘pytest’,
‘passwd’: ‘123456’}
>>> 遍历root的下一层 item —- {‘id’: ‘2’}
>>> 4
>>> 测试
>>> ********************
>>> maxid —- {}
>>> login —- {‘username’: ‘pytest’, ‘passwd’: ‘123456’}
>>> caption —- {}
>>> item —- {‘id’: ‘4’}
>>> caption —- {}
>>> item —- {‘id’: ‘2’}
>>> caption —- {}
>>> ********************
>>> 1
>>> item —- {‘id’: ‘2’} —-
>>> not modify passwd: 123456
>>> modify passwd: 999999

附:

#coding=utf-8

'''
  XML解析类
  @功能-结点的增删改查
'''
import xml.etree.ElementTree as ET
import sys
import os.path

class XmlParse:
  def __init__(self, file_path):
    self.tree = None
    self.root = None
    self.xml_file_path = file_path

  def ReadXml(self):
    try:
      print("xmlfile:", self.xml_file_path)
      self.tree = ET.parse(self.xml_file_path)
      self.root = self.tree.getroot()
    except Exception as e:
      print ("parse xml faild!")
      sys.exit()
    else:
      print ("parse xml success!")      
    finally: 
      return self.tree

  def CreateNode(self, tag, attrib, text):
    element = ET.Element(tag, attrib)
    element.text = text
    print ("tag:%s;attrib:%s;text:%s" %(tag, attrib, text))
    return element

  def AddNode(self, Parent, tag, attrib, text):
    element = self.CreateNode(tag, attrib, text)
    if Parent:
      Parent.append(element)
      el = self.root.find("lizhi")
      print (el.tag, "----", el.attrib, "----", el.text)
    else:
      print ("parent is none")

  def WriteXml(self, destfile):
    dest_xml_file = os.path.abspath(destfile)
    self.tree.write(dest_xml_file, encoding="utf-8",xml_declaration=True)


if __name__ == "__main__":
  xml_file = os.path.abspath("test.xml")
  parse = XmlParse(xml_file)
  tree = parse.ReadXml()
  root = tree.getroot()
  print (root)
  parse.AddNode(root, "Python", {"age":"22", "hello":"world"}, "YES")

  parse.WriteXml("testtest.xml")

2.3 xml.sax.*

SAX是一种基于事件驱动的API,利用SAX解析XML牵涉到两个部分:解析器和事件处理器。

解析器负责读取XML文档,并向事件处理器发送事件,如元素开始跟元素结束事件

事件处理器则负责对事件作出相应,对传递的XML数据进行处理

常用场景:

(1)对大型文件进行处理

(2)只需文件的部分内容,或只需从文件中得到特定信息

(3)想建立自己的对象模型

基于事件驱动的SAX解析XML内容的知识后续补充!

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持帮客之家。

1.
XML简介 XML(eXtensible Markup
Language)指可扩展标记语言,被设计用来传输和存储数据,已经日趋成…

1. XML简介

xml.dom篇

XML(eXtensible Markup
Language)指可扩展标记语言,被设计用来传输和存储数据,已经日趋成为当前许多新生技术的核心,在不同的领域都有着不同的应用。它是web发展到一定阶段的必然产物,既具有SGML的核心特征,又有着HTML的简单特性,还具有明确和结构良好等许多新的特性。

    DOM是Document Object Model的简称,XML
文档的高级树型表示。该模型并非只针对 Python,而是一种普通XML
模型。Python 的 DOM 包是基于 SAX 构建的,并且包括在 Python 2.0 的标准
XML 支持里。

test.XML文件

一、xml.dom的简单介绍

<?xml version="1.0" encoding="utf-8"?>
<catalog>
  <maxid>4</maxid>
  <login username="pytest" passwd='123456'>
    <caption>Python</caption>
    <item id="4">
      <caption>测试</caption>
    </item>
  </login>
  <item id="2">
    <caption>Zope</caption>
  </item>
</catalog>

1、主要方法:

XML详细介绍可以参考:

minidom.parse(filename):加载读取XML文件
doc.documentElement:获取XML文档对象
node.getAttribute(AttributeName):获取XML节点属性值
node.getElementsByTagName(TagName):获取XML节点对象集合
node.childNodes :返回子节点列表。
node.childNodes[index].nodeValue:获取XML节点值
node.firstChild:访问第一个节点,等价于pagexml.childNodes[0]
返回Node节点的xml表示的文本:
doc = minidom.parse(filename)
doc.toxml(‘UTF-8’)

2. XML文件解析

访问元素属性:

python解析XML常见的有三种方法:一是xml.dom.*模块,它是W3C DOM
API的实现,若需要处理DOM API则该模块很适合;二是xml.sax.*模块,它是SAX
API的实现,这个模块牺牲了便捷性来换取速度和内存占用,SAX是一个基于事件的API,这就意味着它可以“在空中”处理庞大数量的的文档,不用完全加载进内存;三是xml.etree.ElementTree模块(简称
ET),它提供了轻量级的Python式的API,相对于DOM来说ET
快了很多,而且有很多令人愉悦的API可以使用,相对于SAX来说ET的ET.iterparse也提供了
“在空中”
的处理方式,没有必要加载整个文档到内存,ET的性能的平均值和SAX差不多,但是API的效率更高一点而且使用起来很方便。

Node.attributes[“id”]
a.name #就是上面的 “id”
a.value #属性的值 

2.1 xml.dom.*

2、举例说明

文件对象模型(Document Object
Model,简称DOM),是W3C组织推荐的处理可扩展置标语言的标准编程接口。一个
DOM
的解析器在解析一个XML文档时,一次性读取整个文档,把文档中所有元素保存在内存中的一个树结构里,之后你可以利用DOM
提供的不同的函数来读取或修改文档的内容和结构,也可以把修改过的内容写入xml文件。python中用xml.dom.minidom来解析xml文件。

例1:文件名:book.xml

a. 获得子标签

复制代码 代码如下:

b. 区分相同标签名的标签

<?xml version=”1.0″ encoding=”utf-8″?>
<info>
   <intro>Book message</intro>
    <list id=’001′>
        <head>bookone</head>
        <name>python check</name>
        <number>001</number>
        <page>200</page>
    </list>

c. 获取标签属性值

    <list id=’002′>
        <head>booktwo</head>
        <name>python learn</name>
        <number>002</number>
        <page>300</page>
    </list>

d. 获取标签对之间的数据

</info>

#coding=utf-8

#通过minidom解析xml文件
import xml.dom.minidom as xmldom
import os
''' 
XML文件读取 
<?xml version="1.0" encoding="utf-8"?>
<catalog>
  <maxid>4</maxid>
  <login username="pytest" passwd='123456'>dasdas
    <caption>Python</caption>
    <item id="4">
      <caption>测试</caption>
    </item>
  </login>
  <item id="2">
    <caption>Zope</caption>
  </item>
</catalog>

'''

xmlfilepath = os.path.abspath("test.xml")
print ("xml文件路径:", xmlfilepath)

# 得到文档对象
domobj = xmldom.parse(xmlfilepath)
print("xmldom.parse:", type(domobj))
# 得到元素对象
elementobj = domobj.documentElement
print ("domobj.documentElement:", type(elementobj))

#获得子标签
subElementObj = elementobj.getElementsByTagName("login")
print ("getElementsByTagName:", type(subElementObj))

print (len(subElementObj))
# 获得标签属性值
print (subElementObj[0].getAttribute("username"))
print (subElementObj[0].getAttribute("passwd"))

#区分相同标签名的标签
subElementObj1 = elementobj.getElementsByTagName("caption")
for i in range(len(subElementObj1)):
  print ("subElementObj1[i]:", type(subElementObj1[i]))
  print (subElementObj1[i].firstChild.data) #显示标签对之间的数据

(1)创建DOM对象

输出结果:

复制代码 代码如下:

>>> D:\Pystu>python xml_instance.py
>>> xml文件路径: D:\Pystu\test.xml
>>> xmldom.parse: <class ‘xml.dom.minidom.Document’>
>>> domobj.documentElement: <class
‘xml.dom.minidom.Element’>
>>> getElementsByTagName: <class
‘xml.dom.minicompat.NodeList’>
>>> username: pytest
>>> passwd: 123456
>>> subElementObj1[i]: <class
‘xml.dom.minidom.Element’>
>>> Python
>>> subElementObj1[i]: <class
‘xml.dom.minidom.Element’>
>>> 测试
>>> subElementObj1[i]: <class
‘xml.dom.minidom.Element’>
>>> Zope

import xml.dom.minidom
dom1=xml.dom.minidom.parse(‘book.xml’)

2.2 xml.etree.ElementTree

(2)获取根字节

ElementTree生来就是为了处理XML,它在Python标准库中有两种实现:一种是纯Python实现的,如xml.etree.ElementTree,另一种是速度快一点的xml.etree.cElementTree。注意:尽量使用C语言实现的那种,因为它速度更快,而且消耗的内存更少。

root=dom1.documentElement #这里得到的是根节点
print root.nodeName,’,’,root.nodeValue,’,’,root.nodeType

a. 遍历根节点的下一层

返回结果为:

b. 下标访问各个标签、属性、文本

info , None , 1

c. 查找root下的指定标签

其中:

d. 遍历XML文件

info是指根节点的名称root.nodeName
None是指根节点的值root.nodeValue

e. 修改XML文件

1是指根节点的类型root.nodeType,更多节点类型如下表:

#coding=utf-8

#通过解析xml文件
'''
try:
  import xml.etree.CElementTree as ET
except:
  import xml.etree.ElementTree as ET

从Python3.3开始ElementTree模块会自动寻找可用的C库来加快速度  
'''
import xml.etree.ElementTree as ET
import os
import sys
''' 
XML文件读取 
<?xml version="1.0" encoding="utf-8"?>
<catalog>
  <maxid>4</maxid>
  <login username="pytest" passwd='123456'>dasdas
    <caption>Python</caption>
    <item id="4">
      <caption>测试</caption>
    </item>
  </login>
  <item id="2">
    <caption>Zope</caption>
  </item>
</catalog>
'''

#遍历xml文件
def traverseXml(element):
  #print (len(element))
  if len(element)>0:
    for child in element:
      print (child.tag, "----", child.attrib)
      traverseXml(child)
  #else:
    #print (element.tag, "----", element.attrib)


if __name__ == "__main__":
  xmlFilePath = os.path.abspath("test.xml")
  print(xmlFilePath)
  try:
    tree = ET.parse(xmlFilePath)
    print ("tree type:", type(tree))

    # 获得根节点
    root = tree.getroot()
  except Exception as e: #捕获除与程序退出sys.exit()相关之外的所有异常
    print ("parse test.xml fail!")
    sys.exit()
  print ("root type:", type(root))  
  print (root.tag, "----", root.attrib)

  #遍历root的下一层
  for child in root:
    print ("遍历root的下一层", child.tag, "----", child.attrib)

  #使用下标访问
  print (root[0].text)
  print (root[1][1][0].text)

  print (20 * "*")
  #遍历xml文件
  traverseXml(root)
  print (20 * "*")

  #根据标签名查找root下的所有标签
  captionList = root.findall("item") #在当前指定目录下遍历
  print (len(captionList))
  for caption in captionList:
    print (caption.tag, "----", caption.attrib, "----", caption.text)

  #修改xml文件,将passwd修改为999999
  login = root.find("login")
  passwdValue = login.get("passwd")
  print ("not modify passwd:", passwdValue)
  login.set("passwd", "999999")  #修改,若修改text则表示为login.text
  print ("modify passwd:", login.get("passwd"))

NodeType

Named Constant

1

ELEMENT_NODE

2

ATTRIBUTE_NODE

3

TEXT_NODE

4

CDATA_SECTION_NODE

5

ENTITY_REFERENCE_NODE

6

ENTITY_NODE

7

PROCESSING_INSTRUCTION_NODE

8

COMMENT_NODE

9

DOCUMENT_NODE

10

DOCUMENT_TYPE_NODE

11

DOCUMENT_FRAGMENT_NODE

12

NOTATION_NODE

输出结果:

(3)子元素、子节点的访问

>>> D:\Pystu\test.xml
>>> tree type: <class
‘xml.etree.ElementTree.ElementTree’>
>>> root type: <class
‘xml.etree.ElementTree.Element’>
>>> catalog —- {}
>>> 遍历root的下一层 maxid —- {}
>>> 遍历root的下一层 login —- {‘username’: ‘pytest’,
‘passwd’: ‘123456’}
>>> 遍历root的下一层 item —- {‘id’: ‘2’}
>>> 4
>>> 测试
>>> ********************
>>> maxid —- {}
>>> login —- {‘username’: ‘pytest’, ‘passwd’: ‘123456’}
>>> caption —- {}
>>> item —- {‘id’: ‘4’}
>>> caption —- {}
>>> item —- {‘id’: ‘2’}
>>> caption —- {}
>>> ********************
>>> 1
>>> item —- {‘id’: ‘2’} —-
>>> not modify passwd: 123456
>>> modify passwd: 999999

A、返回root子节点列表

附:

复制代码 代码如下:

#coding=utf-8

'''
  XML解析类
  @功能-结点的增删改查
'''
import xml.etree.ElementTree as ET
import sys
import os.path

class XmlParse:
  def __init__(self, file_path):
    self.tree = None
    self.root = None
    self.xml_file_path = file_path

  def ReadXml(self):
    try:
      print("xmlfile:", self.xml_file_path)
      self.tree = ET.parse(self.xml_file_path)
      self.root = self.tree.getroot()
    except Exception as e:
      print ("parse xml faild!")
      sys.exit()
    else:
      print ("parse xml success!")      
    finally: 
      return self.tree

  def CreateNode(self, tag, attrib, text):
    element = ET.Element(tag, attrib)
    element.text = text
    print ("tag:%s;attrib:%s;text:%s" %(tag, attrib, text))
    return element

  def AddNode(self, Parent, tag, attrib, text):
    element = self.CreateNode(tag, attrib, text)
    if Parent:
      Parent.append(element)
      el = self.root.find("lizhi")
      print (el.tag, "----", el.attrib, "----", el.text)
    else:
      print ("parent is none")

  def WriteXml(self, destfile):
    dest_xml_file = os.path.abspath(destfile)
    self.tree.write(dest_xml_file, encoding="utf-8",xml_declaration=True)


if __name__ == "__main__":
  xml_file = os.path.abspath("test.xml")
  parse = XmlParse(xml_file)
  tree = parse.ReadXml()
  root = tree.getroot()
  print (root)
  parse.AddNode(root, "Python", {"age":"22", "hello":"world"}, "YES")

  parse.WriteXml("testtest.xml")

import xml.dom.minidom
dom1=xml.dom.minidom.parse(‘book.xml’)
root=dom1.documentElement
#print root.nodeName,’,’,root.nodeValue,’,’,root.nodeType
print root.childNodes

2.3 xml.sax.*

运行结果为:

SAX是一种基于事件驱动的API,利用SAX解析XML牵涉到两个部分:解析器和事件处理器。

[<DOM Text node “u’\n   ‘”>, <DOM Element: intro at
0x124ef58>, <DOM Text node “u’\n    ‘”>, <DOM Element: list
at 0x1254058>, <DOM Text node “u’\n\n    ‘”>, <DOM
Element: list at 0x1254418>, <DOM Text node “u’\n\n'”>]

解析器负责读取XML文档,并向事件处理器发送事件,如元素开始跟元素结束事件

B、获取XML节点值,如返回根节点下第二个子节点intro的值和名字,添加下面一句

事件处理器则负责对事件作出相应,对传递的XML数据进行处理

复制代码 代码如下:

常用场景:

print root.childNodes[1].nodeName,root.childNodes[1].nodeValue

(1)对大型文件进行处理

运行结果为:

(2)只需文件的部分内容,或只需从文件中得到特定信息

intro None

(3)想建立自己的对象模型

C、访问第一个节点

基于事件驱动的SAX解析XML内容的知识后续补充!

复制代码 代码如下:

以上就是本文的全部内容,希望对大家的学习有所帮助,也希望大家多多支持脚本之家。

print root.firstChild.nodeName

您可能感兴趣的文章:

  • 用Python解析XML的几种常见方法的介绍
  • Python 解析XML文件
  • Python中使用ElementTree解析XML示例
  • 深入解读Python解析XML的几种方式
  • 详细解读Python中解析XML数据的方法
  • 简单介绍使用Python解析并修改XML文档的方法
  • 详解在Python程序中解析并修改XML内容的方法
  • python网络编程学习笔记(八):XML生成与解析(DOM、ElementTree)
  • python 解析XML
    python模块xml.dom解析xml实例代码

运行结果为:

#text

D、获取已经知道的元素名字的值,如要获取intro后的book
message可以使用下面的方法:

复制代码 代码如下:

import xml.dom.minidom
dom1=xml.dom.minidom.parse(‘book.xml’)
root=dom1.documentElement
#print root.nodeName,’,’,root.nodeValue,’,’,root.nodeType
node= root.getElementsByTagName(‘intro’)[0]
for node in node.childNodes:
    if node.nodeType in (node.TEXT_NODE,node.CDATA_SECTION_NODE):
        print node.data

这种方法的不足之处是需要对类型进行判断,使用起来不是很方便。运行结果是:

Book message

二、xml解析

对上面的xml进行解析

方法1 代码如下:

复制代码 代码如下:

#@小五义
#xml 解析

import xml.dom.minidom
dom1=xml.dom.minidom.parse(‘book.xml’)
root=dom1.documentElement
book={}
booknode=root.getElementsByTagName(‘list’)
for booklist in booknode:
    print ‘=’*20
    print ‘id:’+booklist.getAttribute(‘id’)
    for nodelist in  booklist.childNodes:
        if nodelist.nodeType ==1:
            print nodelist.nodeName+’:’,
        for node in nodelist.childNodes:
            print node.data

运行结果为:

====================
id:001
head: bookone
name: python check
number: 001

page: 200

id:002
head: booktwo
name: python learn
number: 002
page: 300

方法二:

代码:

复制代码 代码如下:

#@小五义
#xml 解析

import xml.dom.minidom
dom1=xml.dom.minidom.parse(‘book.xml’)
root=dom1.documentElement
book={}
booknode=root.getElementsByTagName(‘list’)
for booklist in booknode:
    print ‘=’*20
    print ‘id:’+booklist.getAttribute(‘id’)
    print
‘head:’+booklist.getElementsByTagName(‘head’)[0].childNodes[0].nodeValue.strip()
    print
‘name:’+booklist.getElementsByTagName(‘name’)[0].childNodes[0].nodeValue.strip()
    print
‘number:’+booklist.getElementsByTagName(‘number’)[0].childNodes[0].nodeValue.strip()
    print
‘page:’+booklist.getElementsByTagName(‘page’)[0].childNodes[0].nodeValue.strip()

 运行结果与方法一一样。比较上面的两个方法,方法一根据xml的树结构进行了多次循环,可读性上不及方法二,方法直接对每一个节点进行操作,更加清晰。为了更加方法程序的调用,可以使用一个list加一个字典进行存储,具体见方法3:

复制代码 代码如下:

#@小五义
#xml 解析
import xml.dom.minidom
dom1=xml.dom.minidom.parse(‘book.xml’)
root=dom1.documentElement
book=[]
booknode=root.getElementsByTagName(‘list’)
for booklist in booknode:
    bookdict={}
    bookdict[‘id’]=booklist.getAttribute(‘id’)
   
bookdict[‘head’]=booklist.getElementsByTagName(‘head’)[0].childNodes[0].nodeValue.strip()
   
bookdict[‘name’]=booklist.getElementsByTagName(‘name’)[0].childNodes[0].nodeValue.strip()
   
bookdict[‘number’]=booklist.getElementsByTagName(‘number’)[0].childNodes[0].nodeValue.strip()
   
bookdict[‘page’]=booklist.getElementsByTagName(‘page’)[0].childNodes[0].nodeValue.strip()
    book.append(bookdict)
print book

运行结果为:

[{‘head’: u’bookone’, ‘page’: u’200′, ‘number’: u’001′, ‘id’: u’001′,
‘name’: u’python check’}, {‘head’: u’booktwo’, ‘page’: u’300′, ‘number’:
u’002′, ‘id’: u’002′, ‘name’: u’python learn’}]

该列表里包含了两个字典。

三、建立XML文件
这里用方法三得到的结果,建立一个xml文件。

复制代码 代码如下:

# -*- coding: cp936 -*-
#@小五义
#xml 创建

import xml.dom
def create_element(doc,tag,attr):
    #创建一个元素节点
    elementNode=doc.createElement(tag)
    #创建一个文本节点
    textNode=doc.createTextNode(attr)
    #将文本节点作为元素节点的子节点
    elementNode.appendChild(textNode)
    return elementNode

dom1=xml.dom.getDOMImplementation()#创建文档对象,文档对象用于创建各种节点。
doc=dom1.createDocument(None,”info”,None)
top_element = doc.documentElement# 得到根节点
books=[{‘head’: u’bookone’, ‘page’: u’200′, ‘number’: u’001′, ‘id’:
u’001′, ‘name’: u’python check’}, {‘head’: u’booktwo’, ‘page’: u’300′,
‘number’: u’002′, ‘id’: u’002′, ‘name’: u’python learn’}]
for book in books:
    sNode=doc.createElement(‘list’)
    sNode.setAttribute(‘id’,str(book[‘id’]))
    headNode=create_element(doc,’head’,book[‘head’])
    nameNode=create_element(doc,’name’,book[‘name’])
    numberNode=create_element(doc,’number’,book[‘number’])
    pageNode=create_element(doc,’page’,book[‘page’])
    sNode.appendChild(headNode)
    sNode.appendChild(nameNode)
    sNode.appendChild(pageNode)
    top_element.appendChild(sNode)# 将遍历的节点添加到根节点下
xmlfile=open(‘bookdate.xml’,’w’)
doc.writexml(xmlfile,addindent=’ ‘*4, newl=’\n’, encoding=’utf-8′)
xmlfile.close()

运行后生成bookdate.xml文件,该文件与book.xml一样。

 xml.etree.ElementTree篇

依然使用例1的例子,对xml进行解析分析。

1、加载XML

方法一:直接加载文件

复制代码 代码如下:

import xml.etree.ElementTree
root=xml.etree.ElementTree.parse(‘book.xml’)

方法二:加载指定字符串

复制代码 代码如下:

import xml.etree.ElementTree
root =
xml.etree.ElementTree.fromstring(xmltext)这里xmltext是指定的字符串。

2、获取节点

方法一 利用getiterator方法得到指定节点

book_node=root.getiterator(“list”)

方法二
利用getchildren方法得到子节点,如例1中,要得到list下面子节点head的值:

复制代码 代码如下:

#@小五义 xml.etree.ElementTree
root=xml.etree.ElementTree.parse(‘book.xml’)
book_node=root.getiterator(“list”)
for node in book_node:
    book_node_child=node.getchildren()[0]
    print book_node_child.tag+’:’+book_node_child.text

运行结果为:

head:bookone
head:booktwo

方法三 使用find和findall方法

 find方法找到指定的第一个节点:

复制代码 代码如下:

# -*- coding: cp936 -*-
#@小五义
import xml.etree.ElementTree
root=xml.etree.ElementTree.parse(‘book.xml’)
book_find=root.find(‘list’)
for note in book_find:
    print note.tag+’:’+note.text

运行结果:

head:bookone
name:python check
number:001
page:200

findall方法将找到指定的所有节点:

复制代码 代码如下:

# -*- coding: cp936 -*-
#@小五义
import xml.etree.ElementTree
root=xml.etree.ElementTree.parse(‘book.xml’)
book=root.findall(‘list’)
for book_list in book:
    for note in book_list:
        print note.tag+’:’+note.text

运行结果:

head:bookone
name:python check
number:001
page:200
head:booktwo
name:python learn
number:002
page:300

3、对book.xml进行解析的实例

复制代码 代码如下:

# -*- coding: cp936 -*-
#@小五义
import xml.etree.ElementTree
root=xml.etree.ElementTree.parse(‘book.xml’)
book=root.findall(‘list’)
for book_list in book:
    print ‘=’*20
    if  book_list.attrib.has_key(‘id’):
        print “id:”+book_list.attrib[‘id’]
    for note in book_list:
        print note.tag+’:’+note.text
print ‘=’*20

运行结果为:

====================
id:001
head:bookone
name:python check
number:001

page:200

id:002
head:booktwo
name:python learn
number:002

page:300

注意:
当要获取属性值时,如list id=’001′,用attrib方法。
当要获取节点值时,如<head>bookone</head>中的bookone用text方法。
当要获取节点名时,用tag方法。

DOM是Document Object Model的简称,XML
文档的高级树型表示。该模型并非只针对 Python,而是一种普通XML
模型。Python 的 DOM 包是基于 SAX…

Author

发表评论

电子邮件地址不会被公开。 必填项已用*标注