Je me permet de “cornichon objets locaux” si j'utilise une classe dérivée?

La pickle référence les états qui de l'ensemble des objets qui peuvent être traitées est plutôt limitée. En effet, j'ai une fonction qui retourne un dinamically-classe générée, et je l'ai trouvé je ne peux pas pickle instances de cette classe:

>>> import pickle
>>> def f():
...     class A: pass
...     return A
... 
>>> LocalA = f()
>>> la = LocalA()
>>> with open('testing.pickle', 'wb') as f:
...     pickle.dump(la, f, pickle.HIGHEST_PROTOCOL)
... 
Traceback (most recent call last):
  File "<stdin>", line 2, in <module>
AttributeError: Can't pickle local object 'f.<locals>.A'

De tels objets sont trop compliqués pour pickle. Ok. Maintenant, ce qui est magique, c'est que, si j'essaie de pickle un objet similaire, mais d'une classe dérivée, il fonctionne!

>>> class DerivedA(LocalA): pass
... 
>>> da = DerivedA()
>>> with open('testing.pickle', 'wb') as f:
...     pickle.dump(da, f, pickle.HIGHEST_PROTOCOL)
...
>>>

Ce qui se passe ici? Si c'est si facile, pourquoi ne pas pickle utiliser cette solution de contournement à mettre en œuvre un dump méthode qui permet de "objets locaux" pour être nettoyée?

OriginalL'auteur fonini | 2016-05-03

23

Je pense que vous n'avez pas lu la référence que vous citez soigneusement. La référence également stipule clairement que seuls les objets suivants sont pickleable:
- fonctions définies au premier niveau d'un module (à l'aide de def, pas >lambda)
- intégré dans les fonctions définies au premier niveau d'un module
- classes qui sont définies au haut niveau d'un module
Votre exemple
```
>>> def f():
...     class A: pass
...     return A
```
ne permet pas de définir une classe à haut niveau d'un module, il définit une classe au sein de l' portée de f(). pickle fonctionne sur mondiale classes, pas de classes locales. Automatiquement à l'échec de la pickleable test.

DerivedA est une classe globale, donc tout va bien.

Comme pour pourquoi seul le haut-niveau (mondial) des classes et des fonctions ne peuvent pas être traitées, la référence répond à la question ainsi que le gras de la mine):

Notez que les fonctions (construit et défini par l'utilisateur) sont décapés par “pleinement qualifié de” nom de la référence, et non par valeur. Cela signifie que seul le nom de la fonction est marinés, ainsi que le nom du module de la fonction est définie. Ni le code de fonction, ni aucun de ses attributs des fonctions sont marinés. Ainsi, le module de définition doit être importables dans la unpickling de l'environnement, et le module doit contenir le nom de l'objet, sinon une exception sera levée.

De même, les classes sont marinés avec le nom de référence, de sorte que les mêmes restrictions dans le unpickling de l'environnement s'appliquent.

Donc là vous l'avez. pickle seulement serialises objets par référence de nom, pas par les premières instructions contenues dans l'objet. C'est parce que pickle's travail est de serialise objet de la hiérarchie, et rien d'autre.

Ok, seul le nom de la classe est décapé. Je pensais que la classe itselft a été enregistré (en quelque sorte), et puis cela impliquerait de sauver sa classe de base, ce qui n'est pas pickleable.
Par ailleurs, si je unpickle dans un environnement dans lequel il ya une autre catégorie, mais avec le même nom, je vais obtenir quelques frankstein monstre objet du présent sans rapport avec la classe, mais avec les attributs de la vieille classe? Je pense que ça se résume à: marinés objets ne sont pas aussi autonomes que je pensais qu'ils étaient.
Aussi à partir de la référence: "... lorsque les instances de classe sont décapés, leur code et les données ne sont pas marinés avec eux. Seules les données d'instance sont décapés. "Donc, oui, qui sonne comme le droit de comportement. 🙂
Je suis entièrement d'enjamba.

OriginalL'auteur Akshat Mahajan
13

Je suis en désaccord, vous pouvez cornichon à la fois. Vous avez juste besoin d'utiliser un meilleur sérialiseur, comme dill. dill (par défaut) cornichons classes par la sauvegarde de la définition de la classe au lieu de décapage par référence, de sorte qu'il ne s'agit pas de votre premier cas. Vous pouvez même utiliser dill d'obtenir le code source, si vous le souhaitez.
```
>>> import dill as pickle
>>> def f():
...   class A: pass
...   return A
... 
>>> localA = f()
>>> la = localA()
>>> 
>>> _la = pickle.dumps(la)
>>> la_ = pickle.loads(_la)
>>>    
>>> class DerivedA(localA): pass
... 
>>> da = DerivedA()
>>> _da = pickle.dumps(da)
>>> da_ = pickle.loads(_da)
>>> 
>>> print(pickle.source.getsource(la_.__class__))
  class A: pass

>>> 
```
J'ai misé sur le fait d'avoir des choses différentes en bref, pas forcément mieux? ou est l'aneth aussi de mieux en termes de vitesse et de la taille de l'objet stocké? mais merci pour la référence!
dill n'est pas plus rapide, et aussi pas de mieux en termes de taille de l'objet stocké. En effet, c'est pire que pickle dans ces deux domaines. Il est de loin meilleur, en termes de capacité de sérialiser les différents types d'objets, et c'est ce que je voulais dire.

OriginalL'auteur Mike McKerns
2

DerivedA instances sont pickleable parce que DerivedA est disponible via une variable globale correspondant à son nom pleinement qualifié, qui est de savoir comment pickle regarde pour les classes lors de la unpickling.

Le problème avec le fait d'essayer de faire quelque chose comme ça avec les classes locales est qu'il n'y a rien d'identification qui A classe une instance correspond à. Si vous exécutez f deux fois, vous obtenez deux A classes, et il n'y a aucun moyen de dire ce qui doit être la classe de unpickled A des instances à partir d'une autre exécution du programme. Si vous ne courez pas f à tous, vous obtenez pas A classes, et puis que diable faites-vous à propos du type de unpickled instances?

OriginalL'auteur user2357112
1

Vous ne pouvez pickle des instances de classes définies au module de haut niveau.

Cependant, vous pouvez pickle instances définies localement des classes si vous les promouvoir à plus haut niveau.

Vous devez définir la __ qualname__ de l'attribut de classe de la classe locale. Ensuite, vous devez attribuer la classe à un haut-niveau de la variable du même nom.
```
def define_class(name):
    class local_class:
        pass
    local_class.__qualname__ = name
    return local_class

class_A = define_class('class_A') # picklable
class_B = define_class('class_B') # picklable
class_X = define_class('class_Y') # unpicklable, names don't match
```
OriginalL'auteur haael

Vous devez vous connecter pour publier un commentaire.