如何为对象列表调用相同的方法？

假设这样的代码：

class Base:
    def start(self):
        pass
    def stop(self)
        pass

class A(Base):
    def start(self):
        ... do something for A
    def stop(self)
        .... do something for A

class B(Base):
    def start(self):

    def stop(self):

a1 = A(); a2 = A()
b1 = B(); b2 = B()

all = [a1, b1, b2, a2,.....]

现在，我要为所有列表中的每个对象调用方法start和stop（也许还有其他）。除了编写像这样的一堆函数外，有什么优雅的方法可以做到这一点

def start_all(all):
    for item in all:
        item.start()

def stop_all(all):

* _all（）函数非常简单，以至于我只想编写一些方法。如果您有很多相同的功能，则可以编写一个通用功能：

def apply_on_all(seq, method, *args, **kwargs):
    for obj in seq:
         getattr(obj, method)(*args, **kwargs)

或创建一个函数工厂：

def create_all_applier(method, doc=None):
    def on_all(seq, *args, **kwargs):
        for obj in seq:
            getattr(obj, method)(*args, **kwargs)
    on_all.__doc__ = doc
    return on_all

start_all = create_all_applier('start', "Start all instances")
stop_all = create_all_applier('stop', "Stop all instances")
...

这会工作

all = [a1, b1, b2, a2,.....]

map(lambda x: x.start(),all)    

简单的例子

all = ["MILK","BREAD","EGGS"]
map(lambda x:x.lower(),all)
>>>['milk','bread','eggs']

并在python3中

all = ["MILK","BREAD","EGGS"]
list(map(lambda x:x.lower(),all))
>>>['milk','bread','eggs']

似乎会有一种更Python化的方法来执行此操作，但我尚未找到它。

如果我要在一堆对象上调用相同的函数（而不是方法），有时会使用“ map”：

map(do_something, a_list_of_objects)

这将替换一堆看起来像这样的代码：

 do_something(a)
 do_something(b)
 do_something(c)
 ...

但也可以通过行人“ for”循环来实现：

  for obj in a_list_of_objects:
       do_something(obj)

缺点是：a）您正在创建一个列表，将其作为从“ map”中被丢弃的返回值； b）仅仅使用简单的循环变量可能会更加令人困惑。

您还可以使用列表理解，但这也有点滥用（再次，创建一个一次性列表）：

  [ do_something(x) for x in a_list_of_objects ]

对于方法，我想这些方法中的任何一个都可以（保留相同）：

map(lambda x: x.method_call(), a_list_of_objects)

要么

[ x.method_call() for x in a_list_of_objects ]

因此，实际上，我认为行人（迄今有效）的“ for”循环可能是您最好的选择。

该方法

for item in all:
    item.start()

简单，容易，可读和简洁。这是Python为此操作提供的主要方法。如果有帮助，您当然可以将其封装在函数中。为此定义一个通用的特殊功能可能比仅写for循环还不清楚。

也许map，但是由于您不想列出清单，因此您可以编写自己的清单...

def call_for_all(f, seq):
    for i in seq:
        f(i)

那么您可以执行以下操作：

call_for_all(lamda x: x.start(), all)
call_for_all(lamda x: x.stop(), all)

顺便说一下，所有都是内置函数，请不要覆盖它；-)

从Python 2.6开始，提供了operator.methodcaller函数。

因此，您可以获得更优雅（更快速）的东西：

from operator import methodcaller

map(methodcaller('method_name'), list_of_objects)

通过@Ants Aasmas进一步回答问题，您可以创建一个包装器，该包装器接受任何方法调用并将其转发给给定列表的所有元素：

class AllOf:
    def __init__(self, elements):
        self.elements = elements
    def __getattr__(self, attr):
        def on_all(*args, **kwargs):
            for obj in self.elements:
                getattr(obj, attr)(*args, **kwargs)
        return on_all

该类可以这样使用：

class Foo:
    def __init__(self, val="quux!"):
        self.val = val
    def foo(self):
        print "foo: " + self.val

a = [ Foo("foo"), Foo("bar"), Foo()]
AllOf(a).foo()

产生以下输出：

foo：foo
foo：栏
富：！

通过一些工作和独创性，可能还可以增强它来处理属性（返回属性值列表）。