Python中如何不重复调用函数1，从函数2获取其变量最新值？

背景与问题 #

我正在学习Python，使用Jupyter Notebook（Python 3.9.13版本），此前仅用过ActionScript 2.0。我想了解从其他函数访问某函数内创建、声明变量的最佳实践。目前我有两种实现方式，但都存在问题：

• 方式一：在func2中调用func1获取变量，但会重复执行func1，无法获取func1上次调用时的变量值
• 方式二：使用global全局变量，虽能实现需求，但了解到不推荐使用全局变量

我的现有代码如下：

方式一代码 #

def func1():
    my_var1 = (1 + 1) #...or something that sets a 'value' for this variable
    my_var2 = (2 + 2) #...or something that sets a 'value' for this variable
    return my_var1, my_var2
func1() #calls func1

def func2():
    my_var1, my_var2 = func1()
    my_var3 = (my_var1 + 1)
    my_var4 = (my_var2 + 1)
    return my_var3, my_var4
func2() #calls func1 (and func2 ?)

方式二代码 #

def func3():
    global my_var5
    global my_var6
    my_var5 = (1 + 1) #...or something that sets a 'value' for this variable
    my_var6 = (2 + 2) #...or something that sets a 'value' for this variable
    return my_var5, my_var6
func3() #calls func3

def func4():
    my_var7 = (my_var5 + 1) #...or something that sets a 'value' for this variable
    my_var8 = (my_var6 + 2) #...or something that sets a 'value' for this variable
    return my_var7, my_var8
func4() #calls func4

推荐解决方案 #

1. 使用类（面向对象） #

这是Python中保存状态、在多个方法间共享变量的标准方案。把需要共享的变量设为类的实例属性，相关逻辑封装为类的方法，既能跨方法访问变量，又能保留状态。

示例代码：

class StateManager:
    def __init__(self):
        # 初始化变量，对应原func1的初始逻辑
        self.var1 = 1 + 1
        self.var2 = 2 + 2
    
    def update_vars(self):
        # 模拟更新变量的逻辑，对应原func1的后续调用
        self.var1 += 1
        self.var2 += 1
    
    def calculate_new_vars(self):
        # 对应原func2，直接访问实例属性
        var3 = self.var1 + 1
        var4 = self.var2 + 1
        return var3, var4

# 使用示例
manager = StateManager()
print(manager.calculate_new_vars())  # 输出(3, 5)
manager.update_vars()
print(manager.calculate_new_vars())  # 输出(4, 6)，使用更新后的变量值

2. 使用闭包 #

如果不想用类，闭包可以让嵌套函数保留外部函数的变量状态，既避免全局变量，又不用重复执行初始化逻辑。

示例代码：

def build_state():
    # 这里的变量会被闭包保留状态
    var1 = 1 + 1
    var2 = 2 + 2
    
    def update_vars():
        nonlocal var1, var2
        var1 += 1
        var2 += 1
    
    def calculate_new_vars():
        var3 = var1 + 1
        var4 = var2 + 1
        return var3, var4
    
    # 返回操作函数
    return update_vars, calculate_new_vars

# 使用示例
update, calculate = build_state()
print(calculate())  # (3, 5)
update()
print(calculate())  # (4, 6)

3. 传递变量作为参数（无状态场景） #

如果不需要保留func1上次调用的变量值，只是想避免重复执行func1，可以先调用一次func1保存结果，再把结果传递给其他函数：

def func1():
    var1 = 1 + 1
    var2 = 2 + 2
    return var1, var2

def func2(var1, var2):
    var3 = var1 + 1
    var4 = var2 + 1
    return var3, var4

# 使用示例
var1, var2 = func1()
print(func2(var1, var2))  # 仅执行一次func1，直接传递变量

为什么不推荐全局变量 #

全局变量会带来以下问题：

• 任何函数都能修改全局变量，很难追踪变量的变化来源，调试难度大
• 全局变量会提升函数间的耦合度，函数不再是独立的可复用单元
• 在多线程或复杂项目中，全局变量容易引发并发冲突

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