在 Python 中，通常我们需要单独运行每个类的实例的方法。但是，有时我们需要同时运行一个类中所有实例的方法，尤其是当实例数量较多时。例如，我们有一个 MyClass 类，其中包含两个方法 power() 和 divide()。我们有两个实例 foo 和 bar，分别调用了这两个方法，如下所示：
class MyClass(object):
def __init__(self, x, y):
self.x = x
self.y = y
def power(self):
print(self.x**self.y)
def divide(self):
print(self.x/self.y)
foo = MyClass(2, 3)
bar = MyClass(4, 7)
foo.power() # Output: 8
bar.divide() # Output: 0.5714285714285714
如果我们有 20 个或更多的实例，则逐个运行方法可能会变得很繁琐。因此，我们想知道是否有办法同时运行一个类中所有实例的方法。
- 解决方案
有多种方法可以同时运行一个类中所有实例的方法。以下是一些解决方案：
方法一：使用 instancelist 属性
我们可以创建一个 instancelist 属性来存储类的所有实例。然后，我们可以使用列表解析来遍历 instancelist 并运行每个实例的方法。例如，我们可以修改 MyClass 类如下：
class MyClass(object):
instancelist = []
def __init__(self, x, y):
self.x = x
self.y = y
MyClass.instancelist.append(self)
def power(self):
print(self.x**self.y)
def divide(self):
print(self.x/self.y)
foo = MyClass(2, 3)
bar = MyClass(4, 7)
[instance.power() for instance in MyClass.instancelist] # Output: 8, 16384
这样，我们就可以同时运行 power() 方法和 divide() 方法。
方法二：使用全局变量
我们也可以使用全局变量来存储类的所有实例。然后，我们可以使用一个循环来遍历全局变量并运行每个实例的方法。例如，我们可以修改 MyClass 类如下：
GLOBAL_MYCLASS_LIST = []
class MyClass(object):
def __init__(self, x, y):
GLOBAL_MYCLASS_LIST.append(self)
self.x = x
self.y = y
def power(self):
print(self.x**self.y)
def divide(self):
print(self.x/self.y)
a = MyClass(2, 3)
b = MyClass(4, 7)
all_powers = [i.power() for i in GLOBAL_MYCLASS_LIST] # Output: 8, 16384
这样，我们也可以同时运行 power() 方法和 divide() 方法。
方法三：使用 __getattr__() 方法
我们还可以使用 __getattr__() 方法来同时运行一个类中所有实例的方法。__getattr__() 方法会在我们尝试访问一个不存在的属性时被调用。我们可以利用这个特性来创建一个动态的方法，该方法可以同时运行所有实例的方法。例如，我们可以修改 MyClass 类如下：
class MyClass(object):
def __init__(self, x, y):
self.x = x
self.y = y
def power(self):
print(self.x**self.y)
def divide(self):
print(self.x/self.y)
class Test:
def __init__(self, items):
self.items = items
def __getattr__(self, key):
def fn():
return [getattr(x,key)() for x in self.items]
return fn
foo = MyClass(2, 3)
bar = MyClass(4, 7)
t = Test([foo,bar])
t.power() # Output: 8, 16384
t.divide() # Output: 0, 0
这样，我们也可以同时运行 power() 方法和 divide() 方法。
方法四：使用列表解析
我们还可以使用列表解析来同时运行一个类中所有实例的方法。列表解析是一种简洁的语法，可以用来创建列表。我们可以使用列表解析来遍历类的所有实例，并运行每个实例的方法。例如，我们可以修改 MyClass 类如下：
class MyClass(object):
def __init__(self, x, y):
self.x = x
self.y = y
def power(self):
return self.x**self.y
def divide(self):
return self.x/self.y
foo = MyClass(2, 3)
bar = MyClass(4, 7)
results = [x.power() for x in [foo, bar]] # Output: [8, 16384]
results = [x.divide() for x in [foo, bar]] # Output: [0, 0]
这样，我们也可以同时运行 power() 方法和 divide() 方法。
方法五：使用循环
我们还可以使用循环来同时运行一个类中所有实例的方法。循环是一种常用的方法，可以用来遍历一个序列。我们可以使用循环来遍历类的所有实例，并运行每个实例的方法。例如，我们可以修改 MyClass 类如下：
class MyClass(object):
def __init__(self, x, y):
self.x = x
self.y = y
def power(self):
print(self.x**self.y)
def divide(self):
print(self.x/self.y)
foo = MyClass(2, 3)
bar = MyClass(4, 7)
for i in [foo, bar]:
i.power() # Output: 8, 16384
i.divide() # Output: 0, 0
这样，我们也可以同时运行 power() 方法和 divide() 方法。
方法六：使用 hasattr() 方法
我们还可以使用 hasattr() 方法来同时运行一个类中所有实例的方法。hasattr() 方法可以用来检查一个对象是否具有某个属性。我们可以使用 hasattr() 方法来检查类的所有实例是否具有某个方法，如果有，则运行该方法。例如，我们可以修改 MyClass 类如下：
class MyClass(object):
def __init__(self, x, y):
self.x = x
self.y = y
def power(self):
print(self.x**self.y)
def divide(self):
print(self.x/self.y)
foo = MyClass(2, 3)
bar = MyClass(4, 7)
for i in [foo, bar]:
if hasattr(i, 'power'):
i.power() # Output: 8, 16384
if hasattr(i, 'divide'):
i.divide() # Output: 0, 0
这样，我们也可以同时运行 power() 方法和 divide() 方法。
以上是一些同时运行一个类中所有实例的方法的解决方案。您可以根据自己的需要选择一种解决方案。
