如何为包含多foo实例的bar类动态构造方法以批量调用同名方法？

我设计了一个标准的foo类，包含多个方法属性，代码如下：

class foo:
    def f1(self):
        print 'f1'
    def f2(self):
        print 'f2'
    # ...
    def fn(self):
        print 'fn'

现在我希望创建一个包含多个foo实例的bar类，代码示例如下：

class bar:
    def __init__(self):
        self.myfoos=[foo(),foo(),foo()]

我需要让bar类调用所有foo实例的f1至fn方法，手动实现方式如下：

class bar:
    def __init__(self):
        self.myfoos=[foo(),foo(),foo()]
    def f1(self):
        for foo_ in self.myfoos:
            foo_.f1()

但f1至fn的方法数量众多，请问如何通过简洁的方式实现该需求？是否有更优的替代设计方案？

嘿，这个场景太常见了——手动写几十个代理方法完全是重复劳动，Python的动态特性刚好能帮我们搞定，同时还有更优雅的设计思路可以参考：

一、快速解决：动态生成代理方法 #

方法1：用__getattr__做动态拦截 #

这是最简洁的方式，利用Python的属性查找机制，当你调用bar实例上不存在的方法时，__getattr__会自动触发，我们只需要在这个方法里把调用转发给所有foo实例：

class bar:
    def __init__(self):
        self.myfoos = [foo(), foo(), foo()]
    
    def __getattr__(self, name):
        # 先确认foo类确实有这个方法，避免乱调用报错
        foo_method = getattr(foo, name, None)
        if callable(foo_method):
            # 返回一个代理函数，遍历所有foo实例执行对应方法
            def proxy(*args, **kwargs):
                for foo_inst in self.myfoos:
                    getattr(foo_inst, name)(*args, **kwargs)
            return proxy
        # 如果不是foo的方法，抛出正常的属性错误，符合Python的行为习惯
        raise AttributeError(f"'bar' object has no attribute '{name}'")

现在你直接调用bar_inst.f1()、bar_inst.f2()甚至bar_inst.fn()，都会自动让所有foo实例执行对应的方法，完全不用手动写每个代理函数。

方法2：类定义时批量生成方法 #

如果你希望这些代理方法在bar类的属性中可见（比如用dir(bar)能看到），可以用inspect模块遍历foo的所有方法，批量添加到bar类中：

import inspect

class foo:
    def f1(self):
        print('f1')
    def f2(self):
        print('f2')
    def fn(self):
        print('fn')

def add_proxy_methods(target_cls, source_cls, instances_attr):
    # 遍历source_cls的所有非特殊方法
    for name, method in inspect.getmembers(source_cls, inspect.isfunction):
        if name.startswith('__') and name.endswith('__'):
            continue  # 跳过__init__这类特殊方法
        # 定义代理方法
        def proxy(self, *args, **kwargs):
            for inst in getattr(self, instances_attr):
                getattr(inst, name)(*args, **kwargs)
        # 把代理方法绑定到目标类
        setattr(target_cls, name, proxy)

class bar:
    def __init__(self):
        self.myfoos = [foo(), foo(), foo()]

# 给bar类批量添加所有foo的方法代理
add_proxy_methods(bar, foo, 'myfoos')

这样bar类会拥有和foo完全一致的方法列表，调用起来和手动写的代理方法没有区别。

二、更优的设计方案：避免动态黑魔法 #

上面的动态方法虽然好用，但如果后续foo的方法有修改，可能会带来维护上的困惑。从设计模式的角度，有更清晰的替代方案：

方案1：命令模式封装批量操作 #

把“执行某个方法”封装成一个明确的操作，bar只负责提供批量执行的入口：

class bar:
    def __init__(self):
        self.myfoos = [foo(), foo(), foo()]
    
    def run_on_all(self, method_name, *args, **kwargs):
        for foo_inst in self.myfoos:
            if hasattr(foo_inst, method_name) and callable(getattr(foo_inst, method_name)):
                getattr(foo_inst, method_name)(*args, **kwargs)

# 使用方式
bar_inst = bar()
bar_inst.run_on_all('f1')
bar_inst.run_on_all('f2')

这种方式更直观，调用者明确知道自己在执行批量操作，代码可读性更高，也更容易调试——比如你可以在run_on_all里加日志、错误处理等逻辑。

方案2：把bar设计为可迭代的集合 #

如果bar的核心就是管理一组foo实例，不如让bar实现迭代器接口，这样外部可以直接遍历bar来操作每个foo：

class bar:
    def __init__(self):
        self.myfoos = [foo(), foo(), foo()]
    
    def __iter__(self):
        return iter(self.myfoos)

# 使用方式
bar_inst = bar()
for foo_inst in bar_inst:
    foo_inst.f1()
# 甚至可以用列表推导式做批量操作
[foo_inst.f2() for foo_inst in bar_inst]

这种方式最灵活，外部可以根据需要选择执行哪些方法，还能组合多个操作，适合需要对foo实例做复杂处理的场景。

总结一下 #

• 想让bar的用法和foo完全一致？用__getattr__动态代理最省事；
• 需要方法在类中可见？批量生成代理方法更合适；
• 追求代码可读性和可维护性？优先考虑run_on_all命令模式或者迭代器集合方案，避免动态特性带来的“黑魔法”成本。

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