El módulo pickle se usa para implementar protocolos binarios para serializar y deserializar una estructura de objeto de Python.
- Decapado: es un proceso en el que una jerarquía de objetos de Python se convierte en un flujo de bytes.
- Decapado: es el proceso inverso al decapado en el que un flujo de bytes se convierte en una jerarquía de objetos.
Interfaz del módulo:
- dumps(): esta función se llama para serializar una jerarquía de objetos.
- loads(): esta función se llama para deserializar un flujo de datos.
Constantes proporcionadas por el módulo pickle:
- pickle.HIGHEST_PROTOCOL
Este es un valor entero que representa la versión de protocolo más alta disponible. Esto se considera como el valor del protocolo que se pasa a las funciones dump(), dumps().
- pickle.DEFAULT_PROTOCOL
Este es un valor entero que representa el protocolo predeterminado utilizado para el decapado cuyo valor puede ser menor que el valor del protocolo más alto.
Funciones proporcionadas por el módulo pickle:
- pickle.dump(obj, archivo, protocolo = Ninguno, *, fix_imports = True)
Esta función es equivalente a Pickler(archivo, protocolo).dump(obj). Esto se usa para escribir una representación encurtida de obj en el archivo de objeto de archivo abierto.
El argumento del protocolo opcional es un número entero que le dice al pickler que use el protocolo dado. Los protocolos admitidos son 0 a HIGHEST_PROTOCOL. Si no se especifica, el valor predeterminado es DEFAULT_PROTOCOL. Si se especifica un número negativo, se selecciona HIGHEST_PROTOCOL.
Si fix_imports es verdadero y el protocolo es inferior a 3, pickle intentará asignar los nuevos nombres de Python 3 a los nombres de módulos antiguos utilizados en Python 2, de modo que el flujo de datos de pickle se pueda leer con Python 2.
Ejemplo:
Python3
# Python program to illustrate
# pickle.dump()
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'))
# Simulate a file with StringIO
out_s = io.StringIO()
# Write to the stream
for o in data:
print ('WRITING: %s (%s)' % (o.name, o.name_backwards))
pickle.dump(o, out_s)
out_s.flush()
- Producción :
WRITING: pickle (elkcip) WRITING: cPickle (elkciPc) WRITING: last (tsal)
- pickle.dumps(obj, protocol = None, *, fix_imports = True)
Esta función devuelve la representación encurtida del objeto como un objeto de bytes.
Ejemplo :
Python3
# Python program to illustrate
#Picle.dumps()
import pickle
data = [ { 'a':'A', 'b':2, 'c':3.0 } ]
data_string = pickle.dumps(data)
print ('PICKLE:', data_string )
- Producción :
PICKLE: (lp0 (dp1 S'a' p2 S'A' p3 sS'c' p4 F3.0 sS'b' p5 I2 sa.
- pickle.load(archivo, *, fix_imports = True, codificación = “ASCII”, errores = “estricto”)
Esta función es equivalente a Unpickler(archivo).load(). Esta función se utiliza para leer una representación de objeto decapado del archivo de objeto de archivo abierto y devolver la jerarquía de objeto reconstituida especificada.
Ejemplo :
Python3
# Python program to illustrate
# pickle.load()
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'))
# Simulate a file with StringIO
out_s = io.StringIO()
# Write to the stream
for o in data:
print ('WRITING: %s (%s)' % (o.name, o.name_backwards))
pickle.dump(o, out_s)
out_s.flush()
# Set up a read-able stream
in_s = io.StringIO(out_s.getvalue())
# Read the data
while True:
try:
o = pickle.load(in_s)
except EOFError:
break
else:
print ('READ: %s (%s)' % (o.name, o.name_backwards))
- Producción :
WRITING: pickle (elkcip) WRITING: cPickle (elkciPc) WRITING: last (tsal) READ: pickle (elkcip) READ: cPickle (elkciPc) READ: last (tsal)
- pickle.loads(bytes_object, *, fix_imports = True, codificación = “ASCII”, errores = “estricto”)
Esta función se utiliza para leer una representación de objeto decapado de un objeto de bytes y devolver la jerarquía de objetos reconstituida especificada.
Ejemplo :
Python3
# Python program to illustrate
# pickle.loads()
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))
- Producción :
BEFORE:[{'a': 'A', 'b': 2, 'c': 3.0}]
AFTER:[{'a': 'A', 'b': 2, 'c': 3.0}]
SAME?: False
EQUAL?: True
Excepciones proporcionadas por el módulo pickle:
- excepción pickle.PickleError
Esta excepción hereda Exception. Es la clase base para todas las demás excepciones planteadas en el decapado.
- excepción pickle.PicklingError
Esta excepción hereda PickleError. Esta excepción se genera cuando Pickler encuentra un objeto no seleccionable.
- excepción pickle.UnpicklingError
Esta excepción hereda PickleError. Esta excepción se genera cuando hay un problema como la corrupción de datos o una violación de seguridad mientras se desempaca un objeto.
Clases exportadas por el módulo pickle:
- class pickle.Pickler(file, protocol = None, *, fix_imports = True)
Esta clase toma un archivo binario para escribir un flujo de datos pickle.- dump (obj): esta función se usa para escribir una representación encurtida de obj en el objeto de archivo abierto proporcionado en el constructor.
- id_persistente(obj): si id_persistente() devuelve Ninguno, obj se decapa como de costumbre. Esto no hace nada por defecto y existe para que cualquier subclase pueda anularlo.
- Dispatch_table: la tabla de despacho de un objeto pickler es una asignación cuyas claves son clases y cuyos valores son funciones de reducción.
De forma predeterminada, un objeto pickler no tendrá un atributo dispatch_table y, en su lugar, utilizará la tabla de envío global administrada por el módulo copyreg.
Ejemplo: el siguiente código crea una instancia de pickle.Pickler con una tabla de despacho privada que maneja especialmente la clase SomeClass.
f = io.BytesIO() p = pickle.Pickler(f) p.dispatch_table = copyreg.dispatch_table.copy() p.dispatch_table[SomeClass] = reduce_SomeClass
- Rápido: el modo rápido desactiva el uso de memo y acelera el proceso de decapado al no generar códigos de operación PUT superfluos.
- class pickle.Unpickler(file, *, fix_imports = True, codificación = “ASCII”, errores = “estricto”)
Esta clase toma un archivo binario para leer un flujo de datos de pickle.
- load(): esta función se usa para leer una representación de objeto encurtida del archivo de objeto de archivo abierto y devolver la jerarquía de objeto reconstituida especificada.
- persistente_load (pid): esto genera un UnpicklingError de forma predeterminada.
- find_class (módulo, nombre): esta función importa el módulo si es necesario y devuelve el objeto llamado nombre, donde los argumentos del módulo y el nombre son objetos str.
¿Qué se puede decapar y decapar?
Se pueden encurtir los siguientes tipos:
- Ninguno, Verdadero y Falso
- enteros, números de coma flotante, números complejos
- strings, bytes, rayos de bytes
- tuplas, listas, conjuntos y diccionarios que contienen solo objetos seleccionables
- funciones definidas en el nivel superior de un módulo (usando def, no lambda)
- funciones integradas definidas en el nivel superior de un módulo
- clases que se definen en el nivel superior de un módulo
- instancias de tales clases cuyo __dict__ o el resultado de llamar a __getstate__() es seleccionable
Decapado de instancias de clase:
esta sección explica los mecanismos generales disponibles para definir, personalizar y controlar cómo se decapan y decapan las instancias de clase.
No se necesita código adicional para que las instancias sean seleccionables. Por defecto, pickle recuperará la clase y los atributos de una instancia a través de la introspección.
Las clases pueden alterar el comportamiento predeterminado proporcionando uno o varios métodos especiales:
- object.__getnewargs_ex__()
Este método dicta los valores que se pasan al método __new__() al decapar. El método debe devolver un par (args, kwargs) donde args es una tupla de argumentos posicionales y kwargs un diccionario de argumentos con nombre para construir el objeto.
- object.__getnewargs__()
Este método solo admite argumentos positivos. Debe devolver una tupla de argumentos args que se pasarán al método __new__() al desempacar.
- object.__getstate__()
Si este método está definido por clases, se llama y el objeto devuelto se selecciona como el contenido de la instancia, en lugar del contenido del diccionario de la instancia.
- object.__setstate__(estado)
Si este método está definido por clases, se llama con el estado sin depilar. El estado conservado debe ser un diccionario y sus elementos se asignan al diccionario de la nueva instancia.
- object.__reduce__()
El método __reduce__() no acepta argumentos y devolverá una string o, preferiblemente, una tupla.
- object.__reduce_ex__(protocolo)
Este método es similar al método __reduce__. Toma un único argumento entero. El uso principal de este método es proporcionar valores de reducción compatibles con versiones anteriores para versiones anteriores de Python.
Ejemplo: manejo de objetos
con estado Este ejemplo muestra cómo modificar el comportamiento de decapado de una clase. La clase TextReader abre un archivo de texto y devuelve el número de línea y el contenido de la línea cada vez que se llama a su método readline().
- Si se selecciona una instancia de TextReader, se guardan todos los atributos excepto el miembro del objeto de archivo.
- Cuando se deselecciona la instancia, el archivo se vuelve a abrir y la lectura se reanuda desde la última ubicación.
Python3
import pickle
class TextReader:
"""Print and number lines in a text file."""
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 = line[:-1]
return "%i: %s" % (self.lineno, line)
def __getstate__(self):
# Copy the object's state from self.__dict__ which contains
# all our instance attributes. Always use the dict.copy()
# method to avoid modifying the original state.
state = self.__dict__.copy()
# Remove the unpicklable entries.
del state['file']
return state
def __setstate__(self, state):
# Restore instance attributes (i.e., filename and lineno).
self.__dict__.update(state)
# Restore the previously opened file's state. To do so, we need to
# reopen it and read from it until the line count is restored.
file = open(self.filename)
for _ in range(self.lineno):
file.readline()
# Finally, save the file.
self.file = file
reader = TextReader("Geeksforgeeks.txt")
print(reader.readline())
print(reader.readline())
new_reader = pickle.loads(pickle.dumps(reader))
print(new_reader.readline())
Producción :
0: hi geeks!, this is line 1. 0: This is line 2. 0: hi geeks!, this is line 1.
Este artículo es una contribución de Aditi Gupta . Si te gusta GeeksforGeeks y te gustaría contribuir, también puedes escribir un artículo usando write.geeksforgeeks.org o enviar tu artículo por correo a contribuir@geeksforgeeks.org. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks.
Y aquí hay un editor para PickleViewer:
Haga clic aquí para Github Repo
Haga clic aquí para descargar la versión 0.7.5
O Haga clic aquí para ver la última versión
Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema discutido anteriormente.
Publicación traducida automáticamente
Artículo escrito por GeeksforGeeks-1 y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA