XML 解析概述

# 场景 A：DOM —— 小型配置，需要修改
from xml.dom import minidom

doc = minidom.parse("web.xml")
servlets = doc.getElementsByTagName("servlet")
# 删除第一个 servlet
first = servlets[0]
first.parentNode.removeChild(first)
print(f"剩余 servlet 数: {len(servlets)-1}")

# 场景 B：SAX —— 超大文件，一次性提取
from xml.sax import parse, ContentHandler

class ErrorHandler(ContentHandler):
    def __init__(self):
        self.in_error = False
    def startElement(self, name, attrs):
        if name == "error":
            self.in_error = True
    def characters(self, content):
        if self.in_error:
            print(f"ERROR: {content.strip()}")
    def endElement(self, name):
        if name == "error":
            self.in_error = False

parse("server_log.xml", ErrorHandler())

# 场景 C：StAX —— 超大文件，找到即停
import xml.etree.ElementTree as ET
# Python 的 iterparse 是类 StAX 拉式解析
for event, elem in ET.iterparse("server_log.xml", events=("start",)):
    if elem.tag == "entry" and elem.get("status") == "fail":
        print(f"第一个失败: {elem.find('msg').text}")
        elem.clear()  # 清理内存
        break

# ❌ 错误：DOM 把整个文档加载进内存
from xml.dom import minidom

doc = minidom.parse("server_log_500mb.xml")
errors = doc.getElementsByTagName("error")
for e in errors:
    print(e.firstChild.data)
# 运行结果：MemoryError —— 500MB XML 展开为 DOM 树后内存占用 3~5 倍

# ✅ 正确：用 SAX 流式处理，逐条读取不堆积
from xml.sax import parse, ContentHandler

class ErrorExtractor(ContentHandler):
    def __init__(self):
        self.in_error = False
    def startElement(self, name, attrs):
        if name == "error":
            self.in_error = True
    def characters(self, content):
        if self.in_error:
            print(content.strip())
    def endElement(self, name):
        if name == "error":
            self.in_error = False

parse("server_log_500mb.xml", ErrorExtractor())
# 运行结果：内存稳定在几十 MB，逐条输出全部 error 节点内容

# SAX（推式）：解析器推数据，你无法控制何时开始/停止读取下一个元素
from xml.sax import parse, ContentHandler

class MyHandler(ContentHandler):
    def startElement(self, name, attrs):
        print(f"收到: {name}")  # 解析器主动触发，你不能"先跳过几个再读"

parse("data.xml", MyHandler())

# StAX（拉式）：应用主动拉取，想停就停
import xml.etree.ElementTree as ET

for event, elem in ET.iterparse("data.xml", events=("start",)):
    if elem.tag == "target":
        print(f"找到目标: {elem.text}")
        break  # ✅ 应用主动停止，解析器立即结束

# ❌ 错误：节点不清除，iterparse 会持有所有已解析元素的引用
import xml.etree.ElementTree as ET

count = 0
for event, elem in ET.iterparse("huge_data.xml", events=("end",)):
    if elem.tag == "record":
        count += 1
        # 没有 elem.clear() —— 所有 record 元素全部堆积在内存中
print(f"共 {count} 条记录")
# 运行结果：随着循环进行，内存持续增长，最终可能 OOM

# ✅ 正确：处理完立刻清除节点，切断引用链
import xml.etree.ElementTree as ET

count = 0
for event, elem in ET.iterparse("huge_data.xml", events=("end",)):
    if elem.tag == "record":
        count += 1
        elem.clear()  # ✅ 切断引用，让 GC 回收
print(f"共 {count} 条记录")
# 运行结果：内存稳定在低位，大文件解析毫无压力

# ❌ 错误：SAX/StAX 的光标只能向前，无法回退
from xml.sax import parse, ContentHandler

class BadHandler(ContentHandler):
    def __init__(self):
        self.first_price = None

    def startElement(self, name, attrs):
        if name == "book" and self.first_price is None:
            # ❌ 先记下第一个 book，等读到第二个 book 时再回头找第一个的价格？
            # 做不到。SAX 的光标已经过去了。
            pass

# ✅ 正确：如果后续需要之前的数据，在回调中自己保存
from xml.sax import parse, ContentHandler

class SmartHandler(ContentHandler):
    def __init__(self):
        self.current_tag = ""
        self.current_book = {}
        self.books = []  # ✅ 自己维护一个轻量数据结构

    def startElement(self, name, attrs):
        self.current_tag = name
        if name == "book":
            self.current_book = {"id": attrs.get("id")}

    def characters(self, content):
        if self.current_tag in ("title", "price") and self.current_book is not None:
            self.current_book[self.current_tag] = content.strip()

    def endElement(self, name):
        if name == "book":
            self.books.append(self.current_book)  # ✅ 持久化到列表

parse("books.xml", SmartHandler())
# 现在可以随机访问 self.books 中任意一本书的 title 和 price