Python pickle: cómo serializar objetos en el lenguaje de programación

Python pickle es un módulo que permite serializar y deserializar objetos. Puedes convertir diversos tipos de datos. Sin embargo, dado que un archivo de almacenamiento puede contener código malicioso, solo debes deserializar archivos provenientes de fuentes confiables.

¿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, compartirlos o reutilizarlos en otro proyecto. Para ello, los objetos se convierten a un formato que se pueda almacenar, lo que se conoce como serialización. Python pickle también permite deserializar objetos, es decir, convertirlos de nuevo a su formato original. Este módulo es particularmente útil si necesitas utilizar objetos de manera recurrente.

El objeto se convierte en un flujo de bytes, lo que garantiza que toda la información se transfiera sin alteraciones. De esta manera, puedes estar seguro de que el objeto, tras ser deserializado a su formato original, se podrá reutilizar sin problemas. Además, Python pickle proporciona las instrucciones necesarias para una deserialización exitosa, lo que permite reconstruir con precisión la estructura 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 almacenamiento es .pkl.

¿Qué tipos de datos se pueden serializar?

Python pickle puede serializar los siguientes tipos de datos:

• Valores booleanos: “True” y “False”, además de “None”
• Números enteros y complejos
• Strings o cadenas de caracteres (tanto normales como Unicode)
• Listas
• Conjuntos
• Tuplas de Python
• Diccionarios que contengan únicamente objetos serializables
• Funciones
• Clases de Python

¿Qué métodos diferentes hay?

El módulo pickle de Python ofrece cuatro métodos principales para trabajar con él:

• pickle.dump(obj, file, protocol=None, *, fix_imports=True, buffer_callback=None): se utiliza para la serializació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 serialización, pero devuelve un string de bytes
• pickle.load(file, *, fix_imports=True, encoding='ASCII', errors="strict", buffers=None): se utiliza para la deserialización, lee el archivo guardado
• pickle.loads(bytes_object, *, fix_imports=True, encoding="ASCII", errors="strict", buffers=None): también se utiliza para la deserialización, pero opera con un string de bytes

Para diferenciarlos, 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']

A continuación, creamos un archivo de texto con formato .pkl y usamos pickle.dump() para guardar la lista en él. Este es el código correspondiente:

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

La abreviatura wb indica al sistema que debe abrir el archivo en formato binario y devolver los datos contenidos como un objeto de tipo bytes. La función dump() almacena la lista “colores” en el archivo, que se cierra automáticamente después.

Deserializar un archivo guardado a su formato original

Para deserializar un archivo binario, utiliza el método pickle.load() de Python. En el siguiente código, deserializamos el objeto a su formato original y mostramos el resultado. Añadimos la abreviatura rb, que significa “read binary”.

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

El resultado obtenido es:

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

Serializar un diccionario con Python pickle

Con Python pickle, también puedes serializar tipos de datos más complejos, como diccionarios, y luego deserializarlos a su formato original. Primero, creamos un diccionario llamado “personas” donde almacenamos diferentes 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"
	}
}

Luego, creamos un nuevo archivo, serializamos los datos y los deserializamos 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)

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"}
}

Ahora puedes acceder a la informació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."
)

El resultado es:

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

Convertir una clase en un string

En el siguiente ejemplo utilizamos Python pickle para guardar una clase en un string. La clase contiene diferentes tipos de datos, todos compatibles con pickle. Creamos una clase llamada “EjemploClase” y luego la serializamos. 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")

Después de serializar la clase y luego deserializarla 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}

Comprimir objetos serializados

Aunque los archivos guardados con Python pickle son bastante compactos, es posible y a veces recomendable reducir aún más su tamaño. Por ejemplo, puedes utilizar bzip2, un programa de compresión libre que forma parte de la biblioteca estándar del lenguaje de programación. En el siguiente ejemplo, creamos un string, lo serializamos y luego aplicamos la compresió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)

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

Aunque el módulo Python pickle permite serializar objetos de manera práctica y efectiva, es importante tener en cuenta que los datos serializados pueden contener código malicioso. Si bien no representa un problema con tus propios datos, debes tener cuidado al tratar con archivos de terceros. Por lo tanto, deserializa únicamente archivos de fuentes de confianza.