如何在不转为类成员函数的前提下避免Python函数使用全局变量？

原代码实现如下：

msg_process.py #

# msg_process.py
global g_msg_mapping = {}

def process_msg_a(msg):
    global g_msg_mapping
    # update g_msg_mapping based on msg_a

def process_msg_b(msg):
    global g_msg_mapping
    # update g_msg_mapping based on msg_b

def process_msg(msg_line, msg_type):
    if msg_type == 'A':
        process_msg_a(msg_line)
    elif msg_type == 'B':
        process_msg_b(msg_line)

main.py #

# main.py
# for each line in a file call msg_process.process_msg

可变全局变量在Python编程中并非良好实践。若将上述函数替换为类成员函数，可避免使用全局变量。

问题： #

是否存在优雅的方法，能在不将Python函数转换为类成员函数的前提下避免使用全局变量？

当然有！不用转成类成员函数，咱们有几种优雅的方式来避开全局变量，核心思路就是把状态（也就是原来的g_msg_mapping）传递给函数，或者让函数闭包持有状态，下面给你具体说两种常用方法：

方法一：使用闭包（Closure） #

闭包可以让内部函数访问并修改外部函数作用域里的变量，不用全局变量。咱们可以把状态封装在一个外层函数里，返回处理消息的函数，这样状态就被闭包持有了：

# msg_process.py
def create_msg_processor():
    msg_mapping = {}  # 这里代替原来的全局变量，是闭包的内部状态
    
    def process_msg_a(msg):
        # 直接访问外层的msg_mapping，无需global声明
        # 按msg_a的逻辑更新mapping，示例逻辑：
        msg_mapping[msg['key']] = msg['value']
    
    def process_msg_b(msg):
        # 按msg_b的逻辑更新mapping，示例逻辑：
        msg_mapping.setdefault(msg['group'], []).append(msg['item'])
    
    def process_msg(msg_line, msg_type):
        if msg_type == 'A':
            process_msg_a(msg_line)
        elif msg_type == 'B':
            process_msg_b(msg_line)
    
    # 返回处理函数，同时返回获取状态的方法（返回副本避免外部随意修改内部状态）
    return process_msg, lambda: msg_mapping.copy()

# main.py
# 创建一个处理器实例，每个实例有独立的状态，互不干扰
process_msg, get_current_mapping = create_msg_processor()

# 模拟文件处理流程
with open('messages.txt', 'r') as f:
    for line in f:
        # 假设已完成行解析，得到msg_type和结构化的msg_line
        msg_type, msg_line = line.strip().split('|', 1)
        process_msg(msg_line, msg_type)

# 查看最终的映射结果
final_mapping = get_current_mapping()
print(final_mapping)

这种方式的好处是状态被封装且实例化——你可以创建多个独立的处理器，每个有自己的msg_mapping，不会互相干扰，比全局变量灵活太多。而且内部状态不会被外部随意修改，安全性更高。

方法二：显式传递状态（纯函数风格） #

另一种更直白的方式，就是把msg_mapping作为参数传给每个处理函数，甚至可以让函数返回更新后的状态（纯函数，无副作用）：

# msg_process.py
def process_msg_a(msg, msg_mapping):
    # 纯函数风格：不修改原映射，返回新的映射副本
    updated_mapping = msg_mapping.copy()
    # 按msg_a的逻辑更新，示例逻辑：
    updated_mapping[msg['key']] = msg['value']
    return updated_mapping

def process_msg_b(msg, msg_mapping):
    updated_mapping = msg_mapping.copy()
    # 按msg_b的逻辑更新，示例逻辑：
    updated_mapping.setdefault(msg['group'], []).append(msg['item'])
    return updated_mapping

def process_msg(msg_line, msg_type, msg_mapping):
    if msg_type == 'A':
        return process_msg_a(msg_line, msg_mapping)
    elif msg_type == 'B':
        return process_msg_b(msg_line, msg_mapping)
    # 未知消息类型，返回原映射
    return msg_mapping

# main.py
# 初始化状态
msg_mapping = {}

with open('messages.txt', 'r') as f:
    for line in f:
        msg_type, msg_line = line.strip().split('|', 1)
        # 每次更新状态，重新赋值
        msg_mapping = process_msg(msg_line, msg_type, msg_mapping)

print(msg_mapping)

这种方式的优点是状态流转完全透明，别人一看代码就知道状态是怎么传递和更新的。纯函数风格还能避免意外的副作用，让代码更容易测试和调试——你可以给函数传入固定的输入，验证输出是否符合预期。

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