Python pickle es un módulo que permite se­ria­li­zar y deseria­li­zar objetos. Puedes convertir diversos tipos de datos. Sin embargo, dado que un archivo de al­ma­ce­na­mie­n­to puede contener código malicioso, solo debes deseria­li­zar archivos pro­ve­nie­n­tes de fuentes co­n­fia­bles.

¿Qué es Python pickle?

El nombre pickle (encurtido en español) puede parecer inusual, pero al entender cómo funciona el módulo y para qué se utiliza, el nombre cobra sentido. El módulo te permite guardar objetos para usarlos más tarde, co­m­pa­r­ti­r­los o re­uti­li­zar­los en otro proyecto. Para ello, los objetos se co­n­vie­r­ten a un formato que se pueda almacenar, lo que se conoce como se­ria­li­za­ción. Python pickle también permite deseria­li­zar objetos, es decir, co­n­ve­r­ti­r­los de nuevo a su formato original. Este módulo es pa­r­ti­cu­la­r­me­n­te útil si necesitas utilizar objetos de manera re­cu­rre­n­te.

El objeto se convierte en un flujo de bytes, lo que garantiza que toda la in­fo­r­ma­ción se tra­n­s­fie­ra sin al­te­ra­cio­nes. De esta manera, puedes estar seguro de que el objeto, tras ser deseria­li­za­do a su formato original, se podrá re­uti­li­zar sin problemas. Además, Python pickle pro­po­r­cio­na las in­s­tru­c­cio­nes ne­ce­sa­rias para una deseria­li­za­ción exitosa, lo que permite re­co­n­s­truir con precisión la es­tru­c­tu­ra original. El uso de Python pickle ahorra mucho tiempo, ya que los objetos creados una vez no necesitan recrearse para cada uso. El formato de al­ma­ce­na­mie­n­to es .pkl.

¿Qué tipos de datos se pueden se­ria­li­zar?

Python pickle puede se­ria­li­zar los si­guie­n­tes tipos de datos:

  • Valores booleanos: “True” y “False”, además de “None”
  • Números enteros y complejos
  • Strings o cadenas de ca­ra­c­te­res (tanto normales como Unicode)
  • Listas
  • Conjuntos
  • Tuplas de Python
  • Di­c­cio­na­rios que contengan úni­ca­me­n­te objetos se­ria­li­za­bles
  • Funciones
  • Clases de Python

¿Qué métodos di­fe­re­n­tes hay?

El módulo pickle de Python ofrece cuatro métodos pri­n­ci­pa­les para trabajar con él:

  • pickle.dump(obj, file, protocol=None, *, fix_imports=True, buffer_callback=None): se utiliza para la se­ria­li­za­ción y crea un archivo con el resultado deseado
  • pickle.dumps(obj, protocol=None, *, fix_imports=True, buffer_callback=None): también se utiliza para la se­ria­li­za­ción, pero devuelve un string de bytes
  • pickle.load(file, *, fix_imports=True, encoding='ASCII', errors="strict", buffers=None): se utiliza para la deseria­li­za­ción, lee el archivo guardado
  • pickle.loads(bytes_object, *, fix_imports=True, encoding="ASCII", errors="strict", buffers=None): también se utiliza para la deseria­li­za­ción, pero opera con un string de bytes

Para di­fe­re­n­ciar­los, puedes recordar que la “s” en pickle.dumps y pickle.loads indica que trabaja con “Strings”.

Ejemplo de Python pickle

Para ilustrar cómo funciona Python pickle, veamos un ejemplo sencillo. Creamos una lista que contiene cuatro colores. Aquí tienes el código:

import pickle
farben = ['Azul', 'Rojo', 'Amarillo', 'Naranja']
python

A co­n­ti­nua­ción, creamos un archivo de texto con formato .pkl y usamos pickle.dump() para guardar la lista en él. Este es el código co­rre­s­po­n­die­n­te:

with open('colores_archivo.pkl', 'wb') as f:
	pickle.dump(colores, f)
python

La abre­via­tu­ra wb indica al sistema que debe abrir el archivo en formato binario y devolver los datos co­n­te­ni­dos como un objeto de tipo bytes. La función dump() almacena la lista “colores” en el archivo, que se cierra au­to­má­ti­ca­me­n­te después.

Deseria­li­zar un archivo guardado a su formato original

Para deseria­li­zar un archivo binario, utiliza el método pickle.load() de Python. En el siguiente código, deseria­li­za­mos el objeto a su formato original y mostramos el resultado. Añadimos la abre­via­tu­ra rb, que significa “read binary”.

with open('colores_archivo.pkl', 'rb') as f:
	colores_deserializados = pickle.load(f)
	print(colores_deserializados)
python

El resultado obtenido es:

['Azul', 'Rojo', 'Amarillo', 'Naranja']
python

Se­ria­li­zar un di­c­cio­na­rio con Python pickle

Con Python pickle, también puedes se­ria­li­zar tipos de datos más complejos, como di­c­cio­na­rios, y luego deseria­li­zar­los a su formato original. Primero, creamos un di­c­cio­na­rio llamado “personas” donde al­ma­ce­na­mos di­fe­re­n­tes datos de varias personas:

import pickle
personas = {
	'Persona 1': {
		'Name': "María", 'Edad': 56, 'Ciudad': "Nueva York"
	},
	'Persona 2': {
		'Name': "Pablo", 'Edad': 66, 'Ciudad': "Los Ángeles"
	},
	'Persona 3': {
		'Name': "Lucía", 'Edad': 22, 'Ciudad': "Houston"
	},
	'Persona 4': {
		'Name': "Laura", 'Edad': 34, 'Ciudad': "Miami"
	}
}
python

Luego, creamos un nuevo archivo, se­ria­li­za­mos los datos y los deseria­li­za­mos como prueba:

with open("personas_dict.pkl", "wb") as f:
	pickle.dump(personas, f)
with open("personas_dict.pkl", "rb") as f:
	dict_deserializado = pickle.load(f)
	print(dict_deserializado)
python

El resultado es:

personas = {
    'Persona 1': { 'Nombre': "María", 'Edad': 56, 'Ciudad': "Nueva York"},
    'Persona 2': { 'Nombre': "Pablo", 'Edad': 66, 'Ciudad': "Los Ángeles"},
    'Persona 3': { 'Nombre': "Lucía", 'Edad': 22, 'Ciudad': "Houston"},
    'Persona 4': { 'Nombre': "Laura", 'Edad': 34, 'Ciudad': "Miami"}
}
python

Ahora puedes acceder a la in­fo­r­ma­ción de manera habitual. A modo de ejemplo, pedimos el siguiente dato:

# Definir el diccionario
dict_deserializado = {
    'Persona 1': {'Nombre': "María", 'Edad': 56, 'Ciudad': "Nueva York"},
    'Persona 2': {'Nombre': "Pablo", 'Edad': 66, 'Ciudad': "Los Ángeles"},
    'Persona 3': {'Nombre': "Lucía", 'Edad': 22, 'Ciudad': "Houston"},
    'Persona 4': {'Nombre': "Laura", 'Edad': 34, 'Ciudad': "Miami"}
}
# Imprimir la salida
print(
    "El nombre de la tercera persona es "
    + dict_deserializado["Persona 3"]["Nombre"]
    + " y tiene "
    + str(dict_deserializado["Persona 3"]["Edad"])
    + " años."
)
python

El resultado es:

El nombre de la tercera persona es Lucía y tiene 22 años.
python

Convertir una clase en un string

En el siguiente ejemplo uti­li­za­mos Python pickle para guardar una clase en un string. La clase contiene di­fe­re­n­tes tipos de datos, todos co­m­pa­ti­bles con pickle. Creamos una clase llamada “Eje­m­plo­Cla­se” y luego la se­ria­li­za­mos. El código es el siguiente:

import pickle
class EjemploClase:
	def __init__(self):
		self.un_número = 17
		self.una_lista = [5, 10, 15]
		self.una_tupla = (18, 19)
		self.un_string = "hola"
		self.un_dict = {"color": "azul", "número": 3}
ejemplo_objeto = EjemploClase ()
objeto_serializado = pickle.dumps(ejemplo_objeto)
print(f"Este es el objeto serializado:\n{objeto_serializado}\n")
ejemplo_objeto.un_dict = None
objeto_deserializado = pickle.loads(objeto_serializado)
print(f"Este es un_dict del objeto deserializado:\n{objeto_deserializado.un_dict}\n")
python

Después de se­ria­li­zar la clase y luego deseria­li­zar­la a su formato original, obtenemos el siguiente resultado:

Este es el objeto serializado:
b'\x80\x03c__main__\nEjemploClase\nq\x00)\x81q\x01.'
Este es un_dict del objeto deserializado:
{'color': 'azul', 'numero': 3}
python

Comprimir objetos se­ria­li­za­dos

Aunque los archivos guardados con Python pickle son bastante compactos, es posible y a veces re­co­me­n­da­ble reducir aún más su tamaño. Por ejemplo, puedes utilizar bzip2, un programa de co­m­pre­sión libre que forma parte de la bi­blio­te­ca estándar del lenguaje de pro­gra­ma­ción. En el siguiente ejemplo, creamos un string, lo se­ria­li­za­mos y luego aplicamos la co­m­pre­sión:

import pickle
import bz2
ejemplo_string = """Almost heaven, West Virginia
Blue Ridge Mountains, Shenandoah River
Life is old there, older than the trees
Younger than the mountains, growin' like a breeze
Country roads, take me home
To the place I belong
West Virginia, mountain mama
Take me home, country roads."""
serializado = pickle.dumps(ejemplo_string)
comprimido = bz2.compress(serializado)
python

Aviso de seguridad al trabajar con el módulo Python pickle

Aunque el módulo Python pickle permite se­ria­li­zar objetos de manera práctica y efectiva, es im­po­r­ta­n­te tener en cuenta que los datos se­ria­li­za­dos pueden contener código malicioso. Si bien no re­pre­se­n­ta un problema con tus propios datos, debes tener cuidado al tratar con archivos de terceros. Por lo tanto, deseria­li­za úni­ca­me­n­te archivos de fuentes de confianza.

Consejo

Despliega di­re­c­ta­me­n­te a través de GitHub: con Deploy Now de IONOS, no solo te be­ne­fi­cias del re­co­no­ci­mie­n­to au­to­má­ti­co del framework y de una co­n­fi­gu­ra­ción rápida, sino que también tienes la opción de elegir entre di­fe­re­n­tes tipos de tarifas. ¡Encuentra la solución que mejor se adapte a tus ne­ce­si­da­des!

Ir al menú principal