Cómo decapar y decapar objetos en Python

En este artículo, aprenderá cómo serializar y deserializar datos en Python con el módulo Pickle. Además, usará datos que han sido serializados/deserializados con Pandas.

Introducción

La conversión de un objeto a un estado que se puede guardar (como un flujo de bytes, una representación textual, etc.) se denomina serialización, mientras que la deserialización convierte los datos del formato mencionado nuevamente en un objeto. Un formato serializado conserva toda la información necesaria para reconstruir un objeto en la memoria, en el mismo estado en que estaba cuando se serializó.

En esta guía, aprenderá a serializar y deserializar datos en Python con el módulo Pickle. Además, trabajaremos con datos que han sido serializados/deserializados, con Pandas.

{.icon aria-hidden=“true”}

Nota: Se recomienda cierto conocimiento de las operaciones de manejo de archivos si es un completo principiante en el lenguaje de programación Python. Si es así, lea nuestra Guía para guardar texto, JSON y CSV en un archivo Python.

¿Qué es decapado y decapado en Python?

Python viene con un paquete incorporado, conocido como pickle, que se puede usar para realizar operaciones de decapado y decapado.

Decapado y decapado en Python es el proceso que se usa para describir la conversión de objetos en flujos de bytes y viceversa: serialización y deserialización, usando el módulo pickle de Python. ¡Veamos algunos ejemplos!

{.icon aria-hidden=“true”}

Nota: El módulo pickle está disponible en la biblioteca estándar desde Python 3.x en adelante.

Considere el siguiente código que imprime el contenido de un diccionario:

1
2
3
4
5
6
7
8
import pickle

athletes = {
    "Name": ["Cristiano Ronaldo", "Lionel Messi", "Eden Hazard", "Luis Suarez", "Neymar"],
    "Club": ["Manchester United", "PSG", "Real Madrid", "Atletico Madrid", "PSG"]
 }

print(athletes)

Esto daría como resultado:

1
2
3
4
{
'Name': ['Cristiano Ronaldo', 'Lionel Messi', 'Eden Hazard', 'Luis Suarez', 'Neymar'],
'Club': ['Manchester United', 'PSG', 'Real Madrid', 'Atletico Madrid', 'PSG']
}

Intentemos "decapar" el objeto atletas en un archivo binario. Podemos hacer esto con la función dump(). Se necesitan dos parámetros: el objeto que se decapa y un objeto “Archivo” para escribir los datos. El siguiente código recoge los datos en un nuevo archivo athletes.txt que se creará en el mismo directorio en el que se ejecuta el script:

1
2
3
athletes_file = open('athletes.txt', 'wb')
pickle.dump(athletes, athletes_file)
athletes_file.close()

{.icon aria-hidden=“true”}

Nota: El modo que hemos usado en el manejo de archivos es "wb" que se usa para escribir archivos binarios. Dado que estamos convirtiendo el objeto en un flujo de bytes, usaremos "b" con cada modo mientras manejamos archivos.

El contenido del archivo creado no puede ser visto por un editor de texto regular porque son datos binarios y no están destinados a ser almacenados en un formato legible por humanos. Para leer esta información, tendremos que deseleccionar o deserializar estos datos. ¡Podemos hacer esto con la función load()!

La función load() lee el contenido de un archivo encurtido y devuelve el objeto construido al leer los datos. El tipo de objeto así como su estado dependen del contenido del archivo. Dado que hemos guardado un diccionario con nombres de atletas, se reconstruye este objeto con las mismas entradas. Leamos el archivo en escabeche que acaba de crear en un objeto de Python e imprimamos su contenido:

1
2
3
4
5
6
import pickle

athletes_file = open("athletes.txt", "rb")
athletes = pickle.load(athletes_file)
athletes_file.close()
print(athletes)

Esto resulta en:

1
{'Name': ['Cristiano Ronaldo', 'Lionel Messi', 'Eden Hazard', 'Luis Suarez', 'Neymar'], 'Club': ['Manchester United', 'PSG', 'Real Madrid', 'Atletico Madrid', 'PSG']}

Como puede ver, recuperamos todos los datos que se decaparon.

{.icon aria-hidden=“true”}

Nota: Al igual que usamos "wb" para escribir datos binarios, usamos el modo "rb" durante el manejo de archivos para leer datos binarios.

Ahora que hemos cubierto el proceso de decapado y decapado en Python, ¡leamos los archivos decapados para que podamos poner su contenido en un DataFrame de Pandas!

¿Cómo leer un archivo Pickle en un marco de datos de Pandas?

Usaremos los mismos datos que usamos en los ejemplos anteriores. Primero, asegúrese de tener instalada la biblioteca Pandas:

1
$ pip install pandas

Ahora comencemos convirtiendo los objetos en un marco de datos de Python:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
import pickle
import pandas as pd

athletes = {
    "Name": ["Cristiano Ronaldo", "Lionel Messi", "Eden Hazard", "Luis Suarez", "Neymar"],        
    "Club": ["Manchester United", "PSG", "Real Madrid", "Atletico Madrid", "PSG"]
}

df = pd.DataFrame(athletes)
print(df)

Esto resulta en:

1
2
3
4
5
6
                Name               Club
0  Cristiano Ronaldo  Manchester United
1       Lionel Messi                PSG
2        Eden Hazard        Real Madrid
3        Luis Suarez    Atletico Madrid
4             Neymar                PSG

Como puede ver en la salida, obtendremos un objeto Pandas DataFrame con 3 columnas y 6 filas, incluidos los índices. Después de esto, el proceso es similar a cómo manejamos los objetos normales que no son DataFrame. Usaremos el manejo de archivos junto con los métodos dump() y load() para crear primero un archivo pickle a partir de un DataFrame de Pandas, y luego leer el flujo de bytes para obtener el DataFrame de Pandas:

1
2
3
4
5
6
# ...
df = pd.DataFrame(athletes)

athelets_df_file = open("athletes_df.txt", "wb")
pickle.dump(df, athelets_df_file)
athelets_df_file.close()

El código anterior creará un archivo pickle que almacenará Pandas DataFrame como un flujo de bytes en nuestro directorio actual como athletes_df.txt.

Cuando queramos usar este DataFrame nuevamente, podemos deshacer este archivo para recuperarlo:

1
2
3
4
5
6
import pickle

athletes_df_file = open("athletes_df.txt", "rb")
athletes = pickle.load(athletes_df_file)
athletes_df_file.close()
print(athletes)

Esto resulta en:

1
2
3
4
5
6
                Name               Club
0  Cristiano Ronaldo  Manchester United
1       Lionel Messi                PSG
2        Eden Hazard        Real Madrid
3        Luis Suarez    Atletico Madrid
4             Neymar                PSG

¡Eso es lo increíble de los archivos en escabeche! No solo obtenemos los contenidos almacenados en el objeto DataFrame cuando lo cargamos, obtenemos el objeto DataFrame en sí. Sin estas capacidades, es común que los programadores guarden los datos en un formato accesible como JSON y luego carguen los datos JSON en un nuevo objeto para usarlos.

Decapado y decapado nos ahorran el uso de formatos de datos intermedios y la creación de métodos para cargar nuestros datos.

Decapado en cuerdas y decapado de cuerdas {#decapado en cuerdas y decapado de cuerdas}

Es bueno saber que el módulo pickle también nos proporciona los métodos dumps() y loads(). Estos métodos seleccionarán y eliminarán los objetos de Python, pero en lugar de usar un archivo binario para almacenar datos, devuelven y aceptan datos de cadena.

Echemos un vistazo a un ejemplo simple para entender cómo funcionan los métodos dumps() y loads() en Python:

1
2
3
4
5
import pickle

simple_obj = {1: ['o', 'n', 'e'], "two": (1, 2), 3: "Three"}
pickled_obj = pickle.dumps(simple_obj)
print(pickled_obj)

Esto resulta en:

1
b'\x80\x04\x95-\x00\x00\x00\x00\x00\x00\x00}\x94(K\x01]\x94(\x8c\x01o\x94\x8c\x01n\x94\x8c\x01e\x94e\x8c\x03two\x94K\x01K\x02\x86\x94K\x03\x8c\x05Three\x94u.'

Como puede ver en la salida, se devuelve la cadena binaria en lugar de un archivo en escabeche que se creó con el método dump(). Podemos tomar esta cadena y cargar el objeto en una nueva variable:

1
2
out = pickle.loads(obj)
print(out)

Esto resulta en:

1
{1: ['o', 'n', 'e'], 'two': (1, 2), 3: 'Three'}

Estos dos métodos facilitan la transferencia entre aplicaciones basadas en Python, y muy bien podría enviar datos encurtidos a través de las API. Sin embargo, más comúnmente, para las aplicaciones web basadas en Python, utilizará objetos serializados JSON en su lugar.

Conclusión

En este artículo, aprendimos sobre las operaciones de decapado y decapado en Python que son útiles para almacenar sus objetos para su uso posterior. Métodos como load(), loads(), dump(), dumps() son proporcionados por el módulo integrado pickle para convertir objetos de Python hacia y desde flujos de bytes.

La creación y carga de datos hacia y desde un objeto DataFrame de Pandas se puede hacer fácilmente usando el módulo pickle en Python. Tenga en cuenta que no se recomienda decapar y decapar si planea usar los objetos en otros lenguajes de programación, ya que el módulo no garantiza la compatibilidad de programación cruzada. ruzada.