簡介

XML是被設計用來傳輸和存儲資料的可擴充标記語言，Python中可以使用xml.etree.ElementTree操作XML檔案。

Python 2.7采用ElementTree 1.3版本。xml.etree.ElementTree的更高效、占用記憶體更少的C語言版本的實作是xml.etree.cElementTree。

ElementTree與Elment

XML按照樹型結構組織，ET有兩種類來表示這種組織結構：ElementTree表示整個XML樹，Element表示樹上的單個節點。操作整個XML文檔時使用ElementTree類，比如讀寫XML檔案。操作XML元素及其子元素時使用Element類。Element是一個靈活的容器對象，在記憶體中存儲階層化的資料結構。

每個元素包含如下屬性：

tag：表示元素類型的字元串。
attrib：以Python字典形式存儲的元素屬性。
text：開始标簽和第一個子元素之間的字元串或開始标簽和結束标簽之間的字元串或None。
tail：結束标簽和下一個标簽之間的字元串或None。
子元素：以Python序列的形式存儲。

建立Element元素，使用Element()構造器或SubElement()工廠函數。

解析XML

比如test.xml内容為：

<?xml version="1.0"?>
<bookstore author="mars loo">
    <book>
        <name>LeaderF</name>
        <price>12.33</price>
    </book>
    <book>
        <name>YCM</name>
        <price>11.91</price>
    </book>
</bookstore>

可以調用ET.parse(filename)将XML文檔解析為ElementTree對象，調用ElementTree.getroot()擷取Element類型的樹根，然後分别通路樹根元素的tag、attrib、text、tail等屬性：

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

tree = ET.parse('test.xml')
root = tree.getroot()
print "Tag:", root.tag, "Attributes:", root.attrib, "Text:", root.text.strip(), "Tail:", root.tail

運作結果：

注意，如果test.xml檔案的第2行是如下内容：

則上面的代碼中

root.text

的類型是None。

使用

tree = ET.ElementTree(file='test.xml')

與使用

tree = ET.parse('test.xml')

效果一樣。如果使用ET.fromstring()方法解析，則直接傳回Element類型的樹根元素。如果一個Element對象有子元素，可以直接周遊，也可以使用下标通路：

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

xml_string = '''<?xml version="1.0"?>
<bookstore author="mars loo">
    <book id="1">
        <name>LeaderF</name>
        <price>12.33</price>
    </book>
    <book id="2">
        <name>YCM</name>
        <price>11.91</price>
    </book>
</bookstore>'''

root = ET.fromstring(xml_string)
for child in root:
    print "Tag:", child.tag, "Attributes:", child.attrib
print "Book 2's price", root[][].text.strip()

運作結果：

Tag: book Attributes: {'id': '1'}
Tag: book Attributes: {'id': '2'}
Book 's price 11.91

周遊元素

Element類和ElementTree類都有iter()方法可以遞歸周遊元素/樹的所有子元素，比如：

for child in root.iter(): //root是Element對象
    print "Tag:", child.tag, "Attributes:", child.attrib, "Text:", child.text.strip()

使用tag參數可以周遊指定tag的元素：

for child in tree.iter(tag='price'): //tree是ElementTree對象
     print "Tag:", child.tag, "Attributes:", child.attrib, "Text:", child.text.strip()

Element.findall(match)方法通過tag名字或xpath比對第一層子元素，按照子元素順序以清單形式傳回所有比對的元素。

Element.find(match)方法通過tag名字或xpath在第一層子元素中查找第一個比對的元素，傳回比對的元素或None。

Element.get(key, default=None)傳回元素名字為key的屬性值，如果沒有找到，傳回None或設定的預設值。

修改XML檔案

ElementTree.write(filename)方法可以友善的将ElementTree對象寫入XML檔案。

可以通過調用Element對象不同的方法修改Element對象，比如：

Element.text=value可以直接修改其text屬性。
Element.tail=value可以直接修改其tail屬性。
Element.set(key, vlaue)可以添加新的attrib。
Element.append(subelement)可以添加新的子元素。
Element.extend(subelements)添加子元素的清單（參數類型是序列）。
Element.remove(subelement)可以删除子元素。

将所有圖書的價格加1，給price元素增加一個

updated="true"

的屬性，同時增加一個内容為

"tail"

的tail：

tree = ET.parse('test.xml')
for child in tree.iter(tag = 'price'):
    child.text = str(float(child.text.strip()) + )
    child.tail = "tail"
    child.set("updated", "true")

tree.write('new.xml')

new.xml内容為：

<bookstore author="mars loo">
    <book>
        <name>LeaderF</name>
        <price updated="true">13.33</price>tail</book>
    <book>
        <name>YCM</name>
        <price updated="true">12.91</price>tail</book>
</bookstore>

将所有圖書元素的price元素删除，增加出版社press元素，press元素的text屬性内容是

CTS

：

bookstore = ET.parse('test.xml')
for book in bookstore.findall('book'):
    book.remove(book.find('price'))
    press = ET.Element('press')
    press.text = "CTS"
    book.append(press)
bookstore.write('new2.xml')

new2.xml内容為：

<bookstore author="mars loo">
    <book>
        <name>LeaderF</name>
        <press>CTS</press></book>
    <book>
        <name>YCM</name>
        <press>CTS</press></book>
</bookstore>

使用ET.SubElement(parent, tag_name)可以快速建立子元素關系，使用ET.dump(elem)可以輸出elem的内容到标準輸出（elem可以是一個Element對象或ElementTree對象）：

root = ET.Element('root')
a = ET.SubElement(root, 'a')
b = ET.SubElement(root, 'b')
c = ET.SubElement(root, 'c')
tree = ET.ElementTree(root)

ET.dump(tree)

運作輸出：

使用iterparse處理大檔案

ET.parse(filename)一次性将整個XML檔案加載到記憶體，ET.iterparse(filename)采用增量形式加載XML資料，占據更小的記憶體空間。如果test.xml包含非常多本書我們想統計書本數量，可以采用iterparse()高效處理：

count = 
for event, elem in ET.iterparse('test.xml'):
    if event == 'end':
        if elem.tag == "book":
            count += 
    elem.clear() //重置元素（删除所有子元素、清除所有attrib、将text和tail設定為None）

print count

出處：https://blog.csdn.net/a464057216/article/details/54915241

-----------------------------------------------------------------------------------------------------------------

概述

對比其他 Python 處理 XML 的方案，xml.etree.ElementTree 子產品（下文我們以 ET 來表示）相對來說比較簡單，接口也較友好。

官方文檔裡面對 ET 子產品進行了較為詳細的描述，總的來說，ET 子產品可以歸納為三個部分：

ElementTree

類，

Element

類以及一些操作 XML 的函數。

XML 可以看成是一種樹狀結構，ET 使用

ElementTree

類來表示整個 XML 文檔，使用

Element

類來表示 XML 的一個結點。對整 XML 文檔的操作一般是對

ElementTree

對象進行，而對 XML 結點的操作一般是對

Element

對象進行。

解析 XML 檔案

ET 子產品支援從一個 XML 檔案構造

ElementTree

對象，例如我們的 XML 檔案

example.xml

内容如下（下文會繼續使用這個 XML 文檔）：

<?xml version="1.0" encoding="utf-8"?>
<data>
    <country name="Liechtenstein">
        <rank>1</rank>
        <year>2008</year>
        <gdppc>141100</gdppc>
        <neighbor name="Austria" direction="E"/>
        <neighbor name="Switzerland" direction="W"/>
    </country>
    <country name="Singapore">
        <rank>4</rank>
        <year>2011</year>
        <gdppc>59900</gdppc>
        <neighbor name="Malaysia" direction="N"/>
    </country>
</data>

可以使用 ET 子產品的

parse()

函數來從指定的 XML 檔案構造一個

ElementTree

對象：

import xml.etree.ElementTree as ET

# 擷取 XML 文檔對象 ElementTree
tree = ET.parse('example.xml')
# 擷取 XML 文檔對象的根結點 Element
root = tree.getroot()
# 列印根結點的名稱
print root.tag

從 XML 檔案構造好

ElementTree

對象後，還可以擷取其結點，或者再繼續對結點進行進一步的操作。

解析 XML 字元串

ET 子產品的

fromstring()

函數提供從 XML 字元串構造一個

Element

對象的功能。

xml_str = ET.tostring(root)
print xml_str
root = ET.fromstring(xml_str)
print root.tag

接着上面的代碼，我們使用 ET 子產品的

tostring()

函數來将上面我們構造的

root

對象轉化為字元串，然後使用

fromstring()

函數重新構造一個

Element

對象，并指派給

root

變量，這時

root

代表整個 XML 文檔的根結點。

構造 XML

如果我們需要構造 XML 文檔，可以使用 ET 子產品的

Element

類以及

SubElement()

函數。

可以使用

Element

類來生成一個

Element

對象作為根結點，然後使用

ET.SubElement()

函數生成子結點。

a = ET.Element('a')
b = ET.SubElement(a, 'b')
b.text = 'leehao.me'
c = ET.SubElement(a, 'c')
c.attrib['greeting'] = 'hello'
d = ET.SubElement(a, 'd')
d.text = 'www.leehao.me'
xml_str = ET.tostring(a, encoding='UTF-8')
print xml_str

輸出：

<?xml version='1.0' encoding='UTF-8'?>
<a><b>leehao.me</b><c greeting="hello" /><d>www.leehao.me</d></a>

如果需要輸出到檔案中，可以繼續使用

ElementTree.write()

方法來處理：

# 先構造一個 ElementTree 以便使用其 write 方法
tree = ET.ElementTree(a)
tree.write('a.xml', encoding='UTF-8')

執行後，便會生成一個 XML 檔案

a.xml

<?xml version='1.0' encoding='UTF-8'?>
<a><b>leehao.me</b><c greeting="hello" /><d>www.leehao.me</d></a>

XML 結點的查找與更新

1. 查找 XML 結點

Element

類提供了

Element.iter()

方法來查找指定的結點。

Element.iter()

會遞歸查找所有的子結點，以便查找到所有符合條件的結點。

# 擷取 XML 文檔對象 ElementTree
tree = ET.parse('example.xml')
# 擷取 XML 文檔對象的根結點 Element
root = tree.getroot()
# 遞歸查找所有的 neighbor 子結點
for neighbor in root.iter('neighbor'):
    print neighbor.attrib

輸出：

{'direction': 'E', 'name': 'Austria'}
{'direction': 'W', 'name': 'Switzerland'}
{'direction': 'N', 'name': 'Malaysia'}

如果使用

Element.findall()

或者

Element.find()

方法，則隻會從結點的直接子結點中查找，并不會遞歸查找。

for country in root.findall('country'):
    rank = country.find('rank').text
    name = country.get('name')
    print name, rank

輸出：

Liechtenstein 1
Singapore 4

2. 更新結點

如果需要更新結點的文本，可以通過直接修改

Element.text

來實作。如果需要更新結點的屬性，可以通過直接修改

Element.attrib

來實作。

對結點進行更新後，可以使用

ElementTree.write()

方法将更新後的 XML 文檔寫入檔案中。

# 擷取 XML 文檔對象 ElementTree
tree = ET.parse('example.xml')
# 擷取 XML 文檔對象的根結點 Element
root = tree.getroot()
for rank in root.iter('rank'):
    new_rank = int(rank.text) + 
    rank.text = str(new_rank)
    rank.attrib['updated'] = 'yes'
tree.write('output.xml', encoding='UTF-8')

新生成的

output.xml

檔案以下：

<?xml version='1.0' encoding='UTF-8'?>
<data>
    <country name="Liechtenstein">
        <rank updated="yes">2</rank>
        <year>2008</year>
        <gdppc>141100</gdppc>
        <neighbor direction="E" name="Austria" />
        <neighbor direction="W" name="Switzerland" />
    </country>
    <country name="Singapore">
        <rank updated="yes">5</rank>
        <year>2011</year>
        <gdppc>59900</gdppc>
        <neighbor direction="N" name="Malaysia" />
    </country>
</data>

對比

example.xml

檔案，可以看到

output.xml

檔案已更新。

出處：https://blog.csdn.net/lihao21/article/details/72891932

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

Element類型是一種靈活的容器對象，用于在記憶體中存儲層次資料結構。可以說是list和dictionary的交叉。

注意：

xml.etree.ElementTree 子產品對含有惡意代碼的資料是不安全的。如果你想處理不信任的資料請使用 XML vulnerabilities.

每個element都有一系列相關屬性：

标簽，用于辨別該元素表示哪種資料（即元素類型）
一些屬性，存儲在Python dictionary中
一個文本字元串
一個可選的尾字元串
一些孩子elements，存儲在Python sequence中

為了建立一個element執行個體，使用Element 構造函數或者SubElement()工廠函數。

ElementTree 類可以用來包裹一個element結構，用于與XML進行互相轉換。

一個 C語言實作的可用 API ： xml.etree.cElementTree.

Changed in version 2.7: The ElementTree API is updated to 1.3. For more information, see Introducing ElementTree 1.3.

19.7.1. 綜述

這是關于使用xml.etree.ElementTree (ET)的簡要綜述，目的是示範如何建立block和子產品的基本概念。

19.7.1.1. XML 樹和elements

XML is an inherently hierarchical data format, and the most natural way to represent it is with a tree. ET has two classes for this purpose - ElementTree 表示整個XML文檔, and Element 表示樹中的一個節點。周遊整個文檔r（讀寫檔案）通常使用 ElementTree 周遊單獨的節點或者子節點通常使用element 。

19.7.1.2. 解析 XML

我們使用下面的XML文檔做為示例:

<?xml version="1.0"?>
<data>
    <country name="Liechtenstein">
        <rank>1</rank>
        <year>2008</year>
        <gdppc>141100</gdppc>
        <neighbor name="Austria" direction="E"/>
        <neighbor name="Switzerland" direction="W"/>
    </country>
    <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>

我們有多種方法導入資料。

從硬碟檔案導入：

import xml.etree.ElementTree as ET
tree = ET.parse('country_data.xml')
root = tree.getroot()

通過字元串導入：

fromstring() 解析XML時直接将字元串轉換為一個 Element，解析樹的根節點。其他的解析函數會建立一個 ElementTree。一個Element, 根節點有一個tag以及一些列屬性（儲存在dictionary中）

>>> root.tag
'data'
>>> root.attrib
{}

有一些列孩子節點可供周遊：

>>> for child in root:
...   print child.tag, child.attrib
...
country {'name': 'Liechtenstein'}
country {'name': 'Singapore'}
country {'name': 'Panama'}

孩子節點是嵌套的，我們可以通過索引通路特定的孩子節點。

>>> root[0][1].text
'2008'

19.7.1.3. 查找感興趣的element

Element 擁有一些方法來幫助我們疊代周遊其子樹。例如：Element.iter():

>>> for neighbor in root.iter('neighbor'):
...   print neighbor.attrib
...
{'name': 'Austria', 'direction': 'E'}
{'name': 'Switzerland', 'direction': 'W'}
{'name': 'Malaysia', 'direction': 'N'}
{'name': 'Costa Rica', 'direction': 'W'}
{'name': 'Colombia', 'direction': 'E'}

Element.findall() 查找目前element的孩子的屬于某個tag的element。 Element.find() 查找屬于某個tag的第一個element, Element.text 通路element的文本内容。 Element.get()擷取element的屬性。:

>>> for country in root.findall('country'):
...   rank = country.find('rank').text
...   name = country.get('name')
...   print name, rank
...
Liechtenstein 1
Singapore 4
Panama 68

使用XPath.可以更加巧妙的通路element。

19.7.1.4. 修改XML檔案

ElementTree 提供了一個簡單的方法來建立XML文檔并将其寫入檔案。 ElementTree.write() 提供了這個功能。

一旦被建立，一個 Element 對象可能會進行以下操作：改變文本（比如Element.text), 添加或修改屬性 (Element.set() ), 添加孩子（例如 Element.append()).

假設我們想将每個國家的排名+1，并且增加一個updated屬性：

>>> for rank in root.iter('rank'):
...   new_rank = int(rank.text) + 1
...   rank.text = str(new_rank)
...   rank.set('updated', 'yes')
...
>>> tree.write('output.xml')

我們的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"/>
    </country>
</data>

我們可以使用這個函數來删除節點：Element.remove(). 讓我們删除所有排名大于50的國家：

>>> for country in root.findall('country'):
...   rank = int(country.find('rank').text)
...   if rank > 50:
...     root.remove(country)
...
>>> tree.write('output.xml')

我們的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>
</data>

19.7.1.5. 建立XML文檔：

SubElement() 函數也提供了一個為已有element建立子element的簡便方法：

>>> a = ET.Element('a')
>>> b = ET.SubElement(a, 'b')
>>> c = ET.SubElement(a, 'c')
>>> d = ET.SubElement(c, 'd')
>>> ET.dump(a)
<a><b /><c><d /></c></a>

19.7.1.6. 其他資源：

See http://effbot.org/zone/element-index.htm for tutorials and links to other docs.

19.7.2. XPath

該子產品提供了對XPath expressions 的有限的支援。目的是支援其中的一部分句法；完整的XPath工程超出了這個子產品的範疇。

19.7.2.1. Example

import xml.etree.ElementTree as ET

root = ET.fromstring(countrydata)

# Top-level elements
root.findall(".")

# All 'neighbor' grand-children of 'country' children of the top-level
# elements
root.findall("./country/neighbor")

# Nodes with name='Singapore' that have a 'year' child
root.findall(".//year/..[@name='Singapore']")

# 'year' nodes that are children of nodes with name='Singapore'
root.findall(".//*[@name='Singapore']/year")

# All 'neighbor' nodes that are the second child of their parent
root.findall(".//neighbor[2]")

19.7.2.2. 支援的 XPath 文法

文法	解釋
tag	選中符合給定tag的全部孩子elements。 For example, spam selects all child elements named spam, and spam/egg selects all grandchildren named egg in all children named spam.
*	選中全部孩子elements。 For example, */egg selects all grandchildren named egg.
.	選中目前element。 This is mostly useful at the beginning of the path, to indicate that it’s a relative path.
//	選中同一級别的全部子element. For example, .//egg selects all egg elements in the entire tree.
..	選中父親節點；
[@attrib]	選中含有給定屬性的全部節點。
[@attrib='value']	選中含有給定屬性以及給定屬性值的全部節點。The value cannot contain quotes.
[tag]	選中所有擁有一個叫做tag的孩子的elements。 Only immediate children are supported.
[position]	選中所有位于指定位置的elements。 The position can be either an integer (1 is the first position), the expression last() (for the last position), or a position relative to the last position (e.g. last()-1).

Predicates (expressions within square brackets) must be preceded by a tag name, an asterisk, or another predicate. position predicates must be preceded by a tag name.

19.7.3. 其他相關

19.7.3.1. 函數

xml.etree.ElementTree. Comment ( text=None )

Comment element factory. This factory function creates a special element that will be serialized as an XML comment by the standard serializer. The comment string can be either a bytestring or a Unicode string. text is a string containing the comment string. Returns an element instance representing a comment.

xml.etree.ElementTree. dump ( elem )

Writes an element tree or element structure to sys.stdout. This function should be used for debugging only.

The exact output format is implementation dependent. In this version, it’s written as an ordinary XML file.

elem is an element tree or an individual element.

xml.etree.ElementTree. fromstring ( text )

Parses an XML section from a string constant. Same as XML(). text is a string containing XML data. Returns an Elementinstance.

xml.etree.ElementTree. fromstringlist ( sequence, parser=None )

Parses an XML document from a sequence of string fragments. sequence is a list or other sequence containing XML data fragments. parser is an optional parser instance. If not given, the standard XMLParser parser is used. Returns an Element instance.

New in version 2.7.

xml.etree.ElementTree. iselement ( element )

Checks if an object appears to be a valid element object. element is an element instance. Returns a true value if this is an element object.

xml.etree.ElementTree. iterparse ( source, events=None, parser=None )

Parses an XML section into an element tree incrementally, and reports what’s going on to the user. source is a filename or file object containing XML data. events is a list of events to report back. If omitted, only “end” events are reported. parser is an optional parser instance. If not given, the standard XMLParser parser is used. parser is not supported by cElementTree. Returns an iterator providing (event, elem) pairs.

Note

iterparse() only guarantees that it has seen the “>” character of a starting tag when it emits a “start” event, so the attributes are defined, but the contents of the text and tail attributes are undefined at that point. The same applies to the element children; they may or may not be present.

If you need a fully populated element, look for “end” events instead.

xml.etree.ElementTree. parse ( source, parser=None )

Parses an XML section into an element tree. source is a filename or file object containing XML data. parser is an optional parser instance. If not given, the standard XMLParser parser is used. Returns an ElementTree instance.

xml.etree.ElementTree. ProcessingInstruction ( target, text=None )

PI element factory. This factory function creates a special element that will be serialized as an XML processing instruction. target is a string containing the PI target. text is a string containing the PI contents, if given. Returns an element instance, representing a processing instruction.

xml.etree.ElementTree. register_namespace ( prefix, uri )

Registers a namespace prefix. The registry is global, and any existing mapping for either the given prefix or the namespace URI will be removed. prefix is a namespace prefix. uri is a namespace uri. Tags and attributes in this namespace will be serialized with the given prefix, if at all possible.

New in version 2.7.

xml.etree.ElementTree. SubElement ( parent, tag, attrib={}, **extra )

Subelement factory. This function creates an element instance, and appends it to an existing element.

The element name, attribute names, and attribute values can be either bytestrings or Unicode strings. parent is the parent element. tag is the subelement name. attrib is an optional dictionary, containing element attributes. extra contains additional attributes, given as keyword arguments. Returns an element instance.

xml.etree.ElementTree. tostring ( element, encoding="us-ascii", method="xml" )

Generates a string representation of an XML element, including all subelements. element is an Element instance. encoding [1] is the output encoding (default is US-ASCII). method is either "xml", "html" or "text" (default is "xml"). Returns an encoded string containing the XML data.

xml.etree.ElementTree. tostringlist ( element, encoding="us-ascii", method="xml" )

New in version 2.7.

xml.etree.ElementTree. XML ( text, parser=None )

Parses an XML section from a string constant. This function can be used to embed “XML literals” in Python code. text is a string containing XML data. parser is an optional parser instance. If not given, the standard XMLParser parser is used. Returns an Element instance.

xml.etree.ElementTree. XMLID ( text, parser=None )

Parses an XML section from a string constant, and also returns a dictionary which maps from element id:s to elements. text is a string containing XML data. parser is an optional parser instance. If not given, the standard XMLParser parser is used. Returns a tuple containing an Element instance and a dictionary.

19.7.3.2. Element 對象

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

Element class. This class defines the Element interface, and provides a reference implementation of this interface.

The element name, attribute names, and attribute values can be either bytestrings or Unicode strings. tag is the element name. attrib is an optional dictionary, containing element attributes. extra contains additional attributes, given as keyword arguments.

tag

A string identifying what kind of data this element represents (the element type, in other words).

text

The text attribute can be used to hold additional data associated with the element. As the name implies this attribute is usually a string but may be any application-specific object. If the element is created from an XML file the attribute will contain any text found between the element tags.

tail

The tail attribute can be used to hold additional data associated with the element. This attribute is usually a string but may be any application-specific object. If the element is created from an XML file the attribute will contain any text found after the element’s end tag and before the next tag.

attrib

A dictionary containing the element’s attributes. Note that while the attrib value is always a real mutable Python dictionary, an ElementTree implementation may choose to use another internal representation, and create the dictionary only if someone asks for it. To take advantage of such implementations, use the dictionary methods below whenever possible.

The following dictionary-like methods work on the element attributes.

clear ( )

Resets an element. This function removes all subelements, clears all attributes, and sets the text and tail attributes to None.

get ( key, default=None )

Gets the element attribute named key.

Returns the attribute value, or default if the attribute was not found.

items ( )

Returns the element attributes as a sequence of (name, value) pairs. The attributes are returned in an arbitrary order.

keys ( )

Returns the elements attribute names as a list. The names are returned in an arbitrary order.

set ( key, value )

Set the attribute key on the element to value.

The following methods work on the element’s children (subelements).

append ( subelement )

Adds the element subelement to the end of this elements internal list of subelements.

extend ( subelements )

Appends subelements from a sequence object with zero or more elements. Raises AssertionError if a subelement is not a valid object.

New in version 2.7.

find ( match )

Finds the first subelement matching match. match may be a tag name or path. Returns an element instance or None.

findall ( match )

Finds all matching subelements, by tag name or path. Returns a list containing all matching elements in document order.

findtext ( match, default=None )

Finds text for the first subelement matching match. match may be a tag name or path. Returns the text content of the first matching element, or default if no element was found. Note that if the matching element has no text content an empty string is returned.

getchildren ( )

Deprecated since version 2.7: Use list(elem) or iteration.

getiterator ( tag=None )

Deprecated since version 2.7: Use method Element.iter() instead.

insert ( index, element )

Inserts a subelement at the given position in this element.

iter ( tag=None )

Creates a tree iterator with the current element as the root. The iterator iterates over this element and all elements below it, in document (depth first) order. If tag is not None or '*', only elements whose tag equals tag are returned from the iterator. If the tree structure is modified during iteration, the result is undefined.

New in version 2.7.

iterfind ( match )

Finds all matching subelements, by tag name or path. Returns an iterable yielding all matching elements in document order.

New in version 2.7.

itertext ( )

Creates a text iterator. The iterator loops over this element and all subelements, in document order, and returns all inner text.

New in version 2.7.

makeelement ( tag, attrib )

Creates a new element object of the same type as this element. Do not call this method, use the SubElement() factory function instead.

remove ( subelement )

Removes subelement from the element. Unlike the find* methods this method compares elements based on the instance identity, not on tag value or contents.

Element objects also support the following sequence type methods for working with subelements: __delitem__(), __getitem__(), __setitem__(), __len__().

Caution: Elements with no subelements will test as False. This behavior will change in future versions. Use specific len(elem) or elem is None test instead.

element = root.find('foo')

if not element:  # careful!
    print "element not found, or element has no subelements"

if element is None:
    print "element not found"

19.7.3.3. ElementTree Objects

class xml.etree.ElementTree. ElementTree ( element=None, file=None )

ElementTree wrapper class. This class represents an entire element hierarchy, and adds some extra support for serialization to and from standard XML.

element is the root element. The tree is initialized with the contents of the XML file if given.

_setroot ( element )

Replaces the root element for this tree. This discards the current contents of the tree, and replaces it with the given element. Use with care. element is an element instance.

find ( match )

Same as Element.find(), starting at the root of the tree.

findall ( match )

Same as Element.findall(), starting at the root of the tree.

findtext ( match, default=None )

Same as Element.findtext(), starting at the root of the tree.

getiterator ( tag=None )

Deprecated since version 2.7: Use method ElementTree.iter() instead.

getroot ( )

Returns the root element for this tree.

iter ( tag=None )

Creates and returns a tree iterator for the root element. The iterator loops over all elements in this tree, in section order. tag is the tag to look for (default is to return all elements)

iterfind ( match )

Finds all matching subelements, by tag name or path. Same as getroot().iterfind(match). Returns an iterable yielding all matching elements in document order.

New in version 2.7.

parse ( source, parser=None )

Loads an external XML section into this element tree. source is a file name or file object. parser is an optional parser instance. If not given, the standard XMLParser parser is used. Returns the section root element.

write ( file, encoding="us-ascii", xml_declaration=None, default_namespace=None, method="xml" )

Writes the element tree to a file, as XML. file is a file name, or a file object opened for writing. encoding [1] is the output encoding (default is US-ASCII). xml_declaration controls if an XML declaration should be added to the file. Use False for never, True for always, None for only if not US-ASCII or UTF-8 (default is None). default_namespace sets the default XML namespace (for “xmlns”). method is either "xml", "html" or "text" (default is "xml"). Returns an encoded string.

This is the XML file that is going to be manipulated:

<html>
    <head>
        <title>Example page</title>
    </head>
    <body>
        <p>Moved to <a href="http://example.org/" target="_blank" rel="external nofollow" >example.org</a>
        or <a href="http://example.com/" target="_blank" rel="external nofollow" >example.com</a>.</p>
    </body>
</html>

Example of changing the attribute “target” of every link in first paragraph:

>>> from xml.etree.ElementTree import ElementTree
>>> tree = ElementTree()
>>> tree.parse("index.xhtml")
<Element 'html' at 0xb77e6fac>
>>> p = tree.find("body/p")     # Finds first occurrence of tag p in body
>>> p
<Element 'p' at 0xb77ec26c>
>>> links = list(p.iter("a"))   # Returns list of all links
>>> links
[<Element 'a' at 0xb77ec2ac>, <Element 'a' at 0xb77ec1cc>]
>>> for i in links:             # Iterates through all found links
...     i.attrib["target"] = "blank"
>>> tree.write("output.xhtml")

19.7.3.4. QName Objects

class xml.etree.ElementTree. QName ( text_or_uri, tag=None )

QName wrapper. This can be used to wrap a QName attribute value, in order to get proper namespace handling on output. text_or_uri is a string containing the QName value, in the form {uri}local, or, if the tag argument is given, the URI part of a QName. If tag is given, the first argument is interpreted as an URI, and this argument is interpreted as a local name. QName instances are opaque.

19.7.3.5. TreeBuilder Objects

class xml.etree.ElementTree. TreeBuilder ( element_factory=None )

Generic element structure builder. This builder converts a sequence of start, data, and end method calls to a well-formed element structure. You can use this class to build an element structure using a custom XML parser, or a parser for some other XML-like format. The element_factory is called to create new Element instances when given.

close ( )

Flushes the builder buffers, and returns the toplevel document element. Returns an Element instance.

data ( data )

Adds text to the current element. data is a string. This should be either a bytestring, or a Unicode string.

end ( tag )

Closes the current element. tag is the element name. Returns the closed element.

start ( tag, attrs )

Opens a new element. tag is the element name. attrs is a dictionary containing element attributes. Returns the opened element.

In addition, a custom TreeBuilder object can provide the following method:

doctype ( name, pubid, system )

Handles a doctype declaration. name is the doctype name. pubid is the public identifier. system is the system identifier. This method does not exist on the default TreeBuilder class.

New in version 2.7.

19.7.3.6. XMLParser Objects

class xml.etree.ElementTree. XMLParser ( html=0, target=None, encoding=None )

Element structure builder for XML source data, based on the expat parser. html are predefined HTML entities. This flag is not supported by the current implementation. target is the target object. If omitted, the builder uses an instance of the standard TreeBuilder class. encoding [1] is optional. If given, the value overrides the encoding specified in the XML file.

close ( )

Finishes feeding data to the parser. Returns an element structure.

doctype ( name, pubid, system )

Deprecated since version 2.7: Define the TreeBuilder.doctype() method on a custom TreeBuilder target.

feed ( data )

Feeds data to the parser. data is encoded data.

XMLParser.feed() calls target‘s start() method for each opening tag, its end() method for each closing tag, and data is processed by method data(). XMLParser.close() calls target‘s method close(). XMLParser can be used not only for building a tree structure. This is an example of counting the maximum depth of an XML file:

>>> from xml.etree.ElementTree import XMLParser
>>> class MaxDepth:                     # The target object of the parser
...     maxDepth = 0
...     depth = 0
...     def start(self, tag, attrib):   # Called for each opening tag.
...         self.depth += 1
...         if self.depth > self.maxDepth:
...             self.maxDepth = self.depth
...     def end(self, tag):             # Called for each closing tag.
...         self.depth -= 1
...     def data(self, data):
...         pass            # We do not need to do anything with data.
...     def close(self):    # Called when all data has been parsed.
...         return self.maxDepth
...
>>> target = MaxDepth()
>>> parser = XMLParser(target=target)
>>> exampleXml = """
... <a>
...   <b>
...   </b>
...   <b>
...     <c>
...       <d>
...       </d>
...     </c>
...   </b>
... </a>"""
>>> parser.feed(exampleXml)
>>> parser.close()
4

出處:https://www.cnblogs.com/CheeseZH/p/4026686.htmlhttps://www.cnblogs.com/CheeseZH/p/4026686.html

python -- xml.etree.ElementTreeElementTree與Elment解析XML周遊元素修改XML檔案使用iterparse處理大檔案

ElementTree與Elment

解析XML

周遊元素

修改XML檔案

使用iterparse處理大檔案

概述

解析 XML 檔案

解析 XML 字元串

構造 XML

XML 結點的查找與更新

1. 查找 XML 結點

2. 更新結點

19.7.1. 綜述

19.7.1.1. XML 樹和elements

19.7.1.2. 解析 XML

19.7.1.3. 查找感興趣的element

19.7.1.4. 修改XML檔案

19.7.1.5. 建立XML文檔：

19.7.1.6. 其他資源：

19.7.2. XPath

19.7.2.1. Example

19.7.2.2. 支援的 XPath 文法

19.7.3. 其他相關

19.7.3.1. 函數

19.7.3.2. Element 對象

19.7.3.3. ElementTree Objects

19.7.3.4. QName Objects

19.7.3.5. TreeBuilder Objects

19.7.3.6. XMLParser Objects

繼續閱讀