Come ripulisco correttamente un oggetto Python?

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

    # ...

    def __del__(self):
        for file in self.files:
            os.unlink(file)

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

Consiglio di utilizzare la withdichiarazione di Python per la gestione delle risorse che devono essere ripulite. Il problema con l'uso di un'istruzione esplicita close()è che devi preoccuparti che le persone dimentichino di chiamarlo o dimentichino di inserirlo in un finallyblocco per evitare una perdita di risorse quando si verifica un'eccezione.

Per utilizzare l' withistruzione, creare una classe con i seguenti metodi:

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

Nel tuo esempio sopra, useresti

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)

Quindi, quando qualcuno volesse usare la tua classe, farebbe quanto segue:

with Package() as package_obj:
    # use package_obj

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

Potresti anche prendere questo approccio un ulteriore passo avanti. Nell'esempio sopra, qualcuno potrebbe ancora creare un'istanza di Package usando il suo costruttore senza usare la withclausola. Non vuoi che ciò accada. È possibile risolvere questo problema creando una classe PackageResource che definisce i metodi __enter__e __exit__. Quindi, la classe Package sarebbe definita rigorosamente all'interno del __enter__metodo e restituita. In questo modo, il chiamante non potrebbe mai creare un'istanza della classe Package senza usare withun'istruzione:

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()

Lo useresti come segue:

with PackageResource() as package_obj:
    # use package_obj

Il modo standard è usare 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 dovresti tenere presente che questo persisterà tutte le istanze create Packagefino a quando Python non sarà terminato.

Demo usando il codice sopra salvato come 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...

Come appendice alla risposta di Clint , puoi semplificare PackageResourceusando contextlib.contextmanager:

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

In alternativa, sebbene probabilmente non come Pythonic, puoi sovrascrivere 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 semplicemente usare with Package(...) as package.

Per rendere le cose più brevi, dai un nome alla funzione di pulizia closee usa contextlib.closing, nel qual caso puoi usare la Packageclasse non modificata tramite with contextlib.closing(Package(...))o sovrascriverla __new__con la più 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 è ereditato, quindi puoi semplicemente ereditare, ad es

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

Non penso che sia possibile rimuovere i membri di esempio prima che __del__venga chiamato. La mia ipotesi sarebbe che il motivo del tuo particolare AttributeError sia da qualche altra parte (forse rimuovi erroneamente il file selfwhere altrove).

Tuttavia, come hanno sottolineato gli altri, dovresti evitare di usarlo __del__. Il motivo principale di ciò è che le istanze con __del__non verranno raccolte in modo inutile (verranno liberate solo quando il loro conto di conto raggiunge 0). Pertanto, se le istanze sono coinvolte in riferimenti circolari, rimarranno in memoria per tutto il tempo in cui l'applicazione viene eseguita. (Potrei sbagliarmi su tutto questo, però, dovrei leggere di nuovo i documenti gc, ma sono piuttosto sicuro che funzioni così).

Un'alternativa migliore è usare weakref.finalize . Vedi gli esempi in Oggetti finalizzatore e Confronto di finalizzatori con i metodi __del __ () .

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

__del__verrà chiamato anche quando __init__non è stato eseguito correttamente o ha generato un'eccezione.

fonte

Ecco uno scheletro di lavoro minimo:

class SkeletonFixture:

    def __init__(self):
        pass

    def __enter__(self):
        return self

    def __exit__(self, exc_type, exc_value, traceback):
        pass

    def method(self):
        pass


with SkeletonFixture() as fixture:
    fixture.method()

Importante: restituire se stessi

Se sei come me e trascuri la return selfparte (della risposta corretta di Clint Miller ), starai fissando questa assurdità:

Traceback (most recent call last):
  File "tests/simplestpossible.py", line 17, in <module>                                                                                                                                                          
    fixture.method()                                                                                                                                                                                              
AttributeError: 'NoneType' object has no attribute 'method'

Spero che aiuti la prossima persona.

Avvolgi semplicemente il distruttore con un'istruzione try / tranne e non genererà un'eccezione se i tuoi globi sono già eliminati.

modificare

Prova questo:

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

Riempirà l'elenco dei file nella funzione del che è garantita al momento della chiamata. Il proxy weakref serve a impedire a Python o all'utente di eliminare in qualche modo la variabile self.files (se viene eliminata, non influirà sull'elenco dei file originale). In caso contrario, anche se ci sono più riferimenti alla variabile, è possibile rimuovere l'incapsulamento del proxy.

Sembra che il modo idiomatico per farlo sia quello di fornire un close()metodo (o simile) e chiamarlo esplicitamente.