如何实现Python解析混合层级结构与点分隔键的YAML配置文件

我刚好遇到过类似的需求，其实不用从头编写完整的YAML解析器，只需要在标准YAML库加载配置后，添加一层数据转换逻辑就能完美解决。核心思路是：将所有带点分隔的键拆分成嵌套字典结构，同时实现和Spring一致的配置合并逻辑（后定义的配置会覆盖或合并前序配置）。

方案一：通用转换函数（适用于所有YAML库） #

这个方法不依赖特定的YAML解析库，不管你用PyYAML还是ruamel.yaml，加载配置后调用这个转换函数即可：

def merge_dict(a, b):
    """递归合并两个字典，模拟Spring的配置覆盖逻辑：b的键值会覆盖a中同层级的键，字典类型则深度合并"""
    for key in b:
        if key in a:
            if isinstance(a[key], dict) and isinstance(b[key], dict):
                merge_dict(a[key], b[key])
            else:
                a[key] = b[key]
        else:
            a[key] = b[key]
    return a

def expand_dot_keys(data):
    """递归展开所有带点分隔的键为嵌套字典，同时处理合并逻辑"""
    if isinstance(data, dict):
        processed_dict = {}
        for key, value in data.items():
            processed_value = expand_dot_keys(value)
            # 处理带点的键
            if '.' in key:
                keys = key.split('.')
                current_level = processed_dict
                # 逐层创建嵌套字典
                for k in keys[:-1]:
                    current_level = current_level.setdefault(k, {})
                # 合并或设置最终键值
                final_key = keys[-1]
                if final_key in current_level:
                    if isinstance(current_level[final_key], dict) and isinstance(processed_value, dict):
                        merge_dict(current_level[final_key], processed_value)
                    else:
                        current_level[final_key] = processed_value
                else:
                    current_level[final_key] = processed_value
            else:
                # 处理普通键，存在则合并
                if key in processed_dict:
                    if isinstance(processed_dict[key], dict) and isinstance(processed_value, dict):
                        merge_dict(processed_dict[key], processed_value)
                    else:
                        processed_dict[key] = processed_value
                else:
                    processed_dict[key] = processed_value
        return processed_dict
    elif isinstance(data, list):
        # 递归处理列表中的每个元素
        return [expand_dot_keys(item) for item in data]
    else:
        # 非字典/列表类型直接返回
        return data

用法示例 #

假设你有混合格式的YAML配置：

service:
  scalingPolicy:
    capacity:
      min: 1
      max: 1
service.scalingPolicy.capacity:
  min: 2
  max: 2
database.url: "jdbc:mysql://localhost:3306/db"

加载并转换的代码：

import yaml

# 加载原始YAML配置
with open("config.yaml", "r") as f:
    raw_config = yaml.safe_load(f)

# 展开点分隔键并合并配置
final_config = expand_dot_keys(raw_config)

# 现在可以像访问层级YAML一样访问所有配置
print(final_config['service']['scalingPolicy']['capacity']['min'])  # 输出2（后配置覆盖前配置）
print(final_config['database']['url'])  # 输出jdbc:mysql://localhost:3306/db

方案说明 #

• 兼容性：适用于任何标准YAML解析库，因为转换逻辑完全基于Python字典操作，和YAML加载过程解耦。
• 合并逻辑：完全模拟Spring的配置优先级，后定义的配置会覆盖同层级的前序配置，如果是字典则深度合并。
• 边缘情况处理：如果键本身需要包含点（而非层级分隔），只需在YAML中用引号包裹该键（如"service.scalingPolicy.capacity": "raw_value"），函数会将其视为普通键，不会拆分。

这个方案既避免了重复造轮子，又完美满足了同时解析两种YAML键格式的需求，代码量小且易于维护。

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