pickle — Sérialisation d’objet Python

Le module pickle est utilisé pour implémenter des protocoles binaires pour la sérialisation et la désérialisation d’une structure d’objet Python.

  • Pickling : C’est un processus où une hiérarchie d’objets Python est convertie en un flux d’octets.
  • Unpickling: C’est l’inverse du processus de Pickling où un flux d’octets est converti en une hiérarchie d’objets.

Interface des modules :

  • dumps() – Cette fonction est appelée pour sérialiser une hiérarchie d’objets.
  • load() – Cette fonction est appelée pour désérialiser un flux de données.

Constantes fournies par le module pickle :

  1. cornichon.HIGHEST_PROTOCOL
    Il s’agit d’une valeur entière représentant la version de protocole la plus élevée disponible. Ceci est considéré comme la valeur de protocole qui est passée aux fonctions dump(), dumps().
  2. cornichon.DEFAULT_PROTOCOL
    Il s’agit d’une valeur entière représentant le protocole par défaut utilisé pour le décapage dont la valeur peut être inférieure à la valeur du protocole le plus élevé.

Fonctions fournies par le module pickle :

  1. pickle.dump(obj, fichier, protocole = Aucun, *, fix_imports = True)
    Cette fonction est équivalente à Pickler(file, protocol).dump(obj). Ceci est utilisé pour écrire une représentation picklée de obj dans le fichier objet ouvert.
    L’argument de protocole facultatif est un entier qui indique au pickler d’utiliser le protocole donné. Les protocoles pris en charge vont de 0 à HIGHEST_PROTOCOL. S’il n’est pas spécifié, la valeur par défaut est DEFAULT_PROTOCOL. Si un nombre négatif est spécifié, HIGHEST_PROTOCOL est sélectionné.
    Si fix_imports est vrai et que le protocole est inférieur à 3, le pickle essaiera de mapper les nouveaux noms Python 3 aux anciens noms de module utilisés dans Python 2, afin que le flux de données pickle soit lisible avec Python 2.
    Exemple :

Python3

import pickle

import io

class SimpleObject(object):

    def __init__(self, name):

        self.name = name

        l = list(name)

        l.reverse()

        self.name_backwards = ''.join(l)

        return

data = []

data.append(SimpleObject('pickle'))

data.append(SimpleObject('cPickle'))

data.append(SimpleObject('last'))

out_s = io.StringIO()

for o in data:

    print ('WRITING: %s (%s)' % (o.name, o.name_backwards))

    pickle.dump(o, out_s)

    out_s.flush()

  1. Production :
WRITING: pickle (elkcip)
WRITING: cPickle (elkciPc)
WRITING: last (tsal)
  1. pickle.dumps(obj, protocol = None, *, fix_imports = True)
    Cette fonction renvoie la représentation picklée de l’objet sous la forme d’un objet bytes.
    Exemple :

Python3

import pickle

data = [ { 'a':'A', 'b':2, 'c':3.0 } ]

data_string = pickle.dumps(data)

print ('PICKLE:', data_string )

  1. Production :
PICKLE: (lp0
(dp1
S'a'
p2
S'A'
p3
sS'c'
p4
F3.0
sS'b'
p5
I2
sa.
  1. pickle.load(file, *, fix_imports = True, encoding = “ASCII”, errors = “strict”)
    Cette fonction est équivalente à Unpickler(file).load(). Cette fonction est utilisée pour lire une représentation d’objet décapée à partir du fichier objet fichier ouvert et renvoyer la hiérarchie d’objets reconstituée spécifiée.
    Exemple :

Python3

import pickle

import io

class SimpleObject(object):

    def __init__(self, name):

        self.name = name

        l = list(name)

        l.reverse()

        self.name_backwards = ''.join(l)

        return

data = []

data.append(SimpleObject('pickle'))

data.append(SimpleObject('cPickle'))

data.append(SimpleObject('last'))

out_s = io.StringIO()

for o in data:

    print ('WRITING: %s (%s)' % (o.name, o.name_backwards))

    pickle.dump(o, out_s)

    out_s.flush()

    

    

in_s = io.StringIO(out_s.getvalue())

while True:

    try:

        o = pickle.load(in_s)

    except EOFError:

        break

    else:

        print ('READ: %s (%s)' % (o.name, o.name_backwards))

  1. Production :
WRITING: pickle (elkcip)
WRITING: cPickle (elkciPc)
WRITING: last (tsal)
READ: pickle (elkcip)
READ: cPickle (elkciPc)
READ: last (tsal)
  1. pickle.loads(bytes_object, *, fix_imports = True, encoding = “ASCII”, errors = “strict”)
    Cette fonction est utilisée pour lire une représentation d’objet picklée à partir d’un objet bytes et retourner la hiérarchie d’objets reconstituée spécifiée.
    Exemple :

Python3

import pickle

import pprint

data1 = [ { 'a':'A', 'b':2, 'c':3.0 } ]

print ('BEFORE:',)

pprint.pprint(data1)

data1_string = pickle.dumps(data1)

data2 = pickle.loads(data1_string)

print ('AFTER:',)

pprint.pprint(data2)

print ('SAME?:', (data1 is data2))

print ('EQUAL?:', (data1 == data2))

  1. Production :
BEFORE:[{'a': 'A', 'b': 2, 'c': 3.0}]
AFTER:[{'a': 'A', 'b': 2, 'c': 3.0}]
SAME?: False
EQUAL?: True

Exceptions fournies par le module pickle :

  1. exception pickle.PickleError
    Cette exception hérite de Exception. C’est la classe de base pour toutes les autres exceptions soulevées dans le décapage.
  2. exception pickle.PicklingError
    Cette exception hérite de PickleError. Cette exception est déclenchée lorsqu’un objet non picklable est rencontré par Pickler.
  3. exception pickle.UnpicklingError
    Cette exception hérite de PickleError. Cette exception est levée lorsqu’il y a un problème comme la corruption de données ou une violation de sécurité lors du décrochage d’un objet.

Classes exportées par le module pickle :

  1. classe pickle.Pickler(fichier, protocole = Aucun, *, fix_imports = True)
    Cette classe prend un fichier binaire pour écrire un flux de données pickle.
    1. dump(obj) – Cette fonction est utilisée pour écrire une représentation picklée de obj dans l’objet fichier ouvert donné dans le constructeur.
    2. persistant_id(obj) – Si persistent_id() renvoie None, obj est décapé comme d’habitude. Cela ne fait rien par défaut et existe pour que n’importe quelle sous-classe puisse le remplacer.
    3. Dispatch_table – La table de répartition d’un objet pickler est un mappage dont les clés sont des classes et dont les valeurs sont des fonctions de réduction.
      Par défaut, un objet pickler n’aura pas d’attribut dispatch_table et utilisera à la place la table de répartition globale gérée par le module copyreg.
      Exemple : Le code ci-dessous crée une instance de pickle.Pickler avec une table de répartition privée qui gère en particulier la classe SomeClass.
f = io.BytesIO()
p = pickle.Pickler(f)
p.dispatch_table = copyreg.dispatch_table.copy()
p.dispatch_table[SomeClass] = reduce_SomeClass
  1. Vite – Le mode rapide désactive l’utilisation du mémo et accélère le processus de décapage en ne générant pas d’opcodes PUT superflus.
  2. classe pickle.Unpickler(file, *, fix_imports = True, encoding = “ASCII”, errors = “strict”)

    Cette classe prend un fichier binaire pour lire un flux de données pickle.

    1. charger() – Cette fonction est utilisée pour lire une représentation d’objet décapée à partir du fichier objet fichier ouvert et renvoyer la hiérarchie d’objets reconstituée spécifiée.
    2. persistent_load(pid) – Cela déclenche une UnpicklingError par défaut.
    3. find_class(module, nom) – Cette fonction importe le module si nécessaire et en renvoie l’objet nommé name, où les arguments module et name sont des objets str.

Qu’est-ce qui peut être mariné et non mariné?
Les types suivants peuvent être marinés :

  • Aucun, vrai et faux
  • entiers, nombres à virgule flottante, nombres complexes
  • chaînes, octets, tableaux d’octets
  • tuples, listes, ensembles et dictionnaires contenant uniquement des objets sélectionnables
  • fonctions définies au niveau supérieur d’un module (en utilisant def, pas lambda)
  • fonctions intégrées définies au niveau supérieur d’un module
  • classes définies au niveau supérieur d’un module
  • instances de telles classes dont __dict__ ou le résultat de l’appel de __getstate__() est picklable

Instances de classe de décapage :
Cette section explique les mécanismes généraux disponibles pour définir, personnaliser et contrôler la manière dont les instances de classe sont picklées et décochées.
Aucun code supplémentaire n’est nécessaire pour rendre les instances sélectionnables. Par défaut, pickle récupérera la classe et les attributs d’une instance via l’introspection.
Les classes peuvent modifier le comportement par défaut en fournissant une ou plusieurs méthodes spéciales :

  1. objet.__getnewargs_ex__()
    Cette méthode dicte les valeurs transmises à la méthode __new__() lors du décrochage. La méthode doit renvoyer une paire (args, kwargs) où args est un tuple d’arguments positionnels et kwargs un dictionnaire d’arguments nommés pour construire l’objet.
  2. objet.__getnewargs__()
    Cette méthode ne prend en charge que les arguments positifs. Il doit renvoyer un tuple d’arguments args qui sera passé à la méthode __new__() lors du dépicklage.
  3. objet.__getstate__()
    Si cette méthode est définie par des classes, elle est appelée et l’objet renvoyé est pris comme contenu de l’instance, au lieu du contenu du dictionnaire de l’instance.
  4. objet.__setstate__(état)
    Si cette méthode est définie par des classes, elle est appelée avec l’état unpicklé. L’état pickled doit être un dictionnaire et ses éléments sont affectés au dictionnaire de la nouvelle instance.
  5. objet.__reduce__()
    La méthode __reduce__() ne prend aucun argument et doit renvoyer soit une chaîne, soit de préférence un tuple.
  6. objet.__reduce_ex__(protocole)
    Cette méthode est similaire à la méthode __reduce__. Il prend un seul argument entier. L’utilisation principale de cette méthode est de fournir des valeurs de réduction rétrocompatibles pour les anciennes versions de Python.

Exemple : Gestion des objets avec état
Cet exemple montre comment modifier le comportement de pickling pour une classe. La classe TextReader ouvre un fichier texte et renvoie le numéro de ligne et le contenu de la ligne chaque fois que sa méthode readline() est appelée.

  1. Si une instance de TextReader est picklée, tous les attributs à l’exception du membre de l’objet fichier sont enregistrés.
  2. Lorsque l’instance est désélectionnée, le fichier est rouvert et la lecture reprend à partir du dernier emplacement.

Python3

import pickle

class TextReader:

    

 

    def __init__(self, filename):

        self.filename = filename

        self.file = open(filename)

        self.lineno = 0

 

    def readline(self):

        self.lineno + 1

        line = self.file.readline()

        if not line:

            return None

        if line.endswith('\n'):

            line = ligne[:-1]

        return "%i: %s" % (self.lineno, line)

 

    def __getstate__(self):

        

        

        

        state = self.__dict__.copy()

        

        del Etat['file']

        return state

 

    def __setstate__(self, state):

        

        self.__dict__.update(state)

        

        

        file = open(self.filename)

        for _ in range(self.lineno):

            file.readline()

        

        self.file = file

  

reader = TextReader("Geeksforgeeks.txt")

print(reader.readline())

print(reader.readline())

new_reader = pickle.loads(pickle.dumps(reader))

print(new_reader.readline())

Production :

0: hi geeks!, this is line 1.
0: This is line 2.
0: hi geeks!, this is line 1.

Cet article est contribué par Aditi Gupta. Si vous aimez GeeksforGeeks et que vous souhaitez contribuer, vous pouvez également écrire un article en utilisant écrire.geeksforgeeks.org ou envoyez votre article à contribute@geeksforgeeks.org. Voyez votre article apparaître sur la page principale de GeeksforGeeks et aidez les autres Geeks.
Et voici un éditeur pour PickleViewer :
Cliquez ici pour le référentiel Github
Cliquez ici pour télécharger la version 0.7.5
Ou Cliquez ici pour la dernière version
Veuillez écrire des commentaires si vous trouvez quelque chose d’incorrect ou si vous souhaitez partager plus d’informations sur le sujet abordé ci-dessus.

Laisser un commentaire

Votre adresse e-mail ne sera pas publiée. Les champs obligatoires sont indiqués avec *

Aller en haut