python 生成xml文件,以及美化的实例代码_Python

看代码吧~

				?

									# -*- coding:utf-8 -*- 

									import os

									import json

									import numpy as np 

									#from xml.etree import ElementTree as  etree

									from xml.etree.ElementTree import Element

									from xml.etree.ElementTree import SubElement

									from xml.etree.ElementTree import ElementTree

									imagePath = r'E:\Desktop\SteelCoilsDetection\test\images'

									jsonPath = r'E:\Desktop\SteelCoilsDetection\test\json'

									savePath = r'E:\Desktop\SteelCoilsDetection\test\xml'

									jsonList = os.listdir(jsonPath)

									for jsonName in jsonList:

									    print(jsonName)

									    readPath = os.path.join(jsonPath, jsonName)

									    # 打开json文件

									    with open(readPath, 'r') as file_loader:

									        jsonDic = json.load(file_loader)

									    # print(jsonDic.keys())

									    # dict_keys(['version', 'flags', 'shapes', 'imagePath', 'imageData', 'imageHeight', 'imageWidth'])

									    # 生成xml文件

									    annotation = Element('annotation')

									    folder = SubElement(annotation, 'folder')

									    folder.text = "images"

									    filename = SubElement(annotation, 'filename')

									    filename.text = jsonName.split('.')[0]

									    path = SubElement(annotation, 'path')

									    path.text = imagePath + jsonName.split('.')[0]

									    source = SubElement(annotation, 'source')

									    database = SubElement(source, 'database')

									    database.text = "Unknown"

									    size = SubElement(annotation, 'size')

									    width = SubElement(size, 'width')

									    width.text = str(jsonDic['imageWidth'])

									    height = SubElement(size, 'height')

									    height.text = str(jsonDic['imageHeight'])

									    depth = SubElement(size, 'depth')

									    depth.text = "3"

									    segmented = SubElement(annotation, 'segmented')

									    segmented.text = "0"

									    for shape in jsonDic['shapes']: 

									        if shape["label"] == 'a':

									            continue       

									        object = SubElement(annotation, 'object') 

									        name = SubElement(object, 'name')

									        name.text = shape["label"]

									        pose = SubElement(object, 'pose')

									        pose.text = 'Unspecified'

									        truncated = SubElement(object, 'truncated')

									        truncated.text = str(0)

									        difficult = SubElement(object, 'difficult')

									        difficult.text = str(0)        

									        points = shape['points']

									        mritx = np.array(points)

									        xxmin = min(mritx[:, 0])

									        xxmax = max(mritx[:, 0])

									        yymin = min(mritx[:, 1])

									        yymax = max(mritx[:, 1])

									        bndbox = SubElement(object, 'bndbox')

									        xmin = SubElement(bndbox, 'xmin')

									        xmin.text = str(int(xxmin))

									        ymin = SubElement(bndbox, 'ymin')

									        ymin.text = str(int(yymin))

									        xmax = SubElement(bndbox, 'xmax')

									        xmax.text = str(int(xxmax))

									        ymax = SubElement(bndbox, 'ymax')

									        ymax.text = str(int(yymax)) 

									    tree = ElementTree(annotation)

									    tree.write(os.path.join(savePath, jsonName.split('.')[0]+'.xml'), encoding = 'utf-8')

美化：

				?

									# -*- coding:utf-8 -*- 

									import os

									from xml.etree import ElementTree      # 导入ElementTree模块  

									# elemnt为传进来的Elment类，参数indent用于缩进，newline用于换行

									def prettyXml(element, indent, newline, level = 0):

									    # 判断element是否有子元素

									    if element:

									        # 如果element的text没有内容

									        if element.text == None or element.text.isspace():

									            element.text = newline + indent * (level + 1)

									        else:

									            element.text = newline + indent * (level + 1) + element.text.strip() + newline + indent * (level + 1)

									    # 此处两行如果把注释去掉，Element的text也会另起一行 

									    #else:

									        #element.text = newline + indent * (level + 1) + element.text.strip() + newline + indent * level

									    temp = list(element) # 将elemnt转成list

									    for subelement in temp:

									        # 如果不是list的最后一个元素，说明下一个行是同级别元素的起始，缩进应一致

									        if temp.index(subelement) < (len(temp) - 1):

									            subelement.tail = newline + indent * (level + 1)

									        else:  # 如果是list的最后一个元素， 说明下一行是母元素的结束，缩进应该少一个

									            subelement.tail = newline + indent * level   

									        # 对子元素进行递归操作 

									        prettyXml(subelement, indent, newline, level = level + 1)  

									dir = r'E:\Desktop\SteelCoilsDetection\test\xml'

									for fileName in os.listdir(dir):

									    print(fileName)

									    tree = ElementTree.parse(os.path.join(dir, fileName))   #解析test.xml这个文件，该文件内容如上文

									    root = tree.getroot()                                   #得到根元素，Element类

									    prettyXml(root, '\t', '\n')                             # 执行美化方法

									    #ElementTree.dump(root)                                 #显示出美化后的XML内容

									    tree.write(os.path.join(dir, fileName), encoding = 'utf-8')

补充：Python 标准库 xml 详解

对于简单的 XML 解析处理, 可以使用标准库 xml, 相对于第三方库 lxml, xml 无需额外安装, 但 xml 是用 Python 实现的, 性能不如 lxml

XML 的解析功能主要由 xml.etree.ElementTree 模块完成, 其中包含两个类, ElementTree 用于表示整个 XML 文档, 而 Element 表示文档中的一个节点

示例数据, 命名为 book.xml

				?

									<?xml version="1.0"?>

									<bookstore>

									    <book name="西游记">

									        <author>吴承恩</author>

									        <dynasty>明朝</dynasty>

									        <similar name="封神演义" author="许仲琳"/>

									    </book>

									    <book name="红楼梦">

									        <author>曹雪芹</author>

									        <dynasty>清朝</dynasty>

									    </book>

									    <book name="三国演义">

									        <author>罗贯中</author>

									        <dynasty>明末清初</dynasty>

									        <similar name="三国志" author="陈寿"/>

									    </book>

									</bookstore>

导入要解析的 XML 文档, 并获取文档的根节点

				?

									import xml.etree.ElementTree as ET

									tree = ET.parse("./book.xml")

									root = tree.getroot()

也可以直接解析字符串

				?

									with open("./book.xml") as fp:

									    root = ET.fromstring(fp.read())

对于每一个节点 Element:

通过列表接口可以访问直接子节点

通过字典接口可以访问属性节点, 也可通过 attrib 属性(例如 root.attrib)得到真正的字典

其他还有 tag 属性表示标签名, text 表示其包含的文本内容

				?

									# 遍历直接子节点

									for book in root:

									    print(book.tag, book.attrib, book.get("name"))

									# 访问根节点下的第2个子节点, 再向下访问第1个子节点的文本, 也就是 "<author>曹雪芹</author>"

									author = root[1][0].text

									print(type(author), author)

打印输出

book {'name': '西游记'} 西游记

book {'name': '红楼梦'} 红楼梦

book {'name': '三国演义'} 三国演义

<class 'str'> 曹雪芹

获取到的文本结果与 lxml 不同, 这里的结果直接是字符串类型

递归函数, 可以遍历所有的后代节点

				?

									# 递归选择所有标签名为 "similar" 的节点

									for book in root.iter("similar"):

									    print(book.attrib)

打印输出

{'name': '封神演义', 'author': '许仲琳'}

{'name': '三国志', 'author': '陈寿'}

XPath 语法

XPath 类似于文件路径, 路径中最末尾的部分表示要提取的内容, 分隔符有两种, "/"表示直接子节点的关系, "//"表示所有的子节点

语法	含义
tag	匹配特定标签
*	匹配所有元素
.	当前节点, 用于相对路径
…	父节点
[@attrib]	匹配包含 attrib 属性的节点
[@attrib=‘value']	匹配 attrib 属性等于 value 的节点
[tag]	匹配包含直接子节点 tag 的节点
[tag=‘text']	匹配包含直接子节点 tag 且子节点文本内容为 text 的节点
[n]	匹配第 n 个节点

[] 前面必须有标签名, book[@name][similar] 匹配带有 name 属性以及 similar 直接子节点的 book 节点, 然后将 book[@name][similar] 置于 XPath 路径中, 例如 “/bookstore/book[@name][similar]”

可以通过 Element 对象的方法 findall(path) 和 find(path) 使用 XPath 语法, 次时路径是从 Element 代表的节点开始, 也可以通过 ElementTree 对象调用 findall 与 find, 相当于路径从根节点开始

匹配到节点, findall 返回所有匹配节点的列表, find 返回首个匹配节点, 没有匹配到节点时, findall 返回空列表, find 返回 None

				?

									# . 表示 bookstore 节点

									author_1 = tree.find("./book[@name='红楼梦']/author").text

									author_2 = tree.findtext("./book[@name='红楼梦']/author")

									print("红楼梦作者:", author_1, author_2)

									author_3 = root.find("./book/similar[@name='三国志']").get("author")

									print("三国志作者:", author_3)

打印结果

红楼梦作者: 曹雪芹曹雪芹

三国志作者: 陈寿

findtext 类似于 find, 直接获取节点的文本内容

				?

									books_1 = root.findall("./book[similar]")

									# 对于直接子节点, 可以省略 ./

									books_2 = root.findall("book[similar]")

									print(books_1 == books_2)

									for book in books_1:

									    print(book[0].text, book[1].text)