python创建并解析xml文件

转载：http://blog.csdn.net/seetheworld518/article/details/49535211

常见的XML编程接口有DOM和SAX，这两种接口处理XML文件的方式不同，当然是用是用场合也不同。 
Python有三种方法解析XML：

• SAX（不常用）
• DOM
• ElementTree

SAX（simple API for XML）

Python标准库中包含SAX解析器，SAX是用的是事件驱动模型，通过在解析XML过程中触发一个个的事件并调用用户定义的回调函数来处理XML文件。 
解析的基本过程： 
读到一个XML开始标签，就会开始一个事件，然后事件就会调用一系列的函数去处理一些事情，当读到一个结束标签时，就会触发另一个事件。所以，我们写XML文档入如果有格式错误的话，解析就会出错。 
这是一种流式处理，一边读一边解析，占用内存少，可以处理一些大的文件，但是把大文件读到缓存中缓存起来就比较难，这样就会影响效率。

DOM（Document Object Model）

将XML数据在内存中解析成一个树，通过对树的操作来操作XML。 
由于DOM是将XML读取到内存，然后解析成一个树，如果要处理的XML文本比较大的话，就会很耗内存，所以DOM一般偏向于处理一些小的XML，（如配置文件）比较快，

ElementTree（Object Model）

ElementTree就像一个轻量级的DOM，具有方便而友好的API。代码的可用性好、速度快、消耗内存少。可以认为是对DOM的改进。

XML解析基本思路是

现将xml文档内容一次性全部读入内存并解析成树结构，然后拿到这个树结构的根结点，然后我们就可以通过调用解析XML的一些函数来操作这个树了，也就是操作xml文档数据。

xml.dom解析xml

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

<?xml version="1.0" encoding="utf-8" ?>
<!--this is a test about xml.-->
<booklist type="science and engineering">
    <book category="math">
        <title>learning math</title>
        <author>张三</author>
        <pageNumber>561</pageNumber>
    </book>
    <book category="Python">
        <title>learning Python</title>
        <author>李四</author>
        <pageNumber>600</pageNumber>
    </book>
</booklist>

 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

使用Python的xml.dom.minidom模块来解析这个xml文件：

#!/usr/bin/python
#coding=utf-8
import xml.dom.minidom
from xml.dom.minidom import parse #从xml.dom.minidom模块引入解析器parse

#minidom解析器打开xml文档并将其解析为内存中的一棵树
DOMTree = xml.dom.minidom.parse(r"C:\book.xml")
#获取xml文档对象，就是拿到树的根
booklist = DOMTree.documentElement
if booklist.hasAttribute("type") : 
  #判断根节点booklist是否有type属性，有则获取并打印属性的值
  print "Root element is", booklist.getAttribute("type")

#获取booklist对象中所有book节点的list集合
books = booklist.getElementsByTagName("book")
print "book节点的个数：", books.length

for book in books :
  print "*******************book*******************"
  if book.hasAttribute("category") :
    print "category is", book.getAttribute("category")

  #根据结点名title拿到这个book结点下所有的title结点的集合list。
  #[0]表示第一个title标签，因为一个<book>...</book>之间可能会
  #定义多个title标签 
  title = book.getElementsByTagName('title')[0]
  print "Title is", title.childNodes[0].data

  author = book.getElementsByTagName('author')[0]
  print "author is", author.childNodes[0].data

  pageNumber = book.getElementsByTagName('pageNumber')[0]
  print "pageNumber is", pageNumber.childNodes[0].data

 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

执行结果：

Root element is science and engineering
book节点的个数： 2
*******************book*******************
category is math
Title is learning math
author is 张三
pageNumber is 561
*******************book*******************
category is Python
Title is learning Python
author is 李四
pageNumber is 600

 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13

由于xml的标签、属性都是程序员自已定义的，所以一个标签下可以出现多个同名的标签，就像上面的的标签或者是像下面这样：

<booklist type="science and engineering">
    <book category="math">
        <title>learning math</title>
        <title>title test</title>
        <author>张三</author>
        <pageNumber>561</pageNumber>
    </book>
</booklist>

 
 
1
2
3
4
5
6
7
8
9
 
 
1
2
3
4
5
6
7
8
9

上面解析xml的程序中，getElementsByTagName()函数返回的是同一父节点下所有同级（即兄弟节点）节点中相同标签的集合（就像上面的两个标签一样），这是一个list对象，所以可以使用list序列所有操作。这个时候，我们可以通过索引去拿相应的节点，也可以使用节点名称去拿相应的节点，推荐第二种方法，准确。也可以通过循环遍历整个返回的list。

xml.dom模块解析xml的部分API函数

• minidom.parse()

函数原型：

parse(file, parser=None, bufsize=None)
    Parse a file into a DOM by filename or file object.

 
 
1
2
3
 
 
1
2
3

函数作用是使用parse解析器打开xml文档并将其解析为一个DOM文档，也就是内存中的一棵树。

• doc.documentElement 
  获取xml文档对象，就是拿到树的根。

• doc.toxml()

函数原型：

toxml(self, encoding=None) method of xml.dom.minidom.Document instance
 
 
1
 
 
1

返回xml的文本内容。如：

>>> DOMTree.toxml('utf-8')
'<?xml version="1.0" encoding="utf-8"?><!--this is a test about xml.--><booklisttype="science and engineering">\n    <book category="math">\n        <title>learning math</title>\n        <author>\xe5\xbc\xa0\xe4\xb8\x89</author>\n        <pageNumber>561</pageNumber>\n    </book>\n    <book category="Python">\n
<title>learning Python</title>\n        <author>\xe6\x9d\x8e\xe5\x9b\x9b</author>\n        <pageNumber>600</pageNumber>\n    </book>\n</booklist>'

 
 
1
2
3
4
 
 
1
2
3
4

如果我们只知道xml文件名，不知道里面的内容，就可以使用这个函数查看。

• node.hasAttribute()

函数原型：

hasAttribute(self, name) method of xml.dom.minidom.Element instance
 
 
1
 
 
1

判断某个节点node是否存在某个属性，存在返回True，否则返回False。如：

if booklist.hasAttribute("type") :
 
 
1
 
 
1

注：这里用的实例是book.xml文档中的。下同

• node. getAttribute() 
  原型：

getAttribute(self, attname) method of xml.dom.minidom.Element instance
 
 
1
 
 
1

获取节点node的某个属性的值。如：

print "Root element is", booklist.getAttribute("type")
 
 
1
 
 
1

• node.getElementsByTagName()

原型：

getElementsByTagName(self, name) method of xml.dom.minidom.Element instance
 
 
1
 
 
1

获取XML文档中节点对象集合。如：

books = booklist.getElementsByTagName("book")
 
 
1
 
 
1

表示获取booklist节点下所有节点名为book组成的对象集合，这是一个list，因此list所有的操作都可以用于它。

• node.childNodes 
  返回node下所有子节点组成的list。如查看节点下的子节点：

>>> books[0].childNodes
[<DOM Text node "u'\n        '">, <DOM Element: title at 0x2830988>, <DOM Text node "u'\n        '">, <DOM Element: author at 0x2830708>, <DOM Text node "u'\n        '">, <DOM Element: pageNumber at 0x28307c8>, <DOM Text node "u'\n    '">]

 
 
1
2
3
 
 
1
2
3

从结果看出，列表中第一个元素是books[0]这个标签下一个文本子节点（默认就是有的），里面存的是该节点的值，此处由于是一个父节点，没有设置值，所以为回车符。 
如：

print author.childNodes
[<DOM Text node "u'\u674e\u56db'">]

 
 
1
2
3
 
 
1
2
3

由于叶子节点下没有子节点了，所以只返回了该叶子节点默认的文本子节点。 
这样就算我们不知道原xml文档结构怎样，就可以使用这个函数来一层层的查看xml文档中的节点。

• node.childNodes[index].data

获取节点的值。如：

print "Title is", title.childNodes[0].data
 
 
1
 
 
1

• node .hasChildNodes()

判断节点node下是否有叶子节点，如有返回True，否则返回False，但是需要注意的是，每个节点都默认有一个文本叶子节点，所以只要标签后有值，就会返回True，只有当标签后没值时才会返回False。如：

print author.hasChildNodes()
 
 
1
 
 
1

原xml文件中author标签下没有子标签，但是有值，所以返回结果是True。下面的情况就会返回False：

<author></author>
 
 
1
 
 
1

有了这个函数，我们可以在不知道xml文档结构的情况下操作xml文档了。

如果还想使用其他的函数，可以使用dir()或help()函数查看各个类拥有的方法和属性。

xml.dom.minidom模块实现创建一个XML文档。

创建XML的过程

1、内存数据产生 
2、产生xml内存对象（也就是DOM树） 
3、产生根对象 
4、往根对象里加数据 
5、把xml内存对象写到文件 
下面是一个创建xml文档的简单实例：

import xml.dom.minidom

#在内存中创建一个空的文档
doc = xml.dom.minidom.Document() 
#创建一个根节点Managers对象
root = doc.createElement('Managers') 
#设置根节点的属性
root.setAttribute('company', 'xx科技') 
root.setAttribute('address', '科技软件园') 
#将根节点添加到文档对象中
doc.appendChild(root) 

managerList = [{'name' : 'joy',  'age' : 27, 'sex' : '女'},
               {'name' : 'tom', 'age' : 30, 'sex' : '男'},
               {'name' : 'ruby', 'age' : 29, 'sex' : '女'}
]

for i in managerList :
  nodeManager = doc.createElement('Manager')
  nodeName = doc.createElement('name')
  #给叶子节点name设置一个文本节点，用于显示文本内容
  nodeName.appendChild(doc.createTextNode(str(i['name'])))

  nodeAge = doc.createElement("age")
  nodeAge.appendChild(doc.createTextNode(str(i["age"])))

  nodeSex = doc.createElement("sex")
  nodeSex.appendChild(doc.createTextNode(str(i["sex"])))

  #将各叶子节点添加到父节点Manager中，
  #最后将Manager添加到根节点Managers中
  nodeManager.appendChild(nodeName)
  nodeManager.appendChild(nodeAge)
  nodeManager.appendChild(nodeSex)
  root.appendChild(nodeManager)
#开始写xml文档
fp = open('c:\\wcx\\Manager.xml', 'w')
doc.writexml(fp, indent='\t', addindent='\t', newl='\n', encoding="utf-8")

 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

执行结果：

<?xml version="1.0" encoding="utf-8"?>
    <Managers address="科技软件园" company="xx科技">
        <Manager>
            <name>joy</name>
            <age>27</age>
            <sex>女</sex>
        </Manager>
        <Manager>
            <name>tom</name>
            <age>30</age>
            <sex>男</sex>
        </Manager>
        <Manager>
            <name>ruby</name>
            <age>29</age>
            <sex>女</sex>
        </Manager>
    </Managers>

 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

用Python自带的写xml文档的API去写，比较方便，后期容易维护。如果直接用打开文件的方式，一行一行的去写，比较费时，也难以维护。

xml.dom模块创建xml的部分API

• minidom.Document()

创建一个空白xml文档树对象。 
每个xml文档都是一个Document对象，代表着内存中的DOM树。

• doc. createElement(tagName) 
  生成xml文档节点。参数表示要生成节点的名称。 
  如：（注意这里使用的例子都来自于上面创建xml文档的程序中，下同）

#创建一个根节点Managers对象
root = doc.createElement('Managers')

 
 
1
2
3
 
 
1
2
3

• node.setAttribute(attname, value)

给节点添加属性值对(Attribute)。 
参数说明： 
attname ：属性的名称 
value ：属性的值 
如： 
设置根节点的属性：

root.setAttribute('company', 'xx科技')
 
 
1
 
 
1

• doc.createTextNode(data)

给叶子节点添加文本节点。如：

#给叶子节点name设置一个文本节点，用于显示文本内容
  nodeName.appendChild(doc.createTextNode(str(i['name'])))

 
 
1
2
3
 
 
1
2
3

• node.appendChild(node1)

将节点node1t添加到节点node下。如：

#将叶子节点nodeName添加到父节点nodeManager下
nodeManager.appendChild(nodeName)

 
 
1
2
3
 
 
1
2
3

• doc. writexml()

函数原型：

writexml(writer, indent='', addindent='', newl='', encoding=None)
 
 
1
 
 
1

将内存中xml文档树写入文件中。 
参数说明： 
writer ：要写的目标文件的文件对象。 
indent ：

fp = open('c:\\Manager.xml', 'w')
doc.writexml(fp, indent='', addindent='\t', newl='\n', encoding="utf-8")