pythonxml教程

❶ python怎麼解析xml文件

python對XML的解析
常見的XML編程介面有DOM和SAX，這兩種介面處理XML文件的方式不同，當然使用場合也不同。
python有三種方法解析XML，SAX，DOM，以及ElementTree:
1.SAX (simple API for XML )
python 標准庫包含SAX解析器，SAX用事件驅動模型，通過在解析XML的過程中觸發一個個的事件並調用用戶定義的回調函數來處理XML文件。
2.DOM(Document Object Model)
將XML數據在內存中解析成一個樹，通過對樹的操作來操作XML。
3.ElementTree(元素樹)
ElementTree就像一個輕量級的DOM，具有方便友好的API。代碼可用性好，速度快，消耗內存少。
註：因DOM需要將XML數據映射到內存中的樹，一是比較慢，二是比較耗內存，而SAX流式讀取XML文件，比較快，佔用內存少，但需要用戶實現回調函數（handler）。

❷ 如何用Python輸出漂亮的xml文件

最近要用Python處理一個xml文件。平時習慣了用xml.etree.ElementTree，結果發現此庫存在一些讓人無法忍受的缺點：
1. 無法處理comment和cdata
2. 輸出後的xml文件沒有換行，沒有縮進，十分難以閱讀

於是嘗試這用xml.dom.minidom，前兩個問題幾乎全部解決了。唯一讓人看著不爽的是minidom對於text的處理。比如，我期待的xml輸入如下：

[html] view plain
<pre name="code" class="html"><pre name="code" class="html"><root>
<host>192.168.0.1</host>
</root>

但是使用xml.dom.minidom.Document.writexml後，輸出的結果卻是這樣的：

[html] view plain
<root>
<host>
192.168.0.1
</host>
</root>

開始的時候，我考慮重寫Document.writexml函數，覺得太麻煩，有用牛刀殺雞之感。後來想想，其實自己的需求非常簡單，只是需要對Document的輸出結果做個二次處理即可。使用python的正則表達式庫就可以實現：

[python] view plain
def save_xml(self, file_name):
xml_str = self.m_dom.toprettyxml(indent=" ")
repl = lambda x: ">%s</" % x.group(1).strip() if len(x.group(1).strip()) != 0 else x.group(0)
pretty_str = re.sub(r'>\n\s*([^<]+)</', repl, xml_str)
open(file_name, 'w').write(pretty_str)

先將Document輸出到字元串，然後使用正則表達式將text中的空行去掉即可。
黑馬程序員的PYthon是國內最早開設的真正人工智慧課程。課程全面系統，緊跟時代潮流。

❸ 如何用python讀取xml文件

一、簡介

XML（eXtensible Markup Language）指可擴展標記語言，被設計用來傳輸和存儲數據，已經日趨成為當前許多新生技術的核心，在不同的領域都有著不同的應用。它是web發展到一定階段的必然產物，既具有SGML的核心特徵，又有著HTML的簡單特性，還具有明確和結構良好等許多新的特性。
python解析XML常見的有三種方法：一是xml.dom.*模塊，它是W3C DOM API的實現，若需要處理DOM API則該模塊很適合，注意xml.dom包裡面有許多模塊，須區分它們間的不同；二是xml.sax.*模塊，它是SAX API的實現，這個模塊犧牲了便捷性來換取速度和內存佔用，SAX是一個基於事件的API，這就意味著它可以「在空中」處理龐大數量的的文檔，不用完全載入進內存；三是xml.etree.ElementTree模塊（簡稱 ET），它提供了輕量級的Python式的API，相對於DOM來說ET 快了很多，而且有很多令人愉悅的API可以使用，相對於SAX來說ET的ET.iterparse也提供了 「在空中」 的處理方式，沒有必要載入整個文檔到內存，ET的性能的平均值和SAX差不多，但是API的效率更高一點而且使用起來很方便。
二、詳解

解析的xml文件（country.xml）：
在CODE上查看代碼片派生到我的代碼片

<?xml version="1.0"?>
<data>
<country name="Singapore">
<rank>4</rank>
<year>2011</year>
<gdppc>59900</gdppc>
<neighbor name="Malaysia" direction="N"/>
</country>
<country name="Panama">
<rank>68</rank>
<year>2011</year>
<gdppc>13600</gdppc>
<neighbor name="Costa Rica" direction="W"/>
<neighbor name="Colombia" direction="E"/>
</country>
</data>

1、xml.etree.ElementTree

ElementTree生來就是為了處理XML，它在Python標准庫中有兩種實現：一種是純Python實現的，如xml.etree.ElementTree，另一種是速度快一點的xml.etree.cElementTree。注意：盡量使用C語言實現的那種，因為它速度更快，而且消耗的內存更少。
在CODE上查看代碼片派生到我的代碼片

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

這是一個讓Python不同的庫使用相同API的一個比較常用的辦法，而從Python 3.3開始ElementTree模塊會自動尋找可用的C庫來加快速度，所以只需要import xml.etree.ElementTree就可以了。
在CODE上查看代碼片派生到我的代碼片

#!/usr/bin/evn python
#coding:utf-8

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

try:
tree = ET.parse("country.xml") #打開xml文檔
#root = ET.fromstring(country_string) #從字元串傳遞xml
root = tree.getroot() #獲得root節點
except Exception, e:
print "Error:cannot parse file:country.xml."
sys.exit(1)
print root.tag, "---", root.attrib
for child in root:
print child.tag, "---", child.attrib

print "*"*10
print root[0][1].text #通過下標訪問
print root[0].tag, root[0].text
print "*"*10

for country in root.findall('country'): #找到root節點下的所有country節點
rank = country.find('rank').text #子節點下節點rank的值
name = country.get('name') #子節點下屬性name的值
print name, rank

#修改xml文件
for country in root.findall('country'):
rank = int(country.find('rank').text)
if rank > 50:
root.remove(country)

tree.write('output.xml')

運行結果：

三、總結
（1）Python中XML解析可用的類庫或模塊有xml、libxml2 、lxml 、xpath等，需要深入了解的還需參考相應的文檔。
（2）每一種解析方式都有自己的優點和缺點，選擇前可以綜合各個方面的性能考慮。
（3）若有不足，請留言，在此先感謝！

❹ 用python怎麼操作xml文件內容

一、什麼是xml？
xml即可擴展標記語言，它可以用來標記數據、定義數據類型，是一種允許用戶對自己的標記語言進行定義的源語言。
abc.xml

復制代碼代碼如下:

<?xml version="1.0" encoding="utf-8"?>
<catalog>
<maxid>4</maxid>
<login username="pytest" passwd='123456'>
<caption>Python</caption>
<item id="4">
<caption>測試</caption>
</item>
</login>
<item id="2">
<caption>Zope</caption>
</item>
</catalog>

Ok ,從結構上，它很像我們常見的HTML超文本標記語言。但他們被設計的目的是不同的，超文本標記語言被設計用來顯示數據，其焦點是數據的外觀。它被設計用來傳輸和存儲數據，其焦點是數據的內容。
那麼它有如下特徵：
首先，它是有標簽對組成，<aa></aa>
標簽可以有屬性：<aa id='123'></aa>
標簽對可以嵌入數據：<aa>abc</aa>
標簽可以嵌入子標簽（具有層級關系）：
二、獲得標簽屬性
那麼，下面來介紹如何用python來讀取這種類型的文件。

復制代碼代碼如下:

#coding=utf-8
import xml.dom.minidom
#打開xml文檔
dom = xml.dom.minidom.parse('abc.xml')
#得到文檔元素對象
root = dom.documentElement
print root.nodeName
print root.nodeValue
print root.nodeType
print root.ELEMENT_NODE

mxl.dom.minidom 模塊被用來處理xml文件，所以要先引入。
xml.dom.minidom.parse() 用於打開一個xml文件，並將這個文件對象dom變數。
documentElement 用於得到dom對象的文檔元素，並把獲得的對象給root
每一個結點都有它的nodeName，nodeValue，nodeType屬性。
nodeName為結點名字。
nodeValue是結點的值，只對文本結點有效。
nodeType是結點的類型。catalog是ELEMENT_NODE類型
現在有以下幾種：
'ATTRIBUTE_NODE'
'CDATA_SECTION_NODE'
'COMMENT_NODE'
'DOCUMENT_FRAGMENT_NODE'
'DOCUMENT_NODE'
'DOCUMENT_TYPE_NODE'
'ELEMENT_NODE'
'ENTITY_NODE'
'ENTITY_REFERENCE_NODE'
'NOTATION_NODE'
'PROCESSING_INSTRUCTION_NODE'
'TEXT_NODE'

三、獲得子標簽
現在要獲得catalog的子標簽以的標簽name

復制代碼代碼如下:

<?xml version="1.0" encoding="utf-8"?>
<catalog>
<maxid>4</maxid>
<login username="pytest" passwd='123456'>
<caption>Python</caption>
<item id="4">
<caption>測試</caption>
</item>
</login>
<item id="2">
<caption>Zope</caption>
</item>
</catalog>

對於知道元素名字的子元素，可以使用getElementsByTagName方法獲取：

復制代碼代碼如下:

#coding=utf-8
import xml.dom.minidom
#打開xml文檔
dom = xml.dom.minidom.parse('abc.xml')
#得到文檔元素對象
root = dom.documentElement
bb = root.getElementsByTagName('maxid')
b= bb[0]
print b.nodeName
bb = root.getElementsByTagName('login')
b= bb[0]
print b.nodeName

如何區分相同標簽名字的標簽：

復制代碼代碼如下:

<?xml version="1.0" encoding="utf-8"?>
<catalog>
<maxid>4</maxid>
<login username="pytest" passwd='123456'>
<caption>Python</caption>
<item id="4">
<caption>測試</caption>
</item>
</login>
<item id="2">
<caption>Zope</caption>
</item>
</catalog>

<caption>和<item>標簽不止一個如何區分？
復制代碼代碼如下:

#coding=utf-8
import xml.dom.minidom
#打開xml文檔
dom = xml.dom.minidom.parse('abc.xml')
#得到文檔元素對象
root = dom.documentElement
bb = root.getElementsByTagName('caption')
b= bb[2]
print b.nodeName
bb = root.getElementsByTagName('item')
b= bb[1]
print b.nodeName

root.getElementsByTagName('caption') 獲得的是標簽為caption 一組標簽，b[0]表示一組標簽中的第一個；b[2] ，表示這一組標簽中的第三個。
四、獲得標簽屬性值

復制代碼代碼如下:

<?xml version="1.0" encoding="utf-8"?>
<catalog>
<maxid>4</maxid>
<login username="pytest" passwd='123456'>
<caption>Python</caption>
<item id="4">
<caption>測試</caption>
</item>
</login>
<item id="2">
<caption>Zope</caption>
</item>
</catalog>

<login>和<item>標簽是有屬性的，如何獲得他們的屬性？
復制代碼代碼如下:

#coding=utf-8
import xml.dom.minidom
#打開xml文檔
dom = xml.dom.minidom.parse('abc.xml')
#得到文檔元素對象
root = dom.documentElement
itemlist = root.getElementsByTagName('login')
item = itemlist[0]
un=item.getAttribute("username")
print un
pd=item.getAttribute("passwd")
print pd
ii = root.getElementsByTagName('item')
i1 = ii[0]
i=i1.getAttribute("id")
print i
i2 = ii[1]
i=i2.getAttribute("id")
print i

getAttribute方法可以獲得元素的屬性所對應的值。
五、獲得標簽對之間的數據
復制代碼代碼如下:

<?xml version="1.0" encoding="utf-8"?>
<catalog>
<maxid>4</maxid>
<login username="pytest" passwd='123456'>
<caption>Python</caption>
<item id="4">
<caption>測試</caption>
</item>
</login>
<item id="2">
<caption>Zope</caption>
</item>
</catalog>

<caption>標簽對之間是有數據的，如何獲得這些數據？
獲得標簽對之間的數據有多種方法，
方法一：

復制代碼代碼如下:

#coding=utf-8
import xml.dom.minidom
#打開xml文檔
dom = xml.dom.minidom.parse('abc.xml')
#得到文檔元素對象
root = dom.documentElement
cc=dom.getElementsByTagName('caption')
c1=cc[0]
print c1.firstChild.data
c2=cc[1]
print c2.firstChild.data
c3=cc[2]
print c3.firstChild.data

firstChild 屬性返回被選節點的第一個子節點，.data表示獲取該節點人數據。
方法二：

復制代碼代碼如下:

#coding=utf-8
from xml.etree import ElementTree as ET
per=ET.parse('abc.xml')
p=per.findall('./login/item')
for oneper in p:
for child in oneper.getchildren():
print child.tag,':',child.text

p=per.findall('./item')
for oneper in p:
for child in oneper.getchildren():
print child.tag,':',child.text

方法二有點復雜，所引用模塊也與前面的不一樣，findall用於指定在哪一級標簽下開始遍歷。
getchildren方法按照文檔順序返回所有子標簽。並輸出標簽名（child.tag）和標簽的數據（child.text）
其實，方法二的作用不在於此，它核心功能是可以遍歷某一級標簽下的所有子標簽。

❺ 如何用Python創建生成xml文檔文件的方法

1、內存數據產生

2、產生xml內存對象（也就是DOM樹）

3、產生根對象

4、往根對象里加數據

5、把xml內存對象寫到文件

下面是一個創建xml文檔的簡單實例：

importxml.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':'女'}
]foriinmanagerList:
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('c:\wcx\Manager.xml','w')
doc.writexml(fp,indent='	',addindent='	',newl='
',encoding="utf-8")

執行結果：

<?xmlversion="1.0"encoding="utf-8"?>
<Managersaddress="科技軟體園"company="xx科技">
<Manager>
<name>joy</name>
<age>27</age>
<sex>女</sex>
</Manager>
<Manager>
<name>tom</name>
<age>30</age>
<sex>男</sex>
</Manager>
<Manager>
<name>ruby</name>
<age>29</age>
<sex>女</sex>
</Manager>
</Managers>

6.用Python自帶的寫xml文檔的API去寫，比較方便，後期容易維護。如果直接用打開文件的方式，一行一行的去寫，比較費時，也難以維護。

❻ 初學Python求助Python解析xml

python有三種方法解析XML，分別是SAX，DOM，以及ElementTree:

1. SAX用事件驅動模型，通過在解析XML的過程中觸發一個個的事件並調用用戶定義的回調函數來處理XML文件。

2. DOM模型將XML數據在內存中解析成一個樹，通過對樹的操作來操作XML。

3. ElementTree就像一個輕量級的DOM，具有方便友好的API。代碼可用性好，速度快，消耗內存少。

Python 解析XML實例：

#!/usr/bin/python
#-*-coding:UTF-8-*-

importxml.sax

classMovieHandler(xml.sax.ContentHandler):
def__init__(self):
self.CurrentData=""
self.type=""
self.format=""
self.year=""
self.rating=""
self.stars=""
self.description=""

#元素開始事件處理
defstartElement(self,tag,attributes):
self.CurrentData=tag
iftag=="movie":
print"*****Movie*****"
title=attributes["title"]
print"Title:",title

#元素結束事件處理
defendElement(self,tag):
ifself.CurrentData=="type":
print"Type:",self.type
elifself.CurrentData=="format":
print"Format:",self.format
elifself.CurrentData=="year":
print"Year:",self.year
elifself.CurrentData=="rating":
print"Rating:",self.rating
elifself.CurrentData=="stars":
print"Stars:",self.stars
elifself.CurrentData=="description":
print"Description:",self.description
self.CurrentData=""

#內容事件處理
defcharacters(self,content):
ifself.CurrentData=="type":
self.type=content
elifself.CurrentData=="format":
self.format=content
elifself.CurrentData=="year":
self.year=content
elifself.CurrentData=="rating":
self.rating=content
elifself.CurrentData=="stars":
self.stars=content
elifself.CurrentData=="description":
self.description=content

if(__name__=="__main__"):

#創建一個XMLReader
parser=xml.sax.make_parser()
#turnoffnamepsaces
parser.setFeature(xml.sax.handler.feature_namespaces,0)

#重寫ContextHandler
Handler=MovieHandler()
parser.setContentHandler(Handler)

parser.parse("movies.xml")

❼ 如何使用python生成xml

最近要用python生成一個xml格式的文件。因為有一些內容是中文，原來的xml文件中使用了CDATA 的部分。 而之前的python程序所用的庫中沒有 創建這個區域的方法。無奈研究了大半天。 最後用了 from lxml import etree 這個庫的方法。 這里將可運行的 python程序分享出來。 供大家參考。 經過測試，這段代碼是可以直接運行生成xml格式內容的。

1 # -*- coding:utf-8 -*-
2 import sys
3 import time
4 import string
5
6 from lxml import etree
7
8
9 #設置默認字元集為UTF8 不然有些時候轉碼會出問題
10 default_encoding = 'utf-8'
11 if sys.getdefaultencoding() != default_encoding:
12 reload(sys)
13 sys.setdefaultencoding(default_encoding)
14
15 def create_xml():
16
17 data = etree.Element("data")
18 #1 interface_version
19 interface_version_txt = '5'
20 interface_version = etree.SubElement(data, 'interface_version')
21 interface_version.text = interface_version_txt
22 #2 site
23 site_txt = 'www.xxx.com'
24 site = etree.SubElement(data, 'site')
25 site.text = site_txt
26 #3 lastmod
27 lastmod_txt = time.strftime('%Y-%m-%d', time.localtime())
28 lastmod = etree.SubElement(data, 'lastmod')
29 lastmod.text = lastmod_txt
30 #5 app
31 app = etree.SubElement(data, 'app')
32 #6 title
33 title_txt = u'%s' % '真心話大冒險'
34 title_txt = etree.CDATA(title_txt)
35 title = etree.SubElement(app, 'title')
36 title.text = title_txt
37 #7 appid
38 appid = etree.SubElement(app, 'appid')
39 appid.text = '%s' % '222'
40
41 dataxml = etree.tostring(data, pretty_print=True, encoding="UTF-8", method="xml", xml_declaration=True, standalone=None)
42 print dataxml
43
44
47 if __name__ == '__main__':
48 create_xml()

❽ python讀取xml文件有哪些方法

引入XML組件：import xml.dom.minidom。
創建一個xml文件，<?xml version="1.0" encoding="utf-8"?>。
相關推薦：《Python教程》
載入讀取XML文件，xml.dom.minidom.parse('abc.xml')，這是xml文件的對象。
獲取XML文檔對象，root = dom.documentElement。
獲取標簽之間的數據 ，rootdata.getElementsByTagName('caption')。
總結一下xml對象，node.getAttribute(AttributeName)，獲取XML節點屬性值，node.getElementsByTagName(TagName)，獲取XML節點對象集合，等等具體的查看手冊。

❾ python 解析xml需要什麼模塊

Python的標准庫中，提供了6種可以用於處理XML的包。

（1）xml.dom

xml.dom實現的是W3C制定的DOM API。如果你習慣於使用DOM API或者有人要求這這樣做，可以使用這個包。不過要注意，在這個包中，還提供了幾個不同的模塊，各自的性能有所區別。

DOM解析器在任何處理開始之前，必須把基於XML文件生成的樹狀數據放在內存，所以DOM解析器的內存使用量完全根據輸入資料的大小。

（2）xml.dom.minidom

xml.dom.minidom是DOM API的極簡化實現，比完整版的DOM要簡單的多，而且這個包也小的多。那些不熟悉DOM的朋友，應該考慮使用xml.etree.ElementTree模塊。據lxml的作者評價，這個模塊使用起來並不方便，效率也不高，而且還容易出現問題。

相關推薦：《Python教程》

（3）xml.dom.pulldom

與其他模塊不同，xml.dom.pulldom模塊提供的是一個「pull解析器」，其背後的基本概念指的是從XML流中pull事件，然後進行處理。雖然與SAX一樣採用事件驅動模型（event-driven processing model），但是不同的是，使用pull解析器時，使用者需要明確地從XML流中pull事件，並對這些事件遍歷處理，直到處理完成或者出現錯誤。

pull解析（pull parsing）是近來興起的一種XML處理趨勢。此前諸如SAX和DOM這些流行的XML解析框架，都是push-based，也就是說對解析工作的控制權，掌握在解析器的手中。

（4）xml.sax

xml.sax模塊實現的是SAX API，這個模塊犧牲了便捷性來換取速度和內存佔用。SAX是Simple API for XML的縮寫，它並不是由W3C官方所提出的標准。它是事件驅動的，並不需要一次性讀入整個文檔，而文檔的讀入過程也就是SAX的解析過程。所謂事件驅動，是指一種基於回調（callback）機制的程序運行方法。

（5）xml.parser.expat

xml.parser.expat提供了對C語言編寫的expat解析器的一個直接的、底層API介面。expat介面與SAX類似，也是基於事件回調機制，但是這個介面並不是標准化的，只適用於expat庫。

expat是一個面向流的解析器。您注冊的解析器回調（或handler）功能，然後開始搜索它的文檔。當解析器識別該文件的指定的位置，它會調用該部分相應的處理程序（如果您已經注冊的一個）。該文件被輸送到解析器，會被分割成多個片斷，並分段裝到內存中。因此expat可以解析那些巨大的文件。

（6）xml.etree.ElementTree（以下簡稱ET）

xml.etree.ElementTree模塊提供了一個輕量級、Pythonic的API，同時還有一個高效的C語言實現，即xml.etree.cElementTree。與DOM相比，ET的速度更快，API使用更直接、方便。與SAX相比，ET.iterparse函數同樣提供了按需解析的功能，不會一次性在內存中讀入整個文檔。ET的性能與SAX模塊大致相仿，但是它的API更加高層次，用戶使用起來更加便捷。

建議：在使用Python進行XML解析時，首選使用ET模塊，除非你有其他特別的需求，可能需要另外的模塊來滿足。

❿ python怎麼讀取xml

引入XML組件：import xml.dom.minidom。
創建一個xml文件，<?xml version="1.0" encoding="utf-8"?>。
相關推薦：《Python教程》
載入讀取XML文件，xml.dom.minidom.parse('abc.xml')，這是xml文件的對象。
獲取XML文檔對象，root = dom.documentElement。
獲取標簽之間的數據 ，rootdata.getElementsByTagName('caption')。
總結一下xml對象，node.getAttribute(AttributeName)，獲取XML節點屬性值，node.getElementsByTagName(TagName)，獲取XML節點對象集合，等等具體的查看手冊。