1

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

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

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

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

4

3 回答 3

4

一个类的实例知道该类的其他实例并不常见。

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

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"
于 2012-07-10T19:26:45.763 回答
3

这是我编写的一个愚蠢的示例，您将一些数据放入第一台机器，然后将其移动到第一个缓冲区，然后将其移动到第二台机器......

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

编辑

缓冲区现在也是机器。

于 2012-07-10T19:57:45.483 回答
1

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

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

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()方法将项目放在队列中进行处理，然后立即返回；这样，您可以使机器并行处理。

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

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

于 2012-07-10T19:38:12.507 回答