python进阶（十七）xml（下）

1、XML简介

xml用到的地方：tomcat配置文件

1) xml 指可扩展标记语言(Extensible Markup Language)

2) xml 被设计用于结构化、存储和传输数据

3) xml 是一种标记语言，很类似于HTML

4) xml 没有像HTML那样具有预定义标签，需要程序员自定义标签

5) xml 被设计为具有自我描述性，并且是W3C的标准。

2、xml和html的区别：

html是xml的一种特例。html里面的标签全都是已经预定义好的，都是有含义的。

xml的数据存储和显示是分开的，存储一个文件，显示一个文件，xml不需要标签，可以自定义。

xml:

<book>

</book>

</bookstore>

如果将以上内容放进浏览器中，浏览器中可以看到，但是不能像html显示各种样式。

如果将以上xml也能作为网页显示，如何实现？

3、html5实例：

网址链接：

http://www.w3school.com.cn/tiy/t.asp?f=html5_video_all

代码：

<!DOCTYPE HTML>

<html>

<body>

Your browser does not support the video tag.

</video>

</body>

</html>

html5比html4的区别就是多了很多标签

<h1>我的第一个标题</h1>

<p>我的死一个段落。</p>

<div>块

<title>标题

4、AJAX

AJAX = Asynchronous JavaScript and XML（异步的 JavaScript 和 XML）。

AJAX 不是新的编程语言，而是一种使用现有标准的新方法。

AJAX 是与服务器交换数据并更新部分网页的艺术，在不重新加载整个页面的情况下。

实际用处：比如，注册页面，用户名还未提交，就提示该用户名已被使用

该技术的好处：不用刷新页面，重新加载页面要3s，而AJAX需要几十-几百毫秒。

异步传输：5个步骤，谁先执行都可以，没有先后顺序，可以并发

同步传输：按照顺序传输，1,2,3,4,5

5、CMS(content management system,新闻发布系统)

6、Apache和tomcat的区别：

Apache只能做静态网页的显示。

tomcat既能动态也能静态

静态网页：网页一旦生成好，网页是不变的。访问的内容是一样的。

动态网页：是根据你的请求数据和服务器的处理规则实时生成的网页。

7、XML文档(树结构)

XML文档形成了一种树结构，它从”根部开始”，然后扩展到“树枝”。

XML文档必须包含根元素，该元素是所有其他元素的父元素，文芳中的所有元素形成了一棵文档树，这棵树从根开始，并扩展到树的最顶端，并且所有的元素都可以有子元素。

<root>

<child>

</child>

</root>

父元素拥有子元素，相同层级上的子元素成为同胞（兄弟或姐妹）。XML中所有子元素都可以有文本内容和属性，类似于HTML.

8、XML基础知识介绍

1) XML元素

XML元素是指开始标签到结束标签的部分（均包括开始结束）。

一个元素可以包含：

1. 其他元素

2. 文本

3. 属性

4. 或混合以上所有

#xml注释

<catalog> #根元素

<cd> #子标签

<title>Empire Burlesque</title> # Empire Burlesque文本节点，和空格也是文本节点,<>内的内容是element 节点

<artist>Bob Dylan</artist> #<title>为标签

<company>Columbia</company>

</cd>

</catalog>

<cd class = "classic"> #class = "classic"为属性，做辅助说明的

<a href = "http://www.souhu.com">souhu</a>

# href = http://www.souhu.com标签里面的内容，以=显示的叫做属性

#点击souhu这个蓝字，会跳转到http://www.souhu.com这个网页中

2) XML语法规则

1. 所有的XML元素都必须有一个开始标签和结束标签，省略结束标签是非法的。如：

<root>content</root>

2. html可以少一个标签，因为浏览器会自动纠错，浏览器怎么解析html都不会崩溃。如果少一个标签，也可以解析，不过解析的内容可能和预期有差异。

<title>光荣之路

3. XML标签对大小写敏感；比如：下面时两个不同的标签

4. XML文档必须有根元素。如：

<note>

</note>

5. XML必须正确嵌套，父元素必须完全包住子元素。如：

6. XML属性值必须加引号，元素的属性值都是一个键值对形式。如：

注意：

book元素中的属性category的值是Python必须用引号引起来，使用单引号和双引号都可以，但是如果属性值本身包含双引号，外层必须使用单引号；但如果包含了单引号，外层必须使用双引号。

9、XML命名规则

XML元素必须遵循以下命名规则：

1）名称可以包含字母、数字以及其他字符

2）名称不能以数字或标点符号开头

3）名称不能以字母xml或XML开始

4）名称不能包含空格

5）可以使用任何名称，没有保留字

6）名称应该具有描述性，简短和简单，可以同时使用下划线。

7）避免-、.、：等字符

8）XML的注释格式为：<! -- 注释内容 --> #和html的注释一样。

#注释的内容不会作为浏览器显示的内容，也不会作为XML解析的内容

10、CDATA

CDATA(Unparsed Character Data)指的是不应由XML解析器进行解析的文本数据。

XML解析器会将“<”(新元素的开始)和”&”(字符实体的开始)解析成具有特殊汉含义的字符。当代码中含有大量的“<”和”&”符号，可以将脚本定义为CDATA来避免这个问题，因为XML文档中的所有文本均会被解析器解析，只有CDATA部分中的所有的内容会被XML解析器忽略。

<![CDATA[“我们自己的代码”]]>

注意：CDATA部分不能包含字符串”]]>”,并且”]]>”之间不能有空格或折行等字符，如果包含了，会以为是CDATA的结束。也不允许嵌套CDATA部分。

<![CDATA[

function test(x,y)

{ if (x<0 &&y<0) then

{

return 0;

}

else

{

return 1:

}

]]>

</script>

11、Python解析XML三种方法

1）SAX(simple API for XML)

Python标准库中包含SAX解析器，SAX是用的是事件驱动模型，通过在解析XML过程中触发一个个的事件并调用用户定义的回调函数来处理XML文件。

解析的基本过程：

读到一个XML开始标签，就会开始一个事件，然后事件就会调用一系列的函数去处理一些事情，当读到一个结束标签时，就会触发另一个事件。所以，我们写XML文档如果有格式错误的话解析就会出错。

这是一种流式处理，一边读一边解析，占用内存少，但速度慢。

2) DOM(Document Object Model)

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

将XML数据在内存中解析成一个树，通过对树的操作来操作XML.

由于DOM是将XML读取到内存，然后解析成一个树，如果要处理的XML文件比较大的话，就会很耗内存，所以DOM一般偏向于处理一些小的XML,(如配置文件)比较快

占内存，但是速度快。--建议这种，因为xml现在普遍挺小，内存已经不是瓶颈。

3) ElementTree(Object Model)

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

支持XPATH,定位元素的一种方式。自动化定位元素的一种方式。

12、Xml.dom解析xml

xml.dom解析xml的思路：

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

<?xml version="1.0" encoding="utf-8" ?> #xml文件头

#注释

<booklist type="science and engineering"> #根节点

<title>learning math</title>

</book>

<title>learning Python</title>

</book>

</booklist>

#以上是book.xml文档的内容

13、xml.dom解析xml常用API

1) minidom.parse(parser=None,bufsize=None)

from xml.dom.minidom import parse #从xml.dom.minidom模块引入解析器parse
DOMTree = parse(r"e:ook.xml") #minidom解析器打开xml文档并将其解析为内存中的一棵树
print(type(DOMTree))

#<class 'xml.dom.minidom.Document'> #xml的document对象

#minidom.parse(parser=None,bufsize=None)

#该函数的作用是使用parse解析器打开XML文档，并将其解析为DOM文档，也就是内存中的一棵树，并得到这个DOM对象。

2) doc.documentElement:获取xml文档对象，就是拿到DOM树的根

>>> from xml.dom.minidom import parse

>>> DOMTree = parse(r"e:ook.xml")

>>> booklist = DOMTree.documentElement

>>> print(booklist)

<DOM Element: booklist at 0x28471659b90> #booklist是根节点

3) doc.toxml:获取xml文本内容

>>> print(DOMTree.toxml)

>>> print(DOMTree.toxml()) #将xml中的内容除了根节点的内容都打印一下

<?xml version="1.0" ?><booklist type="science and engineering">

<title>learning math</title>

</book>

<title>learning Python</title>

</book>

</booklist>

>>>

4) has Attribute:判断是否包含属性

>>> from xml.dom.minidom import parse

>>> DOMTree = parse(r"e:ook.xml") #minidom解析器打开xml文档并将其解析为内存中的一棵树

>>> booklist = DOMTree.documentElement　　#获取xml文档对象，就是拿到树的根

>>> print(u"DOM树的根对象：", booklist)

#DOM树的根对象： <DOM Element: booklist at 0x28471659af8>

>>> if booklist.hasAttribute("type"): #判断根节点booklist是否有type属性

... print(u"booklist元素存在type属性")

... else :

... print(u"booklist元素不存在type属性")

...

booklist元素存在type属性

>>>

5) node.getAttrbute:获取节点node的某个属性值

>>> from xml.dom.minidom import parse

>>> DOMTree = parse(r"e:ook.xml") #minidom解析器打开xml文档并将其解析为内存中的一棵树

>>> booklist = DOMTree.documentElement　　#获取xml文档对象，就是拿到树的根

>>> print(u"DOM树的根对象：", booklist)

#DOM树的根对象： <DOM Element: booklist at 0x284716595a0>

>>> if booklist.hasAttribute("type"): #判断根节点booklist是否有type属性

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

...

Root element is science and engineering

6) node.getElementsByTagName(name):获取节点元素

获取XML文档中某个父节点下具有相同节点名的节点对象集合，是一个list对象。

>>> from xml.dom.minidom import parse

>>> DOMTree = parse(r"e:ook.xml") #minidom解析器打开xml文档并将其解析为内存中的一棵树

>>> booklist = DOMTree.documentElement　　#获取xml文档对象，就是拿到树的根

>>> print(u"DOM树的根对象：", booklist)

#DOM树的根对象： <DOM Element: booklist at 0x28471513c28>

>>> books = booklist.getElementsByTagName("book") #获取根节点下标签是book的

>>> print(type(books)) #节点对象，该返回值是个list

>>> print(books)

[<DOM Element: book at 0x28471513a60>, <DOM Element: book at 0x28471513638>]

>>> print(books[0])

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

注意:

就算某个父节点下没有同名的节点，该方法返回的仍是一个list，只是此时的list为空。

7) node.childNodes:返回节点node下所有子节点组成的list

>>> from xml.dom.minidom import parse

>>> DOMTree = parse(r"e:ook.xml") #minidom解析器打开xml文档并将其解析为内存中的一棵树

>>> booklist = DOMTree.documentElement　　#获取xml文档对象，就是拿到树的根

>>> print(u"DOM树的根对象：", booklist)

#DOM树的根对象： <DOM Element: booklist at 0x284716595a0>

>>> books = booklist.getElementsByTagName("book")#返回父节点下标签为book的节点

>>> print(books[0].childNodes) #返回第一个book节点下的所有的子节点

[<DOM Text node "' '">, <DOM Element: title at 0x28471513898>, <DOM Text node "' '">, <DOM Element: author at 0x284715139c8>, <DOM Text node "' '">, <DOM Element: pageNumber at 0x28471513930>, <DOM Text node "' '">]

#<DOM Text node "' '">是换行，如果不想取换行，拿到所有的子节点，不要文本节点，如何做？

>>> print((books[0].childNodes)[1::2]) #使用切片实现

[<DOM Element: title at 0x28471513898>, <DOM Element: author at 0x284715139c8>, <DOM Element: pageNumber at 0x28471513930>]

8) 获取节点文本值重要！！

　　1.
from xml.dom.minidom import parse #从xml.dom.minidom模块引入解析器parse
DOMTree = parse(r"e:ook.xml") #minidom解析器打开xml文档并将其解析为内存中的一棵树
print(type(DOMTree))

<class 'xml.dom.minidom.Document'>
booklist = DOMTree.documentElement
print(booklist)

<DOM Element: booklist at 0x23b6dba2b90>
print("*"*30)

******************************
books = booklist.getElementsByTagName("book")
d={}
for i in range(1,6,2):
    tag_name = books[1].childNodes[i].tagName          #读取标签名字
    d[tag_name]=books[1].childNodes[i].childNodes[0].data #读取标签值
print(d)              #标签值（文本节点）对于标签来说是一个子节点

{'title': 'learning Python', 'author': '李四', 'pageNumber': '600'}
for k,v in d.items():
print(k,v)

title learning Python

author 李四

pageNumber 600

.data读取文本节点的值，.data是文本对象的属性，必须是文本对象才可用.data

.tagname读取标签值

element节点在<>中，文本节点是看不见的换行和文字内容

　　2.
import xml.dom.minidom
from xml.dom.minidom import parse
DOMTree = xml.dom.minidom.parse(r"e:ook.xml") 　　#minidom解析器打开xml文档并将其解析为内存中的一棵树
booklist = DOMTree.documentElement　　#获取xml文档对象，就是拿到树的根
if booklist.hasAttribute("type") : #判断根节点booklist是否有type属性，有则获取并打印属性的值
print(u"Root element is", booklist.getAttribute("type"))
books = booklist.getElementsByTagName("book")　　#获取booklist对象中所有book节点的list集合
print(u"book节点的个数：", books.length)
for book in books :
    print("*******************book*******************")
    if book.hasAttribute("category") :
        print(u"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)

运行结果：

E:>python a.py

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

9) node.haschildNodes():判断是否有子节点

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

import xml.dom.minidom

from xml.dom.minidom import parse

#minidom解析器打开xml文档并将其解析为内存中的一棵树

DOMTree = xml.dom.minidom.parse(r"e:ook.xml")

#获取xml文档对象，就是拿到树的根

booklist = DOMTree.documentElement

#获取booklist对象中所有book节点的list集合

books = booklist.getElementsByTagName("book")

print(u"book节点的个数：", books.length)

book节点的个数： 2

print(books[0])

if books[0].hasChildNodes():

print(u"存在叶子节点 ", books[0].childNodes)

else :

print(u"不存在叶子节点")

存在叶子节点

[<DOM Text node "' '">, <DOM Element: title at 0x21a3acd0768>, <DOM Text node "' '">, <DOM Element: author at 0x21a3acd0800>, <DOM Text node "' '">, <DOM Element: pageNumber at 0x21a3acd0898>, <DOM Text node "' '">]

14、xml.dom创建xml文件

创建xml文件的步骤如下：

1. 创建xml空文档(在内存中创建，未在本地生成一个文档)

2. 产生根对象

3. 往根对象里加数据

4. 把xml内存对象写到文件

　　1) minidom.Document()：创建xml空白文档

该方法用于创建一个空白的xml文档，并返回这个doc对象

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

>>> import xml.dom.minidom

>>> doc = xml.dom.minidom.Document() #创建空白xml文档

>>> print(doc)

<xml.dom.minidom.Document object at 0x00000172BBBDCAC8>

　　2) doc.createElement(tagName):创建xml文档根节点

生成xml文档节点。参数表示要生成节点的名称

>>> import xml.dom.minidom

>>> doc = xml.dom.minidom.Document()

>>> print(doc)

<xml.dom.minidom.Document object at 0x00000172BBBDCAC8>

>>> root = doc.createElement("Manegers")

>>> print(u"添加的xml的标签为：",root.tagName)

添加的xml的标签为： Manegers #同样未写到文件中，保存在内存中。

3) node.setAttribute(attname,value):添加节点属性值对

参数说明：

attname:属性的名称

value：属性的值

>>> root.setAttribute("company","xx科技")

>>> value = root.getAttribute("company")

>>> print("root元素的company的属性值是：",value)

root元素的company的属性值是： xx科技

4) doc.createTextNode(data):添加文本节点

>>> ceo = doc.createElement("CEO") #CEO节点并没有挂在根节点下

>>> ceo.appendChild(doc.createTextNode("吴总")) #文本节点”吴总”必须依附于element节点ceo下,等价于<CEO>吴总</CEO>

>>> print(ceo.tagName)

CEO

　5) doc/parentNode.appendChild(node):添加子节点

将节点node添加到文档对象doc作为文档树的根节点或者添加到父节点parentNode下作为其子节点。

import xml.dom.minidom

doc = xml.dom.minidom.Document() #在内存中创建一个空的文档

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

root.setAttribute('name', u'公司信息') # 给根节点root添加属性

doc.appendChild(root) #将根节点添加到文档对象中

company = doc.createElement('gloryroad') # 给根节点添加一个叶子节点

name = doc.createElement("Name") # 叶子节点下再嵌套叶子节点

name.appendChild(doc.createTextNode(u"光荣之路教育科技公司"))#给节点添加文本节点

ceo = doc.createElement('CEO')

ceo.appendChild(doc.createTextNode(u'吴总'))

company.appendChild(name) #将各叶子节点添加到父节点company中

company.appendChild(ceo)

root.appendChild(company) #然后将company添加到跟节点companys中

print(doc.toxml())

<?xml version="1.0" ?>

<Name>光荣之路教育科技公司</Name>

</gloryroad>

</companys>

6) doc.writexml():生成xml文档

函数原型：

writexml(writer,indent = “”,addindent = “”,newl = “”,encoding=None)

该方法用于将内存中xml文档树写入文件中，并保存在本地磁盘

参数说明：

writer:要写的目标文件的文件对象

indent:指明根节点缩进方式

addindent:指明子节点缩进方式

newl:针对新行，指明换行方式

encoding：指明所写xml文档的编码

import xml.dom.minidom

doc = xml.dom.minidom.Document() #在内存中创建一个空的文档

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

root.setAttribute('name', u'公司信息') # 给根节点root添加属性

doc.appendChild(root) #将根节点添加到文档对象中

company = doc.createElement('gloryroad') # 给根节点添加一个叶子节点

name = doc.createElement("Name") # 叶子节点下再嵌套叶子节点

name.appendChild(doc.createTextNode(u"光荣之路教育科技公司"))#给节点添加文本节点

ceo = doc.createElement('CEO')

ceo.appendChild(doc.createTextNode(u'吴总'))

company.appendChild(name) #将各叶子节点添加到父节点company中

company.appendChild(ceo)

root.appendChild(company) #然后将company添加到根节点companys中

fp = open(“e:\company.xml”,”w”,encoding = “utf-8”)

doc.writexml(fp,indent=‘ ’，addindent=” ”,newl=” ”,encoding =”utf-8”)

fp.close() #indent=” ”是对根节点生效的。可以看见下面的结果根节点前有个” ”

在e:\company.xml的文件显示的内容是：

<?xml version="1.0" encoding="utf-8"?>

<Name>光荣之路教育科技公司</Name>

</gloryroad>

</companys>

15、xml.dom创建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('e:\Manager.xml', 'w')

doc.writexml(fp, indent=' ', addindent=' ', newl=' ', encoding="utf-8")

fp.close()

Manager.xml文件的内容是：

<?xml version="1.0" encoding="utf-8"?>

</Manager>

</Manager>

</Manager>

</Managers>

16. Etree

movies.xml:

<type>War, Thriller</type>

<description>Talk about a US-Japan war</description>

</movie>

<type>Anime, Science Fiction</type>

<description>A schientific fiction</description>

</movie>

<type>Anime, Action</type>

<description>Vash the Stampede!</description>

</movie>

<type>Comedy</type>

<description>Viewable boredom</description>

</movie>

</collection>

1). 遍历xml文件：

import sys
try:
    import xml.etree.cElementTree as ET #as ET作为别名，是用c语言写的Etree的包，比不带c的包快，但是有可能这个包没有
except ImportError:
    import xml.etree.ElementTree as ET #如果没有，就引入不带c的包

tree = ET.ElementTree(file='e:\movies.xml') #打开movies.xml文件
root=tree.getroot()   #获取根节点

#<Element 'collection' at 0x0000024FA6D96B88>
print (root.tag) #获取根节点的标签

#collection
print (root.attrib) #获取根节点的属性值，返回值是字典
#{'shelf': 'New Arrivals'}

print (root.attrib[“shelf”]) #获取指定属性的属性值

#New Arrivals

for child_of_root in root: #获取root下一级的子节点，并打印标签和属性
print (child_of_root.tag)
print ("********", child_of_root.attrib)

#movie

#******** {'title': 'Enemy Behind'}

#movie

#******** {'title': 'Transformers'}

#movie

#******** {'title': 'Trigun'}

#movie

#******** {'title': 'Ishtar'}

print ("*"*50)

# **************************************************
print (root[0].tag) #打印一个movie

#movie
print (root[0].text) #第一个movie的文本节点，“打印的内容为一个回车”

#打印内容为一个回车
print (root[0][0].tag) #获取第一个movie下面的子节点的标签

#type
print (root[0][0].text) #获取第一个movie下面的子节点的文本内容
# War, Thriller
print ("*"*50)

**************************************************
for elem in tree.iter(): #递归遍历所有子元素
print (elem.tag, elem.attrib)
#collection {'shelf': 'New Arrivals'}

#movie {'title': 'Enemy Behind'}

#type {}

#format {}

#year {}

#rating {}

#stars {}

#description {}

#movie {'title': 'Transformers'}

#type {}

#format {}

#year {}

#rating {}

#stars {}

#description {}

#movie {'title': 'Trigun'}

#type {}

#format {}

#episodes {}

#rating {}

#stars {}

#description {}

#movie {'title': 'Ishtar'}

#type {}

#format {}

#rating {}

#stars {}

#description {}
print ("*"*50)

**************************************************
for elem in tree.iterfind('movie/type'):#查找movie下一级节点中的所有type标签 ,XPATH的应用场景
print (elem.tag, elem.attrib)
#type {}

#type {}

#type {}
print ("*"*50)

**************************************************
for elem in tree.iter(tag='stars'):#在整个树中查找标签为star的元素
print (elem.tag, elem.attrib)

#stars {}

#stars {}
print ("*"*50)

#**************************************************
for elem in tree.iterfind('*[@title="Ishtar"]'): #查找属性为title="Ishtar"的元素，iterfind是个迭代器
print (elem.tag, elem.attrib)
#movie {'title': 'Ishtar'}
print ("*"*50)

#**************************************************
for elem in tree.iterfind('movie[@title="Ishtar"]'): #查找movie下属性为title="Ishtar"的元素
print (elem.tag, elem.attrib)
#movie {'title': 'Ishtar'}
print ("-"*50)

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

root = tree.getroot()
print ("root:",root[0].tag )          #打印第一级movie元素的标签，为movie
print ("subnode:",root[0][0].tag)      #打印第一级movie元素下的第一个子元素标签type
print ("subnode:",root[0][1].tag )     #打印第一级movie元素下的第二个子元素标签format
print ("subnode:",root[0][2].tag )     #打印第一级movie元素下的第三个子元素标签year
print ("subnode:",root[0][3].tag )     #打印第一级movie元素下的第四个子元素标签rating
print ("subnode:",root[0][4].tag )     #打印第一级movie元素下的第五个子元素标签stars
del root[0][4] #删除第一级movie元素下的第四个子元素
del root[0][3] #删除第一级movie元素下的第三个子元素
del root[0][2] #删除第一级movie元素下的第二个子元素
del root[0][1] #删除第一级movie元素下的第一个子元素

del root[3] #删除第四个movie元素
del root[2] #删除第三个movie元素

for subelem in root:
    print (subelem.tag, subelem.attrib) #打印四个movie元素的标签和属性

tree.write("d:\movies.xml") #将变更的xml文件写入到文件中

2) 新建一个xml 文件：

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

a = ET.Element('elem')            #生成一个节点elem，没有文本节点
c = ET.SubElement(a, 'child1')    #生成一个子节点下的子节点child1
c.text = "some text"              #在子节点上添加文本节点
d = ET.SubElement(a, 'child2')    #生成一个子节点下的子节点child2
b = ET.Element('elem_b')          #生成一个节点elem_b，没有文本节点
root = ET.Element('root')         #生成一个节点root
root.extend((a, b))               #将a、b两个变量存储的节点elem和elem1添加到root节点下
tree = ET.ElementTree(root)       #生成节点树
root[0].set('foo', 'bar')         #设定第一个子元素的属性foo,值为bar

tree.write("d:\test.xml")        #将xml文件内容写入到文本文件中

3) 边读边解析xml文件

#coding=utf-8
import sys
try:
    import xml.etree.cElementTree as ET
except ImportError:
    import xml.etree.ElementTree as ET

tree = ET.parse("d:\movies.xml")

count = 0
for elem in tree.iter(tag='movie'): #遍历树中的movie节点
    print (elem.tag)
    if elem[0].text == 'War, Thriller':
        count += 1
print (count)

#以下代码实现了边读文件边解析的作用，节省了内存
count = 0
for event, elem in ET.iterparse("d:\movies.xml"): #遍历所有xml文件中的标签
    #print (elem.tag)
    if event == 'end': #检测“闭合的”(end)事件，标签关闭
        if elem.tag == 'type' and elem.text == 'War, Thriller': #标签为type，且文本内容为War, Thriller ,则count+1
            count += 1
    elem.clear() #清除元素内容,不清除则整个儿树也会在内存中，没有起到节省内存的作用。

print (count)

#事件
#start 在元素打开时触发。数据和元素的子元素仍不可用。
# end 在元素关闭时触发。所有元素的子节点，包括文本节点，现在都是可用的。
#close 在解析完成后触发。

小练习：

获取database.xml文件中的hostusernameassworddatabasename的值。

databases.xml：

<host>localhost</host>

<datasename>wulaoshi</datasename>

</database>

</databaselist>

程序：

from xml.dom.minidom import parse #从xml.dom.minidom模块引入解析器parse

DOMTree = parse(r"e:databases.xml") #minidom解析器打开xml文档并将其解析为内存中的一棵树

databaselist = DOMTree.documentElement

database = databaselist.getElementsByTagName("database")

print(database)

[<DOM Element: database at 0x1e873fa6638>]

d={}

for i in range(1,8,2):

tag_name = database[0].childNodes[i].tagName

d[tag_name]=database[0].childNodes[i].childNodes[0].data

print(d)

{'host': 'localhost', 'username': 'root', 'password': '11111', 'datasename': 'wulaoshi'}

============================

方法1：

for k,v in d.items():

print(k,v)

host localhost

username root

password 11111

datasename wulaoshi

==============================

方法2：

host = d["host"]

username = d["username"]

password = d["password"]

datasename = d["datasename"]

print(host)

==============================