你提到的需求确实有点棘手——既要精准删除节点，又要完全保留XML的原始布局（缩进、空格、属性顺序、命名空间），常规的DOM解析器（比如ElementTree、lxml）因为会把XML转换成内部对象结构，输出时难免会重新格式化，很难满足要求。

针对你的情况，基于事件的流解析器是最佳选择，这类解析器逐行处理XML内容，不会把整个文档加载成DOM树，而是触发"开始标签"、"结束标签"、"文本内容"等事件，你可以在事件回调中决定是否输出当前内容，完美保留原始格式。

下面推荐两种可行的方案：

方案一：使用Python标准库xml.sax #

xml.sax是Python内置的SAX解析器，无需额外安装，非常适合做这种精准的流处理。核心思路是：

• 跟踪当前节点的层级和路径
• 当遇到要删除的节点时，标记"跳过模式"，直到该节点的结束标签出现
• 非跳过模式下，原样输出所有内容（包括原始的空格、缩进、标签格式）

示例代码 #

假设你想要删除<d:ctr name="LinGeneral" type="IDENTIFIABLE">节点及其所有子节点，代码可以这样写：

import xml.sax
import xml.sax.saxutils

class XMLFilter(xml.sax.ContentHandler):
    def __init__(self, target):
        self.target = target
        self.skip_depth = 0
        # 定义要删除的节点：匹配命名空间、标签名和目标属性
        self.target_node = {
            'tag': ('http://www.tresos.de/_projects/DataModel2/06/data.xsd', 'ctr'),
            'attrs': {'name': 'LinGeneral', 'type': 'IDENTIFIABLE'}
        }

    def startElementNS(self, name, qname, attrs):
        # 检查当前节点是否是要删除的目标
        if self.skip_depth == 0 and name == self.target_node['tag']:
            attr_match = all(attrs.get(k) == v for k, v in self.target_node['attrs'].items())
            if attr_match:
                self.skip_depth += 1
                return  # 跳过输出这个节点的开始标签
        # 非跳过模式下，原样转发事件到生成器
        if self.skip_depth == 0:
            self.target.startElementNS(name, qname, attrs)

    def endElementNS(self, name, qname):
        if self.skip_depth > 0:
            if name == self.target_node['tag']:
                self.skip_depth -= 1
            return  # 跳过输出结束标签
        self.target.endElementNS(name, qname)

    def characters(self, content):
        if self.skip_depth == 0:
            self.target.characters(content)

    def processingInstruction(self, target, data):
        if self.skip_depth == 0:
            self.target.processingInstruction(target, data)

# 读取原始XML文件
with open('input.xml', 'r', encoding='utf-8') as f:
    xml_content = f.read()

# 准备输出容器和处理链
output = []
xml_generator = xml.sax.saxutils.XMLGenerator(output, encoding='utf-8')
filter_handler = XMLFilter(xml_generator)

# 解析并过滤XML内容
xml.sax.parseString(xml_content.encode('utf-8'), filter_handler)

# 将结果写入新文件
with open('output.xml', 'w', encoding='utf-8') as f:
    f.write(''.join(output))

说明 #

• 因为你的XML使用了命名空间，SAX解析器会把节点名解析成(命名空间URI, 标签名)的元组，代码中直接用这个元组匹配目标节点
• 这个方案会完全保留原始XML的所有格式细节，包括缩进、空格、属性顺序——我们只是在跳过目标节点时不输出内容，其他时候原样转发SAX事件到XML生成器

方案二：使用xml.parsers.expat（更轻量的流解析器） #

expat也是Python内置的XML解析器，比SAX更底层、更轻量，同样适合流处理。核心逻辑和SAX类似，跟踪节点层级，决定是否输出：

import xml.parsers.expat

def filter_xml(input_content, output_file):
    skip_depth = 0
    # 定义要删除的节点：合并命名空间和标签名
    target_tag = '{http://www.tresos.de/_projects/DataModel2/06/data.xsd}ctr'
    target_attrs = {'name': 'LinGeneral', 'type': 'IDENTIFIABLE'}

    def start_element(name, attrs):
        nonlocal skip_depth
        if skip_depth == 0 and name == target_tag:
            if all(attrs.get(k) == v for k, v in target_attrs.items()):
                skip_depth += 1
                return
        if skip_depth == 0:
            # 手动拼接开始标签，确保属性顺序和原始一致
            attr_parts = [f'{k}="{xml.parsers.expat.escape(v)}"' for k, v in attrs.items()]
            attr_str = ' '.join(attr_parts)
            output_file.write(f'<{name}{" " + attr_str if attr_str else ""}>')

    def end_element(name):
        nonlocal skip_depth
        if skip_depth > 0:
            if name == target_tag:
                skip_depth -= 1
            return
        output_file.write(f'</{name}>')

    def char_data(data):
        if skip_depth == 0:
            output_file.write(xml.parsers.expat.escape(data))

    # 创建解析器并配置命名空间分隔符
    parser = xml.parsers.expat.ParserCreate(namespace_separator='{')
    parser.StartElementHandler = start_element
    parser.EndElementHandler = end_element
    parser.CharacterDataHandler = char_data

    # 处理XML内容
    parser.Parse(input_content)

# 使用示例
with open('input.xml', 'r', encoding='utf-8') as f_in:
    content = f_in.read()

with open('output.xml', 'w', encoding='utf-8') as f_out:
    filter_xml(content, f_out)

说明 #

• 通过设置namespace_separator='{'，expat会直接把命名空间URI和标签名合并成{URI}tag的形式，简化节点匹配
• 这个方案需要手动拼接标签字符串，所以用xml.parsers.expat.escape处理属性值和文本内容的转义，确保输出的XML合法

为什么不推荐其他方案？ #

• xml.etree.ElementTree：命名空间处理繁琐，且输出时会自动格式化，无法保留原始缩进和属性顺序
• lxml.etree：即使设置了preserve_whitespace=True，仍然会重新排列属性顺序，并且可能调整换行和缩进，很难完全和原始文档一致
• sed/awk：对于嵌套复杂的XML结构，正则表达式无法可靠地匹配开始和结束标签，容易出现误删或漏删的情况

这两种流解析方案都能完美满足你的需求，完全保留XML的原始格式，同时精准删除指定节点。如果你需要处理更复杂的节点匹配逻辑，只需要修改代码中的节点条件判断即可。

内容的提问来源于stack exchange，提问作者Louis Caron