Condividi un singoletto attraverso moduli

Question

Dati due moduli, principali e x con il seguente contenuto:

principale:

class Singleton(object): 
    _instance = None 
    def __new__(cls, *args, **kwargs): 
     if not cls._instance: 
      cls._instance = super(Singleton, cls).__new__(cls, *args, **kwargs) 
     cls._instance.x = 10 
     return cls._instance 
uvw = Singleton() 

if __name__ == "__main__": 
    print(id(uvw)) 
    uvw.x += 10 
    print(uvw.x) 
    import x 

e X, rispettivamente:

import main 

print(id(main.uvw)) 
print(main.uvw.x) 

vorrei ora aspettare che l'esecuzione principale restituirebbe gli stessi ID e il valore venti in entrambi i casi, ma ciò che ottengo è questo:

$ python main.py 
140592861777168 
20 
140592861207504 
10 

C'è un modo per garantire che lo uvw sia lo stesso oggetto in entrambi i posti?

Answer 1

Python carica ciascun modulo per nome una volta (a meno che non venga chiamato reload(module)). Se si esegue main.py, il modulo è __main__ (provare a stampare uvw.__class__.__module__). Quandoimporta main, il modulo chiamato main viene caricato per la prima volta.

Se definito uvw in un terzo modulo, o in x - fintanto che viene importato nello stesso modo in __main__ e x - sarebbe lo stesso oggetto.

Answer 2

Il problema è che la tua classe Singleton viene in qualche modo ricaricata e quindi perde il suo campo _instance nel secondo modulo.

---

Penso che questo funzionerà:

singleton.py:

class Singleton(object): 
    _instance = None 
    def __new__(cls, *args, **kwargs): 
     if not cls._instance: 
      cls._instance = super(Singleton, cls).__new__(cls, *args, **kwargs) 
     cls._instance.x = 10 
     return cls._instance 

a.py:

from singleton import Singleton 
uvw = Singleton() 
print(id(uvw)) 
uvw.x += 10 
print(uvw.x) 

b.py:

from singleton import Singleton 
uvw = Singleton() 
print(id(uvw)) 
uvw.x += 10 
print(uvw.x) 

main.py

import a 
import b 

Answer 3

ho scoperto che il problema è che main viene caricato due volte quando è eseguito dalla riga di comando, una volta come __main__ e la seconda volta importati da x come main.

ho trovato un hack molto male per aggirare il secondo carico:

sys.modules["main"] = sys.modules["__main__"] 

Separare il modulo principale e la classe Singleton non è favorevole nel mio caso.