Comment appeler une instance différente de la même classe en python?

Question

Je suis nouveau à Python. J'écris une simulation dans SimPy pour modéliser une ligne de production, qui ressemble à: Machine 1 -> Buffer 1 -> Machine 2 -> Buffer 2 -> et ainsi de suite ..

Ma question: J'ai une classe , Machine, dont il existe plusieurs instances. Supposons que l'instance actuelle soit la machine 2. Les méthodes de cette instance affectent les états des machines 1 et 3. Par exemple, si la mémoire tampon 2 était vide, alors la machine 3 est inactive. Mais lorsque la Machine 2 fait partie du Buffer 2, la Machine 3 devrait être activée.

Alors, comment faire référence à différentes instances de la même classe à partir de n'importe quelle instance de cette classe? Aussi, question légèrement différente: Comment appeler un objet (Buffers 1 et 2, dans ce cas) à partir de l'instance actuelle d'une autre classe?

Éditer: Edité pour plus de clarté sur le système.

Answer 1

Il n'est pas courant que les instances d'une classe connaissent d'autres instances de la classe.

Je vous recommande de garder une sorte de collection d'instances de votre classe elle-même, et utiliser la classe pour rechercher les instances:

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

Maintenant que vous avez ajouté plus d'informations sur le problème, je vais suggérer une solution alternative. Une fois que vous avez créé vos machines, vous pouvez les lier ensemble.

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 

Maintenant, lorsque vous appelez m0.input(item) il fera son traitement, puis la main de l'élément à m1, qui fera la même chose et à la main de m2, qui fera son traitement et appeler output(). Cet exemple montre le traitement synchrone (un élément ira tout au long de la chaîne avant que les appels de fonctions ne retournent) mais vous pouvez également demander à la méthode .input() de placer l'élément dans une file d'attente pour traitement, puis de revenir immédiatement; De cette façon, vous pourriez faire en sorte que les machines fonctionnent en parallèle.

Avec ce système, les connexions entre les machines sont explicites, et chaque machine connaît seulement celle qui la suit (celle-ci a besoin de pour en savoir plus).

J'utilise le mot «threading» pour décrire le processus de liaison entre des objets comme celui-ci. Un élément en cours de traitement suit le fil d'une machine à l'autre avant d'arriver à la sortie. C'est un peu ambigu car il n'a rien à voir avec les threads d'exécution, ce terme n'est donc pas parfait.

Answer 3

Ceci est un exemple idiot que je cuisinais là où vous mettez des données dans la première machine qui se déplace au premier tampon qui se déplace à la deuxième machine ...

Chaque machine balises juste la données avec son numéro d'identification et passe le long, mais vous pouvez faire les machines à faire quelque chose. Vous pouvez même enregistrer une fonction à appeler sur chaque machine lorsqu'elle reçoit des données.

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) 

EDIT

buffers sont maintenant des machines aussi.