Python Language
Serialización de datos de salmuera

Sintaxis

• pickle.dump (objeto, archivo, protocolo) # Para serializar un objeto

• pickle.load (archivo) # Para des-serializar un objeto

• pickle.dumps (objeto, protocolo) # Para serializar un objeto a bytes

• pickle.loads (buffer) # Para eliminar un serial de un objeto de bytes

Parámetros

Observaciones

Usando Pickle para serializar y deserializar un objeto

El módulo pickle implementa un algoritmo para convertir un objeto Python arbitrario en una serie de bytes. Este proceso también se llama serializar el objeto. El flujo de bytes que representa el objeto se puede transmitir o almacenar, y luego reconstruir para crear un nuevo objeto con las mismas características.

Para el código más simple, usamos las funciones dump() y load() .

Para serializar el objeto.

import pickle

# An arbitrary collection of objects supported by pickle.
data = {
    'a': [1, 2.0, 3, 4+6j],
    'b': ("character string", b"byte string"),
    'c': {None, True, False}
}

with open('data.pickle', 'wb') as f:
    # Pickle the 'data' dictionary using the highest protocol available.
    pickle.dump(data, f, pickle.HIGHEST_PROTOCOL)

Deserializar el objeto.

import pickle

with open('data.pickle', 'rb') as f:
    # The protocol version used is detected automatically, so we do not
    # have to specify it.
    data = pickle.load(f)

Usando objetos de pickle y byte

También es posible serializar y deserializar objetos de byte, utilizando la función de dumps y loads , que son equivalentes a dump y load .

serialized_data = pickle.dumps(data, pickle.HIGHEST_PROTOCOL)
# type(serialized_data) is bytes

deserialized_data = pickle.loads(serialized_data)
# deserialized_data == data

Personalizar datos en escabeche

Algunos datos no pueden ser decapados. Otros datos no deben ser decapados por otras razones.

Lo que será decapado se puede definir en el método __getstate__ . Este método debe devolver algo que sea pickable.

En el lado opuesto está __setstate__ : recibirá lo que __getstate__ creó y tiene que inicializar el objeto.

class A(object):
    def __init__(self, important_data):
        self.important_data = important_data
        
        # Add data which cannot be pickled:
        self.func = lambda: 7
        
        # Add data which should never be pickled, because it expires quickly:
        self.is_up_to_date = False
    
    def __getstate__(self):
        return [self.important_data] # only this is needed
    
    def __setstate__(self, state):
        self.important_data = state[0]
        
        self.func = lambda: 7  # just some hard-coded unpicklable function
        
        self.is_up_to_date = False  # even if it was before pickling

Ahora, esto se puede hacer:

>>> a1 = A('very important')
>>>
>>> s = pickle.dumps(a1)  # calls a1.__getstate__()
>>>
>>> a2 = pickle.loads(s)  # calls a1.__setstate__(['very important'])
>>> a2
<__main__.A object at 0x0000000002742470>
>>> a2.important_data
'very important'
>>> a2.func()
7

La implementación aquí muestra una lista con un valor: [self.important_data] . Eso fue solo un ejemplo, __getstate__ podría haber devuelto cualquier cosa que se pueda recoger, siempre y cuando __setstate__ sepa cómo hacer el oppoisite. Una buena alternativa es un diccionario de todos los valores: {'important_data': self.important_data} .

¡El constructor no se llama! Tenga en cuenta que en el ejemplo anterior, la instancia a2 se creó en pickle.loads sin haber llamado a A.__init__ , por lo que A.__setstate__ tuvo que inicializar todo lo que __init__ se habría inicializado si se hubiera llamado.