Come ripulire correttamente un oggetto Python?

Question

__del__(self) non riesce con un'eccezione AttributeError. Capisco Python doesn't guarantee l'esistenza di "variabili globali" (dati dei membri in questo contesto?) Quando viene invocato il numero __del__(). Se questo è il caso e questo è il motivo dell'eccezione, come posso assicurarmi che l'oggetto si distrugga correttamente?

Answer 1

Si consiglia di utilizzare la dichiarazione with di Python per la gestione delle risorse che devono essere ripulite. Il problema con l'utilizzo di un'esplicita dichiarazione close() è che devi preoccuparti che le persone si dimentichino di chiamarlo o dimenticare di inserirlo in un blocco finally per impedire una perdita di risorse quando si verifica un'eccezione.

utilizzare l'istruzione with, creare una classe con i seguenti metodi:

def __enter__(self) 
    def __exit__(self, exc_type, exc_value, traceback) 

Nel tuo esempio sopra, utilizza

class Package: 
    def __init__(self): 
     self.files = [] 

    def __enter__(self): 
     return self 

    # ... 

    def __exit__(self, exc_type, exc_value, traceback): 
     for file in self.files: 
      os.unlink(file) 

Poi, quando qualcuno ha voluto usare la tua classe , farebbero quanto segue:

with Package() as package_obj: 
    # use package_obj 

La variabile package_obj sarà un istanza di tipo Pacchetto (è il valore restituito dal metodo __enter__). Il suo metodo __exit__ verrà chiamato automaticamente, indipendentemente dal fatto che si verifichi o meno un'eccezione.

Si potrebbe anche prendere questo approccio un ulteriore passo avanti. Nell'esempio sopra, qualcuno potrebbe ancora istanziare Package usando il suo costruttore senza usare la clausola with. Non vuoi che ciò accada. È possibile risolvere questo problema creando una classe PackageResource che definisce i metodi __enter__ e __exit__. Quindi, la classe Package verrà definita rigorosamente all'interno del metodo __enter__ e restituita.In questo modo, il chiamante non potrebbe creare un'istanza della classe pacchetto senza utilizzare un with dichiarazione:

class PackageResource: 
    def __enter__(self): 
     class Package: 
      ... 
     self.package_obj = Package() 
     return self.package_obj 

    def __exit__(self, exc_type, exc_value, traceback): 
     self.package_obj.cleanup() 

devi usare questo come segue:

with PackageResource() as package_obj: 
    # use package_obj 

Answer 2

Basta avvolgere il distruttore con un'istruzione try/except e non genererà un'eccezione se i globals sono già eliminati.

Modifica

Prova questa:

from weakref import proxy 

class MyList(list): pass 

class Package: 
    def __init__(self): 
     self.__del__.im_func.files = MyList([1,2,3,4]) 
     self.files = proxy(self.__del__.im_func.files) 

    def __del__(self): 
     print self.__del__.im_func.files 

Sarà roba l'elenco dei file nella del funzionamento che è garantito per esistere al momento della chiamata. Il proxy weakref è di impedire a Python, o se stessi, di eliminare in qualche modo la variabile self.files (se viene cancellata, quindi non avrà effetto sull'elenco dei file originale). Se non è il caso in cui questo viene eliminato anche se ci sono più riferimenti alla variabile, è possibile rimuovere l'incapsulamento del proxy.

Answer 3

Sembra che il modo idiomatico per fare ciò sia fornire un metodo close() (o simile) e chiamarlo esplicitamente.

Answer 4

Non credo che sia possibile per i membri di istanza da rimuovere prima che venga chiamato __del__. La mia ipotesi sarebbe che la ragione del tuo particolare AttributeError è da qualche altra parte (forse rimuovi per errore self.file altrove).

Tuttavia, come hanno sottolineato gli altri, evitare di utilizzare __del__. La ragione principale di ciò è che le istanze con __del__ non verranno raccolte automaticamente (verranno liberate solo quando il loro account raggiunge 0). Pertanto, se le tue istanze sono coinvolte in riferimenti circolari, vivranno in memoria fino a quando l'applicazione verrà eseguita. (Potrei sbagliarmi su tutto questo però, dovrei leggere di nuovo i documenti gc, ma sono piuttosto sicuro che funzioni così).

Answer 5

Penso che il problema potrebbe essere in __init__ se c'è più codice di quello mostrato?

__del__ verrà chiamato anche se __init__ non è stato eseguito correttamente o ha generato un'eccezione.

Source

Answer 6

Come appendice a Clint's answer, è possibile semplificare PackageResource utilizzando contextlib.contextmanager:

@contextlib.contextmanager 
def packageResource(): 
    class Package: 
     ... 
    package = Package() 
    yield package 
    package.cleanup() 

In alternativa, anche se probabilmente non come Pythonic, è possibile ignorare Package.__new__:

class Package(object): 
    def __new__(cls, *args, **kwargs): 
     @contextlib.contextmanager 
     def packageResource(): 
      # adapt arguments if superclass takes some! 
      package = super(Package, cls).__new__(cls) 
      package.__init__(*args, **kwargs) 
      yield package 
      package.cleanup() 

    def __init__(self, *args, **kwargs): 
     ... 

e utilizzare semplicemente with Package(...) as package.

per ottenere le cose più breve, denominare la funzione di pulizia close e utilizzare contextlib.closing, nel qual caso è possibile utilizzare la non modificato Package classe tramite with contextlib.closing(Package(...)) o ignorare la sua __new__ al semplice

class Package(object): 
    def __new__(cls, *args, **kwargs): 
     package = super(Package, cls).__new__(cls) 
     package.__init__(*args, **kwargs) 
     return contextlib.closing(package) 

E questo costruttore viene ereditato , quindi puoi semplicemente ereditare, ad es

class SubPackage(Package): 
    def close(self): 
     pass 

Answer 7

Il metodo standard è quello di utilizzare atexit.register:

# package.py 
import atexit 
import os 

class Package: 
    def __init__(self): 
     self.files = [] 
     atexit.register(self.cleanup) 

    def cleanup(self): 
     print("Running cleanup...") 
     for file in self.files: 
      print("Unlinking file: {}".format(file)) 
      # os.unlink(file) 

Ma si dovrebbe tenere a mente che questo persisterà tutte le istanze create su Package fino Python è terminato.

Demo utilizzando il codice di cui sopra salvato package.py:

$ python 
>>> from package import * 
>>> p = Package() 
>>> q = Package() 
>>> q.files = ['a', 'b', 'c'] 
>>> quit() 
Running cleanup... 
Unlinking file: a 
Unlinking file: b 
Unlinking file: c 
Running cleanup... 

Answer 8

Una migliore alternativa è quella di utilizzare weakref.finalize. Vedere gli esempi allo Finalizer Objects e allo Comparing finalizers with __del__() methods.