Das Entnehmen des Objekts vom Typ X in der Methode __new__ der Klasse X ruft __init__ beim Zurückgeben des nicht gepackten Objekts auf, warum?

Question

Ich habe ein Objekt, das nach der ersten Verwendung zwischengespeichert wird. Ich werde dies mit dem cPickle-Modul tun. Wenn das Modul bereits zwischengespeichert ist, wenn ich versuche, das Objekt das nächste Mal instanziieren (in einem anderen Prozess) möchte ich das zwischengespeicherte Objekt verwenden. meine Grundstruktur folgend:

import cPickle 
class Test(object): 
    def __new__(cls, name): 
     if name == 'john': 
      print "using cached object" 
      with open("cp.p", "rb") as f: 
       obj = cPickle.load(f) 
       print "object unpickled" 
       return obj 
     else: 
      print "using new object" 
      return super(Test, cls).__new__(cls, name) 
    def __init__(self, name): 
     print "calling __init__" 
     self.name = name 
     with open("cp.p", "wb") as f: 
      cPickle.dump(self, f) 

Das Problem ist, dass, wenn ich die im Cache gespeicherte Objekt in der __new__ Methode unpickle den __init__ nennt und neu initialisiert alles. Interessanterweise scheint die __init__ nicht nach dem unpickling aufgerufen zu werden, sondern eher wenn das unpickled Objekt zurückgegeben wird. Ich habe eine print-Anweisung hinzugefügt, die das anzeigt ("object unpickled").

Ich habe eine Hacky Abhilfe durch den folgenden Scheck an die __init__ fügen hinzu:

intiailzed = False 
... 
... 
def __init__(self, name): 
    if not self.intialized: 
     self.initialized = True 
     # Rest of the __init__ here 

Neben ein Klassenattribut initialisiert genannt, aber das ist natürlich nicht ideal.

Jeder Einblick, wie die __init__ Methode unterdrückt werden kann (oder warum es überhaupt aufgerufen wird) würde geschätzt.

Edit: basierend auf Feedback hier ist meine neue vorgeschlagene Lösung:

class Test(object): 
    def __new__(cls, name=None): 
     print "calling __new__" 
     if name == 'john': 
      print "using cached object" 
      with open("cp.p", "rb") as f: 
       obj = cPickle.load(f) 
      print "object unpickled" 
      return obj 
     else: 
      print "using new object" 
      obj = super(Test, cls).__new__(cls, name) 
      obj.initialize(name) 
      return obj 

    def __init__(self, name): 
     pass 

    def initialize(self, name): 
     print "calling __init__" 
     self.name = name 
     with open("cp.p", "wb") as f: 
      cPickle.dump(self, f) 

Answer 1

obj = Test(name) funktioniert wie folgt:

obj = Test.__new__(Test, name) 
if isinstance(obj, Test): 
    obj.__init__(name) 

Da das ungebeizte Objekt aus Test.__new__(Test, name) zurückgegeben wird, ist eine Instanz von Test, seine __init__ Methode wird aufgerufen. Es spielt keine Rolle, ob das Objekt von super(Test, cls).__new__ stammt oder unpickling.

Um Probleme wie diese zu vermeiden, sollten Klassen, die __new__ überschreiben, im Allgemeinen vollständig initialisierte Objekte von __new__ zurückgeben und nicht __init__ definieren. Ihre Unterklassen sollten ebenfalls dieser Regel folgen.