如何使用Python xmlschema解析XML并保留元素顺序，兼顾value_hook功能？

针对你的需求——既保留XML元素顺序，又能利用xmlschema的value_hook处理不同字节序的十六进制值、访问XSD类型信息，提供两种实用方案：

方案1：使用iterparse流式解析（推荐，内存友好） #

xmlschema的iterparse方法支持流式遍历XML元素，完全保留原始顺序，同时可获取对应XSD类型并应用值转换逻辑。

步骤示例 #

1. 假设你的XSD文件（test.xsd）定义如下：

<?xml version="1.0" encoding="UTF-8"?>
<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema">
    <xs:element name="A">
        <xs:complexType>
            <xs:choice maxOccurs="unbounded">
                <xs:element name="B" type="xs:hexBinary"/> <!-- 小端序类型 -->
                <xs:element name="C" type="xs:hexBinary"/> <!-- 大端序类型 -->
            </xs:choice>
        </xs:complexType>
    </xs:element>
</xs:schema>

2. 解析代码实现：

from xmlschema import XMLSchema

def process_hex_value(raw_value, xsd_type):
    """根据XSD类型处理十六进制值的字节序"""
    hex_bytes = bytes.fromhex(raw_value.strip())
    if xsd_type.name == 'B':
        return int.from_bytes(hex_bytes, byteorder='little')
    elif xsd_type.name == 'C':
        return int.from_bytes(hex_bytes, byteorder='big')
    return raw_value

test_prefix = 'test'
xml_file = f"{test_prefix}.xml"
xsd_file = f"{test_prefix}.xsd"

xml_schema = XMLSchema(xsd_file)
ordered_elements = []

# 流式解析，按XML原始顺序处理每个元素
for event, elem in xml_schema.iterparse(xml_file, events='end'):
    # 仅处理根元素A下的子元素
    if elem.tag in xml_schema.root_type.content_type.elements:
        xsd_element = xml_schema.root_type.content_type.elements[elem.tag]
        processed_val = process_hex_value(elem.text, xsd_element.type)
        ordered_elements.append({
            'tag': elem.tag,
            'value': processed_val,
            'xsd_type': xsd_element.type.name
        })

# 遍历输出结果（保留B、C、B的顺序）
for item in ordered_elements:
    print(f"{item['tag']}: {item['value']} (XSD类型: {item['xsd_type']})")

方案2：自定义解码器重写Choice逻辑 #

通过继承XmlElementDecoder，重写choice类型的解码方法，让其返回有序元素列表而非字典，同时保留value_hook的功能。

代码实现 #

from xmlschema import XMLSchema, XsdChoice
from xmlschema.decoders import XmlElementDecoder

class OrderedChoiceDecoder(XmlElementDecoder):
    def decode_choice(self, choice: XsdChoice, elem, *args, **kwargs):
        """重写Choice解码逻辑，返回有序的(标签, 值)元组列表"""
        ordered_result = []
        for child in elem:
            if child.tag in choice.elements:
                xsd_elem = choice.elements[child.tag]
                # 调用父类解码方法，自动应用value_hook
                decoded_val = self.decode(xsd_elem, child, *args, **kwargs)
                ordered_result.append((child.tag, decoded_val))
        return ordered_result

test_prefix = 'test'
xml_file = f"{test_prefix}.xml"
xsd_file = f"{test_prefix}.xsd"

xml_schema = XMLSchema(xsd_file)
# 替换默认解码器为自定义实现
xml_schema.decoder = OrderedChoiceDecoder(xml_schema)

def parsing_value_hook(value, xsd):
    """value_hook处理字节序转换"""
    if xsd.name == 'B':
        return int.from_bytes(bytes.fromhex(value.strip()), byteorder='little')
    elif xsd.name == 'C':
        return int.from_bytes(bytes.fromhex(value.strip()), byteorder='big')
    return value

parsed_data = xml_schema.decode(xml_file, value_hook=parsing_value_hook)
# parsed_data为有序列表：[('B', 对应小端整数), ('C', 对应大端整数), ('B', 对应小端整数)]
print(parsed_data)

# 遍历处理后的有序元素
for tag, val in parsed_data:
    print(f"{tag}: {val}")

方案对比 #

• 方案1：适合大型XML文件，流式解析内存占用低，完全保留原始元素顺序，灵活性高。
• 方案2：更贴近xmlschema原生解码流程，返回结构化的有序数据，适合中小型文件。

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