Frage Wie man sich einkocht?


Ich möchte, dass meine Klasse Save- und Load-Funktionen implementiert, die einfach ein Pickel der Klasse sind. Aber anscheinend können Sie "Selbst" nicht in der unten beschriebenen Weise verwenden. Wie kannst du das tun?

self = cPickle.load(f)

cPickle.dump(self,f,2)

44
2018-04-25 20:16


Ursprung


Antworten:


Das ist, was ich getan habe. Aktualisierung der __dict__ bedeutet, dass wir alle neuen Membervariablen, die ich der Klasse hinzufüge, behalten und nur die aktualisieren, die beim letzten Pickle des Objekts vorhanden waren. Es scheint am einfachsten zu sein, während der Code zum Speichern und Laden innerhalb der Klasse selbst beibehalten wird, so dass der aufrufende Code nur eine object.save () ausführt.

def load(self):
    f = open(self.filename, 'rb')
    tmp_dict = cPickle.load(f)
    f.close()          

    self.__dict__.update(tmp_dict) 


def save(self):
    f = open(self.filename, 'wb')
    cPickle.dump(self.__dict__, f, 2)
    f.close()

33
2018-05-16 06:01



Der Dump-Teil sollte so funktionieren, wie Sie es vorgeschlagen haben. Für den Ladeteil können Sie a definieren @ Klassenmethode Das lädt eine Instanz aus einer bestimmten Datei und gibt sie zurück.

@classmethod
def loader(cls,f):
    return cPickle.load(f)

dann würde der Anrufer etwas tun wie:

class_instance = ClassName.loader(f)

16
2018-04-25 20:29



Wenn Sie möchten, dass Ihre Klasse sich selbst von einer gespeicherten Beize aktualisiert, müssen Sie ziemlich viel verwenden __dict__.updateWie du in deiner eigenen Antwort hast. Es ist irgendwie wie eine Katze, die ihren Schwanz jagt, jedoch ... wie Sie die Instanz bitten, sich im Wesentlichen mit dem vorherigen Zustand "zurückzusetzen".

Es gibt eine kleine Verbesserung Ihrer Antwort. Sie können tatsächlich beizen self.

>>> import dill
>>> class Thing(object):
...   def save(self):
...     return dill.dumps(self)
...   def load(self, obj):
...     self.__dict__.update(dill.loads(obj).__dict__)
... 
>>> t = Thing()
>>> t.x = 1
>>> _t = t.save()
>>> t.x = 2
>>> t.x
2
>>> t.load(_t)
>>> t.x
1

ich benutzte loads und dumps Anstatt von load und dump weil ich wollte, dass die Gurke zu einer Schnur speichert. Verwenden load und dump zu einer Datei funktioniert auch. Und eigentlich kann ich es gebrauchen dill eine Klasseninstanz für eine spätere Verwendung in eine Datei einfügen ... selbst wenn die Klasse interaktiv definiert ist. Fortsetzung von oben ...

>>> with open('self.pik', 'w') as f:
...   dill.dump(t, f)
... 
>>> 

dann stoppen und neu starten ...

Python 2.7.10 (default, May 25 2015, 13:16:30) 
[GCC 4.2.1 Compatible Apple LLVM 5.1 (clang-503.0.40)] on darwin
Type "help", "copyright", "credits" or "license" for more information.
>>> import dill
>>> with open('self.pik', 'r') as f:
...   t = dill.load(f)
... 
>>> t.x
1
>>> print dill.source.getsource(t.__class__)
class Thing(object):
  def save(self):
    return dill.dumps(self)
  def load(self, obj):
    self.__dict__.update(dill.loads(obj).__dict__)

>>> 

Ich benutze dill, die hier verfügbar ist: https://github.com/uqfoundation


8
2017-08-04 21:54



Es gibt ein Beispiel dafür, wie eine Instanz gebeizt werden kann hier, in den Dokumenten. (Suchen Sie nach dem Beispiel "TextReader"). Die Idee ist zu definieren __getstate__ und __setstate__ Methoden, mit denen Sie definieren können, welche Daten gebeizt werden müssen und wie diese Daten verwendet werden, um das Objekt erneut zu instanziieren.


2
2018-04-25 20:24



Wie wäre es mit dem Schreiben einer Klasse namens Serializable, die Dump und Load implementiert und Ihre Klasse davon erben lässt?


-2
2018-04-25 21:02