如何在python中调用同一类的不同实例？

我是Python新手。我正在用SimPy编写一个模拟来模拟一条生产线，它看起来像：机器1->缓冲区1->机器2->缓冲区2->等等

我的问题: 我有一个类，Machine，其中有几个实例。假设当前实例是machine2。此实例的方法影响机器1和3的状态。例如：如果缓冲器2为空，则机器3处于空闲状态。但当机器2将零件放入缓冲器2中时，应激活机器3

那么，从该类的任何给定实例引用同一类的不同实例的方法是什么？ 还有一个稍微不同的问题：从另一个类的当前实例调用对象（本例中为缓冲区1和2）的方法是什么

---

编辑：编辑以增加系统的清晰度。

一个类的实例了解该类的其他实例并不常见

我建议您在类本身中保留某种类型的实例集合，并使用该类查找实例：

class Machine(object):
    lst = []
    def __init__(self, name):
        self.name = name
        self.id = len(Machine.lst)
        Machine.lst.append(self)

m0 = Machine("zero")
m1 = Machine("one")

print(Machine.lst[1].name)  # prints "one"

---

一个类的实例了解该类的其他实例并不常见

我建议您在类本身中保留某种类型的实例集合，并使用该类查找实例：

class Machine(object):
    lst = []
    def __init__(self, name):
        self.name = name
        self.id = len(Machine.lst)
        Machine.lst.append(self)

m0 = Machine("zero")
m1 = Machine("one")

print(Machine.lst[1].name)  # prints "one"

---

现在，您添加了有关该问题的更多信息，我将建议另一种解决方案

创建计算机后，您可能希望将它们链接在一起

class Machine(object):
    def __init__(self):
        self.handoff = None
    def input(self, item):
        item = do_something(item)  # machine processes item
        self.handoff(item)  # machine hands off item to next machine

m0 = Machine()

m1 = Machine()
m0.handoff = m1.input

m2 = Machine()
m1.handoff = m2.input

def output(item):
    print(item)

m2.handoff = output

现在，当您调用

m0.input（item）

时，它将进行处理，然后将该项交给

m1

，m1也将进行同样的操作，并交给

m2

，m2将进行处理并调用

output（）

。此示例显示了同步处理（在函数调用返回之前，项目将一直通过链），但您也可以使用

.input（）

方法将项目放入队列中进行处理，然后立即返回；通过这种方式，您可以使机器并行处理

在这个系统中，机器之间的连接是明确的，每台机器只知道跟随它的机器（它需要知道的机器）

---

我用“线程化”这个词来描述将这样的对象链接在一起的过程。在到达输出之前，正在处理的项目沿着线程从一台机器到另一台机器。它有点模棱两可，因为它与执行线程无关，所以这个术语并不完美。

既然您添加了关于这个问题的更多信息，我将建议一个替代解决方案

创建计算机后，您可能希望将它们链接在一起

class Machine(object):
    def __init__(self):
        self.handoff = None
    def input(self, item):
        item = do_something(item)  # machine processes item
        self.handoff(item)  # machine hands off item to next machine

m0 = Machine()

m1 = Machine()
m0.handoff = m1.input

m2 = Machine()
m1.handoff = m2.input

def output(item):
    print(item)

m2.handoff = output

现在，当您调用

m0.input（item）

时，它将进行处理，然后将该项交给

m1

，m1也将进行同样的操作，并交给

m2

，m2将进行处理并调用

output（）

。此示例显示了同步处理（在函数调用返回之前，项目将一直通过链），但您也可以使用

.input（）

方法将项目放入队列中进行处理，然后立即返回；通过这种方式，您可以使机器并行处理

在这个系统中，机器之间的连接是明确的，每台机器只知道跟随它的机器（它需要知道的机器）

---

我用“线程化”这个词来描述将这样的对象链接在一起的过程。在到达输出之前，正在处理的项目沿着线程从一台机器到另一台机器。它有点模棱两可，因为它与执行线程无关，所以这个术语并不完美。

这是一个我编造的愚蠢的例子，你把一些数据放入第一台机器，然后将其移动到第一个缓冲区，然后再将其移动到第二台机器

每台机器都只是用它的ID号标记数据并传递，但是你可以让机器做任何事情。您甚至可以注册一个函数，在每台机器获取数据时调用它

class Machine(object):
    def __init__(self,number,next=None):
        self.number=number
        self.register_next(next)

    def register_next(self,next):
        self.next=next

    def do_work(self,data):
        #do some work here
        newdata='%s %d'%(str(data),self.number)
        if(self.next is not None):
            self.next.do_work(newdata)

class Buffer(Machine):
    def __init__(self,number,next=None):
        Machine.__init__(self,number,next=next)
        data=None

    def do_work(self,data):
        if(self.next is not None):
            self.next.do_work(data)
        else:
            self.data=data

#Now, create an assembly line
assembly=[Machine(0)]
for i in xrange(1,20):
    machine=not i%2
    assembly.append(Machine(i) if machine else Buffer(i))
    assembly[-2].register_next(assembly[-1])

assembly[0].do_work('foo')
print (assembly[-1].data)

编辑

---

缓冲区现在也是机器。

这是我编造的一个愚蠢的例子，你把一些数据放入第一台机器，然后移动到第一个缓冲区，然后移动到第二台机器

每台机器都只是用它的ID号标记数据并传递，但是你可以让机器做任何事情。您甚至可以注册一个函数，在每台机器获取数据时调用它

class Machine(object):
    def __init__(self,number,next=None):
        self.number=number
        self.register_next(next)

    def register_next(self,next):
        self.next=next

    def do_work(self,data):
        #do some work here
        newdata='%s %d'%(str(data),self.number)
        if(self.next is not None):
            self.next.do_work(newdata)

class Buffer(Machine):
    def __init__(self,number,next=None):
        Machine.__init__(self,number,next=next)
        data=None

    def do_work(self,data):
        if(self.next is not None):
            self.next.do_work(data)
        else:
            self.data=data

#Now, create an assembly line
assembly=[Machine(0)]
for i in xrange(1,20):
    machine=not i%2
    assembly.append(Machine(i) if machine else Buffer(i))
    assembly[-2].register_next(assembly[-1])

assembly[0].do_work('foo')
print (assembly[-1].data)

编辑

---

缓冲区现在也是机器。

您需要提供有关代码结构的更多信息。机器2是如何知道其他机器存在的？这些状态是在所有机器之间共享的，还是每台机器都有一个单独的状态？您需要提供有关代码结构的更多信息。机器2是如何知道其他机器存在的？这些状态是在所有机器之间共享的，还是每台机器都有一个单独的状态？+1。对于非平凡的模拟，可能不可能使用循环连接所有机器和缓冲区；也许有必要至少部分地用手把东西摆好。但我完全喜欢这种方法。我建议这样做，但我没有同时显示机器和缓冲区；你在这里多走了一英里，给出了一个非常完整的答案。@steveha——在某些方面我更喜欢你的（+1）。例如，我不确定我是否喜欢我的

def register\u machine（self，machine）

。（

mybuff.machine=mymachine

可以很好地工作，但是，当我想象把一台机器的各个部分放在一起时，它更适合作为一个功能，而不是我心目中的一个属性）。。。我不确定这个API应该如何工作。但无论如何，我们都在想同样的事情。当然，你想得快多了，因为你比我早回答了20分钟，而我之前没有看到你的答案