Python全局可访问对象组管理方案的疑问与优化咨询

我需要在代码的任意位置跟踪并访问对象组，为此在包主目录的__init__.py中实现了一套快速解决方案（代码如下），现提出以下疑问：

1. 是否有开发者采用此类实现方式？
2. 是否已有现成方案或更Pythonic的实现方式（已知全局变量，希望规避）？
3. 该方案存在哪些明显的弊端或陷阱？

注：我已知不存在的组名会引发错误，且同一组内重复对象可能导致问题，我的使用场景中对象均为唯一。

# 代码位于包主目录的__init__.py中
# 在需要访问组的其他模块中，我只导入这些操作函数

_groups = {}


def add_to_group(group_name: str, thing) -> None:
    if group_name in _groups.keys():
        _groups[group_name].append(thing)
    else:
        _groups[group_name] = [thing]


def remove_from_group(group_name: str, thing) -> None:
    if group_name in _groups.keys():
        ix = _groups[group_name].index(thing)
        _groups[group_name].pop(ix)
    else:
        raise NameError(f"group_name '{group_name}' was not found in groups. group names found were {_groups.keys()}")


def get_all_in_group(group_name: str) -> list:
    return _groups.get(group_name, [])


def delete_group(group_name: str) -> list:
    return _groups.pop(group_name)


if __name__ == "__main__":
    my_thing = 5
    add_to_group("stuff", my_thing)
    add_to_group("more_stuff", my_thing)
    print(get_all_in_group("stuff"))
    remove_from_group("stuff", my_thing)
    print(get_all_in_group("stuff"))
    delete_group("stuff")
    print(_groups)
    remove_from_group("stuff", my_thing)

问题解答 #

1. 是否有开发者采用此类实现方式？

这类实现非常常见，尤其是在小型项目、快速原型或者内部工具开发中。本质是把Python模块当作天然的单例使用，用模块级私有字典存储状态，搭配操作函数提供接口，简单直接且无需额外依赖，是快速解决全局对象管理问题的常用方案。

2. 更Pythonic的实现方式（规避全局变量）

有几种更符合Python风格的替代方案：

• 面向对象的单例管理器：将状态与操作封装到类中，用类方法实现全局访问，既保留全局管理能力，又符合封装原则：

class GroupManager:
    _groups = {}

    @classmethod
    def add_to_group(cls, group_name: str, thing) -> None:
        cls._groups.setdefault(group_name, []).append(thing)

    @classmethod
    def remove_from_group(cls, group_name: str, thing) -> None:
        if group_name not in cls._groups:
            raise NameError(f"group_name '{group_name}' was not found in groups. group names found were {cls._groups.keys()}")
        cls._groups[group_name].remove(thing)

    @classmethod
    def get_all_in_group(cls, group_name: str) -> list:
        return cls._groups.get(group_name, [])

    @classmethod
    def delete_group(cls, group_name: str) -> list:
        return cls._groups.pop(group_name)

• 用collections.defaultdict优化原实现：用defaultdict简化add_to_group的判断逻辑，让代码更简洁：

from collections import defaultdict

_groups = defaultdict(list)

def add_to_group(group_name: str, thing) -> None:
    _groups[group_name].append(thing)

• 依赖注入模式：如果想彻底规避全局状态，可以将GroupManager实例作为依赖传递给需要的模块或对象，适合架构更严谨的项目，状态可控性更强，测试也更方便。

3. 方案的弊端与陷阱

除了你已知的问题外，还有几个明显隐患：

• 线程安全问题：多线程环境下，并发调用add_to_group或remove_from_group会引发列表并发修改异常，需要通过threading.Lock等锁机制保证操作的原子性。
• 内存泄漏风险：组内的对象引用会阻止垃圾回收器回收不再使用的对象，若对象数量多、生命周期长，容易导致内存占用过高，需确保无用对象被及时移除。
• 封装性不足：Python没有真正的私有变量，其他模块可直接导入并修改_groups字典，破坏状态一致性，引发难以排查的bug。
• 测试复杂度高：全局状态会导致测试用例互相干扰，每次测试前都需要重置_groups状态，增加测试成本。
• 缺乏类型约束：thing参数无类型限制，任何对象都可加入组，后续使用时可能出现类型不匹配错误，建议添加类型注解或类型检查。

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