Python 中 XML 解析器的路线图

目录

如果您以前曾尝试过用 Python解析XML 文档，那么您就会知道这样的任务有多么困难。一方面，Python之禅承诺只有一种显而易见的方法来实现您的目标。同时，标准库遵循电池包含的座右铭，让您可以从多个 XML 解析器中进行选择。幸运的是，Python 社区通过创建更多 XML 解析库解决了这个过剩问题。

撇开玩笑不谈，所有 XML 解析器在充满或大或小的挑战的世界中都有自己的位置。熟悉可用的工具是值得的。

在本教程中，您将学习如何：

• 选择正确的 XML解析模型
• 使用标准库中的 XML 解析器
• 使用主要的 XML 解析库
• 使用数据绑定以声明方式解析 XML 文档
• 使用安全的 XML 解析器消除安全漏洞

您可以将本教程用作路线图，引导您了解 Python 中 XML 解析器的混乱世界。到最后，您将能够为给定的问题选择正确的 XML 解析器。要从本教程中获得最大收益，您应该已经熟悉XML及其构建块，以及如何在 Python 中处理文件。

选择正确的 XML 解析模型

事实证明，您可以使用一些与语言无关的策略来处理 XML 文档。每个都展示了不同的内存和速度权衡，这可以部分证明 Python 中可用的各种 XML 解析器是合理的。在下一节中，您将了解它们的差异和优势。

<?xml version="1.0" encoding="UTF-8" standalone="no"?>
<!DOCTYPE svg PUBLIC "-//W3C//DTD SVG 1.1//EN"
  "http://www.w3.org/Graphics/SVG/1.1/DTD/svg11.dtd" [
    <!ENTITY custom_entity "Hello">
]>
<svg xmlns="http://www.w3.org/2000/svg"
  xmlns:inkscape="http://www.inkscape.org/namespaces/inkscape"
  viewBox="-105 -100 210 270" width="210" height="270">
  <inkscape:custom x="42" inkscape:z="555">Some value</inkscape:custom>
  <defs>
    <linearGradient id="skin" x1="0" x2="0" y1="0" y2="1">
      <stop offset="0%" stop-color="yellow" stop-opacity="1.0"/>
      <stop offset="75%" stop-color="gold" stop-opacity="1.0"/>
      <stop offset="100%" stop-color="orange" stop-opacity="1"/>
    </linearGradient>
  </defs>
  <g id="smiley" inkscape:groupmode="layer" inkscape:label="Smiley">
    <!-- Head -->
    <circle cx="0" cy="0" r="50"
      fill="url(#skin)" stroke="orange" stroke-width="2"/>
    <!-- Eyes -->
    <ellipse cx="-20" cy="-10" rx="6" ry="8" fill="black" stroke="none"/>
    <ellipse cx="20" cy="-10" rx="6" ry="8" fill="black" stroke="none"/>
    <!-- Mouth -->
    <path d="M-20 20 A25 25 0 0 0 20 20"
      fill="white" stroke="black" stroke-width="3"/>
  </g>
  <text x="-40" y="75">&custom_entity; &lt;svg&gt;!</text>
  <script>
    <![CDATA[
      console.log("CDATA disables XML parsing: <svg>")
      const smiley = document.getElementById("smiley")
      const eyes = document.querySelectorAll("ellipse")
      const setRadius = r => e => eyes.forEach(x => x.setAttribute("ry", r))
      smiley.addEventListener("mouseenter", setRadius(2))
      smiley.addEventListener("mouseleave", setRadius(8))
    ]]>
  </script>
</svg>

它以XML 声明开头，然后是文档类型定义 (DTD)和<svg> 根元素。DTD 是可选的，但如果您决定使用 XML 验证器，它可以帮助验证您的文档结构。根元素为特定于编辑器的元素和属性指定默认命名空间 xmlns以及带前缀的命名空间 xmlns:inkscape。该文件还包含：

• 嵌套元素
• 属性
• 注释
• 字符数据 ( CDATA)
• 预定义和自定义实体

继续，将 XML 保存在一个名为smiley.svg的文件中，然后使用现代 Web 浏览器打开它，这将运行最后出现的 JavaScript 代码段：

该代码向图像添加了一个交互式组件。当您将鼠标悬停在笑脸上时，它会眨眼。如果您想使用方便的图形用户界面 (GUI) 编辑笑脸，则可以使用矢量图形编辑器（例如Adobe Illustrator或Inkscape）打开文件。

值得注意的是，Python 的标准库定义了用于解析 XML 文档的抽象接口，同时让您提供具体的解析器实现。在实践中，您很少这样做，因为 Python 捆绑了Expat库的绑定，这是一种广泛使用的开源 XML 解析器，用 C 编写。标准库中的以下所有 Python 模块默认使用 Expat。

不幸的是，虽然 Expat 解析器可以告诉您文档是否格式正确，但它无法根据XML 架构定义 (XSD)或文档类型定义 (DTD)验证文档的结构。为此，您必须使用稍后讨论的第三方库之一。

xml.dom.minidom: 最小的 DOM 实现

考虑到使用 DOM 解析 XML 文档可以说是最直接的方式，您不会对在 Python 标准库中找到 DOM 解析器感到惊讶。然而，令人惊讶的是，实际上有两个 DOM 解析器。

该xml.dom包包含两个模块以在 Python 中处理 DOM：

1. xml.dom.minidom
2. xml.dom.pulldom

第一个是符合 W3C 规范相对较旧版本的 DOM 接口的精简实现。它提供了通过DOM API诸如定义的通用对象Document，Element以及Attr。正如您即将发现的那样，该模块的文档很差，而且实用性非常有限。

第二个模块的名称有点误导，因为它定义了一个流式拉取解析器，它可以选择生成文档树中当前节点的 DOM 表示。你会发现有关的更多信息pulldom分析器后。

有两个函数minidom可以让您解析来自各种数据源的 XML 数据。一个接受文件名或文件对象，而另一个接受Python 字符串：

>>> from xml.dom.minidom import parse, parseString

>>> # Parse XML from a filename
>>> document = parse("smiley.svg")

>>> # Parse XML from a file object
>>> with open("smiley.svg") as file:
...     document = parse(file)
...

>>> # Parse XML from a Python string
>>> document = parseString("""\
... <svg viewBox="-105 -100 210 270">
...   <!-- More content goes here... -->
... </svg>
... """)

的三重引号字符串有助于嵌入多行字符串文字不使用继续符（\）中的每一行的末尾。在任何情况下，您最终都会得到一个Document实例，它展示了熟悉的 DOM 接口，让您可以遍历树。

除此之外，您将能够访问 XML 声明、DTD 和根元素：

>>> document = parse("smiley.svg")

>>> # XML Declaration
>>> document.version, document.encoding, document.standalone
('1.0', 'UTF-8', False)

>>> # Document Type Definition (DTD)
>>> dtd = document.doctype
>>> dtd.entities["custom_entity"].childNodes
[<DOM Text node "'Hello'">]

>>> # Document Root
>>> document.documentElement
<DOM Element: svg at 0x7fc78c62d790>

如您所见，即使 Python 中的默认 XML 解析器无法验证文档，它仍然允许您检查.doctypeDTD（如果存在）。请注意，XML 声明和 DTD 是可选的。如果缺少 XML 声明或给定的 XML 属性，则相应的 Python 属性将为None.

要按 ID 查找元素，您必须使用Document实例而不是特定的 parent Element。示例 SVG 图像有两个具有id属性的节点，但您找不到其中任何一个：

>>> document.getElementById("skin") is None
True
>>> document.getElementById("smiley") is None
True

对于只使用过 HTML 和 JavaScript 但以前从未使用过 XML 的人来说，这可能会令人惊讶。虽然 HTML 定义了某些元素和属性（例如<body>或 ）的语义id，但 XML 没有为其构建块附加任何意义。您需要使用 DTD 或通过.setIdAttribute()在 Python 中调用来显式地将属性标记为 ID ，例如：

但是，如果您的文档具有默认命名空间（示例 SVG 图像就是这种情况），则使用 DTD 并不足以解决问题。为了解决这个问题，你可以在 Python 中递归访问所有元素，检查它们是否具有该id属性，并一次性将其指示为它们的 ID：

>>> from xml.dom.minidom import parse, Node

>>> def set_id_attribute(parent, attribute_name="id"):
...     if parent.nodeType == Node.ELEMENT_NODE:
...         if parent.hasAttribute(attribute_name):
...             parent.setIdAttribute(attribute_name)
...     for child in parent.childNodes:
...         set_id_attribute(child, attribute_name)
...
>>> document = parse("smiley.svg")
>>> set_id_attribute(document)

您的自定义set_id_attribute()函数采用一个父元素和一个可选的身份属性名称，默认为"id"。当您在 SVG 文档上调用该函数时，所有具有id属性的子元素都可以通过 DOM API 访问：

>>> document.getElementById("skin")
<DOM Element: linearGradient at 0x7f82247703a0>

>>> document.getElementById("smiley")
<DOM Element: g at 0x7f8224770940>

现在，您将获得与id属性值对应的预期 XML 元素。

使用 ID 最多只能找到一个唯一元素，但您也可以通过标签名称找到一组相似元素。与.getElementById()方法不同，您可以调用.getElementsByTagName()文档或特定的父元素来缩小搜索范围：

>>> document.getElementsByTagName("ellipse")
[
    <DOM Element: ellipse at 0x7fa2c944f430>,
    <DOM Element: ellipse at 0x7fa2c944f4c0>
]

>>> root = document.documentElement
>>> root.getElementsByTagName("ellipse")
[
    <DOM Element: ellipse at 0x7fa2c944f430>,
    <DOM Element: ellipse at 0x7fa2c944f4c0>
]

请注意，.getElementsByTagName()始终返回元素列表而不是单个元素或None。在两种方法之间切换时忘记它是常见的错误来源。

不幸的是，不会包含<inkscape:custom>这样的以命名空间标识符为前缀的元素。必须使用 搜索它们.getElementsByTagNameNS()，它需要不同的参数：

>>> document.getElementsByTagNameNS(
...     "http://www.inkscape.org/namespaces/inkscape",
...     "custom"
... )
...
[<DOM Element: inkscape:custom at 0x7f97e3f2a3a0>]

>>> document.getElementsByTagNameNS("*", "custom")
[<DOM Element: inkscape:custom at 0x7f97e3f2a3a0>]

第一个参数必须是 XML 命名空间，它通常具有域名的形式，而第二个参数是标记名称。请注意，名称空间前缀无关紧要！要搜索所有命名空间，您可以提供通配符 ( *)。

一旦你找到你感兴趣的元素，你就可以用它来遍历树。然而，另一个令人不快的怪癖minidom是它如何处理元素之间的空白字符：

>>> element = document.getElementById("smiley")

>>> element.parentNode
<DOM Element: svg at 0x7fc78c62d790>

>>> element.firstChild
<DOM Text node "'\n    '">

>>> element.lastChild
<DOM Text node "'\n  '">

>>> element.nextSibling
<DOM Text node "'\n  '">

>>> element.previousSibling
<DOM Text node "'\n  '">

换行符和前导缩进被捕获为单独的树元素，这是规范所要求的。一些解析器让你忽略这些，但不是 Python 的。但是，您可以手动折叠此类节点中的空白：

>>> def remove_whitespace(node):
...     if node.nodeType == Node.TEXT_NODE:
...         if node.nodeValue.strip() == "":
...             node.nodeValue = ""
...     for child in node.childNodes:
...         remove_whitespace(child)
...
>>> document = parse("smiley.svg")
>>> set_id_attribute(document)
>>> remove_whitespace(document)
>>> document.normalize()

请注意，您还必须.normalize()将文档合并相邻的文本节点。否则，您最终可能会得到一堆只有空格的冗余 XML 元素。同样，递归是访问树元素的唯一方法，因为您无法使用循环遍历文档及其元素。最后，这应该给你预期的结果：

>>> element = document.getElementById("smiley")

>>> element.parentNode
<DOM Element: svg at 0x7fc78c62d790>

>>> element.firstChild
<DOM Comment node "' Head '">

>>> element.lastChild
<DOM Element: path at 0x7f8beea0f670>

>>> element.nextSibling
<DOM Element: text at 0x7f8beea0f700>

>>> element.previousSibling
<DOM Element: defs at 0x7f8beea0f160>

>>> element.childNodes
[
    <DOM Comment node "' Head '">,
    <DOM Element: circle at 0x7f8beea0f4c0>,
    <DOM Comment node "' Eyes '">,
    <DOM Element: ellipse at 0x7fa2c944f430>,
    <DOM Element: ellipse at 0x7fa2c944f4c0>,
    <DOM Comment node "' Mouth '">,
    <DOM Element: path at 0x7f8beea0f670>
]

Elements 公开了一些有用的方法和属性，让您可以查询它们的详细信息：

>>> element = document.getElementsByTagNameNS("*", "custom")[0]

>>> element.prefix
'inkscape'

>>> element.tagName
'inkscape:custom'

>>> element.attributes
<xml.dom.minidom.NamedNodeMap object at 0x7f6c9d83ba80>

>>> dict(element.attributes.items())
{'x': '42', 'inkscape:z': '555'}

>>> element.hasChildNodes()
True

>>> element.hasAttributes()
True

>>> element.hasAttribute("x")
True

>>> element.getAttribute("x")
'42'

>>> element.getAttributeNode("x")
<xml.dom.minidom.Attr object at 0x7f82244a05f0>

>>> element.getAttribute("missing-attribute")
''

例如，您可以检查元素的命名空间、标签名称或属性。如果您要求缺少的属性，那么您将得到一个空字符串 ( '')。

处理命名空间属性并没有太大不同。您只需要记住相应地为属性名称添加前缀或提供域名：

>>> element.hasAttribute("z")
False

>>> element.hasAttribute("inkscape:z")
True

>>> element.hasAttributeNS(
...     "http://www.inkscape.org/namespaces/inkscape",
...     "z"
... )
...
True

>>> element.hasAttributeNS("*", "z")
False

奇怪的是，通配符 ( *) 在这里并不像以前的.getElementsByTagNameNS()方法那样起作用。

由于本教程仅涉及 XML 解析，因此您需要查看minidom文档以了解修改 DOM 树的方法。它们大多遵循 W3C 规范。

如您所见，该minidom模块并不是非常方便。它的主要优点是作为标准库的一部分，这意味着您无需在项目中安装任何外部依赖项即可使用 DOM。

xml.sax：Python 的 SAX 接口

要开始在 Python 中使用 SAX，您可以使用与以前相同parse()且parseString()方便的函数，但要使用xml.sax包中的函数。您还必须至少提供一个更多的必需参数，它必须是一个内容处理程序实例。本着 Java 的精神，您可以通过对特定基类进行子类化来提供一个：

from xml.sax import parse
from xml.sax.handler import ContentHandler

class SVGHandler(ContentHandler):
    pass

parse("smiley.svg", SVGHandler())

内容处理程序在解析文档时接收与文档中的元素相对应的事件流。运行此代码不会做任何有用的事情，因为您的处理程序类是空的。要使其工作，您需要从超类中重载一个或多个回调方法。

启动您最喜欢的编辑器，键入以下代码，并将其保存在名为 的文件中svg_handler.py：

# svg_handler.py

from xml.sax.handler import ContentHandler

class SVGHandler(ContentHandler):

    def startElement(self, name, attrs):
        print(f"BEGIN: <{name}>, {attrs.keys()}")

    def endElement(self, name):
        print(f"END: </{name}>")

    def characters(self, content):
        if content.strip() != "":
            print("CONTENT:", repr(content))

这个修改后的内容处理程序将一些事件打印到标准输出上。SAX 解析器将为您调用这三个方法，以响应查找开始标记、结束标记和它们之间的一些文本。当您打开 Python 解释器的交互式会话时，导入您的内容处理程序并对其进行测试。它应该产生以下输出：

>>> from xml.sax import parse
>>> from svg_handler import SVGHandler
>>> parse("smiley.svg", SVGHandler())
BEGIN: <svg>, ['xmlns', 'xmlns:inkscape', 'viewBox', 'width', 'height']
BEGIN: <inkscape:custom>, ['x', 'inkscape:z']
CONTENT: 'Some value'
END: </inkscape:custom>
BEGIN: <defs>, []
BEGIN: <linearGradient>, ['id', 'x1', 'x2', 'y1', 'y2']
BEGIN: <stop>, ['offset', 'stop-color', 'stop-opacity']
END: </stop>
⋮

这本质上是观察者设计模式，它允许您逐步将 XML 转换为另一种分层格式。假设您想将该 SVG 文件转换为简化的JSON表示。首先，您需要将内容处理程序对象存储在一个单独的变量中，以便稍后从中提取信息：

>>> from xml.sax import parse
>>> from svg_handler import SVGHandler
>>> handler = SVGHandler()
>>> parse("smiley.svg", handler)

由于 SAX 解析器发出事件而不提供有关它找到的元素的任何上下文，因此您需要跟踪您在树中的位置。因此，将当前元素推入和弹出到堆栈中是有意义的，您可以通过常规Python 列表来模拟。您还可以定义一个辅助属性.current_element，该属性将返回放置在堆栈顶部的最后一个元素：

# svg_handler.py

# ...

class SVGHandler(ContentHandler):

    def __init__(self):
        super().__init__()
        self.element_stack = []

    @property
    def current_element(self):
        return self.element_stack[-1]

    # ...

当 SAX 解析器发现一个新元素时，您可以立即捕获其标记名称和属性，同时为子元素和值制作占位符，这两者都是可选的。现在，您可以将每个元素存储为一个dict对象。用.startElement()新的实现替换现有的方法：

# svg_handler.py

# ...

class SVGHandler(ContentHandler):

    # ...

    def startElement(self, name, attrs):
        self.element_stack.append({
            "name": name,
            "attributes": dict(attrs),
            "children": [],
            "value": ""
        })

SAX 解析器为您提供属性作为映射，您可以通过调用函数将其转换为普通Python 字典dict()。元素值通常分布在多个部分上，您可以使用加号运算符 ( +) 或相应的扩充赋值语句将这些部分连接起来：

# svg_handler.py

# ...

class SVGHandler(ContentHandler):

    # ...

    def characters(self, content):
        self.current_element["value"] += content

以这种方式聚合文本将确保多行内容最终出现在当前元素中。例如，<script>示例 SVG 文件中的标记包含六行 JavaScript 代码，这些代码会触发对characters()回调的单独调用。

最后，一旦解析器偶然发现结束标记，您就可以从堆栈中弹出当前元素并将其附加到其父元素的子元素。如果只剩下一个元素，那么它将是您文档的根目录，您应该保留以备后用。除此之外，您可能希望通过删除具有空值的键来清理当前元素：

# svg_handler.py

# ...

class SVGHandler(ContentHandler):

    # ...

    def endElement(self, name):
        clean(self.current_element)
        if len(self.element_stack) > 1:
            child = self.element_stack.pop()
            self.current_element["children"].append(child)

def clean(element):
    element["value"] = element["value"].strip()
    for key in ("attributes", "children", "value"):
        if not element[key]:
            del element[key]

请注意，这clean()是在类主体之外定义的函数。必须在最后进行清理，因为无法预先知道可能要连接的文本片段数量。您可以展开下面的可折叠部分以获得完整的内容处理程序代码。

现在，是时候通过解析 XML、从内容处理程序中提取根元素并将其转储为 JSON 字符串来测试所有内容：

>>> from xml.sax import parse
>>> from svg_handler import SVGHandler
>>> handler = SVGHandler()
>>> parse("smiley.svg", handler)
>>> root = handler.current_element

>>> import json
>>> print(json.dumps(root, indent=4))
{
    "name": "svg",
    "attributes": {
        "xmlns": "http://www.w3.org/2000/svg",
        "xmlns:inkscape": "http://www.inkscape.org/namespaces/inkscape",
        "viewBox": "-105 -100 210 270",
        "width": "210",
        "height": "270"
    },
    "children": [
        {
            "name": "inkscape:custom",
            "attributes": {
                "x": "42",
                "inkscape:z": "555"
            },
            "value": "Some value"
        },
⋮

值得注意的是，此实现与 DOM 相比没有内存增益，因为它像以前一样构建了整个文档的抽象表示。不同之处在于您制作了自定义字典表示而不是标准 DOM 树。但是，您可以想象在接收 SAX 事件时直接写入文件或数据库而不是内存。这将有效地解除您的计算机内存限制。

如果您想解析 XML 名称空间，那么您需要使用一些样板代码自己创建和配置 SAX 解析器，并实现略有不同的回调：

# svg_handler.py

from xml.sax.handler import ContentHandler

class SVGHandler(ContentHandler):

    def startPrefixMapping(self, prefix, uri):
        print(f"startPrefixMapping: {prefix=}, {uri=}")

    def endPrefixMapping(self, prefix):
        print(f"endPrefixMapping: {prefix=}")

    def startElementNS(self, name, qname, attrs):
        print(f"startElementNS: {name=}")

    def endElementNS(self, name, qname):
        print(f"endElementNS: {name=}")

这些回调接收有关元素命名空间的附加参数。要使 SAX 解析器实际触发这些回调而不是一些早期的回调，您必须显式启用XML 命名空间支持：

>>> from xml.sax import make_parser
>>> from xml.sax.handler import feature_namespaces
>>> from svg_handler import SVGHandler

>>> parser = make_parser()
>>> parser.setFeature(feature_namespaces, True)
>>> parser.setContentHandler(SVGHandler())

>>> parser.parse("smiley.svg")
startPrefixMapping: prefix=None, uri='http://www.w3.org/2000/svg'
startPrefixMapping: prefix='inkscape', uri='http://www.inkscape.org/namespaces/inkscape'
startElementNS: name=('http://www.w3.org/2000/svg', 'svg')
⋮
endElementNS: name=('http://www.w3.org/2000/svg', 'svg')
endPrefixMapping: prefix='inkscape'
endPrefixMapping: prefix=None

设置此功能会将元素name转换为由命名空间的域名和标签名称组成的元组。

该xml.sax包提供了一个不错的基于事件的 XML 解析器接口，该接口以原始 Java API 为模型。与 DOM 相比，它有些限制，但应该足以实现基本的 XML 流推送解析器，而无需求助于第三方库。考虑到这一点，Python 中提供了一个不那么冗长的拉式解析器，接下来您将对其进行探索。

>>> from xml.dom.pulldom import parse
>>> event_stream = parse("smiley.svg")
>>> for event, node in event_stream:
...     print(event, node)
...
START_DOCUMENT <xml.dom.minidom.Document object at 0x7f74f9283e80>
START_ELEMENT <DOM Element: svg at 0x7f74fde18040>
CHARACTERS <DOM Text node "'\n'">
⋮
END_ELEMENT <DOM Element: script at 0x7f74f92b3c10>
CHARACTERS <DOM Text node "'\n'">
END_ELEMENT <DOM Element: svg at 0x7f74fde18040>

>>> from xml.dom.pulldom import parse, START_ELEMENT
>>> event_stream = parse("smiley.svg")
>>> for event, node in event_stream:
...     if event == START_ELEMENT:
...         print(node.parentNode, node.previousSibling, node.childNodes)
<xml.dom.minidom.Document object at 0x7f90864f6e80> None []
None None []
None None []
None None []
⋮

from xml.dom.pulldom import parse, START_ELEMENT

def process_group(parent):
    left_eye, right_eye = parent.getElementsByTagName("ellipse")
    # ...

event_stream = parse("smiley.svg")
for event, node in event_stream:
    if event == START_ELEMENT:
        if node.tagName == "g":
            event_stream.expandNode(node)
            process_group(node)

import xml.etree.ElementTree as ET

在稍旧的代码中，您可能已经看到cElementTree导入的模块。它的实现速度比用 C 编写的相同接口快几倍。今天，常规模块尽可能使用快速实现，因此您无需再费心了。

您可以通过采用不同的解析策略来使用 ElementTree API：

非增量策略以类似DOM 的方式将整个文档加载到内存中。模块中有两个适当命名的函数，它们允许解析带有 XML 内容的文件或 Python 字符串：

>>> import xml.etree.ElementTree as ET

>>> # Parse XML from a filename
>>> ET.parse("smiley.svg")
<xml.etree.ElementTree.ElementTree object at 0x7fa4c980a6a0>

>>> # Parse XML from a file object
>>> with open("smiley.svg") as file:
...     ET.parse(file)
...
<xml.etree.ElementTree.ElementTree object at 0x7fa4c96df340>

>>> # Parse XML from a Python string
>>> ET.fromstring("""\
... <svg viewBox="-105 -100 210 270">
...   <!-- More content goes here... -->
... </svg>
... """)
<Element 'svg' at 0x7fa4c987a1d0>

解析文件对象或文件名并parse()返回ET.ElementTree类的实例，该实例代表整个元素层次结构。另一方面，解析字符串 withfromstring()将返回特定的 root ET.Element。

或者，您可以使用流式拉式解析器以增量方式读取 XML 文档，这会产生一系列事件和元素：

>>> for event, element in ET.iterparse("smiley.svg"):
...     print(event, element.tag)
...
end {http://www.inkscape.org/namespaces/inkscape}custom
end {http://www.w3.org/2000/svg}stop
end {http://www.w3.org/2000/svg}stop
end {http://www.w3.org/2000/svg}stop
end {http://www.w3.org/2000/svg}linearGradient
⋮

默认情况下，iterparse()仅发出end与关闭 XML 标记关联的事件。但是，您也可以订阅其他事件。您可以使用字符串常量找到它们，例如"comment"：

>>> import xml.etree.ElementTree as ET
>>> for event, element in ET.iterparse("smiley.svg", ["comment"]):
...     print(element.text.strip())
...
Head
Eyes
Mouth

以下是所有可用事件类型的列表：

• start:元素的开始
• end:元素的结尾
• comment:评论元素
• pi:处理指令，如XSL
• start-ns:命名空间的开始
• end-ns:命名空间的结尾

缺点iterparse()是它使用阻塞调用来读取下一个数据块，这可能不适合在单个执行线程上运行的异步代码。为了缓解这种情况，您可以查看XMLPullParser，它有点冗长：

import xml.etree.ElementTree as ET

async def receive_data(url):
    """Download chunks of bytes from the URL asynchronously."""
    yield b"<svg "
    yield b"viewBox=\"-105 -100 210 270\""
    yield b"></svg>"

async def parse(url, events=None):
    parser = ET.XMLPullParser(events)
    async for chunk in receive_data(url):
        parser.feed(chunk)
        for event, element in parser.read_events():
            yield event, element

这个假设示例为解析器提供了可能相隔几秒钟到达的 XML 块。一旦有足够的内容，您就可以迭代解析器缓冲的一系列事件和元素。这种非阻塞增量解析策略允许在您下载多个 XML 文档时真正同时实时解析它们。

树中的元素是可变的、可迭代的和可索引的序列。它们的长度对应于它们的直系子节点的数量：

>>> import xml.etree.ElementTree as ET
>>> tree = ET.parse("smiley.svg")
>>> root = tree.getroot()

>>> # The length of an element equals the number of its children.
>>> len(root)
5

>>> # The square brackets let you access a child by an index.
>>> root[1]
<Element '{http://www.w3.org/2000/svg}defs' at 0x7fe05d2e8860>
>>> root[2]
<Element '{http://www.w3.org/2000/svg}g' at 0x7fa4c9848400>

>>> # Elements are mutable. For example, you can swap their children.
>>> root[2], root[1] = root[1], root[2]

>>> # You can iterate over an element's children.
>>> for child in root:
...     print(child.tag)
...
{http://www.inkscape.org/namespaces/inkscape}custom
{http://www.w3.org/2000/svg}g
{http://www.w3.org/2000/svg}defs
{http://www.w3.org/2000/svg}text
{http://www.w3.org/2000/svg}script

标记名称的前缀可能是由一对花括号 ( {})括起来的可选命名空间。定义时，默认的 XML 命名空间也会出现在那里。请注意突出显示行中的交换分配如何使<g>元素位于之前<defs>。这显示了序列的可变性质。

这里还有一些值得一提的元素属性和方法：

>>> element = root[0]

>>> element.tag
'{http://www.inkscape.org/namespaces/inkscape}custom'

>>> element.text
'Some value'

>>> element.attrib
{'x': '42', '{http://www.inkscape.org/namespaces/inkscape}z': '555'}

>>> element.get("x")
'42'

此 API 的好处之一是它如何使用 Python 的本机数据类型。上面，它使用 Python 字典来表示元素的属性。在之前的模块中，这些被包装在不太方便的适配器中。与 DOM 不同，ElementTree API 不公开用于在任何方向遍历树的方法或属性，但有几个更好的替代方法。

正如您之前看到的，Element该类的实例实现了序列协议，让您可以使用循环遍历它们的直接子代：

>>> for child in root:
...     print(child.tag)
...
{http://www.inkscape.org/namespaces/inkscape}custom
{http://www.w3.org/2000/svg}defs
{http://www.w3.org/2000/svg}g
{http://www.w3.org/2000/svg}text
{http://www.w3.org/2000/svg}script

你得到根的直接孩子的序列。但是，要更深入地了解嵌套后代，您必须.iter()在祖先元素上调用该方法：

>>> for descendant in root.iter():
...     print(descendant.tag)
...
{http://www.w3.org/2000/svg}svg
{http://www.inkscape.org/namespaces/inkscape}custom
{http://www.w3.org/2000/svg}defs
{http://www.w3.org/2000/svg}linearGradient
{http://www.w3.org/2000/svg}stop
{http://www.w3.org/2000/svg}stop
{http://www.w3.org/2000/svg}stop
{http://www.w3.org/2000/svg}g
{http://www.w3.org/2000/svg}circle
{http://www.w3.org/2000/svg}ellipse
{http://www.w3.org/2000/svg}ellipse
{http://www.w3.org/2000/svg}path
{http://www.w3.org/2000/svg}text
{http://www.w3.org/2000/svg}script

根元素只有五个子元素，但总共有 13 个子元素。还可以通过使用可选参数仅过滤特定标签名称来缩小后代范围tag：

>>> tag_name = "{http://www.w3.org/2000/svg}ellipse"
>>> for descendant in root.iter(tag_name):
...     print(descendant)
...
<Element '{http://www.w3.org/2000/svg}ellipse' at 0x7f430baa03b0>
<Element '{http://www.w3.org/2000/svg}ellipse' at 0x7f430baa0450>

这一次，你只有两个<ellipse>元素。请记住在标记名称中包含XML 名称空间，例如{http://www.w3.org/2000/svg}，只要它已被定义。否则，如果您只提供标签名称而没有正确的命名空间，您最终会得到比最初预期更少或更多的后代元素。

使用 时处理命名空间更方便.iterfind()，它接受前缀到域名的可选映射。要指示默认命名空间，您可以将键留空或分配任意前缀，稍后必须在标签名称中使用：

>>> namespaces = {
...     "": "http://www.w3.org/2000/svg",
...     "custom": "http://www.w3.org/2000/svg"
... }

>>> for descendant in root.iterfind("g", namespaces):
...     print(descendant)
...
<Element '{http://www.w3.org/2000/svg}g' at 0x7f430baa0270>

>>> for descendant in root.iterfind("custom:g", namespaces):
...     print(descendant)
...
<Element '{http://www.w3.org/2000/svg}g' at 0x7f430baa0270>

命名空间映射允许您使用不同的前缀引用相同的元素。令人惊讶的是，如果您<ellipse>像以前一样尝试查找那些嵌套元素，则.iterfind()不会返回任何内容，因为它需要一个XPath 表达式而不是一个简单的标记名称：

>>> for descendant in root.iterfind("ellipse", namespaces):
...     print(descendant)
...

>>> for descendant in root.iterfind("g/ellipse", namespaces):
...     print(descendant)
...
<Element '{http://www.w3.org/2000/svg}ellipse' at 0x7f430baa03b0>
<Element '{http://www.w3.org/2000/svg}ellipse' at 0x7f430baa0450>

巧合的是，该字符串"g"恰好是相对于当前root元素的有效路径，这就是该函数之前返回非空结果的原因。但是，要在 XML 层次结构中找到嵌套更深一层的省略号，您需要更详细的路径表达式。

ElementTree对XPath 迷你语言的语法支持有限，您可以使用它来查询 XML 中的元素，类似于 HTML 中的 CSS 选择器。还有其他方法可以接受这样的表达式：

>>> namespaces = {"": "http://www.w3.org/2000/svg"}

>>> root.iterfind("defs", namespaces)
<generator object prepare_child.<locals>.select at 0x7f430ba6d190>

>>> root.findall("defs", namespaces)
[<Element '{http://www.w3.org/2000/svg}defs' at 0x7f430ba09e00>]

>>> root.find("defs", namespaces)
<Element '{http://www.w3.org/2000/svg}defs' at 0x7f430ba09e00>

虽然.iterfind()懒惰地产生匹配元素，.findall()返回一个列表，并且.find()只返回第一个匹配元素。同样，您可以使用以下命令提取包含在元素的开始和结束标记之间的文本.findtext()或获取整个文档的内部文本.itertext()：

>>> namespaces = {"i": "http://www.inkscape.org/namespaces/inkscape"}

>>> root.findtext("i:custom", namespaces=namespaces)
'Some value'

>>> for text in root.itertext():
...     if text.strip() != "":
...         print(text.strip())
...
Some value
Hello <svg>!
console.log("CDATA disables XML parsing: <svg>")
⋮

您首先查找嵌入在特定 XML 元素中的文本，然后是整个文档中的任何地方。按文本搜索是 ElementTree API 的一项强大功能。可以使用其他内置解析器复制它，但代价是代码复杂性增加和便利性降低。

ElementTree API 可能是其中最直观的一种。它是 Pythonic、高效、健壮和通用的。除非您有使用 DOM 或 SAX 的特定原因，否则这应该是您的默认选择。

探索第三方 XML 解析器库

有时，使用标准库中的 XML 解析器可能感觉就像拿起大锤敲碎坚果。在其他时候，情况正好相反，您希望有一个可以做更多事情的解析器。例如，您可能希望根据架构验证 XML 或使用高级 XPath 表达式。在这些情况下，最好查看PyPI 上可用的外部库。

在下面，您将找到一系列具有不同程度的复杂性和复杂性的外部库。

>>> import untangle

>>> # Parse XML from a URL
>>> untangle.parse("http://localhost:8000/smiley.svg")
Element(name = None, attributes = None, cdata = )

>>> # Parse XML from a filename
>>> untangle.parse("smiley.svg")
Element(name = None, attributes = None, cdata = )

>>> # Parse XML from a file object
>>> with open("smiley.svg") as file:
...     untangle.parse(file)
...
Element(name = None, attributes = None, cdata = )

>>> # Parse XML from a Python string
>>> untangle.parse("""\
... <svg viewBox="-105 -100 210 270">
...   <!-- More content goes here... -->
... </svg>
... """)
Element(name = None, attributes = None, cdata = )

>>> import untangle
>>> document = untangle.parse("smiley.svg")

>>> document.svg
Element(name = svg, attributes = {'xmlns': ...}, ...)

>>> document.svg["viewBox"]
'-105 -100 210 270'

>>> dir(document)
['svg']

>>> dir(document.svg)
['defs', 'g', 'inkscape_custom', 'script', 'text']

>>> dir(document.svg.defs.linearGradient)
['stop', 'stop', 'stop']

>>> for stop in document.svg.defs.linearGradient.stop:
...     print(stop)
...
Element <stop> with attributes {'offset': ...}, ...
Element <stop> with attributes {'offset': ...}, ...
Element <stop> with attributes {'offset': ...}, ...

>>> document.svg.defs.linearGradient.stop[1]
Element(name = stop, attributes = {'offset': ...}, ...)

>>> dir(untangle.parse("<com:company.web-app></com:company.web-app>"))
['com_company_web_app']

>>> element = document.svg.text

>>> list(vars(element).keys())
['_name', '_attributes', 'children', 'is_root', 'cdata']

>>> element._name
'text'

>>> element._attributes
{'x': '-40', 'y': '75'}

>>> element.children
[]

>>> element.is_root
False

>>> element.cdata
'Hello <svg>!'

<feed>
  <doc>
    <title>Wikipedia: Anarchism</title>
    <url>https://en.wikipedia.org/wiki/Anarchism</url>
    <abstract>Anarchism is a political philosophy...</abstract>
    <links>
      <sublink linktype="nav">
        <anchor>Etymology, terminology and definition</anchor>
        <link>https://en.wikipedia.org/wiki/Anarchism#Etymology...</link>
      </sublink>
      <sublink linktype="nav">
        <anchor>History</anchor>
        <link>https://en.wikipedia.org/wiki/Anarchism#History</link>
      </sublink>
      ⋮
    </links>
  </doc>
  ⋮
</feed>

>>> with XMLTagStream("abstract.xml", "doc") as stream:
...     for doc in stream:
...         print(doc.title.cdata.center(50, "="))
...         for sublink in doc.links.sublink:
...             print("-", sublink.anchor.cdata)
...         if "q" == input("Press [q] to exit or any key to continue..."):
...             break
...
===============Wikipedia: Anarchism===============
- Etymology, terminology and definition
- History
- Pre-modern era
⋮
Press [q] to exit or any key to continue...
================Wikipedia: Autism=================
- Characteristics
- Social development
- Communication
⋮
Press [q] to exit or any key to continue...

>>> import xmltodict

>>> xmltodict.parse("""\
... <svg viewBox="-105 -100 210 270">
...   <!-- More content goes here... -->
... </svg>
... """)
OrderedDict([('svg', OrderedDict([('@viewBox', '-105 -100 210 270')]))])

>>> with open("smiley.svg", "rb") as file:
...     xmltodict.parse(file)
...
OrderedDict([('svg', ...)])

>>> import xmltodict

>>> with open("smiley.svg", "rb") as file:
...     xmltodict.parse(file, dict_constructor=dict)
...
{'svg': ...}

>>> import xmltodict

>>> # Rename attributes by default
>>> with open("smiley.svg", "rb") as file:
...     document = xmltodict.parse(file)
...     print([x for x in document["svg"] if x.startswith("@")])
...
['@xmlns', '@xmlns:inkscape', '@viewBox', '@width', '@height']

>>> # Ignore attributes when requested
>>> with open("smiley.svg", "rb") as file:
...     document = xmltodict.parse(file, xml_attribs=False)
...     print([x for x in document["svg"] if x.startswith("@")])
...
[]

>>> import xmltodict

>>> # Ignore namespaces by default
>>> with open("smiley.svg", "rb") as file:
...     document = xmltodict.parse(file)
...     print(document.keys())
...
odict_keys(['svg'])

>>> # Process namespaces when requested
>>> with open("smiley.svg", "rb") as file:
...     document = xmltodict.parse(file, process_namespaces=True)
...     print(document.keys())
...
odict_keys(['http://www.w3.org/2000/svg:svg'])

>>> # Rename and skip some namespaces
>>> namespaces = {
...     "http://www.w3.org/2000/svg": "svg",
...     "http://www.inkscape.org/namespaces/inkscape": None,
... }
>>> with open("smiley.svg", "rb") as file:
...     document = xmltodict.parse(
...         file, process_namespaces=True, namespaces=namespaces
...     )
...     print(document.keys())
...     print("custom" in document["svg:svg"])
...     print("inkscape:custom" in document["svg:svg"])
...
odict_keys(['svg:svg'])
True
False

>>> import xmltodict
>>> with open("smiley.svg", "rb") as file:
...     document = xmltodict.parse(file, dict_constructor=dict)
...

>>> from pprint import pprint as pp
>>> pp(document)
{'svg': {'@height': '270',
         '@viewBox': '-105 -100 210 270',
         '@width': '210',
         '@xmlns': 'http://www.w3.org/2000/svg',
         '@xmlns:inkscape': 'http://www.inkscape.org/namespaces/inkscape',
         'defs': {'linearGradient': {'@id': 'skin',
         ⋮

>>> import json
>>> print(json.dumps(document, indent=4, sort_keys=True))
{
    "svg": {
        "@height": "270",
        "@viewBox": "-105 -100 210 270",
        "@width": "210",
        "@xmlns": "http://www.w3.org/2000/svg",
        "@xmlns:inkscape": "http://www.inkscape.org/namespaces/inkscape",
        "defs": {
            "linearGradient": {
             ⋮

>>> import yaml  # Install first with 'pip install PyYAML'
>>> print(yaml.dump(document))
svg:
  '@height': '270'
  '@viewBox': -105 -100 210 270
  '@width': '210'
  '@xmlns': http://www.w3.org/2000/svg
  '@xmlns:inkscape': http://www.inkscape.org/namespaces/inkscape
  defs:
    linearGradient:
    ⋮

>>> import xmltodict

>>> with open("smiley.svg", "rb") as file:
...     document = xmltodict.parse(file, dict_constructor=dict)
...

>>> xmltodict.unparse(document)
'<?xml version="1.0" encoding="utf-8"?>\n<svg...'

import lxml.etree as ET

>>> import lxml.etree as ET

>>> xml_schema = ET.XMLSchema(
...     ET.fromstring("""\
...         <xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
...             <xsd:element name="parent"/>
...             <xsd:complexType name="SomeType">
...                 <xsd:sequence>
...                     <xsd:element name="child" type="xsd:string"/>
...                 </xsd:sequence>
...             </xsd:complexType>
...         </xsd:schema>"""))

>>> valid = ET.fromstring("<parent><child></child></parent>")
>>> invalid = ET.fromstring("<child><parent></parent></child>")

>>> xml_schema.validate(valid)
True

>>> xml_schema.validate(invalid)
False

from bs4 import BeautifulSoup

# Parse XML from a file object
with open("smiley.svg") as file:
    soup = BeautifulSoup(file, features="lxml-xml")

# Parse XML from a Python string
soup = BeautifulSoup("""\
<svg viewBox="-105 -100 210 270">
  <!-- More content goes here... -->
</svg>
""", features="lxml-xml")

>>> from bs4 import BeautifulSoup

>>> soup = BeautifulSoup("""\
... <parent>
...     <child>Forbidden < character </parent>
...     </child>
... ignored
... """, features="lxml-xml")

>>> print(soup.prettify())
<?xml version="1.0" encoding="utf-8"?>
<parent>
 <child>
  Forbidden
 </child>
</parent>

>>> from bs4 import BeautifulSoup

>>> with open("smiley.svg") as file:
...     soup = BeautifulSoup(file, features="lxml-xml")
...

>>> soup.find_all("ellipse", limit=1)
[<ellipse cx="-20" cy="-10" fill="black" rx="6" ry="8" stroke="none"/>]

>>> soup.find(x=42)
<inkscape:custom inkscape:z="555" x="42">Some value</inkscape:custom>

>>> soup.find("stop", {"stop-color": "gold"})
<stop offset="75%" stop-color="gold" stop-opacity="1.0"/>

>>> soup.find(text=lambda x: "value" in x).parent
<inkscape:custom inkscape:z="555" x="42">Some value</inkscape:custom>

<KeyboardEvent>
    <Type>keydown</Type>
    <Timestamp>253459.17999999982</Timestamp>
    <Key>
        <Code>Digit2</Code>
        <Unicode>@</Unicode>
    </Key>
    <Modifiers>
        <Alt>false</Alt>
        <Ctrl>false</Ctrl>
        <Shift>true</Shift>
        <Meta>false</Meta>
    </Modifiers>
</KeyboardEvent>

<MouseEvent>
    <Type>mousemove</Type>
    <Timestamp>52489.07000000145</Timestamp>
    <Cursor>
        <Delta x="-4" y="8"/>
        <Window x="171" y="480"/>
        <Screen x="586" y="690"/>
    </Cursor>
    <Buttons bitField="0"/>
    <Modifiers>
        <Alt>false</Alt>
        <Ctrl>true</Ctrl>
        <Shift>false</Shift>
        <Meta>false</Meta>
    </Modifiers>
</MouseEvent>

$ python -m pip install websockets lxml

# server.py

import asyncio
import websockets

async def handle_connection(websocket, path):
    async for message in websocket:
        print(message)

if __name__ == "__main__":
    future = websockets.serve(handle_connection, "localhost", 8000)
    asyncio.get_event_loop().run_until_complete(future)
    asyncio.get_event_loop().run_forever()

# server.py

import asyncio
import websockets
import lxml.objectify

async def handle_connection(websocket, path):
    async for message in websocket:
        try:
            xml = lxml.objectify.fromstring(message)
        except SyntaxError:
            print("Malformed XML message:", repr(message))
        else:
            if xml.tag == "KeyboardEvent":
                if xml.Type == "keyup":
                    print("Key:", xml.Key.Unicode)
            elif xml.tag == "MouseEvent":
                screen = xml.Cursor.Screen
                print("Mouse:", screen.get("x"), screen.get("y"))
            else:
                print("Unrecognized event type")

# ...

$ python server.py
Mouse: 820 121
Mouse: 820 122
Mouse: 820 123
Mouse: 820 124
Mouse: 820 125
Key: a
Mouse: 820 125
Mouse: 820 125
Key: a
Key: A
Key: Shift
Mouse: 821 125
Mouse: 821 125
Mouse: 820 123
⋮

# ...

class Event(Model):
    """Base class for event messages with common elements."""
    type_: str = XPath("./Type")
    timestamp: float = XPath("./Timestamp")

class Modifiers(Model):
    alt: bool = XPath("./Alt")
    ctrl: bool = XPath("./Ctrl")
    shift: bool = XPath("./Shift")
    meta: bool = XPath("./Meta")

class KeyboardEvent(Event):
    key: str = XPath("./Key/Code")
    modifiers: Modifiers = XPath("./Modifiers")

class MouseEvent(Event):
    x: int = XPath("./Cursor/Screen/@x")
    y: int = XPath("./Cursor/Screen/@y")
    modifiers: Modifiers = XPath("./Modifiers")

if xml.tag == "KeyboardEvent":
    event = KeyboardEvent(xml)
    if event.type_ == "keyup":
        print("Key:", event.key)
elif xml.tag == "MouseEvent":
    event = MouseEvent(xml)
    print("Mouse:", event.x, event.y)
else:
    print("Unrecognized event type")

<xsd:schema xmlns:xsd="http://www.w3.org/2001/XMLSchema">
    <xsd:element name="KeyboardEvent" type="KeyboardEventType"/>
    <xsd:complexType name="KeyboardEventType">
        <xsd:sequence>
            <xsd:element type="xsd:string" name="Type"/>
            <xsd:element type="xsd:float" name="Timestamp"/>
            <xsd:element type="KeyType" name="Key"/>
            <xsd:element type="ModifiersType" name="Modifiers"/>
        </xsd:sequence>
    </xsd:complexType>
    <xsd:complexType name="KeyType">
        <xsd:sequence>
            <xsd:element type="xsd:string" name="Code"/>
            <xsd:element type="xsd:string" name="Unicode"/>
        </xsd:sequence>
    </xsd:complexType>
    <xsd:complexType name="ModifiersType">
        <xsd:sequence>
            <xsd:element type="xsd:string" name="Alt"/>
            <xsd:element type="xsd:string" name="Ctrl"/>
            <xsd:element type="xsd:string" name="Shift"/>
            <xsd:element type="xsd:string" name="Meta"/>
        </xsd:sequence>
    </xsd:complexType>
</xsd:schema>

$ generateDS -o models.py models.xsd

>>> from models import parseString

>>> event = parseString("""\
... <KeyboardEvent>
...     <Type>keydown</Type>
...     <Timestamp>253459.17999999982</Timestamp>
...     <Key>
...         <Code>Digit2</Code>
...         <Unicode>@</Unicode>
...     </Key>
...     <Modifiers>
...         <Alt>false</Alt>
...         <Ctrl>false</Ctrl>
...         <Shift>true</Shift>
...         <Meta>false</Meta>
...     </Modifiers>
... </KeyboardEvent>""", silence=True)

>>> event.Type, event.Key.Code
('keydown', 'Digit2')

使用安全解析器消除 XML 炸弹

Python 标准库中的 XML 解析器容易受到一系列安全威胁的攻击，这些安全威胁最多可能导致拒绝服务 (DoS)或数据丢失。公平地说，这不是他们的错。它们只是遵循 XML 标准的规范，它比大多数人知道的要复杂和强大。

最常见的攻击之一是XML Bomb，也称为十亿笑声攻击。该攻击利用DTD中的实体扩展来炸毁内存并尽可能长时间地占用CPU。阻止未受保护的 Web 服务器接收新流量所需的只是以下几行 XML 代码：

import xml.etree.ElementTree as ET
ET.fromstring("""\
<?xml version="1.0"?>
<!DOCTYPE lolz [
 <!ENTITY lol "lol">
 <!ELEMENT lolz (#PCDATA)>
 <!ENTITY lol1 "&lol;&lol;&lol;&lol;&lol;&lol;&lol;&lol;&lol;&lol;">
 <!ENTITY lol2 "&lol1;&lol1;&lol1;&lol1;&lol1;&lol1;&lol1;&lol1;&lol1;&lol1;">
 <!ENTITY lol3 "&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;&lol2;">
 <!ENTITY lol4 "&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;&lol3;">
 <!ENTITY lol5 "&lol4;&lol4;&lol4;&lol4;&lol4;&lol4;&lol4;&lol4;&lol4;&lol4;">
 <!ENTITY lol6 "&lol5;&lol5;&lol5;&lol5;&lol5;&lol5;&lol5;&lol5;&lol5;&lol5;">
 <!ENTITY lol7 "&lol6;&lol6;&lol6;&lol6;&lol6;&lol6;&lol6;&lol6;&lol6;&lol6;">
 <!ENTITY lol8 "&lol7;&lol7;&lol7;&lol7;&lol7;&lol7;&lol7;&lol7;&lol7;&lol7;">
 <!ENTITY lol9 "&lol8;&lol8;&lol8;&lol8;&lol8;&lol8;&lol8;&lol8;&lol8;&lol8;">
]>
<lolz>&lol9;</lolz>""")

一个简单的解析器将尝试&lol9;通过检查 DTD来解析放置在文档根目录中的自定义实体。但是，该实体本身多次引用另一个实体，后者又引用另一个实体，依此类推。当你运行上面的脚本时，你会注意到内存和处理单元有一些令人不安的事情：

>>> from xml.sax import make_parser
>>> from xml.sax.handler import feature_external_ges

>>> parser = make_parser()
>>> parser.setFeature(feature_external_ges, True)

>>> from xml.dom.minidom import parseString

>>> xml = """\
... <?xml version="1.0" encoding="UTF-8"?>
... <!DOCTYPE root [
...     <!ENTITY usernames SYSTEM "/etc/passwd">
... ]>
... <root>&usernames;</root>"""

>>> document = parseString(xml, parser)
>>> print(document.documentElement.toxml())
<root>root:x:0:0:root:/root:/bin/bash
daemon:x:1:1:daemon:/usr/sbin:/usr/sbin/nologin
bin:x:2:2:bin:/bin:/usr/sbin/nologin
⋮
realpython:x:1001:1001:Real Python,,,:/home/realpython:/bin/bash
</root>

>>> import defusedxml.ElementTree as ET
>>> ET.parse("bomb.xml")
Traceback (most recent call last):
  ...
    raise EntitiesForbidden(name, value, base, sysid, pubid, notation_name)
defusedxml.common.EntitiesForbidden:
 EntitiesForbidden(name='lol', system_id=None, public_id=None)