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

Question

我是Python的新手。 我正在SimPy中编写模拟以对生产线进行建模，如下所示：Machine 1-> Buffer 1-> Machine 2-> Buffer 2->依此类推。

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

那么，从该类的任何给定实例引用同一类的不同实例的方式是什么？ 另外，还有一点不同的问题：从另一个类的当前实例调用对象（在这种情况下为缓冲区1和2）的方式是什么？

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

Answer 1

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

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

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"

Answer 2

这是一个愚蠢的示例，我在这里做饭，您在其中将一些数据放入第一台计算机，然后将其移至第一台缓冲区，然后将其移至第二台计算机...

每台机器都只是使用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)

编辑

缓冲区现在也是机器。

Answer 3

现在，您已添加了有关该问题的更多信息，我将建议替代解决方案。

创建机器后，可能需要将它们链接在一起。

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 ，后者将执行相同的操作，然后交给m2进行处理，并调用output() 。 此示例显示了同步处理（在函数调用返回之前，一个项目将贯穿整个链），但是您也可以让.input()方法将该项目放在队列中进行处理，然后立即返回； 这样，您可以使机器并行处理。

使用此系统，机器之间的连接是显式的，并且每台机器仅知道其后面的机器（它需要知道的机器）。

我使用“线程”一词来描述将对象链接在一起的过程。 在到达输出之前，要处理的项目遵循机器之间的线程。 它有点模棱两可，因为它与执行线程无关，因此该术语并不完美。