Comment pickle vous-même?

Je veux ma classe pour mettre en œuvre Enregistrer et Charger des fonctions qui, tout simplement, faire un cornichon de la classe. Mais apparemment, vous ne pouvez pas utiliser un 'soi' dans le mode ci-dessous. Comment pouvez-vous faire cela?

self = cPickle.load(f)

cPickle.dump(self,f,2)

Je pourrais pickle la dict, mais je serais incapable de modifier ultérieurement la classe.
excellent titre, +1 ed

InformationsquelleAutor | 2010-04-25

pickle python

41

C'est ce que j'ai fait. La mise à jour de la __dict__ signifie que nous garder de tout nouveau membre variables-je ajouter de la classe et de simplement mettre à jour ceux qui étaient là lors de la dernière pickle avais. Il semble que le plus simple, tout en maintenant la sauvegarde et le chargement de code à l'intérieur de la classe elle-même afin de l'appelant code ne fonctionne tout simplement un objet.save().
```
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()
```
- Un mineur PEP8 pinaille - les fonctions doivent être nomméeload et save en minuscules python.org/dev/peps/pep-0008/#function-names
- Je dirais que les grands...
- C'est un merge. Vous devriez appeler self.__dict__.clear() avant d'appeler self.__dict__.update(..)
InformationsquelleAutor
20

Le dump partie devrait fonctionner comme vous l'avez suggéré. pour le chargement de la partie, vous pouvez définir un @classmethod qui charge une instance à partir d'un fichier donné et le renvoie.
```
@classmethod
def loader(cls,f):
    return cPickle.load(f)
```
ensuite, l'appelant aurait faire quelque chose comme:
```
class_instance = ClassName.loader(f)
```
- Donc, ce que vous dites est avec la classe Foo, instance foo je peux faire foo.Save() mais je ne peux pas faire foo.Load (), j'aurais à faire foo = foo.Load() -- (les méthodes de la classe peut être appelée avec une instance ou un nom de classe)
- Il est parfaitement logique que vous devez utiliser foo=Foo.load(), et non pas foo=Foo();foo.load(). par exemple, si Toto a certaines des variables qui DOIVENT être transmis à l'init, vous auriez besoin de faire pour le foo=Foo(); ou si l'initialisation n'certains gros calculs des variables stockées dans l'exemple, il serait pour rien.
- Cela fonctionne, à l'origine, j'avais foo = Foo('somefilename') Et Foo était en train de faire son propre chargement de ses données. Maintenant, je fais un: foo = Foo.Load('somefilename') Si je modifie la définition de Toto, je peux toujours utiliser les nouvelles fonctions de membres/dans la saumure chargé foo instance.
InformationsquelleAutor Ofri Raviv

Si vous voulez avoir votre classe de mise à jour de lui-même à partir d'un sauvés cornichon... vous devez utiliser __dict__.update, comme vous l'avez dans votre propre réponse. C'est un peu comme un chat chassant sa queue, mais... comme vous le demander à l'instance de l'essentiel "reset" avec l'état antérieur.

Il y a un petit tweak pour votre réponse. Vous pouvez réellement pickle 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

J'ai utilisé loads et dumps au lieu de load et dump parce que je voulais le cornichon pour enregistrer une chaîne. À l'aide de load et dump à un fichier fonctionne également.
Et, effectivement, je peux utiliser dill à pickle une instance de classe dans un fichier, pour les utiliser plus tard... même si la classe est définie de manière interactive. Continuant à partir de ci-dessus...

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

puis arrêt et redémarrage...

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

>>>

Je suis en utilisant dill, qui est disponible ici: https://github.com/uqfoundation

InformationsquelleAutor Mike McKerns

2

Il est un exemple de la façon de pickle une instance ici, dans les docs. (Recherche vers le bas pour le "TextReader" par exemple). L'idée est de définir __getstate__ et __setstate__ méthodes qui vous permettent de définir quelles données doivent être traitées, et comment utiliser ces données pour ré-instancier l'objet.
- Cela ne résout pas le problème, car vous ne parvenez toujours pas à l'intérieur de la classe de la fonction de Charge de l'appel self = cPickle.charge(f) afin de combler la classe avec les données chargées. Ou je peux les achards de données de la classe elle-même, mais je vais essayer d'éviter d'écrire tout ce code et d'être forcé de le mettre à jour lorsque le membre de la classe des variables de changement.
InformationsquelleAutor unutbu
-3

Comment sur l'écriture d'une classe Sérialisable la mise en œuvre de décharge et de charge et faire de votre classe hérite d'elle?

InformationsquelleAutor Alex K

Vous devez vous connecter pour publier un commentaire.