Python-Json字符串和XML解析
Python-json字符串和xml解析
JSON:JavaScript Object Notation(JavaScript 對象表示法)
JSON是存儲和交換文本信息的語法，類似XML
JSON比XML更小，更快，更易解析。
1、JSON語法與語法規則
JSON語法是JavaScript語法的子集。
JSON語法是JavaScript對象表示語法的子集。
- 數據在名稱/值對中
- 數據由逗號分隔
- 花括號保存對象
- 方括號保存數組
1.1：JSON對象
JSON對象是保存在花括號中的。對象可以包含多個名稱/值對。例如
{ "firstName":"John" , "lastName":"Doe" }
這等價於JavaScript語句：
firstName=”Jonh”
lastname=”Doe”
1.2：JSON數組
JSON數組是保存在方括號[]中的。數組可以包含多個對象對象。例如
{
“employees”:[
{“firstName”:”John”,”lastName”:”Doe”},
{“firstName”:”Anna”,”lastName”:”Smith”},
{“firstName”:”Petter”,”lastName”:”Jones”}
]
}
在上述例子中，數組”employees”包含三個對象，每一個對象代表一條記錄
2、Python操作JSON
Python2.6開始加入了json模塊，Python的json模塊系列化和反序列化分別是dumps和loads。對簡單的數據類型可以直接處理，如：string,Unicode,int,float,list,tuple,dict
json.dumps():將一個Python對象編碼成JSON字符串。
json.loads():將JSON格式字符串解碼成Python對象。
2.1：Json編碼
使用json.dumps()方法來將一個Python數據類型列表編碼成json格式的字符串
#coding=utf-8
import json
a = [{1:12, ‘a‘:12.3}, [1,2,3], (1,2), ‘asd‘, u‘ad‘,12,13L,3.3,True,False,None]
print u"Python類型:\n", a
print u"編碼後的json串:\n",json.dumps(a)
#執行結果
E:\>python 0328test.txt
Python類型:
[{‘a‘: 12.3, 1: 12}, [1, 2, 3], (1, 2), ‘asd‘, u‘ad‘, 12, 13L, 3.3, True, False,None]
編碼後的json串:
[{"a": 12.3, "1": 12}, [1, 2, 3], [1, 2], "asd", "ad", 12, 13, 3.3, true, false,null]
觀察打印結果，會發現Python對象被轉換成JSON字符串之後，跟原始的輸出結果相比有一些特殊的變化；在json編碼的過程中，會存在從Python原始類型轉化為json類型的過程，這兩種語言的類型存在一些差異，對照如下
2.2：json.dumps()
函數原型：
dumps(obj,skipkeys=False,ensure_ascii=True,check_circular=True,allow_nan=True,cls=None,indent=None,separators=None,encoding=‘utf-8‘,d
efault=None,sort_keys=False,**kw)
該方法返回編碼後的一個json字符串，是一個str對象encodedjson
dumps函數的參數非常的多，常用參數介紹如下：
sort_keys:是否按字典排序(a-z)輸出，默認為False，默認編碼成json格式字符串後是緊湊輸出，並且也沒有順序，不利於可讀。示例如下：
#coding=utf-8
import json
a = [{"a":"A", "b":(2,3),"c":3.0}]
print json.dumps(a)
print json.dumps(a,sort_keys=True)
#執行結果
E:\>python 0328test.txt
[{"a": "A", "c": 3.0, "b": [2, 3]}]
[{"a": "A", "b": [2, 3], "c": 3.0}]
indent:設置參數縮進的空格數。縮進顯示 使讀起來更加清晰。例如：
#coding=utf-8
import json
a = [{"a":"A", "b":(2,3),"c":3.0}]
print json.dumps(a)
print json.dumps(a,sort_keys=True,indent=4)
#執行結果
E:\>python 0328test.txt
[{"a": "A", "c": 3.0, "b": [2, 3]}]
[
{
"a": "A",
"b": [
2,
3
],
"c": 3.0
}
]
separators:中文意思：分離器；參數的作用是去掉逗號”,”和分號”；”後面的空格，為了美化輸出結果，在輸出數據時逗號和分號後面都有空格，但是在傳輸數據的過程中越精簡越好，就可以使用separators對傳輸的json串進行壓縮。該參數是元組格式的，例如：
#coding=utf-8
import json
a = [{"a":"A", "b":(2,3),"c":3.0}]
print json.dumps(a)
print json.dumps(a,separators=(",",";"))
#執行結果
E:\>python 0328test.txt
[{"a": "A", "c": 3.0, "b": [2, 3]}]
[{"a";"A","c";3.0,"b";[2,3]}] #明顯有了縮短
skipkeys:在encoding過程中，dict對象的key只可以是基本數據類型(str,Unicode,int,long,float,bool,None),如果是其他類型，那麽在編碼過程中就會拋出TypeError的異常。skipkeys可以跳過那些非string對象key的處理，就是不處理。例如：
#coding=utf-8
import json
data= [ { ‘a‘:‘A‘, ‘b‘:(2, 4), ‘c‘:3.0, (1,2):‘D tuple‘ } ]
print u"不設置skipkeys參數"
try :
res1 = json.dumps(data) #skipkeys參數默認為False時
except Exception,e:
print e
print u"設置skipkeys參數"
print json.dumps(data,skipkeys=True) # skipkeys=True時
#執行結果
E:\>python 0328test.txt
不設置skipkeys參數
keys must be a string
設置skipkeys參數
[{"a": "A", "c": 3.0, "b": [2, 4]}]
ensure_ascii：表示編碼使用的字符集，默認是True，表示使用ascii碼進行編碼。如果設置為False，就會以Unicode進行編碼。由於解碼json字符串時返回的就是Unicode字符串，所以可以直接操作Unicode字符，然後直接編碼Unicode字符串，這樣會簡單些
2.3：Jsoon解碼json.loads()
將json格式字符串解碼成Python對象，使用json.loads()函數，可以將簡單數據類型解碼成Python對象，例如
#coding=utf-8
import json
a = [{1:12, ‘a‘:12.3}, [1,2,3], (1,2), ‘asd‘, u‘ad‘, 12, 13L, 3.3, True, False, None]
print u"編碼後\n", json.dumps(a)
print u"解碼後\n", json.loads(json.dumps(a))
#執行結果
E:\>python 0328test.txt
編碼後
[{"a": 12.3, "1": 12}, [1, 2, 3], [1, 2], "asd", "ad", 12, 13, 3.3, true, false, null]
解碼後
[{u‘a‘: 12.3, u‘1‘: 12}, [1, 2, 3], [1, 2], u‘asd‘, u‘ad‘, 12, 13, 3.3, True, False, None]
Json格式的字符串解碼成Python對象以後，String類型都變成了Unicode類型，數組變成了list，不會回到原來的元組類型，字典key的字符類型也被轉成Unicode類型。從json到Python的類型轉化
2.4：將類對象編碼成json串
Python中的dict對象可以直接序列化為json的{}，但是很多時候，可能用class表示對象，比如定義Animals類，然後直接去系列化就會報錯。因為類不是一個可以直接序列化的對象，我們需要用dumps()函數中的default參數來實現。
#coding=utf-8
import json
class Animals(object):
def __init__(self,name,sex,weight):
self.name=name
self.sex=sex
self.weight=weight
#將序列化函數定義到類裏面
def obj_json(self,obj_instance):
return{
"name":obj_instance.name,
"sex":obj_instance.sex,
"weight":obj_instance.weight}
#實例化
D=Animals("dog","man","30kg")
print json.dumps(D,default=D.obj_json)
#執行結果
E:\>python py.txt
{"name": "dog", "weight": "30kg", "sex": "man"}
相對於上面這種方法，還有一種更為簡單的方法，通常class及其實例都會有一個__dict__屬性（除非類中添加了__slots__屬性），它是一個dict類型，存儲的是類或者類實例中有效的屬性。
#coding=utf-8
import json
class Animals(object):
def __init__(self,name,sex,weight):
self.name=name
self.sex=sex
self.weight=weight
#將序列化函數定義到類裏面
def obj_json(self,obj_instance):
return{
"name":obj_instance.name,
"sex":obj_instance.sex,
"weight":obj_instance.weight}
#實例化
D=Animals("dog","man","30kg")
print D.__dict__
print json.dumps(D,default=lambda Animals:Animals.__dict__)
print json.dumps(D,default=lambda D:D.__dict__)
執行結果
E:\>python py.txt
{‘name‘: ‘dog‘, ‘weight‘: ‘30kg‘, ‘sex‘: ‘man‘}
{"name": "dog", "weight": "30kg", "sex": "man"}
{"name": "dog", "weight": "30kg", "sex": "man"}
2.4：將Json反序列化為類對象
json串反序列化成類對象或類的實例，使用的是loads()方法中的object_hook參數來實現。
#coding=utf-8
import json
class Animals(object):
def __init__(self,name,sex,weight):
self.name=name
self.sex=sex
self.weight=weight
#實例化
D=Animals("dog","man","30kg")
def JsonToClass(D):
return Animals(D["name"],D["sex"],D["weight"])
json_str=‘{"name":"cat","sex":"woman","weight":"5kg"}‘
d=json.loads(json_str,object_hook=JsonToClass)
print d
print d.name
#執行結果
E:\>python py.txt
<__main__.Animals object at 0x00000000026F2898>
cat
3、Xml
XML指可擴展標記語言（Extensible Markup Language）
XML被設計用於結構化、存儲和傳輸數據
XML是一種標記語言，很類似於HTML
XML沒有像HTML那樣具有預定義標簽，需要程序員自己定義標簽
XML被設計為具有自我描述性，並且是W3C的標準
3.1：XML文檔（樹結構）
XML文檔形成了一種樹結構，他從“根部”開始，然後擴展到“樹枝”。
XML文檔必須包含根元素，該元素是所有其他元素的父元素，文檔中的所有元素形成了一顆文檔樹，這棵樹從根開始，擴展到樹的最頂端，並且所有的元素都可以有子元素。
父元素擁有子元素，相同層級上的子元素成為同胞（兄弟或姐妹）。
XML中所有元素都可以有文本內容和屬性，類似於HTML。
<root>
<child>
<subchild>....</subchild>
</child>
</root>
3.2：XML元素&語法規則
XML的元素是指從開始標簽直到結束標簽的部分（均包括開始結束）。
一個元素可以包含：其他元素、文本、屬性
所有的XML元素都必須有一個開始標簽和結束標簽，省略結束標簽是非法的，如
<root> content </root>
XML標簽對大小寫敏感，區分大小寫，比如，下面是兩個不同的標簽
<Note>this is a test1</Note>
<note>this is a test2</note>
XML文檔必須有根元素。如：
<note>
<b>this is a test2</b>
<name>joy</name>
</note>
XML必須正確嵌套，父元素必須完全包住子元素
XML屬性值必須加引號，元素的屬性值都是一個鍵值對形式，如
<book category=" Python"></book>
註意：book元素中的屬性category的值是python必須用引號引起來，使用單引號和雙引號都可以，但是如果屬性值本身包含雙引號，外層就必須使用單引號；但如果包含了單引號，外層必須使用雙引號
3.2.1:XML命名規則
名稱可以包含字母、數字和其他字符
名稱不能以數字或者標點符號開頭
名稱不能以字母xml或者XML開始
名稱不能包含空格
可以使用任何名稱，沒有保留字
名稱應該具有描述性，簡短和簡單，可以同時使用下劃線
避免使用“-”“.”“：”等字符
XML註釋格式為：<!--註釋內容-->
3.2.2:CDATA
CDATA（Unparsed Character Data）指的是不應由Xml解析器進行解析的文本數據，因為Xml解析器會將”<”(新元素的開始)和”&”(字符實體的開始)解析成具有特殊含義的字符，所以在文本中需要使用這些字符時，就必須使用實體引用去代替。但是有些文本，如JavaScript代碼中會包含大量的”<”和”&”符號，這時我們可以將我們的腳本定義為CDATA來避免這個問題，因為XML文檔中的所有文本均會被解析器解析，只有CDATA部分中所有的內容會被XML解析器忽略。
CDATA固定語法格式：<![CDATA[]”我們自己的代碼”]>，如下示例
<script>
<![CDATA[
function test(x, y)
{ if (x < 0 && y < 0) then
{
return 0;
}
else
{
return 1;
}}
]]>
</script>
註意：CDATA部分不能包含字符串”]]>”,並且]]>之間不能有空格或者折行等支付，如果包含了，會以為是CDATA的結束。也不允許嵌套CDATA部分
3.3：Python解析XML三種方法
1.SAX(simple API for XML):python標準庫中包含SAX解析器,SAX使用的是事件驅動模型，通過在解析XML過程中觸發一個個的事件並調用用戶定義的回調函數來處理XML文件。
解析基本過程：讀到一個XML開始標簽，就會開始一個事件，然後事件就會調用一系列的函數去處理一些事情，當讀到一個結束標簽時，就會觸發另一個事件，所以如果XML文檔有格式錯誤的話，解析就會出錯。這是一種流式處理，一邊讀一邊解析，速度比較快，占用內存少，但是需要用戶實現回調函數（handler）
2.DOM(Document Object Model):DOM，他是以對象樹來表示一個XML文檔的方法，使用它的好處就是你可以非常靈活的在對象中進行遍歷。將XML數據在內存中解析成一個樹，通過對樹的操作來操作XML。由於DOM是將XML讀取到內存，然後解析成一個樹，一般比較慢，而且比較消耗內存，所以DOM一般偏向於處理一些小的XML，如配置文件
3.ElementTree(Object Model):ElementTree就像一個輕量級的DOM，具有方便而友好的API。代碼的可用性好、速度快，消耗內存少，可以認為是對DOM的改進。
3.3.1使用xml.dom解析xml
#XML文檔內容movie.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>
"""
minidom.parse(parser=None,bufsize=None):此函數的作用是使用parse解析器打開xml文檔，並將其解析為DOM文檔，也就是內存中的一棵樹，並得到這個DOM對象。
#coding=utf-8
#從xml.dom.minidom模塊引入解析器parse
from xml.dom.minidom import parse
import xml.dom.minidom
#minidom解析器打開xml文檔並將其解析為內存中的一棵樹
DOMTree= xml.dom.minidom.parse(r"e:\movie.xml")
print type(DOMTree)
執行結果
E:\>python py.txt
<type ‘instance‘>
doc.documentElement:獲取XML文檔對象，就是拿到DOM樹的根。
#coding=utf-8
#從xml.dom.minidom模塊引入解析器parse
from xml.dom.minidom import parse
#minidom解析器打開xml文檔並將其解析為內存中的一棵樹
DOMTree= parse(r"e:\movie.xml")
#獲取XML文檔對象，也就是樹的根節點
collection=DOMTree.documentElement
print collection
執行結果
E:\>python py.txt
<DOM Element: collection at 0x2771e48>
doc.toxml(encoding=None):獲取XML文檔函數，返回xml的文本內容
#coding=utf-8
#從xml.dom.minidom模塊引入解析器parse
from xml.dom.minidom import parse
#minidom解析器打開xml文檔並將其解析為內存中的一棵樹
DOMTree= parse(r"e:\movie.xml")
#獲取XML文檔對象，也就是樹的根節點
collection=DOMTree.documentElement
print u"DOM樹的根對象:",collection
print u"xml文檔內容:\n",DOMTree.toxml()
執行結果：
hasAttribute(name):判斷某個節點node是否存在某個屬性，存在則返回True,否則返回False。
#coding=utf-8
#從xml.dom.minidom模塊引入解析器parse
from xml.dom.minidom import parse
#minidom解析器打開xml文檔並將其解析為內存中的一棵樹
DOMTree= parse(r"e:\movie.xml")
#獲取XML文檔對象，也就是數的根節點
collection=DOMTree.documentElement
print u"DOM樹的根對象:",collection
if collection.hasAttribute("type"):
#判斷根節點collection是否存在type屬性
print u"collection元素存在type屬性"
else:
print u"collection元素不存在type屬性"
執行結果
E:\>python py.txt
DOM樹的根對象: <DOM Element: collection at 0x2881f48>
collection元素不存在type屬性
node.getAttribute(attname):獲取節點node的某個屬性的值
#coding=utf-8
#從xml.dom.minidom模塊引入解析器parse
from xml.dom.minidom import parse
#minidom解析器打開xml文檔並將其解析為內存中的一棵樹
DOMTree= parse(r"e:\movie.xml")
#獲取XML文檔對象，也就是數的根節點
collection=DOMTree.documentElement
print u"DOM樹的根對象:",collection
if collection.hasAttribute("shelf"):
print u"DOM樹的根節點屬性：",collection.getAttribute("shelf")
"""
執行結果
E:\>python py.txt
DOM樹的根對象: <DOM Element: collection at 0x2781f48>
DOM樹的根節點屬性： New Arrivals
"""
node.getElementsByTagName(name):獲取XML文檔中某個父節點下具有相同節點名稱的節點對象集合，是一個list對象。
#coding=utf-8
#從xml.dom.minidom模塊引入解析器parse
from xml.dom.minidom import parse
#minidom解析器打開xml文檔並將其解析為內存中的一棵樹
DOMTree= parse(r"e:\movie.xml")
#獲取XML文檔對象，也就是數的根節點
collection=DOMTree.documentElement
print u"DOM樹的根對象:",collection
#獲取根節點collection下所有movie節點的list集合
movies=collection.getElementsByTagName("movie")
print movies
for i in movies:
print i
"""
執行結果
E:\>python py.txt
DOM樹的根對象: <DOM Element: collection at 0x2851f48>
[<DOM Element: movie at 0x285f108>, <DOM Element: movie at 0x285f908>, <DOM Element: movie at 0x2868148>, <DOM Element: movie at 0x2868948>]
<DOM Element: movie at 0x285f108>
<DOM Element: movie at 0x285f908>
<DOM Element: movie at 0x2868148>
<DOM Element: movie at 0x2868948>
"""
node.childNodes:返回節點node下所有子節點組成的list。
#coding=utf-8
#從xml.dom.minidom模塊引入解析器parse
from xml.dom.minidom import parse
#minidom解析器打開xml文檔並將其解析為內存中的一棵樹
DOMTree= parse(r"e:\movie.xml")
#獲取XML文檔對象，也就是數的根節點
collection=DOMTree.documentElement
print u"DOM樹的根對象:",collection
#獲取根節點collection下所有movie節點的list集合
movies=collection.getElementsByTagName("movie")
print movies[0].childNodes
執行結果
node.childNodes[index].data:獲取節點node的文本值，即標簽之間的內容。
#coding=utf-8
#從xml.dom.minidom模塊引入解析器parse
from xml.dom.minidom import parse
#minidom解析器打開xml文檔並將其解析為內存中的一棵樹
DOMTree= parse(r"e:\movie.xml")
#獲取XML文檔對象，也就是數的根節點
collection=DOMTree.documentElement
print u"DOM樹的根對象:",collection
#獲取根節點collection下所有movie節點的list集合
Movies=collection.getElementsByTagName("movie")
print u"共有%s部電影"%Movies.length
#獲取根節點collection下第一個movie節點下所有stars節點的list集合
movies=Movies[0].getElementsByTagName("stars")
print u"第一部電影有%s個stars參數"%movies.length
print u"這個stars是:",movies[0].childNodes[0].data
"""
執行結果
E:\>python py.txt
DOM樹的根對象: <DOM Element: collection at 0x2831f48>
共有4部電影
第一部電影有1個stars參數
這個stars是: 10
"""
node.haschildNodes():判斷節點node下是否有葉子節點，如果有返回True，否則返回False；註意：每個節點都默認有一個文本葉子節點，所以只要標簽後有值，就返回True，只有當標簽後沒有值並且也沒有葉子節點時才會返回False。
#coding=utf-8
#從xml.dom.minidom模塊引入解析器parse
from xml.dom.minidom import parse
#minidom解析器打開xml文檔並將其解析為內存中的一棵樹
DOMTree= parse(r"e:\movie.xml")
#獲取XML文檔對象，也就是數的根節點
collection=DOMTree.documentElement
print u"DOM樹的根對象:",collection
#獲取根節點collection下所有movie節點的list集合
Movies=collection.getElementsByTagName("movie")
print u"共有%s部電影"%Movies.length
#獲取根節點collection下第一個movie節點下所有stars節點的list集合
if Movies[0].hasChildNodes():
print u"第一部電影存在葉子節點"
else:
print u"第一部電影不存在葉子節點"
"""
執行結果
E:\>python py.txt
DOM樹的根對象: <DOM Element: collection at 0x2801f48>
共有4部電影
第一部電影存在葉子節點
"""
3.3.2使用xml.dom解析xml的完整實例
#coding=utf-8
#從xml.dom.minidom模塊引入解析器parse
from xml.dom.minidom import parse
import xml.dom.minidom
#minidom解析器打開xml文檔並將其解析為內存中的一棵樹
DOMTree= xml.dom.minidom.parse(r"e:\movie.xml")
print type(DOMTree)
#獲取XML文檔的根節點
collection=DOMTree.documentElement
#判斷根節點中是否有"shelf"屬性，如果有則獲取並打印
if collection.hasAttribute("shelf"):
print "root element:%s"%collection.getAttribute("shelf")
#獲取所有電影getElementsByTagName()方法可返回帶有指定標簽名的對象的集合
movies=collection.getElementsByTagName("movie")
#print movies
"""
[<DOM Element: movie at 0x28d2fc8>, <DOM Element: movie at 0x28df808>, <DOM Element: movie at 0x28e8048>, <DOM Element: movie at
0x28e8848>]
"""
#打印每部電影的詳細信息
for movie in movies:
print "*****Movie*****"
#獲取並打印電影名稱
if movie.hasAttribute("title"):
print "Title:%s"%movie.getAttribute("title")
#獲取並打印每部電影的其他屬性childNodes以Nodelist對象的形式返回節點的子節點集合
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
stars=movie.getElementsByTagName("stars")[0]
print "stars:%s"%stars.childNodes[0].data
if movie.getElementsByTagName("year"):
print "year:%s"%movie.getElementsByTagName("year")[0].childNodes[0].data
"""
執行結果
E:\>python py.txt
<type ‘instance‘>
root element:New Arrivals
*****Movie*****
Title:Enemy Behind
Type: War, Thriller
Format: DVD
Rating: PG
Description: Talk about a US-Japan war
stars:10
year:2003
*****Movie*****
Title:Transformers
Type: Anime, Science Fiction
Format: DVD
Rating: R
Description: A schientific fiction
stars:8
year:1989
*****Movie*****
Title:Trigun
Type: Anime, Action
Format: DVD
Rating: PG
Description: Vash the Stampede!
stars:10
*****Movie*****
Title:Ishtar
Type: Comedy
Format: VHS
Rating: PG
Description: Viewable boredom
stars:2
"""
3.4：xml.dom創建XML文件
創建xml文件的步驟如下：
1、創建xml空文檔
2、產生根對象
3、往根對象裏加數據
4、把xml內存對象寫到文件
3.4.1創建xml空白文檔
minidom.Document():此方法用於創建一個空白的xml文檔對象，並返回這個doc對象。每個xml文檔都是一個Document對象，代表著內存中的DOM樹。
>>> import xml.dom.minidom
>>> doc=xml.dom.minidom.Document()
>>> print doc
<xml.dom.minidom.Document instance at 0x0000000002858D08>
>>>
3.4.2創建xml文檔根節點
doc.createElement(tagName):生成xml文檔節點。參數表示要生成節點的名稱。
>>> import xml.dom.minidom
>>> doc=xml.dom.minidom.Document()
>>> print doc
<xml.dom.minidom.Document instance at 0x0000000002858D08>
>>> root=doc.createElement("Managers")
>>> print u"添加的xml標簽為:",root.tagName
添加的xml標簽為: Managers
3.4.3添加節點屬性
node.setAttribute(attname,value):此方法表示給節點添加屬性值對。attname表示屬性的名稱，value表示屬性的值
>>> import xml.dom.minidom
>>> doc=xml.dom.minidom.Document()
>>> print doc
<xml.dom.minidom.Document instance at 0x0000000002858D08>
>>> root=doc.createElement("Managers")
>>> print u"添加的xml標簽為:",root.tagName
添加的xml標簽為: Managers
>>> root.setAttribute("company","XX技術")
>>> value=root.getAttribute("company")
>>> print u"root元素的‘company‘屬性值為:",value
root元素的‘company‘屬性值為: XX技術
3.4.4添加文本節點
doc.createTextNode(data):給葉子節點添加文本節點。
>>> import xml.dom.minidom
>>> doc=xml.dom.minidom.Document()
>>> print doc
<xml.dom.minidom.Document instance at 0x0000000002858D08>
>>> root=doc.createElement("Managers")
>>> print u"添加的xml標簽為:",root.tagName
添加的xml標簽為: Managers
>>> root.setAttribute("company","XX技術")
>>> value=root.getAttribute("company")
>>> print u"root元素的‘company‘屬性值為:",value
root元素的‘company‘屬性值為: XX技術
>>> ceo=doc.createElement("CEO")
>>> ceo.appendChild(doc.createTextNode("pang"))
<DOM Text node "‘pang‘">
>>> print ceo.tagName
CEO
>>>
3.4.5添加子節點
doc/parentNode.appendChild(node):將節點node添加到文檔對象doc作為文檔樹的根節點或者添加到父節點parentNode下作為其子節點。
#coding=utf-8
import xml.dom.minidom
#在內存中創建一個空的xml文檔 Document對象
doc=xml.dom.minidom.Document()
#創建一個根節點school對象
root=doc.createElement("school")
#給根節點添加屬性
root.setAttribute("name",u"學校信息")
#將根節點添加到文檔對象中
doc.appendChild(root)
#給根節點添加一個葉子結點
school=doc.createElement(u"class")
#葉子節點下在嵌套葉子節點，並給節點添加文本節點
name=doc.createElement("schoolName")
name.appendChild(doc.createTextNode(u"北京大學附屬中學"))
#將子節點name添加到根節點school中
school.appendChild(name)
teacher=doc.createElement("Teacher")
teacher.appendChild(doc.createTextNode(u"張三"))
school.appendChild(teacher)
#將school節點添加到父節點root中
root.appendChild(school)
#打印xml內容
print doc.toxml()
執行結果
E:\>python py.txt
<?xml version="1.0" ?><school name="學校信息"><class><schoolName>北京大學附屬中
學</schoolName><Teacher>張三</Teacher></class></school>
3.4.6生成XML文檔
doc.writexml():函數原型writexml(write,indent=””,addindent=””,newl=””,encoding=None).此方法用於將內存中的xml文檔樹寫入文件中，並保存到本地磁盤。
write：要寫的目標文件的文件對象
indent：指明根節點縮進方式。
addindent:指明子節點的縮進方式
newl:針對新行，指明換行方式
enconding：指明所寫xml文檔的編碼
#coding=utf-8
import xml.dom.minidom
import codecs
#在內存中創建一個空的xml文檔 Document對象
doc=xml.dom.minidom.Document()
#創建一個根節點school對象
root=doc.createElement("school")
#給根節點添加屬性
root.setAttribute("name",u"北京大學附屬中學")
#將根節點添加到文檔對象中
doc.appendChild(root)
#給根節點添加一個葉子結點
school=doc.createElement(u"class")
#葉子節點下在嵌套葉子節點，並給節點添加文本節點
name=doc.createElement("className")
name.appendChild(doc.createTextNode(u"三五班"))
#將子節點name添加到根節點school中
school.appendChild(name)
teacher=doc.createElement("Teacher")
teacher.appendChild(doc.createTextNode(u"張三"))
school.appendChild(teacher)
#將school節點添加到父節點root中
root.appendChild(school)
#寫入文件
fp=codecs.open("e:\\school.xml","w","utf-8")
doc.writexml(fp,indent="",addindent="\t",newl="\n",encoding="utf-8")
fp.close()
Python-Json字符串和XML解析