如何实现无需传参即可隐式获取调用者实例的Python函数

给定以下animal类和fav_food函数的示例：

def fav_food(qty):
    # 该函数应返回包含喜爱食物和数量`qty`的元组
    # 不允许将animal实例作为参数传递
    # 若species为'cat'，应返回('tuna', qty)
    # 若species为'mouse'，应返回('cheese', qty)
    return ('dummyfood', qty)

class animal: 
    def __init__(self, name, weight, species):
        self.name = name
        self.weight = weight
        self.species = species        
    def eats(self, food):
        print(self.name + ' eats ' + food[0])
        self.weight = self.weight + food[1]
        print(self.name + '\'s new weight is: ' + str(self.weight))
    

tom = animal('tom', 5000, 'cat')
jerry = animal('jerry', 300, 'mouse')
tom.eats(fav_food(50)) # 期望返回('tuna', 50)
jerry.eats(fav_food(20)) # 期望返回('cheese', 20)

当前调用输出为：

tom eats dummyfood
tom's new weight is: 5050
jerry eats dummyfood
jerry's new weight is: 320

需要在**不将tom/jerry作为参数传递给fav_food**的前提下，得到如下输出：

tom eats tuna
tom's new weight is: 5050
jerry eats cheese
jerry's new weight is: 320

方案一：利用调用栈获取上下文实例 #

通过Python的inspect模块获取调用栈信息，直接从调用上下文提取animal实例，无需显式传递参数。

修改后的fav_food函数代码：

import inspect

def fav_food(qty):
    # 获取调用当前函数的上层栈帧（即eats方法的执行栈）
    caller_frame = inspect.currentframe().f_back
    # 从栈帧的局部变量中取出self，即调用eats的animal实例
    caller_self = caller_frame.f_locals.get('self')
    
    if caller_self and caller_self.species == 'cat':
        return ('tuna', qty)
    elif caller_self and caller_self.species == 'mouse':
        return ('cheese', qty)
    return ('dummyfood', qty)

说明 #

• inspect.currentframe()获取当前函数的栈帧对象，f_back指向调用它的上一层栈帧
• 栈帧的f_locals字典包含了调用方（eats方法）的局部变量，其中self就是当前的animal实例
• 根据实例的species属性返回对应食物元组，完全符合原调用方式的要求

注意点 #

• 该方法依赖Python解释器的栈帧实现，属于“黑魔法”写法，若调用上下文改变（比如不是从animal.eats调用），会导致逻辑失效
• 生产环境中需谨慎使用，建议配合边界判断避免报错

方案二：修改eats方法传递上下文（更健壮） #

通过调整eats方法的逻辑，用闭包隐式传递实例信息，同时保持外部调用风格的一致性。

修改后的代码：

def fav_food(animal_instance, qty):
    if animal_instance.species == 'cat':
        return ('tuna', qty)
    elif animal_instance.species == 'mouse':
        return ('cheese', qty)
    return ('dummyfood', qty)

class animal: 
    def __init__(self, name, weight, species):
        self.name = name
        self.weight = weight
        self.species = species        
    def eats(self, food_provider):
        # 调用传入的提供者函数，将自身实例传递进去
        food = food_provider(self)
        print(self.name + ' eats ' + food[0])
        self.weight = self.weight + food[1]
        print(self.name + '\'s new weight is: ' + str(self.weight))

# 调用时用lambda包装，保持原调用的直观性
tom = animal('tom', 5000, 'cat')
jerry = animal('jerry', 300, 'mouse')
tom.eats(lambda self: fav_food(self, 50))
jerry.eats(lambda self: fav_food(self, 20))

说明 #

• 把fav_food改成接收实例和数量的函数，逻辑更清晰
• eats方法接收一个可调用对象（这里用lambda），在内部将自身实例传递给该对象，实现隐式传递
• 这种方式不依赖底层栈帧，逻辑更健壮，适合生产环境使用

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