# 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](https://www.ionos.es/digitalguide/paginas-web/desarrollo-web/python-data-types/):

- 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](https://www.ionos.es/digitalguide/paginas-web/desarrollo-web/python-tuples/)
- Diccionarios que contengan únicamente objetos serializables
- Funciones
- [Clases de Python](https://www.ionos.es/digitalguide/paginas-web/desarrollo-web/python-classes/)

## ¿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:

```python
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:

```python
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”.

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

El resultado obtenido es:

```python
['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:

```python
import pickle
personas = {
	'Persona 1': {
		'Name': "María", 'Edad': 56, 'Ciudad': "Madrid"
	},
	'Persona 2': {
		'Name': "Pablo", 'Edad': 66, 'Ciudad': "Barcelona"
	},
	'Persona 3': {
		'Name': "Lucía", 'Edad': 22, 'Ciudad': "Sevilla"
	},
	'Persona 4': {
		'Name': "Laura", 'Edad': 34, 'Ciudad': "Valencia"
	}
}
```

Luego, creamos un nuevo archivo, serializamos los datos y los deserializamos como prueba:

```python
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:

```python
personas = {
    'Persona 1': { 'Nombre': "María", 'Edad': 56, 'Ciudad': "Madrid"},
    'Persona 2': { 'Nombre': "Pablo", 'Edad': 66, 'Ciudad': "Barcelona"},
    'Persona 3': { 'Nombre': "Lucía", 'Edad': 22, 'Ciudad': "Sevilla"},
    'Persona 4': { 'Nombre': "Laura", 'Edad': 34, 'Ciudad': "Valencia"}
}
```

Ahora puedes acceder a la información de manera habitual. A modo de ejemplo, pedimos el siguiente dato:

```python
# Definir el diccionario
dict_deserializado = {
    'Persona 1': {'Nombre': "María", 'Edad': 56, 'Ciudad': "Madrid"},
    'Persona 2': {'Nombre': "Pablo", 'Edad': 66, 'Ciudad': "Barcelona"},
    'Persona 3': {'Nombre': "Lucía", 'Edad': 22, 'Ciudad': "Sevilla"},
    'Persona 4': {'Nombre': "Laura", 'Edad': 34, 'Ciudad': "Valencia"}
}
# 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:

```python
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:

```python
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:

```python
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](https://www.ionos.es/digitalguide/paginas-web/desarrollo-web/que-lenguaje-de-programacion-aprender/). En el siguiente ejemplo, creamos un string, lo serializamos y luego aplicamos la compresión:

```python
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.

Consejo Despliega directamente a través de GitHub: con [Deploy Now](https://www.ionos.es/alojamiento/deploy-now "Deploy Now de IONOS") de IONOS, no solo te beneficias del reconocimiento automático del framework y de una configuración rápida, sino que también tienes la opción de elegir entre diferentes tipos de tarifas. ¡Encuentra la solución que mejor se adapte a tus necesidades!


This is a markdown version of: [https://www.ionos.es/digitalguide/paginas-web/desarrollo-web/python-pickle/](https://www.ionos.es/digitalguide/paginas-web/desarrollo-web/python-pickle/) for AI/LLM consumption.