用 ElementTree.iterparse 流式解析超大 XML：边解析边清理元素

问题场景

很多系统导出 XML 时会把大量记录放在一个根节点下，例如订单、日志、设备上报。文件可能几百 MB 甚至更大。如果直接用 xml.etree.ElementTree.parse() 或 minidom，解析器会先把整个文档构建成树，内存占用随文件大小线性增长，容易触发 OOM。ElementTree.iterparse() 提供了事件驱动的流式解析能力，但如果只是迭代事件而不清理已经处理过的元素，ElementTree 内部的树仍会保留这些元素，内存依然会持续上升。

核心思路

iterparse(source, events=('start', 'end')) 会在遇到元素开始和结束时产生事件。我们可以在 end 事件中拿到已经解析完成的元素，提取需要的数据，然后：

1. 调用 elem.clear() 清空该元素的子元素、文本和属性，减少对象内部引用；
2. 从父节点中 remove(elem)，让父节点不再持有对已完成元素的引用；
3. 用栈维护当前解析路径，以便在 end 时找到父节点。

这样，内存中主要保留根节点和当前正在解析的分支，而不是整个文档。

最小可运行示例

假设有一个 orders.xml：

<?xml version='1.0' encoding='UTF-8'?>
<orders>
  <order id='A-1001'>
    <customer>alice</customer>
    <amount>19.99</amount>
  </order>
  <order id='A-1002'>
    <customer>bob</customer>
    <amount>5.00</amount>
  </order>
</orders>

统计每个客户的订单总额：

import sys
import xml.etree.ElementTree as ET
from collections import defaultdict

def parse_orders(path):
    totals = defaultdict(float)
    count = 0
    stack = []
    context = ET.iterparse(path, events=('start', 'end'))
    for event, elem in context:
        if event == 'start':
            stack.append(elem)
            continue
        # event == 'end'
        if elem.tag == 'order':
            customer_node = elem.find('customer')
            amount_node = elem.find('amount')
            if customer_node is not None and amount_node is not None:
                customer = customer_node.text
                try:
                    amount = float(amount_node.text)
                except (TypeError, ValueError):
                    amount = 0.0
                if customer:
                    totals[customer] += amount
                    count += 1
            elem.clear()
            if len(stack) >= 2:
                parent = stack[-2]
                parent.remove(elem)
        stack.pop()
    return totals, count

def main():
    path = sys.argv[1] if len(sys.argv) > 1 else 'orders.xml'
    totals, count = parse_orders(path)
    for customer, total in sorted(totals.items()):
        print(f'{customer}: {total:.2f}')
    print(f'orders: {count}')

if __name__ == '__main__':
    main()

运行方法：

python parse_orders.py orders.xml

如果想测试更大文件，可以自行生成包含大量 <order> 节点的 XML。可以用系统监控或 tracemalloc 观察内存趋势，但不要期望一个固定数值，因为内存取决于单个元素大小和解析器内部缓冲。

关键细节

• 数据必须在 clear 之前提取。elem.clear() 会删除子元素、属性、文本和尾部文本，之后无法再读取。
• 栈维护父子关系。start 压栈，end 弹栈。在 end 事件中，栈顶是当前元素，栈顶下一个就是父节点。用 parent.remove(elem) 断开父节点对已完成元素的引用。
• 命名空间。如果 XML 带命名空间，elem.tag 会变成 {uri}local 形式。可以用完整名称匹配，或写一个辅助函数去掉命名空间。
• 扁平结构更简单。如果所有记录都是根节点的直接子元素，可以在每个记录 end 时调用 root.clear()，再配合 elem.clear()。但嵌套结构更适合上面的栈方案。

边界与限制

1. 单个元素本身过大：iterparse 是流式的，但它仍会把当前正在解析的元素构建到内存中。如果某个 <order> 节点包含几百 MB 文本，清理已完成的元素也无法避免该节点峰值内存。
2. 文本与尾部文本：end 事件时 text 可用；clear() 会清除 tail，如果依赖元素在父节点中的尾部空白或文本，需要先保存。
3. 异常与资源：解析中抛异常会中断迭代。建议用 with open(path, 'rb') as f: ET.iterparse(f, ...) 确保文件关闭。iterparse 接收文件名或二进制文件对象。
4. 安全：不要用标准库解析不受信任的 XML。虽然 ElementTree 默认不展开外部实体，但面向不可信输入时应使用专门的安全解析库或限制输入。
5. 编码：解析器会根据 XML 声明和字节流处理编码；用文本模式打开文件再传给 iterparse 可能引入编码问题，建议传文件名或二进制流。
6. 不是万能：iterparse 适合记录式 XML，即大文件由大量独立子元素组成。如果数据模型必须整体关联，流式清理会丢失上下文。

总结：iterparse 解决的是“一次性构建整棵树”的问题，而边解析边清理解决的是“树虽然流式构建但已处理节点仍被父节点引用”的问题。两者结合，可以让超大 XML 的处理变得可控。