python解析xml模块封装代码

有如下的xml文件:

代码如下:

<?xml version="1.0" encoding="utf-8" ?> 
<root> 
<childs> 
<child name='first' >1</child> 
<child value="2">2</child> 
</childs> 
</root>

下面介绍python解析xml文件的几种方法,使用python模块实现。

方式1,python模块实现自动遍历所有节点:

代码如下:

#!/usr/bin/env python 
# -*- coding: utf-8 -*- 
from xml.sax.handler import ContentHandler 
from xml.sax import parse
class TestHandle(ContentHandler): 
    def __init__(self, inlist): 
        self.inlist = inlist

def startElement(self,name,attrs): 
        print 'name:',name, 'attrs:',attrs.keys()

def endElement(self,name): 
        print 'endname',name

def characters(self,chars): 
        print 'chars',chars 
        self.inlist.append(chars)

if __name__ == '__main__': 
    lt = [] 
    parse('test.xml', TestHandle(lt)) 
    print lt

结果:
[html] view plaincopy
name: root attrs: [] 
chars

name: childs attrs: [] 
chars

name: child attrs: [u'name'] 
chars 1 
endname child 
chars

name: child attrs: [u'value'] 
chars 2 
endname child 
chars

endname childs 
chars

endname root 
[u'\n', u'\n', u'1', u'\n', u'2', u'\n', u'\n']

方式2,python模块实现获取根节点,按需查找指定节点:

代码如下:

#!/usr/bin/env python   
# -*- coding: utf-8 -*-   
from xml.dom import minidom   
xmlstr = '''''<?xml version="1.0" encoding="UTF-8"?>
<hash>
    <request name='first'>/2/photos/square/type.xml</request>
    <error_code>21301</error_code>
    <error>auth faild!</error>
</hash>
''' 
def doxml(xmlstr): 
    dom = minidom.parseString(xmlstr)     
    print 'Dom:'     
    print dom.toxml()

root = dom.firstChild     
    print 'root:'     
    print root.toxml()

childs = root.childNodes   
    for child in childs: 
        print child.toxml() 
        if child.nodeType == child.TEXT_NODE: 
            pass 
        else: 
            print 'child node attribute name:', child.getAttribute('name') 
            print 'child node name:', child.nodeName 
            print 'child node len:',len(child.childNodes) 
            print 'child data:',child.childNodes[0].data 
            print '=======================================' 
            print 'more help info to see:' 
            for med in dir(child): 
                print help(med)

if __name__ == '__main__':   
    doxml(xmlstr)

结果:
[html] view plaincopy
Dom: 
<?xml version="1.0" ?><hash> 
    <request name="first">/2/photos/square/type.xml</request> 
    <error_code>21301</error_code> 
    <error>auth faild!</error> 
</hash> 
root: 
<hash> 
    <request name="first">/2/photos/square/type.xml</request> 
    <error_code>21301</error_code> 
    <error>auth faild!</error> 
</hash>

<request name="first">/2/photos/square/type.xml</request> 
child node attribute name: first 
child node name: request 
child node len: 1 
child data: /2/photos/square/type.xml 
======================================= 
more help info to see: 
两种方法各有其优点,python的xml处理模块太多,目前只用到这2个。

=====补充分割线================
实际工作中发现python的mimidom无法解析其它编码的xml,只能解析utf-8的编码,而其xml文件的头部申明也必须是utf-8,为其它编码会报错误。
网上的解决办法都是替换xml文件头部的编码申明,然后转换编码为utf-8再用minidom解码,实际测试为可行,不过有点累赘的感觉。

本节是 python解析xml模块封装代码 的第二部分。
====写xml内容的分割线=========

代码如下:

#!\urs\bin\env python 
#encoding: utf-8 
from xml.dom import minidom

class xmlwrite: 
    def __init__(self, resultfile): 
        self.resultfile = resultfile 
        self.rootname = 'api' 
        self.__create_xml_dom()

def __create_xml_dom(self): 
        xmlimpl = minidom.getDOMImplementation() 
        self.dom = xmlimpl.createDocument(None, self.rootname, None) 
        self.root = self.dom.documentElement

def __get_spec_node(self, xpath): 
        patharr = xpath.split(r'/') 
        parentnode = self.root 
        exist = 1 
        for nodename in patharr: 
            if nodename.strip() == '': 
                continue 
            if not exist: 
                return None 
            spcindex = nodename.find('[') 
            if spcindex > -1: 
                index = int(nodename[spcindex+1:-1]) 
            else: 
                index = 0 
            count = 0 
            childs = parentnode.childNodes 
            for child in childs: 
                if child.nodeName == nodename[:spcindex]: 
                    if count == index: 
                        parentnode = child 
                        exist = 1 
                        break 
                    count += 1 
                    continue 
                else: 
                    exist = 0 
        return parentnode

def write_node(self, parent, nodename, value, attribute=None, CDATA=False): 
        node = self.dom.createElement(nodename) 
        if value: 
            if CDATA: 
                nodedata = self.dom.createCDATASection(value) 
            else: 
                nodedata = self.dom.createTextNode(value) 
            node.appendChild(nodedata) 
            if attribute and isinstance(attribute, dict): 
                for key, value in attribute.items(): 
                    node.setAttribute(key, value)    
        try: 
            parentnode = self.__get_spec_node(parent) 
        except: 
            print 'Get parent Node Fail, Use the Root as parent Node' 
            parentnode = self.root 
        parentnode.appendChild(node)

def write_start_time(self, time): 
        self.write_node('/','StartTime', time)

def write_end_time(self, time): 
        self.write_node('/','EndTime', time)

def write_pass_count(self, count): 
        self.write_node('/','PassCount', count)

def write_fail_count(self, count): 
        self.write_node('/','FailCount', count)

def write_case(self): 
        self.write_node('/','Case', None)

def write_case_no(self, index, value): 
        self.write_node('/Case[%s]/' % index,'No', value)

def write_case_url(self, index, value): 
        self.write_node('/Case[%s]/' % index,'URL', value)

def write_case_dbdata(self, index, value): 
        self.write_node('/Case[%s]/' % index,'DBData', value)

def write_case_apidata(self, index, value): 
        self.write_node('/Case[%s]/' % index,'APIData', value)

def write_case_dbsql(self, index, value): 
        self.write_node('/Case[%s]/' % index,'DBSQL', value, CDATA=True)

def write_case_apixpath(self, index, value): 
        self.write_node('/Case[%s]/' % index,'APIXPath', value)

def save_xml(self): 
        myfile = file(self.resultfile, 'w') 
        self.dom.writexml(myfile, encoding='utf-8') 
        myfile.close()

if __name__ == '__main__': 
      xr = xmlwrite(r'D:\test.xml') 
      xr.write_start_time('2223') 
      xr.write_end_time('444')       
      xr.write_pass_count('22') 
      xr.write_fail_count('33')   
      xr.write_case() 
      xr.write_case() 
      xr.write_case_no(0, '0') 
      xr.write_case_url(0, 'http://www.google.com')    
      xr.write_case_url(0, 'http://www.google.com')    
      xr.write_case_dbsql(0, 'select * from ') 
      xr.write_case_dbdata(0, 'dbtata') 
      xr.write_case_apixpath(0, '/xpath') 
      xr.write_case_apidata(0, 'apidata') 
      xr.write_case_no(1, '1')        
      xr.write_case_url(1, 'http://www.baidu.com')    
      xr.write_case_url(1, 'http://www.baidu.com')    
      xr.write_case_dbsql(1, 'select 1 from ') 
      xr.write_case_dbdata(1, 'dbtata1') 
      xr.write_case_apixpath(1, '/xpath1') 
      xr.write_case_apidata(1, 'apidata1') 
      xr.save_xml()

以上封装了minidom,支持通过xpath来写节点,不支持xpath带属性的匹配,但支持带索引的匹配。
比如:/root/child[1], 表示root的第2个child节点。

时间: 2014-02-05

Python常用内置模块之xml模块(详解)

xml即可扩展标记语言,它可以用来标记数据.定义数据类型,是一种允许用户对自己的标记语言进行定义的源语言.从结构上,很像HTML超文本标记语言.但他们被设计的目的是不同的,超文本标记语言被设计用来显示数据,其焦点是数据的外观.它被设计用来传输和存储数据,其焦点是数据的内容.那么Python是如何处理XML语言文件的呢?下面一起来看看Python常用内置模块之xml模块吧. 本文主要学习的ElementTree是python的XML处理模块,它提供了一个轻量级的对象模型.在使用ElementTre

Python常用模块用法分析

本文较为详细的讲述了Python中常用的模块,分享给大家便于大家查阅参考之用.具体如下: 1.内置模块(不用import就可以直接使用) 常用内置函数: help(obj) 在线帮助, obj可是任何类型 callable(obj) 查看一个obj是不是可以像函数一样调用 repr(obj) 得到obj的表示字符串,可以利用这个字符串eval重建该对象的一个拷贝 eval_r(str) 表示合法的python表达式,返回这个表达式 dir(obj) 查看obj的name space中可见的nam

Python中的两个内置模块介绍

使用了Python一段时间后,可以说Python的基本单位就是模块了,在使用模块的时候我们一般会使用通过import语句来将其导入,但是我们在没有导入任何模块的时候,我们却能使用这样的一些函数:int(),str(),len(),range(),以及使用try except语句来捕获异常,那么这些又是从哪儿来的呢. 基本 Python在启动时会自动导入内建的__builtin__和exceptions这两个模块, 使任何程序都能够使用它们,所以说这两个模块应该是整个Python语言中最重要的模块

Python中实现两个字典(dict)合并的方法

本文实例讲述了Python中实现两个字典(dict)合并的方法,分享给大家供大家参考.具体方法如下: 现有两个字典dict如下: dict1={1:[1,11,111],2:[2,22,222]} dict2={3:[3,33,333],4:[4,44,444]} 合并两个字典得到类似: {1:[1,11,111],2:[2,22,222],3:[3,33,333],4:[4,44,444]} 方法1: dictMerged1=dict(dict1.items()+dict2.items())

Python中交换两个元素的实现方法

Python既具有普通程序开发语言的特点,也具有Matlab语言用于数值计算的特点,,当然了数值计算是由其其强大的第三方库numpy实现的,矩阵在python中数据类型是ndarray,python中交换两个数值的代码和交换同一矩阵(ndarray)中不同向量的写法是不一样的. 以下是用Python原生的数据结构list实现的交换 >> a = [1,2,3] >> b = [4,5,6] >> a [1,2,3] >> b [4,5,6] >>

在Python中获取两数相除的商和余数方法

方法一:可以使用//求取两数相除的商.%求取两数相除的余数.[/在Python中获取的是相除的结果,一般为浮点数] 方法二:使用divmod()函数,获取商和余数组成的元祖 实例代码: #!/usr/bin/python3 # -*- coding: utf-8 -*- a = int(input(u"输入被除数: ")) b = int(input(u"输入除数:")) div = a // b mod = a % b print("{} / {} =

对Python中实现两个数的值交换的集中方法详解

如下所示: #定义两个数并赋值 x = 1 y = 2 #第1种方式:引入第三方变量 z = 0 z = x x = y y = z #第2种:不引入第三方变量 x = x+y y = x-y x = x-y #第3种:推荐 x,y = y,x print("x=%d,y=%d"%(x,y)) 以上这篇对Python中实现两个数的值交换的集中方法详解就是小编分享给大家的全部内容了,希望能给大家一个参考,也希望大家多多支持我们.

python中 ? : 三元表达式的使用介绍

(1) variable = a if exper else b(2)variable = (exper and [b] or [c])[0](2) variable = exper and b or c 上面三种用法都可以达到目的,类似C语言中 variable = exper ? b : c;即:如果exper表达式的值为true则variable = b,否则,variable = c 例如: 复制代码 代码如下: a,b=1,2max = (a if a > b else b)max =

python中使用mysql数据库详细介绍

一.安装mysql 如果是windows 用户,mysql 的安装非常简单,直接下载安装文件,双击安装文件一步一步进行操作即可. Linux 下的安装可能会更加简单,除了下载安装包进行安装外,一般的linux 仓库中都会有mysql ,我们只需要通过一个命令就可以下载安装: Ubuntu\deepin 复制代码 代码如下: >>sudo apt-get install mysql-server >>Sudo apt-get install  mysql-client centOS/

python中合并两个文本文件并按照姓名首字母排序的例子

前段时间前在网上看到一段面试题,要求如下: employee文件中记录了工号和姓名 复制代码 代码如下: cat employee.txt: 100 Jason Smith 200 John Doe 300 Sanjay Gupta 400 Ashok Sharma bonus文件中记录工号和工资 复制代码 代码如下: cat bonus.txt: 100 $5,000 200 $500 300 $3,000 400 $1,250 要求把两个文件合并并输出如下, 处理结果: 复制代码 代码如下:

python中比较两个列表的实例方法

cmp() 方法用于比较两个列表的元素. cmp()方法语法: cmp(list1, list2) 参数: list1 -- 比较的列表.list2 -- 比较的列表. 返回值: 如果比较的元素是同类型的,则比较其值,返回结果. 如果两个元素不是同一种类型,则检查它们是否是数字. 如果是数字,执行必要的数字强制类型转换,然后比较.如果有一方的元素是数字,则另一方的元素"大"(数字是"最小的")否则,通过类型名字的字母顺序进行比较. 如果有一个列表首先到达末尾,则另一

Python中类型检查的详细介绍

前言 大家都知道Python 是一门强类型.动态类型检查的语言.所谓动态类型,是指在定义变量时,我们无需指定变量的类型,Python 解释器会在运行时自动检查. 与静态类型语言(如 C 语言)相比,这不仅仅是少写了几个类型声明字符: #include <stdlib.h> #include <stdio.h> #define BUFF 100 char* greeting(char* name){ char* msg = (char *) malloc(sizeof(char) *