XML
XML指可扩展标记语言（Extensible Markup Language）
XML被设计用于结构化、存储和传输数据
XML是一种标记语言，很类似于HTML
XML没有像HTML那样具有预定义标签，需要程序员自定义标签。
XML被设计为具有自我描述性，并且是W3C的标准
<html>
<head>
<title>gloryroad test</title>
</head>
<body>
<h1>标题1</h1>
<h2>标题2</h2>
<h3>标题3</h3>
<h4>标题4</h4>
<h5>标题5</h5>
<h6>标题1</h6>
<p><i><b>I am a boy! </b></i></p>
</br>
<div>
<table>
<th>company</th>
<tr><td>gloryroad1</td></tr>
<tr><td>gloryroad2</td></tr>
<tr><td>gloryroad3</td></tr>
</table>
</div>
<a href="http://www.gloryroad.cn" target ="_blank"> gloryroad</a>
<a href="http://www.gloryroad.cn"><img src="https://ss0.bdstatic.com/5aV1bjqh_Q23odCf/static/superman/img/logo_top_ca79a146.png">pic</img></a>
<form method = "POST" action="sssss.asp" >
<input type="text">用户名 </input>
<input type="password">密码 </input>
<input type="submit" value="提交"> </input>
</form>
<textarea cols=200> </textarea>
</body>
</html>
XML文档（树结构）
<root>
<child>
<subchild>....</subchild>
</child>
</root>
XML文档形成了一种树结构，它从“根部”开始，然后扩展到“树枝”。
XML文档必须包含根元素，该元素是所有其他元素的父元素，文档中的所有元素形成了一棵文档树，这课树从根开始，并扩展到树的最顶端，并且所有的元素都可以有子元素。
父元素拥有子元素，相同层级上的子元素成为同胞（兄弟或姐妹）。
XML中所有子元素都可以有文本内容和属性，类似于HTML
XML基础知识介绍
XML的元素是指从开始标签直到结束标签的部分（均包括开始结束）。
一个元素可以包含：
1、其他元素
2、文本
3、属性
4、或混合以上所有
XML元素 XML语法规则
ü所有的XML元素都必须有一个开始标签和结束标签，省略结束标签是非法的。如： <root> content </root>
üXML标签对大小写敏感；比如： 下面是两个不同的标签 <Note>this is a test1</Note> <note>this is a test2</note>
XML基础知识介绍
XML文档必须有根元素。如： <note> <b>this is a test2</b> <name>joy</name> </note>
XML必须正确嵌套，父元素必须完全包住子元素。如： <note><b>this is a test2</b></note>
üXML属性值必须加引号，元素的属性值都是一个键值对形式。如： <book category=" Python"></book> 注意：book元素中的属性category的值是python必须用引号引起来，使用单引号和双引号都可以，但是如果属性值本身包含双引号，外层就必须使用单引号；但如果包含了单引号，外层必须使用双引号。
XML命名规则
XML元素必须遵循以下命名规则：
Ø名称可以包含字母、数字以及其他字符
Ø名称不能以数字或标点符号开头
Ø名称不能以字母xml或XML开始
Ø名称不能包含空格
Ø可以使用任何名称，没有保留字
Ø名称应该具有描述性，简短和简单，可以同时使用下划线。
Ø避免“-”、“.”、“：”等字符。
XML注释格式为:
<!-- 注释内容 -->
CDATA
CDATA（Unparsed Character Data）指的是不应由XML解析器进行解析的文本数据。
因为XML解析器会将“<”（新元素的开始）和”&”（字符实体的开始）解析成具有特殊含义的字符，所以如果在文本中需要使用这些字符时，就必须使用实体引用去代替。但是有些文本，如JavaScript代码中会包含大量的”<”和”&”符号，这时我们可以将我们的脚本定义为CDATA来避免这个问题，因为XML文档中的所有文本均会被解析器解析，只有CDATA部分中所有的内容会被XML解析器忽略。
CDATA固定语法格式：
<![CDATA[“我们自己的代码"]]>
Python解析XML三种方法
1、SAX（simple API for XML）
Python标准库中包含SAX解析器，SAX是用的是事件驱动模型，通过在解析XML过程中触发一个个的事件并调用用户定义的回调函数来处理XML文件。
解析的基本过程：
读到一个XML开始标签，就会开始一个事件，然后事件就会调用一系列的函数去处理一些事情，当读到一个结束标签时，就会触发另一个事件。所以，我们写XML文档入如果有格式错误的话，解析就会出错。
这是一种流式处理，一边读一边解析，占用内存少。
2、DOM（Document Object Model）
DOM是Document Object Model的简称，它是以对象树来表示一个XML文档的方法，使用它的好处就是你可以非常灵活的在对象中进行遍历。
将XML数据在内存中解析成一个树，通过对树的操作来操作XML。
由于DOM是将XML读取到内存，然后解析成一个树，如果要处理的XML文本比较大的话，就会很耗内存，所以DOM一般偏向于处理一些小的XML，（如配置文件）比较快。
3、ElementTree（Object Model）
ElementTree就像一个轻量级的DOM，具有方便而友好的API。代码的可用性好、速度快、消耗内存少。可以认为是对DOM的改进。
注意：DOM需要将XML数据映射到内存中的树，一是比较慢，而是比较耗内存，而SAX流式读取XML文件，比较快，占内存少，但需要用户实现回调函数（handler）。
Xml.dom解析XML
xml.dom解析xml思路
一个DOM的解析器在解析一个XML文档时，一次性读取整个文档，把文档中所有元素保存在内存中的一个树结构里，之后利用DOM提供的不同函数来读取该文档的内容和结构，也可以把修改过的内容写入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>
xml.dom解析xml常用API
minidom.parse(parser=None, bufsize=None)
该函数的作用是使用parse解析器打开xml文档，并将其解析为DOM文档，也就是内存中的一棵树，并得到这个DOM对象。
#coding=utf-8
#从xml.dom.minidom模块引入解析器parse
from xml.dom.minidom import parse
#minidom解析器打开xml文档并将其解析为内存中的一棵树
DOMTree = parse(r"D:XXX.xml")
print type(DOMTree)
c:Python27Scripts>python task_test.py
<type 'instance'>
xml.dom解析xml常用API
doc.documentElement
获取xml文档对象，就是拿到DOM树的根。
#coding=utf-8
from xml.dom.minidom import parse
#minidom解析器打开xml文档并将其解析为内存中的一棵树
DOMTree = parse(r"D:xxx.xml")
#获取xml文档对象，就是拿到树的根
booklist = DOMTree.documentElement
print booklist
c:Python27Scripts>python task_test.py
<DOM Element: booklist at 0x5908bc0>
获取xml文档函数 doc.toxml(encoding=None)
DOMTree.toxml()查看xml标签的内容是什么
-------------------------------------------------------------------------
from xml.dom.minidom import parse
#minidom解析器打开xml文档并将其解析为内存中的一棵树
DOMTree = parse(r"D:xxx.xml")
#获取xml文档对象，就是拿到树的根
booklist = DOMTree.documentElement
print u"DOM树的根对象：", booklist
print u"xml文档内容： %s" %DOMTree.toxml()
c:Python27Scripts>python task_test.py
DOM树的根对象： <DOM Element: booklist at 0x59fad78>
xml文档内容：
<?xml version="1.0" ?><!--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>
判断是否包含属性
hasAttribute(name): 判断某个节点node是否存在某个属性，存在则返回True，否则返回False。
#coding=utf-8
from xml.dom.minidom import parse
#minidom解析器打开xml文档并将其解析为内存中的一棵树
DOMTree = parse(r"D:xxx.xml")
#获取xml文档对象，就是拿到树的根
booklist = DOMTree.documentElement
print u"DOM树的根对象：", booklist
if booklist.hasAttribute("type") :
#判断根节点booklist是否有type属性
print u"booklist元素存在type属性"
else :
print u"booklist元素不存在type属性"
c:Python27Scripts>python task_test.py
DOM树的根对象： <DOM Element: booklist at 0x5a99df0>
booklist元素存在type属性
获取属性
node. getAttribute(attname)，获取节点node的某个属性的值。
#coding=utf-8
from xml.dom.minidom import parse
#minidom解析器打开xml文档并将其解析为内存中的一棵树
DOMTree = parse(r"D:xxx.xml")
#获取xml文档对象，就是拿到树的根
booklist = DOMTree.documentElement
if booklist.hasAttribute("type") :
#判断根节点booklist是否有type属性，有则获取并打印属性的值
print "Root element is", booklist.getAttribute("type")
c:Python27Scripts>python task_test.py
Root element is science and engineering
获取节点元素
node.getElementsByTagName(name) 获取XML文档中某个父节点下具有相同节点名的节点对象集合，是一个list对象。
#coding=utf-8
from xml.dom.minidom import parse
#minidom解析器打开xml文档并将其解析为内存中的一棵树
DOMTree = parse(r"D:xxx.xml")
#获取xml文档对象，就是拿到树的根
booklist = DOMTree.documentElement
#获取booklist对象中所有book节点的list集合
books = booklist.getElementsByTagName("book")
print type(books)
print books
c:Python27Scripts>python task_test.py
<class 'xml.dom.minicompat.NodeList'>
[<DOM Element: book at 0x59f8d00>, <DOM Element: book at 0x5a00058>]
获取author节点
#coding=utf-8
#coding=utf-8
from xml.dom.minidom import parse
#minidom解析器打开xml文档并将其解析为内存中的一棵树
DOMTree = parse(r"D:xxx.xml")
#获取xml文档对象，就是拿到树的根
booklist = DOMTree.documentElement
#获取booklist对象中所有book节点的list集合
books = booklist.getElementsByTagName("book")
print type(books)
print books
author = booklist.getElementsByTagName("author")
print type(author)
print author
c:Python27Scripts>python task_test.py
<class 'xml.dom.minicompat.NodeList'>
[<DOM Element: book at 0x5438d00>, <DOM Element: book at 0x5440058>]
<class 'xml.dom.minicompat.NodeList'>
[<DOM Element: author at 0x5438eb8>, <DOM Element: author at 0x5440210>]
上面解析xml的程序中，getElementsByTagName()函数返回的是同一父节点下所有同级（即兄弟节点）节点中相同标签的集合，这是一个list对象，所以可以使用list序列所有操作。这个时候，我们可以通过索引去拿相应的节点，也可以使用节点名称去拿相应的节点，推荐第二种方法，准确。也可以通过循环遍历整个返回的list。
注意：
就算某个父节点下没有同名的节点，该方法返回的仍是一个list，只是此时的list为空。
node.childNodes
返回节点node下所有子节点组成的list。
#coding=utf-8
from xml.dom.minidom import parse #从xml.dom.minidom模块引入解析器parse
#minidom解析器打开xml文档并将其解析为内存中的一棵树
DOMTree = parse(r"D:xxx.xml")
#获取xml文档对象，就是拿到树的根
booklist = DOMTree.documentElement
#获取booklist对象中所有book节点的list集合
books = booklist.getElementsByTagName("book")
print books[0].childNodes
c:Python27Scripts>python task_test.py
[<DOM Text node "u' '">, <DOM Element: title at 0x5418df0>, <DOM Text node "u' '">, <DOM Element: author at 0x5418e90>, <DOM Text node "u' '">, <DOM Element: pageNumber at 0x5418f30>, <DOM Text node "u' '">]
把book[0]节点下所有子节点名称和内容列出来
#coding=utf-8
#从xml.dom.minidom模块引入解析器parse
from xml.dom.minidom import parse
#minidom解析器打开xml文档并将其解析为内存中的一棵树
DOMTree = parse(r"d:xxx.xml")
print type(DOMTree)
booklist = DOMTree.documentElement
print booklist
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
for k,v in d.items():
print k,v
c:Python27Scripts>python task_test.py
<type 'instance'>
<DOM Element: booklist at 0x55a8bc0>
******************************
{u'author': u'u674eu56db', u'pageNumber': u'600', u'title': u'learning Python'}
author 李四
pageNumber 600
title learning Python
指示：
<?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>
#排序
0、2、4、6文本节点回车
1、3、5是标签节点
<book category="Python">0
<title1>learning Python</title>2
<author3>李四</author>4
<pageNumber5>600</pageNumber>6
</book>
</booklist>
book[1].childnodes:0,1,2,3,4,5,6
<title1>learning Python</title>
book[1].childnodes[1].childnodes---》列表
book[1].childnodes[1].childnodes[0]--->文本结点对象
book[1].childnodes[1].childnodes[0].data--->取到文本结点对象的具体内容值
练习：
1 自定义一个xml文件，包含数据库的ip地址，用户名、密码和数据库名称
2 将它从xml中读取出来，放到一个List里面
#coding=utf-8
#从xml.dom.minidom模块引入解析器parse
from xml.dom.minidom import parse
#minidom解析器打开xml文档并将其解析为内存中的一棵树
DOMTree = parse(r"e:database.xml")
#print type(DOMTree)
databases = DOMTree.documentElement
databases =databases.getElementsByTagName("database")
database_info =[]
for i in range(1,8,2):
config_name = databases[0].childNodes[i].tagName
config_value=databases[0].childNodes[i].childNodes[0].data
database_info.append(config_name+":"+config_value)
print database_info
for i in database_info:
print i
获取节点文本值
node.childNodes[index].data
获取节点node的文本值，即标签之间的文本内容
#coding=utf-8
import xml.dom.minidom
from xml.dom.minidom import parse
#minidom解析器打开xml文档并将其解析为内存中的一棵树
DOMTree = xml.dom.minidom.parse(r"D:xxx.xml")
#获取xml文档对象，就是拿到树的根
booklist = DOMTree.documentElement
if booklist.hasAttribute("type") :
#判断根节点booklist是否有type属性，有则获取并打印属性的值
print u"Root element is", booklist.getAttribute("type")
#获取booklist对象中所有book节点的list集合
books = booklist.getElementsByTagName("book")
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
c:Python27Scripts>python task_test.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
练习：获取title节点的个数：
#coding=utf-8
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
books = booklist.getElementsByTagName("book")
count =0
for book in books :
print "*******************book*******************"
title = book.getElementsByTagName('title')
count+= len(title)
print u"共有%s 个title" %str(count)
c:Python27Scripts>python task_test.py
*******************book*******************
*******************book*******************
共有2 个title
X判断是否有子节点
node .hasChildNodes()
判断节点node下是否有叶子节点，如果有返回True，否则返回False。但是需要注意的是，每个节点都默认有一个文本叶子节点，所以只要标签后有值，就返回True，只有当标签后没值时并且也没有叶子节点时才会返回False 。
#coding=utf-8
import xml.dom.minidom
from xml.dom.minidom import parse
#minidom解析器打开xml文档并将其解析为内存中的一棵树
DOMTree = xml.dom.minidom.parse(r"D:xxx.xml")
#获取xml文档对象，就是拿到树的根
booklist = DOMTree.documentElement
#获取booklist对象中所有book节点的list集合
books = booklist.getElementsByTagName("book")
print u"book节点的个数：", books.length
print books[0]
if books[0].hasChildNodes():
print u"存在叶子节点 ", books[0].childNodes
else :
print u"不存在叶子节点"
c:Python27Scripts>python task_test.py
book节点的个数： 2
<DOM Element: book at 0x4e5aeb8>
存在叶子节点
[<DOM Text node "u' '">, <DOM Element: title at 0x4e5afd0>, <DOM Text node "u' '">, <DOM Element: author at 0x4e630a8>, <DOM Text node "u' '">, <DOM Element: pageNumber at 0x4e63148>, <DOM Text node "u' '">]
xml.dom解析xml的完整实例
xml文件：
<?xml version="1.0" encoding="utf-8" ?>
<!--this is a test about xml.-->
<collection shelf="New Arrivals">
<movie title="Enemy Behind">
<type>War, Thriller</type>
<format>DVD</format>
<year>2003</year>
<rating>PG</rating>
<stars>10</stars>
<description>Talk about a US-Japan war</description>
</movie>
<movie title="Transformers">
<type>Anime, Science Fiction</type>
<format>DVD</format>
<year>1989</year>
<rating>R</rating>
<stars>8</stars>
<description>A schientific fiction</description>
</movie>
<movie title="Trigun">
<type>Anime, Action</type>
<format>DVD</format>
<episodes>4</episodes>
<rating>PG</rating>
<stars>10</stars>
<description>Vash the Stampede!</description>
</movie>
<movie title="Ishtar">
<type>Comedy</type>
<format>VHS</format>
<rating>PG</rating>
<stars>2</stars>
<description>Viewable boredom</description>
</movie>
</collection>
存成yyy.xml, utf-8格式
#coding=utf-8
from xml.dom.minidom import parse
import xml.dom.minidom
# 使用minidom解析器打开 XML 文档
DOMTree = xml.dom.minidom.parse(r"D:yyy.xml")
collection = DOMTree.documentElement
if collection.hasAttribute("shelf"):
print "Root element : %s" % collection.getAttribute("shelf")
# 在集合中获取所有电影
movies = collection.getElementsByTagName("movie")
# 打印每部电影的详细信息
for movie in movies:
print "*****Movie*****"
if movie.hasAttribute("title"):
print "Title: %s" % movie.getAttribute("title")
type = movie.getElementsByTagName('type')[0]
print "Type: %s" % type.childNodes[0].data
format = movie.getElementsByTagName('format')[0]
print "Format: %s" % format.childNodes[0].data
rating = movie.getElementsByTagName('rating')[0]
print "Rating: %s" % rating.childNodes[0].data
description = movie.getElementsByTagName('description')[0]
print "Description: %s" % description.childNodes[0].data
c:Python27Scripts>python task_test.py
Root element : New Arrivals
*****Movie*****
Title: Enemy Behind
Type: War, Thriller
Format: DVD
Rating: PG
Description: Talk about a US-Japan war
*****Movie*****
Title: Transformers
Type: Anime, Science Fiction
Format: DVD
Rating: R
Description: A schientific fiction
*****Movie*****
Title: Trigun
Type: Anime, Action
Format: DVD
Rating: PG
Description: Vash the Stampede!
*****Movie*****
Title: Ishtar
Type: Comedy
Format: VHS
Rating: PG
Description: Viewable boredom
xml.dom创建XML文件
创建xml文件的步骤如下：
1、创建xml空文档
2、产生根对象
3、往根对象里加数据
4、把xml内存对象写到文件
创建xml空白文档
minidom.Document()
该方法用于创建一个空白的xml文档对象，并返回这个doc对象。
每个xml文档都是一个Document对象，代表着内存中的DOM树。
#coding=utf-8
import xml.dom.minidom
#在内存中创建一个空的文档
doc = xml.dom.minidom.Document()
print doc
c:Python27Scripts>python task_test.py
<xml.dom.minidom.Document instance at 0x04FFDE18>
创建xml文档根节点
doc.createElement(‘table’)
创建标签
#coding=utf-8
import xml.dom.minidom
#在内存中创建一个空的文档
doc = xml.dom.minidom.Document()
print doc
#创建一个根节点Managers对象
root = doc.createElement('Managers')
print u"添加的xml标签为：", root.tagName
c:Python27Scripts>python task_test.py
<xml.dom.minidom.Document instance at 0x054DDFD0>
添加的xml标签为： Managers
添加节点属性
#coding=utf-8
#coding=utf-8
import xml.dom.minidom
#在内存中创建一个空的文档
doc = xml.dom.minidom.Document()
print doc
#创建一个根节点Managers对象
root = doc.createElement('Managers')
print u"添加的xml标签为：", root.tagName
# 给根节点root添加属性
root.setAttribute('company', 'xx科技')
value = root.getAttribute('company')
print u"root元素的'company'属性值为：", value.decode('utf-8').encode('gbk')
c:Python27Scripts>python task_test.py
<xml.dom.minidom.Document instance at 0x05014030>
添加的xml标签为： Managers
root元素的'company'属性值为： xx科技
node.setAttribute(attname, value)
该方法表示给节点添加属性值对（Attribute） 。
参数说明：
attname ：属性
添加文本节点
doc.createTextNode(data)
给叶子节点添加文本节点。
#coding=utf-8
import xml.dom.minidom
#在内存中创建一个空的文档
doc = xml.dom.minidom.Document()
print doc
#创建一个根节点Managers对象
root = doc.createElement('company')
print u"添加的xml标签为：", root.tagName
# 给根节点root添加属性
root.setAttribute('name', '光荣之路教育科技有限公司')
# 给根节点添加一个叶子节点
ceo = doc.createElement('CEO')
#给叶子节点name设置一个文本节点，用于显示文本内容
ceo.appendChild(doc.createTextNode('吴总'))#在ceo的节点上加的，不是加到根节点上
print ceo.tagName
print u"给叶子节点添加文本节点成功"
c:Python27Scripts>python task_test.py
<xml.dom.minidom.Document instance at 0x05014030>
添加的xml标签为： Managers
root元素的'company'属性值为： xx科技
添加子节点
doc/parentNode.appendChild(node)
将节点node添加到文档对象doc作为文档树的根节点或者添加到父节点parentNode下作为其子节点。
#coding=utf-8
import xml.dom.minidom
#在内存中创建一个空的文档
doc = xml.dom.minidom.Document()
#创建一个根节点company对象
root = doc.createElement('companys')
# 给根节点root添加属性
root.setAttribute('name', u'公司信息')
#将根节点添加到文档对象中
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中
# 然后将company添加到跟节点companys中
company.appendChild(name)
company.appendChild(ceo)
root.appendChild(company)
print doc.toxml()
c:Python27Scripts>python task_test.py
<?xml version="1.0" ?><companys name="公司信息"><gloryroad><Name>光荣之路教育科技公司</Name><CEO>吴总</CEO></gloryroad></companys>
生成XML文档
doc.writexml()
函数原型：
writexml(writer, indent='', addindent='', newl='', encoding=None)
该方法用于将内存中xml文档树写入文件中，并保存到本地磁盘。
上面我创建的xml文档仅是存在内存中的，并未真正写入硬盘，只有调用该方法以后，才能真正将我们创建的xml文档写入本地硬盘，这时我们才能在硬盘中看见新建的xml文档。
参数说明：
writer ：要写的目标文件的文件对象。
indent ：指明根节点缩进方式。
addindent：指明子节点缩进方式
newl : 针对新行，指明换行方式
encoding : 指明所写xml文档的编码
#coding=utf-8
import codecs
import xml.dom.minidom
#在内存中创建一个空的文档
doc = xml.dom.minidom.Document()
#创建一个根节点company对象
root = doc.createElement('companys')
# 给根节点root添加属性
root.setAttribute('name', u'公司信息')
#将根节点添加到文档对象中
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中
# 然后将company添加到跟节点companys中
company.appendChild(name)
company.appendChild(ceo)
root.appendChild(company)
#codecs就是一个编码解码器，如果不用的话，默认存成gbk
fp = codecs.open('D:\company.xml', 'w','utf-8')
doc.writexml(fp, indent='', addindent=' ', newl=' ', encoding="utf-8")
fp.close()
练习：自己写一个xml的文件，例如：刚才的database的配置文件
需要改：
#coding=utf-8
import codecs
import xml.dom.minidom
doc=xml.dom.minidom.Document()
root=doc.createElement('database')
root.setAttribute('name',u'数据库信息')
doc.appendChild(root)
database=doc.createElement('oracle')
name=doc.createElement('Name')
name.appendChild(doc.createTextNode(u'xxx'))
passwd=doc.createElement('passwd')
passwd.appendChild(doc.createTextNode("123456"))
database.appendChild(name)
database.appendChild(passwd)
root.appendChild(database)
fp = codecs.open('D:\database.xml', 'w','utf-8')
doc.writexml(fp, indent='', addindent=' ', newl=' ', encoding="utf-8")
fp.close()
import xml.dom.minidom
import codecs
# 在内存中创建一个空的文档
doc = xml.dom.minidom.Document()
# 创建一个根节点company对象
root = doc.createElement('database')
# 给根节点root添加属性
root.setAttribute('dbinfo', u'數據庫信息')
# 将根节点添加到文档对象中
doc.appendChild(root)
# 给根节点添加一个叶子节点
company = doc.createElement('userinfo')
# 叶子节点下再嵌套叶子节点
name = doc.createElement("root")
# 给节点添加文本节点
name.appendChild(doc.createTextNode(u"root"))
ceo = doc.createElement('password')
ceo.appendChild(doc.createTextNode('123456'))
host = doc.createElement('IP')
host.appendChild(doc.createTextNode('127.0.0.1'))
# 将各叶子节点添加到父节点company中
# 然后将company添加到跟节点companys中
company.appendChild(name)
company.appendChild(ceo)
company.appendChild(host)
root.appendChild(company)
print doc.toxml()
fp = codecs.open('company.xml', 'a+', 'utf-8')
doc.writexml(fp, indent='', addindent=' ', newl=' ', encoding="utf-8")
fp.close()
批量生成xml文件
#coding=utf-8
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('D:\Manager.xml', 'w')
doc.writexml(fp, indent=' ', addindent=' ', newl=' ', encoding="utf-8")
fp.close()
边读边解析
Movies.xml:
<collection shelf="New Arrivals">
<movie title="Enemy Behind">
<type>War, Thriller</type>
<format>DVD</format>
<year>2003</year>
<rating>PG</rating>
<stars>10</stars>
<description>Talk about a US-Japan war</description>
</movie>
<movie title="Transformers">
<type>Anime, Science Fiction</type>
<format>DVD</format>
<year>1989</year>
<rating>R</rating>
<stars>8</stars>
<description>A schientific fiction</description>
</movie>
<movie title="Trigun">
<type>Anime, Action</type>
<format>DVD</format>
<episodes>4</episodes>
<rating>PG</rating>
<stars>10</stars>
<description>Vash the Stampede!</description>
</movie>
<movie title="Ishtar">
<type>Comedy</type>
<format>VHS</format>
<rating>PG</rating>
<stars>2</stars>
<description>Viewable boredom</description>
</movie>
</collection>
获取根节点
import sys
try:
import xml.etree.cElementTree as ET
except ImportError:
import xml.etree.ElementTree as ET
tree = ET.ElementTree(file='movies.xml')
root=tree.getroot()
print root.tag
print root.attrib
for child_of_root in root:
print child_of_root.tag
print "********", child_of_root.attrib
c:Python27Scripts>python task_test.py
collection
{'shelf': 'New Arrivals'}
movie
******** {'title': 'Enemy Behind'}
movie
******** {'title': 'Transformers'}
movie
******** {'title': 'Trigun'}
movie
******** {'title': 'Ishtar'}
获取文本节点内容
import sys
try:
import xml.etree.cElementTree as ET
except ImportError:
import xml.etree.ElementTree as ET
tree = ET.ElementTree(file='movies.xml')
root=tree.getroot()
print "*"*50
print root[0].tag
print root[0].text #“打印的内容为一个回车”
print root[0][0].tag
print root[0][0].text
c:Python27Scripts>python task_test.py
**************************************************
movie
type
War, Thriller
递归把xml文档所有的节点都取到
import sys
try:
import xml.etree.cElementTree as ET
except ImportError:
import xml.etree.ElementTree as ET
tree = ET.ElementTree(file='movies.xml')
print "*"*50
for elem in tree.iter(): #递归遍历所有子元素
print elem.tag, elem.text, elem.attrib
c:Python27Scripts>python task_test.py
**************************************************
collection
{'shelf': 'New Arrivals'}
movie
{'title': 'Enemy Behind'}
type War, Thriller {}
format DVD {}
year 2003 {}
rating PG {}
stars 10 {}
description Talk about a US-Japan war {}
movie
{'title': 'Transformers'}
type Anime, Science Fiction {}
format DVD {}
year 1989 {}
rating R {}
stars 8 {}
description A schientific fiction {}
movie
{'title': 'Trigun'}
type Anime, Action {}
format DVD {}
episodes 4 {}
rating PG {}
stars 10 {}
description Vash the Stampede! {}
movie
{'title': 'Ishtar'}
type Comedy {}
format VHS {}
rating PG {}
stars 2 {}
description Viewable boredom {}