XML

XML tree and elements

將XML文檔解析為樹（tree）

我們先從基礎講起。XML是一種結構化、層級化的數(shù)據(jù)格式，最適合體現(xiàn)XML的數(shù)據(jù)結構就是樹。ET提供了兩個對象：ElementTree將整個XML文檔轉化為樹，Element則代表著樹上的單個節(jié)點。對整個XML文檔的交互（讀取，寫入，查找需要的元素），一般是在ElementTree層面進行的。對單個XML元素及其子元素，則是在Element層面進行的。

XML是一種固有的分層數(shù)據(jù)格式，最自然的表示方法是使用樹ET。ET有兩個類：

• ElementTree：表示整個XML文檔為樹，元素表示此樹中的單個節(jié)點。與整個文檔的交互(讀取和寫入文件)通常是在ElementTree級別上完成的。
• Element：與單個XML元素及其子元素的交互是在Element元素級別上完成的。

tree和root分別是ElementTree中兩個很重要的類的對象：ElementTree和Element。

下面對XML文件的格式做一些說明：

• Tag： 使用<>包圍的部分，如：<表示：start-tag，>表示：end-tags；
• Element：被Tag包圍的部分，如：<rank>68</rank>中的68，可以認為是一個節(jié)點，它可以有子節(jié)點；
• Attribute：在Tag中可能存在的name/value對，如<country name="Liechtenstein">中的name=”Liechtenstein”，一般表示屬性。

在Python中處理XML格式文件需要導入的第三方庫：

# 導入第三方庫
import xml.etree.ElementTree as ET

詳細參考：xml.etree.ElementTree的官方文檔

XML文件的常見操作

1. 讀入xml格式的文件，并顯示全部行數(shù)據(jù)

讀入xml格式的文件，并顯示全部行數(shù)據(jù)：

假設有.xml格式文件file_xml，現(xiàn)需要使用Python讀入.xml格式文件，并顯示全部行數(shù)據(jù)，執(zhí)行代碼如下：

open_file = open(file_xml) # file_xml為.xml格式文件
read_file = open_file.readlines() # 讀入所有行數(shù)據(jù)

典型范例：

from xml.etree import ElementTree as ETfile_xml = r'/Users/edz/Documents/yandi_data/taishi_loading/to_xlm/anno.xml'open_file = open(file_xml)
read_file = open_file.readlines() # 讀入所有行數(shù)據(jù)
print(read_file)
>>>
['<annotation>\n','\t<folder>id12_玻璃膜疣</folder>\n','\t<filename>014f80f346d72001267240b1a62f1b72.jpg</filename>\n','\t<path>/Users/edz/Documents/yandi_data/taishi_loading/load_image/原始TXT表/第一批七種病灶/id12_玻璃膜疣/014f80f346d72001267240b1a62f1b72.jpg</path>\n','\t<source>\n','\t\t<database>Unknown</database>\n','\t</source>\n','\t<size>\n','\t\t<width>1924</width>\n','\t\t<height>1556</height>\n','\t\t<depth>3</depth>\n','\t</size>\n','\t<segmented>0</segmented>\n','\t<object>\n','\t\t<name>id12</name>\n','\t\t<pose>Unspecified</pose>\n','\t\t<truncated>0</truncated>\n','\t\t<difficult>0</difficult>\n','\t\t<bndbox>\n','\t\t\t<xmin>1378</xmin>\n','\t\t\t<ymin>742</ymin>\n','\t\t\t<xmax>1700</xmax>\n','\t\t\t<ymax>1319</ymax>\n','\t\t</bndbox>\n','\t</object>\n','\t<object>\n','</annotation>\n']

2. 解析xml格式的文件

解析xml格式的文件：

欲解析xml格式的文件，需要先以另外一種方式讀入一個XML模板文件（如：file_xml），方便后續(xù)以它為基礎模板，進行增、刪、改等操作，得到自定義的目標XML文件。

備注： 個人理解解析xml格式的文件與上邊提到的讀入xml文件的區(qū)別在于:
讀入xml文件進行的是只讀操作，無法對其進行后續(xù)的增、刪、改等操作；而解析xml文件則是先讀入一個模板xml文件，后續(xù)可以對其進行增、刪、改等一系列神操作。

在解析xml格式的文件之前，讀入模板XML文件（如：file_xml），有兩種途徑，從文件讀入和從字符串讀入。

1. 從文件讀入： 通過tree = ET.parse(file_xml)和root = tree.getroot()兩行代碼實現(xiàn)，具體示例如下：

import xml.etree.ElementTree as ETfile_xml = r'/Users/edz/Documents/yandi_data/taishi_loading/to_xlm/anno.xml'
tree = ET.parse(file_xml)  # 類ElementTree
root = tree.getroot()  # 類Element
print(root)  # 這時得到的root是一個指向Element的對象
>>> <Element 'annotation' at 0x135444590>

2. 從字符串讀入： 通過root = ET.fromstring(sample_as_string)實現(xiàn)，不太推薦！！！

root = ET.fromstring(sample_as_string)  # 沒有嘗試過

獲取XML中的元素

查看一個Element的Tag和Attribute的方法

tree和root分別是ElementTree中兩個很重要的類的對象：ElementTree和Element。

以解析XML文件的方式讀入一個xlm文件后，得到的 root是一個指向Element的對象 ，我們可以通過root.tag和root.attrib來分別查看root的tag和attrib，從而驗證這一點，示例如下：

# - 查看root下的`Tag`和`Attribute`
root.tag
>>> 'data'
root.attrib
>>>{}  # 字典為空，表示無屬性

上面的代碼說明了查看一個Element的Tag和Attribute的方法，Tag是一個字符串，而Attribute得到的是一個字典。

另外，還可以使用Element.get(AttributeName)來代替Element.attrib[AttributeName]來訪問（此處的Element即：root）。

獲取XML中的元素：

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'}

1.Element.findall(): 只找到帶有標簽的元素，該標簽是當前元素的直接子元素。
2.Element.find() :找到第一個帶有特定標簽的子元素，例如：root.find('folder').text可以查看指向Element的對象root的"folder"項標簽對應的內(nèi)容，即：”玻璃膜疣“。
3.Element.text: 查看Element的值（或訪問標簽的內(nèi)容）， 使用root.find('filename').text查看標簽內(nèi)容時，可以根據(jù)縮進層次不同，依次添加多個find(‘xxx’)級層，得到對應層級下的Element的值。
4.Element.get()：訪問標簽的屬性值

典型范例：

.xml格式的模板文件template_file的內(nèi)容如下：

<annotation><folder>玻璃膜疣</folder><filename>0002.jpg</filename><path>/Users/edz/Documents/yandi_data/taishi_loading/load_image/原始TXT表/第一批七種病灶/id12_玻璃膜疣/002.jpg</path><source><database>Unknown</database></source><size><width>1924</width><height>1556</height><depth>3</depth></size><segmented>0</segmented><object><name>id12</name><pose>Unspecified</pose><truncated>0</truncated><difficult>0</difficult><bndbox><xmin>1378</xmin><ymin>742</ymin><xmax>1700</xmax><ymax>1319</ymax></bndbox></object>
</annotation>

使用root.find('filename').text查看標簽內(nèi)容，并根據(jù)縮進層次不同添加多個find(‘xxx’)級層，詳細代碼如下：

from lxml.etree import Element, SubElement, tostring, ElementTree
from xml.dom import minidom # 修改自己的路徑
template_file = r'/Users/edz/Documents/yandi_data/taishi_loading/to_xlm/anno.xml'
# 通過讀取模板xlm文件來導入這些數(shù)據(jù):
tree.parse(template_file)  # 調(diào)用parse()方法，返回解析樹
root = tree.getroot()  # 獲取根節(jié)點# 查看Element的值——我們可以直接用`Element.text`來得到這個Element的值。
# 使用root.find().text查看
root.find('filename').text  # 第一層下每一項內(nèi)容
>>>
0002.jpgroot.find('size').find('height').text  # 查看第二層下每一項內(nèi)容
>>>
1556root.find('object').find('bndbox').find('xmin').text  # 查看第三層下每一項內(nèi)容
>>>
1378# 使用root.findall('size')[i].findall('width')[i].text查看
print([root.findall('size')[i].findall('width')[i].text for i in range(len(root.findall('size')[i].findall('width')))])  # 列表生成式輸出# 使用root.iter('filename')循環(huán)查看：
for neighbor in root.iter('filename'):print(neighbor.text)

修改XML文件——修改一個Element

前面已經(jīng)介紹了如何獲取一個Element的對象，以及查看它的Tag、Attribute、值和它的孩子。下面介紹如何修改一個Element并對XML文件進行保存。

修改Element：

• 修改Element可以直接訪問Element.text。
• 修改Element的Attribute，也可以用來新增Attribute，語法格式為：Element.set('AttributeName','AttributeValue')，示例如下：

##Element.set('AttributeName','AttributeValue')  # 通過修改Element的`Attribute`，實現(xiàn)新增`Attribute`
root[0].set('name','9999') 

新增孩子節(jié)點：

Element.append(childElement)

刪除孩子節(jié)點：

Element.remove(childElement)

保存XML文件

保存XML文件：

我們從文件解析的時候，我們用了一個ElementTree的對象tree，在完成修改之后，還用tree來保存最終的XML文件，語法格式為：tree=ET.ElementTree(root)和tree.write(file_path)兩行代碼實現(xiàn)。

tree=ET.ElementTree(root)  # root為修改后的root
tree.write("/Users/edz/Documents/yandi_data/taishi_loading/to_xlm/99.xml")

構建XML文件

利用ET，很容易就可以完成XML文檔構建，并寫入保存為文件。ElementTree對象的write方法就可以實現(xiàn)這個需求。

一般來說，有兩種主要使用場景：

• 一是你先讀取一個XML文檔，進行修改，然后再將修改寫入文檔；
• 二是從頭創(chuàng)建一個新XML文檔。

構建XML文件：

ElementTree提供了兩個靜態(tài)函數(shù)（直接用類名訪問，這里我們用的是ET）可以很方便的構建一個XML，語法格式為：root = ET.Element('data')和b = ET.SubElement(root, 'b')：用于創(chuàng)建新的子元素b。示例如下：

import xml.etree.ElementTree as ET
root = ET.Element('data') 
country = ET.SubElement(root,'country', {'name':'Liechtenstein'})
rank = ET.SubElement(country,'rank')
rank.text = '1'
year = ET.SubElement(country,'year')
year.text = '2008'
tree=ET.ElementTree(root)
tree.write("99.xml")

創(chuàng)建的xml文件內(nèi)容如下：

<data><country name="Liechtenstein"><rank>1</rank><year>2008</year></country></data>

完整練手實例

實例001：

Target: 本實例旨在幫助大家學習、了解XML文件的解析、元素查詢等操作的使用：

準備工作: 下面這段XML文件，我們將它保存為文件sample.xml，并將其作為.xml格式的模板文件，用以完成后續(xù)所有操作。

<?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>

功能實現(xiàn)：

（1）解析xml格式的文件：

import xml.etree.ElementTree as ET
#首先從文件讀入：
file_xml = r'/Users/edz/Documents/yandi_data/taishi_loading/to_xlm/anno.xml'
tree = ET.parse(file_xml)  # 類ElementTree
root = tree.getroot()  # 類Element
print(root)  # 這時得到的root是一個指向Element的對象
>>> <Element 'annotation' at 0x135444590>

（2）查看一個Element的Tag和Attribute的方法：

# 讀入xlm文件后得到的root是一個指向Element的對象，我們可以通過查看root的tag和attrib來驗證這一點：
root.tag #`Tag`是一個字符串，
>>> 'data'
root.attrib # `Attribute`得到的是一個字典。
>>>{}
###另外，還可以使用`Element.get(AttributeName)`來代替`Element.attrib[AttributeName]`來訪問。

（3）獲取XML中的元素：

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'}
#1.`Element.findall():` 只找到帶有標簽的元素，該標簽是當前元素的直接子元素。 
#2.`Element.find()` :找到第一個帶有特定標簽的子元素。
#3.`Element.text`:訪問標簽的內(nèi)容
#4.`Element.get()`：訪問標簽的屬性值

（4）獲取XML中的元素：

#修改Element可以直接訪問Element.text。
#修改Element的Attribute，也可以用來新增Attribute，語法如下：Element.set('AttributeName','AttributeValue')
root[0].set('name','9999')
# 新增孩子節(jié)點：
Element.append(childElement)
# 刪除孩子節(jié)點：
Element.remove(childElement)

實例002：

Target: 先打開一個定義好的.xlm格式的模板文件，之后將TXT文件中的標注框信息逐行讀入，用于修改xlm文件模板對應的指標數(shù)據(jù)，最后將修改后的新xlm文件寫出保存。

"""核心思想：先打開一個定義好的xlm文件模板，之后將TXT文件中的標注框信息逐行讀入，用于修改xlm文件模板對應的指標數(shù)據(jù)，最后將修改后的新xlm文件寫出保存。"""
import copy
from lxml.etree import Element, SubElement, tostring, ElementTree
import cv2# 模板xlm文件的存儲路徑
template_file = r'/Users/edz/Documents/yandi_data/taishi_loading/to_xlm/anno.xml'
path = r'/Users/edz/Documents/yandi_data/taishi_loading/to_xlm/' # TXT文件數(shù)據(jù)的原始格式
train_files = '014f80f346d72001267240b1a62f1b72.jpg id12 1.3418148e+03, 6.2916492e+02, 1.4483580e+03, 9.2253162e+02, 6.3271374e-01'   
trainFile = train_files.split()  # trainFile存放全量的原始數(shù)據(jù)
print('原始數(shù)據(jù)集格式：{}'.format(trainFile))
>>>
原始數(shù)據(jù)集格式：['014f80f346d72001267240b1a62f1b72.jpg', 'id12', '1.3418148e+03,', '6.2916492e+02,', '1.4483580e+03,', '9.2253162e+02,', '6.3271374e-01']
file_name = trainFile[0]
print(file_name) 
>>>
014f80f346d72001267240b1a62f1b72.jpg# 定義新的xlm文件的詳細指標數(shù)據(jù)
label = trainFile[1]
xmin = trainFile[2]
ymin = trainFile[3]
xmax = trainFile[4]
ymax = trainFile[5]############# 讀取模板xlm文件——用于存放TXT文件內(nèi)容:
tree.parse(template_file)  # 調(diào)用parse()方法，返回解析樹
root = tree.getroot()  # 獲取根節(jié)點##########修改新的xlm文件的詳細指標數(shù)據(jù)
# folder
root.find('folder').text = 'new_folders'
# 修改魔板xlm文件中的內(nèi)容為目標結果
root.find('filename').text = file_name   #  2.Element.find() :找到第一個帶有特定標簽的子元素。
# # path
root.find('path').text = path + file_name
# 查看部分修改結果
print(root.find('filename').text)  # 第一層下每一項內(nèi)容
print(root.find('path').text)  # 第一層下每一項內(nèi)容
print(root.find('size').find('height').text)  # 查看第二層下每一項內(nèi)容
print(root.find('object').find('bndbox').find('xmin').text)  # 查看第三層下每一項內(nèi)容
>>>
014f80f346d72001267240b1a62f1b72.jpg
/Users/edz/Documents/yandi_data/taishi_loading/to_xlm/014f80f346d72001267240b1a62f1b72.jpg
1556
1378
# size
sz = root.find('size')
im = cv2.imread(path + file_name) # 讀取圖片信息sz.find('height').text = str(im.shape[0])
sz.find('width').text = str(im.shape[1])
sz.find('depth').text = str(im.shape[2])print('iamge height:',im.shape[0])
print('iamge width:',im.shape[1])
print('iamge depth:',im.shape[2])
>>>
iamge height: 1556
iamge width: 1924
iamge depth: 3# object
obj = root.find('object')obj.find('name').text = label
bb = obj.find('bndbox')
bb.find('xmin').text = xmin
bb.find('ymin').text = ymin
bb.find('xmax').text = xmax
bb.find('ymax').text = ymax########## 校驗修改后的root是否為新數(shù)據(jù)
root.find('object').find('bndbox').find('ymax').text
>>>
'9.2253162e+02,'  # 符合預期
########## 保存新生成的xlm數(shù)據(jù)文件
tree=ET.ElementTree(root)
tree.write("/Users/edz/Documents/yandi_data/taishi_loading/to_xlm/99.xml")

常用的屬性 & 方法

ET 里面的屬性 & 方法很多，這里列出常用的幾個，供使用中備查。

1.Element 對象

常用的屬性如下：

• tag：string，元素數(shù)據(jù)種類
• text：string，元素的內(nèi)容
• attrib：dictionary，元素的屬性字典
• tail：string，元素的尾形

針對屬性的操作如下：

• clear()：清空元素的后代，屬性，text 和 tail 也設置為 None。
• items()：根據(jù)屬性字典返回一個列表，列表元素為(key,value)。
• keys()：返回包含所有元素屬性鍵的列表。
• set(key,value)：設置新的屬性鍵和值。

針對后代的操作如下：

• append(subelement)：添加直系子元素。
• extend(sunelements)：增加一串元素對象作為子元素。
• find(match)：尋找第一個匹配子元素，匹配對象可以為 tag 或 path。
• findall(match)：尋找所有匹配子元素，匹配對象可以為 tag 或 path。
• insert(index,element)：在指定位置插入子元素。
• remove(subelement)：刪除子元素

2.ElementTree 對象

• find(match)。
• findall(match)。
• getroot()：獲取根結點。
• parse(source,parser = None)：裝載 XML 對象，source 可以為文件名或文件類型對象。

具體使用

1. 解析XML文件并獲取根節(jié)點：

import xml.etree.ElementTree as ETtree = ET.parse('example.xml')
root = tree.getroot()
print(root.tag)

2. 遍歷XML文件的所有節(jié)點：

for child in root:print(child.tag, child.attrib)for subchild in child:print(subchild.tag, subchild.text)

3. 根據(jù)標簽名查找子節(jié)點：

for child in root.iter('tagName'):print(child.text)

4. 根據(jù)屬性查找節(jié)點：

for child in root.findall('.//tagName[@attrName="value"]'):print(child.text)

5. 修改XML文件中的文本內(nèi)容：

for subchild in root.findall('.//tagName'):subchild.text = 'new text'
tree.write('example.xml')

6. 添加新的子節(jié)點：

new_child = ET.Element('tagName')
new_child.text = 'new text'
root.append(new_child)
tree.write('example.xml')

7. 刪除XML文件中的節(jié)點：

for child in root.findall('.//tagName'):root.remove(child)
tree.write('example.xml')

8. 創(chuàng)建XML文件并保存到磁盤：

root = ET.Element('root')
child = ET.SubElement(root, 'child')
child.text = 'child text'
tree = ET.ElementTree(root)
tree.write('example.xml')

9. 解析XML字符串并獲取根節(jié)點：

xml_string = '<root><child>child text</child></root>'
root = ET.fromstring(xml_string)
print(root.tag)

JSON

就數(shù)據(jù)傳遞而言， XML 是一種選擇，當然這里還有另一種選擇 – 「JSON」。它是一種輕量級的數(shù)據(jù)交換格式，如果各位想要做 Web 編程的話，則肯定會用到它。下面我們就開始今天的學習。

首先我們參考《維基百科》中的相關內(nèi)容，來對 JSON 做如下介紹：

JSON ( JavaScript Object Notation )
是一種由道格拉斯構想設計、輕量級的數(shù)據(jù)交換語言，以文字為基礎，且易于讓人閱讀。盡管 JSON 是 JavaScript 的一個子集，但
JSON 是獨立于語言的文本格式，并且采用了類似 C 語言家族的一些習慣。 關于 JSON
更為詳細的內(nèi)容，可以參考其官方網(wǎng)站，在這我截取部分內(nèi)容，讓大家更好的了解一下 JSON 的結構。

JSON 構建于兩種結構基礎之上：

• “名稱/值”對的集合。不同的語言中，它被理解為對象（object），記錄（record），結構（struct），字典（dictionary），哈希表（hash table）等。
• 值的有序列表。在某些語言中，它被理解為數(shù)組（array），類似于 Python 中的類表。

Python 標準庫中有 JSON 模塊，主要是執(zhí)行序列化和反序列化功能。

• 序列化：encoding，把一個 Python 對象編碼轉化成 JSON 字符串；
• 反序列化：decoding，把 JSON 格式字符串解碼轉換為 Python 數(shù)據(jù)對象。

基本操作

JSON 模塊相比于 XML 來說真的是簡單多了：

>>> import json
>>> json.__all__
['dump', 'dumps', 'load', 'loads', 'JSONDecoder', 'JSONDecodeError', 'JSONEncoder']

1.encoding：dumps()

>>> data = [{'name':'rocky','like':('python','c++'),'age':23}]
>>> data
[{'name': 'rocky', 'like': ('python', 'c++'), 'age': 23}]
>>> data_json = json.dumps(data)
>>> data_json
'[{"name": "rocky", "like": ["python", "c++"], "age": 23}]'

encoding 的操作比較簡單，請仔細觀察一下上面代碼中 data 和 data_json 的不同：like 的值從元組變成了列表，其實還有不同，請看下面：

>>> type(data)
<class 'list'>
>>> type(data_json)
<class 'str'>

2.decoding：loads()

decoding 的過程其實也像上面那么簡單：

>>> new_data = json.loads(data_json)
>>> new_data
[{'name': 'rocky', 'like': ['python', 'c++'], 'age': 23}]

上面需要注意的是，解碼之后并沒有將值中的列表還原為數(shù)組。上面的 data 都不是很長，還能湊活著看，如何很長，閱讀其實就很有難度了。所以 JSON 的 dumps() 提供了可選的參數(shù)，利用它們能在輸入上對人更好，當然這個對機器來說都是無所謂的事情。

>>> data1 = json.dumps(data,sort_keys = True,indent = 2)
>>> print(data1)
[{"age": 23,"like": ["python","c++"],"name": "rocky"}
]

sort_keys = True 的意思是按照鍵的字典順序排序；indent = 2 則是讓每個鍵值對顯示的時候，以縮進兩個字符對齊，這樣的視覺效果就好多了。

n)

new_data
[{‘name’: ‘rocky’, ‘like’: [‘python’, ‘c++’], ‘a(chǎn)ge’: 23}]

上面需要注意的是，解碼之后并沒有將值中的列表還原為數(shù)組。上面的 data 都不是很長，還能湊活著看，如何很長，閱讀其實就很有難度了。所以 JSON 的 dumps() 提供了可選的參數(shù)，利用它們能在輸入上對人更好，當然這個對機器來說都是無所謂的事情。```text
>>> data1 = json.dumps(data,sort_keys = True,indent = 2)
>>> print(data1)
[{"age": 23,"like": ["python","c++"],"name": "rocky"}
]

sort_keys = True 的意思是按照鍵的字典順序排序；indent = 2 則是讓每個鍵值對顯示的時候，以縮進兩個字符對齊，這樣的視覺效果就好多了。