Python之XML模块

1.XML基本概念

XML指可扩展语言(eXtensible Markup Language)，用来传输和存储数据，一个XML文件分为如下几部分内容：

1）文档声明   2）元素   3）属性   4）注释    5）CDATA区   6）实体

1.1 文档声明 

在编写XML文档时，需要先使用文档声明，声明XML文档的类型。最简单的声明语法：<?xml version="1.0" encoding="UTF-8"?>，其中version表示XML的版本，encoding表示文档的编码格式，默认为utf-8。当XML文件中有中文时，必须使用encoding属性指明文档的字符编码，例如：encoding="GB2312"或者encoding="utf-8"，并且在保存文件时，也要以相应的文件编码来保存，否则在使用浏览器解析XML文件时，就会出现解析错误的情况。

1.2 元素

XML元素指XML文件中出现的标签，一个标签分为开始标签和结束标签，一个标签有如下几种书写形式，例如：

• 包含标签体：<a>www.cnblogs.com/</a>
• 不含标签体的：<a></a>, 简写为：<a/>

一个标签中也可以嵌套若干子标签。但所有标签必须合理的嵌套，绝对不允许交叉嵌套 ，例如：错误的写法：<a>welcome to <b>www.cnblogs.com/</a></b>

格式良好的XML文档必须有且仅有一个根标签，其它标签都是这个根标签的子孙标签。此外对于XML标签中出现的所有空格和换行，XML解析程序都会当作标签内容进行处理，例如：下面两段内容的意义是不一样的。

第一段：<网址>http://www.cnblogs.com/</网址>

第二段：

<网址>
     http://www.cnblogs.com/
</网址>

由于在XML中，空格和换行都作为原始内容被处理，所以，在编写XML文件时，使用换行和缩进等方式来让原文件中的内容清晰可读的“良好”书写习惯可能要被迫改变。

XML元素名称命名规范：

1. 区分大小写，例如，<P>和<p>是两个不同的标记。
2. 不能以数字或"_" (下划线)开头。
3. 不能以xml(或XML、或Xml 等)开头。
4. 不能包含空格。
5. 名称中间不能包含冒号（:）

1.3 属性

一个标签可以有多个属性，每个属性都有它自己的名称和取值，例如：<input name='text'>，属性值一定要用双引号（"）或单引号（'）引起来，定义属性必须遵循与标签相同的命名规范 。多学一招：在XML技术中，标签属性所代表的信息，也可以被改成用子元素的形式来描述，例如：

<input>
   <name>text</name>
</input>

1.4 注释

Xml文件中的注释采用： <!--注释--> 格式。

　　注意：

• XML声明之前不能有注释
• 注释不能嵌套，例如：　

<!--大段注释

　　……

　　<!--局部注释-->

　　……

-->  

1.5 CDATA区

在编写XML文件时，有些内容可能不想让解析引擎解析执行，而是当作原始内容处理，遇到此种情况，可以把这些内容放在CDATA区里，对于CDATA区域内的内容，XML解析程序不会处理，而是直接原封不动的输出。

语法：<![CDATA[ 内容 ]]>

示例:

<?xml version="1.0" encoding="UTF-8"?> <!--声明部分-->
<studentlist>  <!--根节点-->
    <student id="10086">  <!--子节点,id节点属性-->
        <name>张三</name>
        <age>20</age>
        <description>
            <![CDATA[个人说明：<title></title>]]>
        </description>
    </student>
    <student id="10087">
        <name>李四</name>
        <age>22</age>
    </student>
</studentlist>

1.6 实体

对于一些单个字符，若想显示其原始样式，也可以使用转义的形式予以处理。

1.7 格式良好的XML文档

　　1）必须有XML的声明语句     2）必须有且只有一个XML根元素       3）标签大小写敏感

　　4）属性使用双引号                5）标签必须成对出现                         6）空标签关闭

　　7）元素必须正确的嵌套         8）必须对特殊字符使用实体

2. xml的解析方法

常见的XML编程接口有DOM和SAX，这两种接口处理XML文件的方式不同，使用场合自然也就不同。Python有三种方法解析XML: SAX，DOM，以及ElementTree。

2.1 SAX (Simple API for XML )

Pyhton标准库包含SAX解析器，SAX用事件驱动模型，通过在解析XML的过程中触发一个个的事件并调用用户定义的回调函数来处理XML文件。SAX是一种基于事件驱动的API。利用SAX解析XML文档牵涉到两个部分:解析器和事件处理器。解析器负责读取XML文档,并向事件处理器发送事件,如元素开始及结束事件;而事件处理器则负责对事件作出处理。

优点:SAX流式读取XML文件，比较快，占用内存少。

缺点:需要用户实现回调函数（handler）。

2.2 DOM(Document Object Model)

将XML数据在内存中解析成一个树，通过对树的操作来操作XML。一个DOM的解析器在解析一个XML文档时，一次性读取整个文档，把文档中所有元素保存在内存中的一个树结构里，之后你可以利用DOM提供的不同的函数来读取或修改文档的内容和结构，也可以把修改过的内容写入xml文件。

优点:使用DOM的好处是你不需要对状态进行追踪，因为每一个节点都知道谁是它的父节点，谁是子节点.

缺点:DOM需要将XML数据映射到内存中的树，一是比较慢，二是比较耗内存，使用起来也比较麻烦！

2.3 ElementTree(元素树)

ElementTree就像一个轻量级的DOM，具有方便友好的API。代码可用性好，速度快，消耗内存少。相比而言，第三种方法，即方便，又快速，下面介绍用元素树如何解析XML。

3. ElementTree 详解

 以Country.xml为例,内容如下

<?xml version="1.0"?>
<data>
    <country name="Liechtenstein">
        <rank updated="yes">2</rank>
        <year>2008</year>
        <gdppc>141100</gdppc>
        <neighbor name="Austria" direction="E"/>
        <neighbor name="Switzerland" direction="W"/>
    </country>
    <country name="Singapore">
        <rank updated="yes">5</rank>
        <year>2011</year>
        <gdppc>59900</gdppc>
        <neighbor name="Malaysia" direction="N"/>
    </country>
    <country name="Panama">
        <rank updated="yes">69</rank>
        <year>2011</year>
        <gdppc>13600</gdppc>
        <neighbor name="Costa Rica" direction="W"/>
        <neighbor name="Colombia" direction="E"/>
        <weather>
            <Monday>rainy day</Monday>
            <Tuesday>sunny day</Tuesday>
        </weather>
    </country>
</data>

我们把<country>xxx</contry>这种结构称为一个element，country称作element的tag，<></>之间的内容称作element的text或data，<>中的name称作element的attrib，而整个XML树被称作ElementTree。ElementTree生来就是为了处理 XML ，它在 Python 标准库中有两种实现。一种是纯 Python 实现例如xml.etree.ElementTree，另外一种是速度快一点的xml.etree.cElementTree。你要记住：尽量使用C语言实现的那种，因为它速度更快，而且消耗的内存更少。如果你的电脑上没有 _elementtree，那么你需要这样做：

try:
　　import xml.etree.cElementTree as ET
except ImportError:
　　import xml.etree.ElementTree as ET

这是一个让 Python 不同的库使用相同 API 的一个比较常用的办法。注意：从Python3.3开始，你没有必要这么做了，因为ElementTree模块会自动寻找可用的C库来加快速度。所以只需要 import xml.etree.ElementTree 就可以。

ElementTree模块拥有两个类

1）ElementTree: 代表整个XML文档，视作tree；用于对整个XML文档的操作；
2）Element： 代表XML文档(tree)上的单个节点；用于对XML节点及子节点的操作；

其官方中文版说明文档地址如下:

http://doc.codingdict.com/python_352/library/xml.etree.elementtree.html

3.1 模块方法

1) xml.etree.ElementTree.fromstring(text) ： 从字符串常量中解析XML，与XML()方法解析的方式也一样，它们返回的都是一个Element实例。

2) xml.etree.ElementTree.iselement(element)：检查element是否是有效的element对象，如果是element对象返回true，否则返回false.

3) xml.etree.ElementTree.parse(source, parser=None)：把XML文件解析成 element tree，参数source是一个文件名或包含XML数据的文件对象，解析器是一个可选的解析器实例。如果没有指定parser的参数值，默认使用的是XMLParser解析器。调用此函数返回ElementTree实例对象

4) xml.etree.ElementTree.SubElement(parent, tag, attrib={}, **extra)：此函数是一个Subelement工厂，这个函数用于创建 element 实例，并将其添加到现有的 element 中。

5) xml.etree.ElementTree.tostring(element, encoding=”us-ascii”, method=”xml”, short_empty_elements=True):：将element及其所有的subelements转化成字符串。

其中element：表示一个element实例 ，encoding：默认编码是”us-ascii” ，method：默认是”xml”，可以选择“html”、“text”。

6) xml.etree.ElementTree.tostringlist(element, encoding=”us-ascii”, method=”xml”, *, short_empty_elements=True)：转化成字符串列表。

7) xml.etree.ElementTree.XML(text, parser=None)：用于从字符串常量中解析XML部分。其中text ：包含xml数据的字符串。 parser：解析器，默认是XMLParser ，结果返回的是一个Element实例

8）xml.etree.ElementTree.iterparse(source, events=None, parser=None)：在元素树中逐步解析XML,并且报告用户的情况。其中source是包含XML数据的文件名或文件对象。 events是要报告的事件列表，event有start，end，startns和endns四种选择 ，默认为end。 parser是一个可选的解析器实例，如果没有给出，则使用标准XMLParser解析器。 cElementTree不支持解析器。由iterparse创建的迭代器会产生形如(event,elem)的元组，其中event是事件列表中的某一个，而elem是相应的XML元素。

3.2 方法释义

3.2.1 使用模块方法读取XML数据

#_*_coding=utf-8
import xml.etree.ElementTree as ET
#1.ET对象具有多种方法从不同来源导入XML数据
#1)调用parse()方法，返回解析树
tree = ET.parse(r'E:2018-12-19country.xml')#载入数据<xml.etree.ElementTree.ElementTree object at 0x000001F36FFF8A20>
root =tree.getroot()#获取根节点，<Element 'data' at 0x0000018607C88638>
#2)调用fromstring()方法，从字符串常量中解析XML，返回解析树的根元素
data = open(r'E:2018-12-19country.xml').read()
root1= ET.fromstring(data)#<Element 'data' at 0x000001D99F539778>
#3)调用ElementTree类ElementTree(self, element=None, file=None)
tree1 = ET.ElementTree(r'E:2018-12-19country.xml')#<xml.etree.ElementTree.ElementTree object at 0x0000015EEBBB69B0>
root2 = tree.getroot()#<Element 'data' at 0x000001E74E558638>
#4)调用XML()方法，用于从字符串常量中解析XML部分。
root3 = ET.XML(data)#<Element 'data' at 0x0000027B351AAD68>

 3.2.2 element对象的属性和方法

Element类
class xml.etree.ElementTree.Element(tag, attrib={}, **extra)

#属性
　　tag：string，元素类型，element type。
　　text：string，元素的内容,元素起始tag于结尾tag之间的文本。
　　tail：string，元素的尾形。元素结尾tag与下一个起始tag之间的文本
　　attrib：dictionary，元素的属性字典。
　　
＃针对属性的操作
　　clear()：清空元素的后代、属性，并设置text和tail的属性为None。
　　get(key, default=None)：获取key对应的属性值，如该属性不存在则返回default值。
　　items()：根据属性字典返回一个列表，列表元素为(key, value）。
　　keys()：返回包含所有元素属性键的列表。
　　set(key, value)：设置新的属性键与值。

＃针对后代的操作
　　append(subelement)：添加一个直系子元素。
　　extend(subelements)：通过列表对象追加0个或多个子元素。＃python2.7新特性
　　find(match,namespaces=None)：寻找第一个匹配子元素，匹配对象可以为tag或path。
　　findall(match,namespaces=None)：寻找所有匹配子元素，匹配对象可以为tag或path。
　　findtext(match)：寻找第一个匹配子元素，返回其text值。匹配对象可以为tag或path。
　　insert(index, element)：在指定位置插入子元素。
　　iter(tag=None)：以当前element为root，创建一个tree iterator。＃python2.7新特性
　　iterfind(match,namespaces=None)：根据tag或path查找所有的后代。
　　itertext()：遍历所有后代并返回text值。
　　remove(subelement)：删除子元素。

 练习:

#_*_coding=utf-8
import xml.etree.ElementTree as ET
tree = ET.parse(r'E:2018-12-19country.xml')#载入数据<xml.etree.ElementTree.ElementTree object at 0x000001F36FFF8A20>
root =tree.getroot()#获取根节点，<Element 'data' at 0x0000018607C88638>
#1.获取element object 的四大属性tag、text、attrib以及tail
print(root.tag) #root element的tag
print(root.text) #root element的text
print(root.attrib) #root element本身的attrib,dict格式的
print(root.tail) #root element的tag结束到下一个tag之间的text
# #通过DICT逻辑获取树形结构的text，表示第一个child的第二个child element的text
print(root[0][1].text)#2008
#2. 针对属性的操作
#1)简单操作
print(root[0][3].keys())#['name', 'direction']
print(root[0][3].get('name'))#Austria
print(root[0][3].items())#[('name', 'Austria'), ('direction', 'E')]
root[0][3].set('name','aa')
#2）将所有的rank值加1,并添加属性updated为yes
for rank in root.iter("rank"):
    new_rank = int(rank.text) + 1
    rank.text = str(new_rank)  # 必须将int转为str
    rank.set("updated", "yes") # 添加属性
# 再终端显示整个xml
ET.dump(root)
# 注意 修改的内容存在内存中 尚未保存到文件中
# 保存修改后的内容
tree.write(r'E:2018-12-19country1.xml')
#3）删除添加的updated属性
for rank in root.iter("rank"):
    # attrib为属性字典
    # 删除对应的属性updated
    del rank.attrib['updated']
ET.dump(root)
#3.遍历
#1)简单遍历
# 遍历xml文档的第二层
for child in root:
    # 第二层节点的标签名称和属性
    print(child.tag,":", child.attrib)
    # 遍历xml文档的第三层
    for children in child:
        # 第三层节点的标签名称和属性
        print(children.tag, ":", children.attrib)
#2）利用Element提供的方法遍历
#过滤出所有neighbor标签
for neighbor in root.iter('neighbor'):
    print(neighbor.tag,":",neighbor.attrib)
#遍历所有的country标签
for country in root.findall('country'):
    # 查找country标签下的第一个rank标签
    rank = country.find("rank").text
    # 获取country标签的name属性
    name = country.get("name")
    print(name, rank)

Xpath句法含义列表:

#_*_coding=utf-8
import xml.etree.ElementTree as ET
tree = ET.parse(r'E:2018-12-19country.xml')#载入数据<xml.etree.ElementTree.ElementTree object at 0x000001F36FFF8A20>
root =tree.getroot()#获取根节点，<Element 'data' at 0x0000018607C88638>
#4.查找感兴趣的标签
#1)使用element方法查找country名为"singapore"的国家的gdp值以及排名
#findall只能用来查找直接子元素，不能用来查找rank，neighbor等element
for country in root.findall('country'):
    name = country.get('name')
    if name == 'Singapore':
        rank = country.find('rank').text
        gdp = country.find('gdppc').text
        print("{name}: rank={rank},gdp={gdp}".format(name=name,rank=rank,gdp=gdp))
    else:
        continue
#输出:Singapore: rank=5,gdp=59900
#2)使用Xpath寻找所有国家的name属性
countrylist=root.findall("./country")
for country in countrylist:
    print(country.get('name'))
#输出
# Liechtenstein
#Singapore
#Panama
#3)Xpath练习
#a)选取所有的country元素的rank子元素
print(root.findall('./country/rank'))#[<Element 'rank' at 0x0000029686D98228>, <Element 'rank' at 0x0000029686F79458>, <Element 'rank' at 0x0000029686F795E8>]
#b)以根节点为始祖，选取其后代中的rank元素
print(root.findall('.//rank'))#[<Element 'rank' at 0x0000023C970B71D8>, <Element 'rank' at 0x0000023C9729B408>, <Element 'rank' at 0x0000023C9729B598>]
#c)以country为始祖，选取后代中的year元素
print(root.findall('country//year'))#[<Element 'year' at 0x0000028F45BD1AE8>, <Element 'year' at 0x0000028F45BEC458>, <Element 'year' at 0x0000028F45BEC5E8>]
#d)以country为始祖，选取后代中的具有direction属性的元素
print(root.findall("country//*[@direction]"))#[<Element 'neighbor' at 0x000001E7E4A13228>, <Element 'neighbor' at 0x000001E7E4A1A368>, <Element 'neighbor' at 0x000001E7E4A1A4F8>, <Element 'neighbor' at 0x000001E7E4A1A688>, <Element 'neighbor' at 0x000001E7E4A1A6D8>]
#e)选取根元素的第一个country子元素
print(root.findall('./country[1]'))#[<Element 'country' at 0x0000024D411B4048>]
#f)选取根元素的最后一个country子元素
print(root.findall('./country[last()]'))#[<Element 'country' at 0x00000228D371A548>]
#g)选取根元素的倒数第二个country子元素
print(root.findall('./country[last()-1]'))#[<Element 'country' at 0x0000013D1C94A3B8>]
#h)以根节点为始祖，选取其后代含有name属性且值为Malaysia的元素
print(root.findall(".//*[@name='Malaysia']"))#[<Element 'neighbor' at 0x00000223B202A4F8>]
#i)以root为始祖，选取具有year子元素且其子元素text为2011的元素
print(root.findall(".//*[year='2011']"))#[<Element 'country' at 0x000002982D2D93B8>, <Element 'country' at 0x000002982D2D9548>]
#g)以country为始祖，选取具有名为Monday子元素的元素
print(root.findall("country//*[Monday]"))#[<Element 'weather' at 0x000001C447FBA728>]
#k)以root为始祖，选取name=panama的元素的后代Monday元素
print(root.findall(".//*[@name='Panama']/weather/Monday"))#[<Element 'Monday' at 0x0000017AA408A778>]
print(root.findall(".//*[@name='Panama']/*/Monday"))

 3.2.3 创建XML文档

1）创建XML

#_*_coding=utf-8
import xml.etree.ElementTree as ET
#使用indent函数，使element tree 输出带缩进格式的xml
def indent(elem, level=0):
    i = "
" + level*"	"
    if len(elem):
        if not elem.text or not elem.text.strip():
            elem.text = i + "	"
        if not elem.tail or not elem.tail.strip():
            elem.tail = i
        for elem in elem:
            indent(elem, level+1)
        if not elem.tail or not elem.tail.strip():
            elem.tail = i
    else:
        if level and (not elem.tail or not elem.tail.strip()):
            elem.tail = i
#创建根节点
data = ET.Element('data')
#创建子节点并添加属性
sub1= ET.SubElement(data,'country',attrib={'name':'Liechtenstein','MothorTongue':'German'})
#sub1.attrib = {'MothorTongue':'German'}#此处再赋值，会覆盖之前设置的attrib值
country1_rank = ET.SubElement(sub1,'rank')
country1_rank.text = '2'
country1_year = ET.SubElement(sub1,'year')
country1_year.text = '2008'
country1_gdp = ET.SubElement(sub1,'gdppc')
country1_gdp.text = '141100'
country1_neighbor = ET.SubElement(sub1,'neighbor',attrib={'name':'Austria','direction':'w'})
indent(data)
ET.dump(data)
#创建element tree对象，写文件
tree = ET.ElementTree(data)
tree.write(r'E:2018-12-19	ext.xml')

 2)将字典转换为XML文档

#_*_coding=utf-8
import xml.etree.ElementTree as ET

#使用indent函数，使element tree 输出带缩进格式的xml
def indent(elem, level=0):
    i = "
" + level*"	"
    if len(elem):
        if not elem.text or not elem.text.strip():
            elem.text = i + "	"
        if not elem.tail or not elem.tail.strip():
            elem.tail = i
        for elem in elem:
            indent(elem, level+1)
        if not elem.tail or not elem.tail.strip():
            elem.tail = i
    else:
        if level and (not elem.tail or not elem.tail.strip()):
            elem.tail = i
def dict_to_xml(tag, d):
    '''
    Turn a simple dict of key/value pairs into XML
    '''
    elem = ET.Element(tag)
    for key, val in d.items():
        child = ET.Element(key)
        child.text = str(val)
        elem.append(child)
    return elem

dict1 = {'rank':'2','year':'2008','gdppc':'141100','neighbor':''}
data = dict_to_xml('country',dict1)
indent(data)
ET.dump(data)

#输出
# <country>
#     <rank>2</rank>
#     <year>2008</year>
#     <gdppc>141100</gdppc>
#     <neighbor />
# </country>

3.2.4 解析大型XML文档

使用xml.etree.ElementTree.iterparse(source, events=None, parser=None)方法你将用尽可能少的内存从一个超大的XML文档中提取数据。

示例1：iterparse的简单使用

#_*_coding=utf-8
import xml.etree.ElementTree as ET
data = ET.iterparse(r'E:2018-12-19country.xml',('start','end'))
print(next(data))
print(next(data))
print(next(data))
print(next(data))
print(next(data))
print(next(data))
print(next(data))
print(next(data))
print(next(data))
print(next(data))
print(next(data))
print(next(data))
print(next(data))
print(next(data))
print(next(data))
#输出
# ('start', <Element 'data' at 0x000001A2AFA23228>)
# ('start', <Element 'country' at 0x000001A2AFA2B368>)
# ('start', <Element 'rank' at 0x000001A2AFA2B3B8>)
# ('end', <Element 'rank' at 0x000001A2AFA2B3B8>)
# ('start', <Element 'year' at 0x000001A2AFA2B408>)
# ('end', <Element 'year' at 0x000001A2AFA2B408>)
# ('start', <Element 'gdppc' at 0x000001A2AFA2B458>)
# ('end', <Element 'gdppc' at 0x000001A2AFA2B458>)
# ('start', <Element 'neighbor' at 0x000001A2AFA2B4A8>)
# ('end', <Element 'neighbor' at 0x000001A2AFA2B4A8>)
# ('start', <Element 'neighbor' at 0x000001A2AFA2B4F8>)
# ('end', <Element 'neighbor' at 0x000001A2AFA2B4F8>)
# ('end', <Element 'country' at 0x000001A2AFA2B368>)
# ('start', <Element 'country' at 0x000001A2AFA2B548>)
# ('start', <Element 'rank' at 0x000001A2AFA2B598>)

由上例可以看出，start 事件在某个元素第一次被创建并且还没有被插入其他数据 (如子元素) 时被创建，即是当遇到标签的“>”符号时触发start，而 end 事件在某个元素已经完成时被创建，即是遇到标签的结束标志时会触发end。

下面是一个包含iterparse()方法的很简单的函数，该函数只使用很少的内存就能增量式的处理一个大型 XML 文件，实现对节点的迭代式解析和删除，返回指定路径的最后一层元素。

#_*_coding=utf-8
from xml.etree.ElementTree import iterparse

def parse_and_remove(filename,path):
    path_parts = path.split('/')
    doc = iterparse(filename, ('start', 'end'))
    # Skip the root element
    next(doc)
    tag_stack = []
    elem_stack = []
    for event, elem in doc:
        if event == 'start':
            tag_stack.append(elem.tag)
            elem_stack.append(elem)
        elif event == 'end':
            if tag_stack == path_parts:
                yield elem
                elem_stack[-2].remove(elem)
            try:
                tag_stack.pop()
                elem_stack.pop()
            except IndexError:
                pass

data = parse_and_remove(r'E:2018-12-19country.xml',('country/weather/Monday'))
print(next(data))
#输出
#<Element 'Monday' at 0x00000283BCD89958>

>>>>待续