Python：使用 ElementTree 更新 XML 文件，同时尽可能保留布局

Question

我有一个使用 XML 命名空间的文档，我想将其 /group/house/dogs 加一：（该文件名为 houses.xml）

<?xml version="1.0"?>
<group xmlns="http://dogs.house.local">
    <house>
            <id>2821</id>
            <dogs>2</dogs>
    </house>
</group>

我当前使用以下代码的结果是：（创建的文件名为houses2.xml）

<ns0:group xmlns:ns0="http://dogs.house.local">
    <ns0:house>
        <ns0:id>2821</ns0:id>
        <ns0:dogs>3</ns0:dogs>
    </ns0:house>
</ns0:group>

我想解决两件事（如果可以使用 ElementTree。如果不是，我会很高兴提出我应该改用什么的建议）：

1. 我想保留<?xml version="1.0"?> 这一行。
2. 我不想为所有标签添加前缀，我想保持原样。

总之，我不想过多地弄乱文档。

生成上述结果的我当前的代码（除上述缺陷外都有效）如下。

我制作了一个实用函数，它使用 ElementTree 加载 XML 文件并返回 elementTree 和命名空间（因为我不想对命名空间进行硬编码，并且愿意承担它所暗示的风险）：

def elementTreeRootAndNamespace(xml_file):
    from xml.etree import ElementTree
    import re
    element_tree = ElementTree.parse(xml_file)

    # Search for a namespace on the root tag
    namespace_search = re.search('^({\S+})', element_tree.getroot().tag)
    # Keep the namespace empty if none exists, if a namespace exists set
    # namespace to {namespacename}
    namespace = ''
    if namespace_search:
        namespace = namespace_search.group(1)

    return element_tree, namespace

这是我更新狗数量并将其保存到新文件houses2.xml的代码：

elementTree, namespace = elementTreeRootAndNamespace('houses.xml')

# Insert the namespace before each tag when when finding current number of dogs,
# as ElementTree requires the namespace to be prefixed within {...} when a
# namespace is used in the document.
dogs = elementTree.find('{ns}house/{ns}dogs'.format(ns = namespace))

# Increase the number of dogs by one
dogs.text = str(int(dogs.text) + 1)

# Write the result to the new file houses2.xml.
elementTree.write('houses2.xml')

Answer 1

来自 lxml 的 etree 提供了这个功能。

1. elementTree.write('houses2.xml',encoding = "UTF-8",xml_declaration = True) 帮助您不遗漏声明

2. 写入文件时不会更改命名空间。

http://lxml.de/parsing.html 是其教程的链接。

P.S : lxml 应该单独安装。

Answer 2

当保存 xml 添加 default_namespace 参数很容易避免 ns0，在我的代码上

关键代码：xmltree.write(xmlfile,"utf-8",default_namespace=xmlnamespace)

if os.path.isfile(xmlfiile):
            xmltree = ET.parse(xmlfiile)
            root = xmltree.getroot()
            xmlnamespace = root.tag.split('{')[1].split('}')[0]  //get namespace

            initwin=xmltree.find("./{"+ xmlnamespace +"}test")
            initwin.find("./{"+ xmlnamespace +"}content").text = "aaa"
            xmltree.write(xmlfiile,"utf-8",default_namespace=xmlnamespace)

Answer 3

一个基于 XML 的解决方案是为 ElementTree 编写一个帮助类：

• 在写作时在将 XML 声明行解析为 ElementTree 之前，如果不编写编码属性，则无法编写 XML 声明行（我检查了源代码）。
• 解析输入文件一次，获取根元素的命名空间。使用 ElementTree 将该名称空间注册为具有空字符串作为前缀。完成后，将使用 ElementTree再次使用该新设置解析源文件。

它有一个主要缺点：

• XML-cmets 丢失了。我了解到的这种情况是不可接受的（我最初认为输入数据没有任何 cmets，但事实证明它有）。

我的助手类与示例：

from xml.etree import ElementTree as ET
import re


class ElementTreeHelper():
    def __init__(self, xml_file_name):
        xml_file = open(xml_file_name, "rb")

        self.__parse_xml_declaration(xml_file)

        self.element_tree = ET.parse(xml_file)
        xml_file.seek(0)

        root_tag_namespace = self.__root_tag_namespace(self.element_tree)
        self.namespace = None
        if root_tag_namespace is not None:
            self.namespace = '{' + root_tag_namespace + '}'
            # Register the root tag namespace as having an empty prefix, as
            # this has to be done before parsing xml_file we re-parse.
            ET.register_namespace('', root_tag_namespace)
            self.element_tree = ET.parse(xml_file)

    def find(self, xpath_query):
        return self.element_tree.find(xpath_query)

    def write(self, xml_file_name):
        xml_file = open(xml_file_name, "wb")
        if self.xml_declaration_line is not None:
            xml_file.write(self.xml_declaration_line + '\n')

        return self.element_tree.write(xml_file)

    def __parse_xml_declaration(self, xml_file):
        first_line = xml_file.readline().strip()
        if first_line.startswith('<?xml') and first_line.endswith('?>'):
            self.xml_declaration_line = first_line
        else:
            self.xml_declaration_line = None
        xml_file.seek(0)

    def __root_tag_namespace(self, element_tree):
        namespace_search = re.search('^{(\S+)}', element_tree.getroot().tag)
        if namespace_search is not None:
            return namespace_search.group(1)
        else:
            return None


def __main():
    el_tree_hlp = ElementTreeHelper('houses.xml')

    dogs_tag = el_tree_hlp.element_tree.getroot().find(
                   '{ns}house/{ns}dogs'.format(
                         ns=el_tree_hlp.namespace))
    one_dog_added = int(dogs_tag.text.strip()) + 1
    dogs_tag.text = str(one_dog_added)

    el_tree_hlp.write('hejsan.xml')

if __name__ == '__main__':
    __main()

输出：

<?xml version="1.0"?>
<group xmlns="http://dogs.house.local">
    <house>
            <id>2821</id>
            <dogs>3</dogs>
    </house>
</group>

如果有人对此解决方案有改进，请不要犹豫，获取代码并改进它。

Answer 4

不幸的是，往返并不是一个小问题。对于 XML，除非您使用特殊的解析器（例如 DecentXML，但这是针对 Java 的），否则通常无法保留原始文档。

根据您的需要，您有以下选择：

• 如果您控制源代码并且可以使用单元测试保护您的代码，您可以编写自己的简单解析器。此解析器不接受 XML，而只接受有限的子集。例如，您可以将整个文档作为字符串读取，然后使用 Python 的字符串操作来定位 <dogs> 并将任何内容替换为下一个 <。黑客？是的。

• 您可以过滤输出。 XML 只允许字符串<ns0: 在一个位置，因此您可以使用< 搜索和替换它，然后使用<group xmlns:ns0=" → <group xmlns=" 进行相同的搜索和替换。除非您可以在 XML 中包含 CDATA，否则这是非常安全的。

• 您可以编写自己的简单 XML 解析器。将输入读取为字符串，然后为每对 <> 加上它们在输入中的位置创建元素。这使您可以快速拆分输入，但仅适用于少量输入。