如何在Python中实现全局配置的统一访问与分发？

首先得帮你理清为什么用globals()会失败：每个Python模块都有自己独立的全局命名空间，你在__main__.py里给globals()['config']赋值，只会修改主模块的全局变量，而module.py的globals()是它自己的命名空间，根本找不到这个key，自然会报KeyError。

接下来给你几个实用的解决方案，从简单到灵活，你可以根据自己的场景选：

方案1：用模块做天然单例（最省心的Pythonic方案） #

Python里模块第一次导入后就会被缓存，天然是单例模式，拿来存全局配置简直完美，不用自己写单例逻辑。

实现步骤： #

1. 新建一个myapp/config.py专门管配置：

import json

# 内部存储配置，初始为None
_config = None

def load_config(config_path='config.json'):
    """加载配置，只执行一次"""
    global _config
    if _config is None:
        with open(config_path, 'r') as f:
            _config = json.load(f)
    return _config

def get_config():
    """获取当前配置，确保已加载"""
    if _config is None:
        raise RuntimeError("先调用load_config()初始化配置哦！")
    return _config

def update_config(new_config):
    """运行时更新配置，所有模块都会拿到最新值"""
    global _config
    if _config is not None:
        _config.update(new_config)

2. 在__main__.py里初始化一次配置：

from myapp.config import load_config
from myapp.module import MyClass

# 只加载解析一次配置文件
load_config('config.json')

# 实例化类，不用传配置
x = MyClass()

3. 在module.py里直接拿配置：

from myapp.config import get_config

class MyClass:
    def __init__(self):
        config = get_config()
        print(config)

这个方案的优点：

• 零额外单例代码，利用Python本身的特性
• 配置只加载解析一次，启动快
• 调用update_config()后，所有模块再调用get_config()都会拿到最新配置，满足你运行时更新可见的需求

方案2：单例Config类（面向对象风格） #

如果你更喜欢用类来封装配置逻辑，可以实现一个单例类，用类似pthread_once()的机制保证初始化只执行一次：

实现代码： #

# myapp/config.py
import json

class Config:
    _instance = None
    _has_initialized = False

    def __new__(cls):
        # 保证只有一个实例
        if cls._instance is None:
            cls._instance = super().__new__(cls)
        return cls._instance

    def __init__(self):
        # 保证初始化逻辑只执行一次，对应pthread_once的效果
        if not self._has_initialized:
            with open('config.json', 'r') as f:
                self.data = json.load(f)
            self._has_initialized = True

    def update(self, new_config):
        """更新配置"""
        self.data.update(new_config)

使用方式： #

• __main__.py里初始化：

from myapp.config import Config
from myapp.module import MyClass

# 第一次实例化时加载配置
Config()

x = MyClass()

• module.py里获取配置：

from myapp.config import Config

class MyClass:
    def __init__(self):
        config = Config().data
        print(config)

这个方案封装性更强，适合需要给配置加更多业务逻辑的场景。

方案3：依赖注入（高可测试性方案） #

如果你的应用需要写单元测试，或者不想用全局状态，依赖注入是更好的选择——把配置实例直接传给需要的类，完全避免全局变量：

实现代码： #

# myapp/config.py
class Config:
    def __init__(self, data):
        self.data = data

    def update(self, new_data):
        self.data.update(new_data)

# __main__.py
import json
from myapp.config import Config
from myapp.module import MyClass

# 加载配置并创建实例
with open('config.json', 'r') as f:
    config_data = json.load(f)
config = Config(config_data)

# 实例化类时传入配置
x = MyClass(config)

# module.py
class MyClass:
    def __init__(self, config):
        self.config = config.data
        print(self.config)

这个方案的好处是测试时可以轻松传入模拟配置，不用依赖真实的配置文件，代码耦合度更低。

总结一下： #

• 想快速搞定，选模块单例，最符合Python的设计思路
• 要面向对象封装，选单例Config类
• 注重测试和低耦合，选依赖注入

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