整理网上python解析xml文件相关资料汇总

  查看文章  

[原创]python--------xml 读写 修改 删除
2011-11-25 13:37
python本身的模块用的不是很顺手，所以就顺手封装了个类，这下顺手了，我顺手不代表其他人用的顺手，因为不是教程贴，所以有时间在解释下这个程序

#!/usr/bin/python

# coding=gbk

'''

Created on 2011-11-22

 

@author: Sruing

'''

 

import xml.etree.ElementTree as etree

import os

 

#全局变量用于返回找到的节点

resultOfChild = ''

resultOfParents = ''

#---------------------------------------------------------------------------------------------

class handleXML():

    #初始化类

    def __init__(self,fileName):

        #读入的文件名

        self.fileName = fileName

        #判断XML是否存在

        #存在

        if os.path.isfile(self.fileName) == True:

            #解析XML文件 

            self.tree = etree.parse(self.fileName)

        #不存在

        else:

            #文件不存在创建新文件

            print "The file doesn't exist! please input a tagname for root.\n"

            self.rootTagName = raw_input("Your root here:\n")

            self.creatRootTag(self.rootTagName)

            print "The file have been successfully created!"

            #解析创建的文件

            self.tree = etree.parse(self.fileName)

        #获取XML树的root

        self.root = self.tree.getroot()

        #用于删除节点是标记子节点

        self.exits = False

        #

        return

#----------------------------------------------------------------------------------------------- 

    #文件不存在在类初始化中调用此方法，创建根节点

    def creatRootTag(self,rootTagName):

        #新建文件内容

        self.fileContent = "<" + rootTagName + ">" + "</" + rootTagName + ">"

        xmlFile = file(self.fileName,'w')

        xmlFile.write(self.fileContent)

        xmlFile.close()

        return

#--------------------------------------------------------------------------------------------------

    #寻找指定的节点

    def findTag(self,tag,initRoot = ""):

        global resultOfChild

        #默认参数为空为从根节点查找

        if initRoot is "":initRoot = self.root

        #递归退出条件

        if resultOfChild is '':

            #查找当前节点下的子节点

            for self.children in initRoot.getchildren():

                if self.children.tag == tag:

                    resultOfChild = self.children

                    break

                else:

                    self.findTag(tag,self.children)

        #返回找到的节点

        return resultOfChild

#--------------------------------------------------------------------------------------------------

    #寻找指定节点的父节点

    def findFatherTag(self,tag,initRoot = ""):

        global resultOfParents

        #默认参数为空为从根节点查找

        if initRoot is "":initRoot = self.root

        #递归退出条件

        if resultOfParents is '':

            #查找当前节点下的子节点

            for self.children in initRoot.getchildren():

                if self.children.tag == tag:

                    resultOfParents = initRoot

                    break

                else:

                    self.findFatherTag(tag,self.children)

        #返回找到的节点的父节点

        return resultOfParents

#--------------------------------------------------------------------------------------------------

    #创建根节点的直接子节点

    def creatDirectSubTag(self,subTag):

        self.subTag = subTag

        etree.SubElement(self.root,self.subTag)

        self.tree.write(self.fileName)

        return

#--------------------------------------------------------------------------------------------------      

    #创建根节点的非直接子节点

    def creatIndirectSubTag(self,fatherTag,SonTag):

        #self.fatherTag = self.tree.findall(fatherTag)

        self.fatherTag = self.findTag(fatherTag)

        #print type(self.findTag(fatherTag))

        self.SonTag = SonTag

        #etree.SubElement(self.fatherTag[0], self.SonTag)

        etree.SubElement(self.fatherTag, self.SonTag)

        self.tree.write(self.fileName)

        return

#---------------------------------------------------------------------------------------------------   

    #添加节点属性

    def addNodeAttribute(self,tag,attribute,value):

        self.tag = self.findTag(tag)

        #print type(self.tag)

        self.attribute = attribute

        self.value = value

        self.tag.set(self.attribute,self.value)

        self.tree.write(self.fileName)

        return

#----------------------------------------------------------------------------------------------------  

    #添加节点文本

    def addNodeText(self,tag,text):

        self.tag = self.findTag(tag)

        #print type(self.tag)

        self.text = text

        self.tag.text = self.text

        self.tree.write(self.fileName)

        return

#------------------------------------------------------------------------------------------------------

    #删除节点

    def delNode(self,tag):

        self.fatherTag = self.findFatherTag(tag)

        #print self.fatherTag

        self.sonTag = self.findTag(tag)

        #print self.sonTag

        self.fatherTag.remove(self.sonTag)

        self.tree.write(self.fileName)

        return

#-------------------------------------------------------------------------------------------------------
 

 

 

请问用python怎么修改xml的节点值？

如：<string>win xp</string>怎么把win xp修改为xin 7.
最佳答案

from xml.etree import ElementTree
filePath = 'd:\\aaa.xml'
xmldoc = ElementTree.parse(filePath)
node = xmldoc.find('./string')
node.text = "win 7"

追问
我这样写之后，为什么我的xml里的值没有变化？
回答
他是改变不了原xml里的值的,需要你写到一个新的xml文件里
xmldoc.write(path)
 

 

 

 

python之操作xml文件
 
小鱼儿 发表于 2007-10-18 14:29:00
 

假设有一下xml文件：
Sample.xml
<?xml version="1.0" encoding="utf-8"?>
<configuration>
<policy-list>
<policy id="123456">
<group>1</group>
</policy>
</policy-list>
</configuration>

from elementtree.ElementTree as ET
如果你使用的是python2.5的话：
import xml.etree.ElementTree as ET

tree = ET.parse("path/to/Sample.xml")
doc = tree.getroot()         #获得根

元素的标签名字 : print doc.tag  #@result: configuration
Element text: print doc.text  #@result: "\n"  如果所有元素是一行的话，结果为空

子元素

迭代子元素: for child in doc
for child in doc:
    print child.tag        #@result: policy-list 自由policy-list一个子元素
获得第1、2个子元素: doc[0:2]
获得节点的子元素：elem.getchildren() 返回这个节点的子元素(list)
获得名为policy-list的元素: doc.find('policy-list')
这里需要注意，由于doc是root的元素，这里不能用doc.find("policy")，来找到policy这个节点，尽管代码不会报错，但是获得是"NoneType" object,如果你调用这个对象的方法，便会报错，比如 policy = doc.find("policy")   policy.find("group")，第一句不会报错，但是第二句就会报错，因为policy是一个NoneType object
append(), remove(), insert()方法
g2 = ET.Element("group")
g2.text = "3"
p2 = ET.Element("policy")
p2.set("id","122334")
p2.append(g2)  #policy下面增加一个group节点
policylist = doc.find("policy-list")
policylist.append(p2) #policy-list下面增加一个policy节点
tree.write("path/to/Sample.xml") #写入文件

insert(index,elem) #在制定的index插入一个元素

del elem[n] #删除第n个节点
elem.remove(elem2) #从节点elem中删除elem2子节点

getiterator(tag) 返回一个列表，或者另外一个迭代对象
节点的属性操作

获得节点的属性key列表: policy.keys()#@result: ["id"]
获得节点的属性数组: policy.items()   #@result: ["id","123456"]
测试节点是否包含某个属性(NAME):
if policy.get('NAME') is not None, or
if 'NAME' in book.attrib
获得属性 id的值:
policy.attrib.get('id'), or
policy.get('id')
给属性赋值: policy.set('Name', 'httppolicy')
保存修改后的文件 tree.write("path/to/Sample.xml")
另外几种保存方法，上面这种保存的文件是ascii格式的，如果要保存为utf-8的，可以用这种方式，
f = open("path/to/Sample.xml","w")
tree.write(f,"utf-8")
创建节点
elem.makeelement(tag,attr_dict)
example: feed = root.makeelement('feed',{'version':'0.22'})

ET.Element(tag,attr_dict,**extra)
policy = ET.Element("policy",{"id":"12121"})

ET.SubElement(parent,tag,attr_dict,**extra)
group = ET.SubElement(policy,"group")

 
 

 

 

from xml.etree.ElementTree import ElementTree
from xml.etree.ElementTree import Element
from xml.etree.ElementTree import SubElement
from xml.etree.ElementTree import dump
from xml.etree.ElementTree import Comment
from xml.etree.ElementTree import tostring

'''
<?xml version="1.0"?>
<PurchaseOrder>
  <account refnum="2390094"/>
  <item sku="33-993933" qty="4">
    <name>Potato Smasher</name>
    <description>Smash Potatoes like never before.</description>
  </item>
</PurchaseOrder>
'''

## Writing the content to xml document
book = ElementTree()

purchaseorder = Element('PurchaseOrder')
book._setroot(purchaseorder)

SubElement(purchaseorder,  'account', {'refnum' : "2390094"})

item = Element("item", {'sku' : '33-993933', 'qty' : '4'})
purchaseorder.append(item)
print item.items()       # [('sku', '33-993933'), ('qty', '4')]
print item.attrib        # {'sku': '33-993933', 'qty': '4'}
print item.get('sku')    # 33-993933
SubElement(item, 'name').text = "Potato Smasher"
SubElement(item, 'description').text = "Smash Potatoes like never before."

#book.write('book.xml',"utf-8")

#print tostring(purchaseorder)

#import sys
#book.write(sys.stdout)

#dump(book)

## Displaying the content of the xml document
print purchaseorder.find('account')
print purchaseorder.find('account').get('refnum')
print purchaseorder.findall('account')[0].get('refnum')

print purchaseorder.find('item/name')
print purchaseorder.find('item/name').text

## How to use ElementTree([element,] [file])
## 1. From standard XML element, it becomes root element
print ElementTree(item).getroot().find('name').text
## 2. From XML file
print ElementTree(file='book.xml').getroot().find('item/description').text

## Create an iterator
for element in purchaseorder.getiterator():
    print element.tag

## Get pretty look
def indent(elem, level=0):
    i = "\n" + level*"  "
    if len(elem):
        if not elem.text or not elem.text.strip():
            elem.text = i + "  "
        for e in elem:
            indent(e, level+1)
        if not e.tail or not e.tail.strip():
            e.tail = i
    if level and (not elem.tail or not elem.tail.strip()):
        elem.tail = i
    return elem

if __name__=="__main__":
    dump(indent(purchaseorder))
    book.write('book.xml',"utf-8")

 

一、基本知识
1、插入节点
Element.insert(index, element) 、ET.SubElement(parent, tag[, attrib[, **extra]]) 、Element.append(subelement)
2、删除节点
Element.remove(subelement) 删除一个节点、Element.clear()删除该节点下所有子节点
3、在节点中插入属性
Element.set(key, value)

二、示例

Java代码 
# -*- coding:UTF-8 -*-  
 
import xml.etree.ElementTree as ET  
import xml.dom.minidom as minidom  
 
#获取根节点  
def getRoot(xmlpath):  
    '''  
    xmlpath:xml文件的路径  
    '''  
    root = ET.parse(xmlpath).getroot()  
    return root  
 
#格式化输出xml文件  
def display(root):  
      
    rough_string = ET.tostring(root, 'utf-8')  
    reparsed = minidom.parseString(rough_string)  
    print reparsed.toprettyxml(indent="  " , encoding="utf-8");  
 
 
if __name__ == '__main__':  
      
    root = ET.Element('bookList')  
      
    #==============添加节点========================  
    #向root节点下插入节点<book id='ISO001'>  
    bookE = ET.SubElement(root,'book')#方式一  
    bookE.set('id', 'ISO001')#为节点添加属性  
    #向<book>节点下插入<author>Gaosilin</version>节点  
    authorE = ET.Element('author')  
    authorE.text = 'Gaosilin'#为节点赋值  
    bookE.append(authorE)#方式二  
    ##向<book>节点下插入<name>Java</name>节点  
    nameE = ET.Element('name')  
    nameE.text = 'java' 
    bookE.insert(1,nameE)#方式三  
    #修改  
    nameE.text = '修改后的C' 
    display(root)  
    #==============删除节点========================  
    bookE.remove(nameE)#注意需删除的节点一定要是该父节点的下一级节点  
    bookE.remove(authorE)  
    bookE.clear()#删除该节点下的所有子节点，等价于上两句  
    root.remove(bookE)  
#    root.remove(nameE)#出错：因为nameE的上一级节点是bookE而不是root  
    display(root)
 

 

[Python学习]使用minidom来处理XML的示例(一)–XML的读取
 

在 NewEdit 中有代码片段的功能，代码片段分为片段的分类和片段的内容。在缺省情况下都是用XML格式保存的。下面我讲述一下，如何使用minidom来读取和保存XML文件。

下面是片段分类的一个示例文件–catalog.xml

<?xml version=”1.0″ encoding=”utf-8″?>
<catalog>
    <maxid>4</maxid>
    <item id=”1″>
        <caption>Python</caption>
        <item id=”4″>
            <caption>测试</caption>
        </item>
    </item>
    <item id=”2″>
        <caption>Zope</caption>
    </item>
</catalog>

分类是树状结构，显示出来可能为：

Python
    测试
Zope

先简单介绍一下XML的知识，如果你已经知道了可以跳过去。

1. XML文档的编码

此XML文档的编码为utf-8，因此你看到的“测试”其实是UTF-8编码。在XML文档的处理中都是使用UTF-8编码进行的，因此，如果你不写明encoding的话，都是认为文件是UTF-8编码的。在Python中，好象只支持几种编码，象我们常用的GB2312码就不支持，因此建议大家在处理XML时使用UTF-8编码。

2. XML文档的结构

XML文档有XML头信息和XML信息体。头信息如：

<?xml version=”1.0″ encoding=”utf-8″?>

它表明了此XML文档所用的版本，编码方式。有些复杂的还有一些文档类型的定义(DOCTYPE)，用于定义此XML文档所用的DTD或Schema和一些实体的定义。这里并没有用到，而且我也不是专家，就不再细说了。

XML信息体是由树状元素组成。每个XML文档都有一个文档元素，也就是树的根元素，所有其它的元素和内容都包含在根元素中。

3. DOM

DOM是Document Object Model的简称，它是以对象树来表示一个XML文档的方法，使用它的好处就是你可以非常灵活的在对象中进行遍历。

4. 元素和结点

元素就是标记，它是成对出现的。XML文档就是由元素组成的，但元素与元素之间可以有文本，元素的内容也是文本。在minidom中有许多的结点，元素也属于结点的一种，它不是叶子结点，即它存在子结点；还存在一些叶子结点，如文本结点，它下面不再有子结点。

象catalog.xml中，文档元素是catalog，它下面有两种元素：maxid和item。maxid用来表示当前最大的item的id值。每一个item都有一个id属性，id属性是唯一的，在 NewEdit 中用来生成每个分类所对应的代码片段的XML文档名，因此不能重复，而且它是一个递增的值。item元素有一个caption子元素，用来表示此分类项的名称，它还可以包含item元素。这样，就定义了一个树状XML结构，下面让我们看一看如果把它们读出来。

一、得到dom对象

>>> import xml.dom.minidom
>>> dom = xml.dom.minidom.parse(‘d:/catalog.xml’)

这样我们得到了一个dom对象，它的第一个元素应该是catalog。

二、得到文档元素对象

>>> root = dom.documentElement

这样我们得到了根元素(catalog)。

三、结点属性

每一个结点都有它的nodeName，nodeValue，nodeType属性。nodeName为结点名字。

>>> root.nodeName
u’catalog’

nodeValue是结点的值，只对文本结点有效。nodeType是结点的类型，现在有以下几种：

‘ATTRIBUTE_NODE’
‘CDATA_SECTION_NODE’
‘COMMENT_NODE’
‘DOCUMENT_FRAGMENT_NODE’
‘DOCUMENT_NODE’
‘DOCUMENT_TYPE_NODE’
‘ELEMENT_NODE’
‘ENTITY_NODE’
‘ENTITY_REFERENCE_NODE’
‘NOTATION_NODE’
‘PROCESSING_INSTRUCTION_NODE’
‘TEXT_NODE’

这些结点通过名字很好理解。catalog是ELEMENT_NODE类型。

>>> root.nodeType
1
>>> root.ELEMENT_NODE
1

四、子元素、子结点的访问

访问子元素、子结点的方法很多，对于知道元素名字的子元素，可以使用getElementsByTagName方法，如读取maxid子元素：

>>> root.getElementsByTagName(‘maxid’)
[<DOM Element: maxid at 0xb6d0a8>]

这样返回一个列表，由于我们的例子中maxid只有一项，因此列表也只有一项。

如果想得到某个元素下的所有子结点(包括元素)，可以使用childNodes属性：

>>> root.childNodes
[<DOM Text node "\n    ">, <DOM Element: maxid at 0xb6d0a8>, <DOM Text node "\n    ">, <DOM Element: item at 0xb6d918>, <DOM Text node "\n    ">, <DOM Element: item at 0xb6de40>, <DOM Text node "\n    ">, <DOM Element: item at 0xb6dfa8>, <DOM Text node "\n">]

可以看出所有两个标记间的内容都被视为文本结点。象每行后面的回车，都被看到文本结点。从上面的结果我们可以看出每个结点的类型，本例中有文本结点和元素结点；结点的名字（元素结点）；结点的值（文本结点）。每个结点都是一个对象，不同的结点对象有不同的属性和方法，更详细的要参见文档。由于本例比较简单，只涉及文本结点和元素结点。

getElementsByTagName可以搜索当前元素的所有子元素，包括所有层次的子元素。childNodes只保存了当前元素的第一层子结点。

这样我们可以遍历childNodes来访问每一个结点，判断它的nodeType来得到不同的内容。如，打印出所有元素的名字：

>>> for node in root.childNodes:
    if node.nodeType == node.ELEMENT_NODE:
        print node.nodeName
       
maxid
item
item

对于文本结点，想得到它的文本内容可以使用: .data属性。

对于简单的元素，如：<caption>Python</caption>，我们可以编写这样一个函数来得到它的内容（这里为Python）。

def getTagText(root, tag):
    node = root.getElementsByTagName(tag)[0]
    rc = “”
    for node in node.childNodes:
        if node.nodeType in ( node.TEXT_NODE, node.CDATA_SECTION_NODE):
            rc = rc + node.data
    return rc

这个函数只处理找到的第一个符合的子元素。它会将符合的第一个子元素中的所有文本结点拼在一起。当nodeType为文本类结点时，node.data为文本的内容。如果我们考查一下元素caption，我们可能看到：

[<DOM Text node "Python">]

说明caption元素只有一个文本结点。

如果一个元素有属性，那么可以使用getAttribute方法，如：

>>> itemlist = root.getElementsByTagName(‘item’)
>>> item = itemlist[0]
>>> item.getAttribute(‘id’)
u’1′