Python vs JSON: Guia para serializar y deserializar.

Desde sus inicios, JSON se ha convertido rápidamente en el estándar por defecto para el intercambio de información. Lo más probable es que esté aquí porque necesita transportar algunos datos de aquí para allá. Tal vez esté recopilando información a través de una API o almacenando sus datos en una base de datos de documentos. De una forma u otra, estás hasta el cuello en JSON, y tienes que salir con Python.

Afortunadamente, esta es una tarea bastante común y, como ocurre con la mayoría de las tareas comunes, Python lo hace casi asquerosamente fácil. No tengáis miedo, compañeros Pythoneers y Pythonistas. ¡Esto va a ser pan comido!

Veamos un JSON de ejemplo:

{
    "firstName": "Jasmine",
    "lastName": "Doe",
    "hobbies": ["running", "cooking", "singing"],
    "age": 35,
    "children": [
        {
            "firstName": "Alice",
            "age": 6
        },
        {
            "firstName": "Bob",
            "age": 8
        }
    ]
}

Como puede ver, JSON admite tipos primitivos, como cadenas y números, así como listas y objetos anidados.

Espera, ¡eso parece un diccionario de Python! ¿Yo se, verdad? Es una notación de objeto bastante universal en este punto.

¡Python es compatible con JSON de forma nativa!

Python viene con un paquete integrado llamado json para codificar y decodificar datos JSON.

Solo coloca a este pequeño en la parte superior de tu archivo:

import json

Un poco de vocabulario

El proceso de codificación de JSON generalmente se denomina serialización. Este término se refiere a la transformación de datos en una serie de bytes (por lo tanto, en serie) para ser almacenados o transmitidos a través de una red. También puede escuchar el término clasificación, pero esa es otra discusión. Naturalmente, la deserialización es el proceso recíproco de decodificación de datos que se han almacenado o entregado en el estándar JSON.

¡Ay! Eso suena bastante técnico. Definitivamente. Pero en realidad, de todo lo que estamos hablando aquí es de leer y escribir. Piénselo de esta manera: la codificación es para escribir datos en el disco, mientras que la decodificación es para leer datos en la memoria.

Serializando JSON

¿Qué sucede después de que una computadora procesa mucha información? Necesita tomar un volcado de datos. En consecuencia, la biblioteca json expone el método dump() para escribir datos en archivos. También hay un método dumps() (pronunciado como “dump-s”) para escribir en una cadena de Python.

Los objetos simples de Python se traducen a JSON de acuerdo con una conversión bastante intuitiva.

Python	JSON
dict	object
list, tuple	array
str	string
int, long, float	number
True	true
False	false
None	null

Un ejemplo de serialización simple

Imagina que estás trabajando con un objeto de Python en la memoria que se parece a esto:

data = {
    "presidente": {
        "nombre": "Zaphod Beeblebrox",
        "especie": "Betelgeusian"
    }
}

Es fundamental que guarde esta información en el disco, por lo que su misión es escribirla en un archivo.

Usando el administrador de contexto de Python, puede crear un archivo llamado archivo_data.json y abrirlo en modo de escritura. (Los archivos JSON terminan convenientemente en una extensión .json).

with open("archivo_data.json", "w") as write_file:
    json.dump(data, write_file)

Tenga en cuenta que dump() toma dos argumentos posicionales: (1) el objeto de datos que se serializará y (2) el objeto similar a un archivo en el que se escribirán los bytes.

O, si estuviera tan inclinado a continuar usando estos datos JSON serializados en su programa, podría escribirlos en un objeto str nativo de Python.

json_string = json.dumps(data)

Tenga en cuenta que el objeto similar a un archivo está ausente ya que en realidad no está escribiendo en el disco. Aparte de eso, dumps() es como dump().

¡Hurra! Ha dado a luz a un bebé JSON y está listo para liberarlo en la naturaleza para que crezca grande y fuerte.

Algunos argumentos útiles

Recuerde, JSON está diseñado para que los humanos puedan leerlo fácilmente, pero la sintaxis legible no es suficiente si todo está comprimido. Además, probablemente tengas un estilo de programación diferente al mío, y podría ser más fácil para ti leer el código cuando está formateado a tu gusto.

NOTA: Los métodos dump() y dumps() utilizan los mismos argumentos.

La primera opción que la mayoría de la gente quiere cambiar es el espacio en blanco. Puede usar el argumento sangría para especificar el tamaño de sangría para estructuras anidadas. Comprueba la diferencia por ti mismo utilizando datos, que definimos anteriormente, y ejecutando los siguientes comandos en una consola:

>>> json.dumps(data)
>>> json.dumps(data, indent=4)

Otra opción de formato es el argumento de palabra clave separadores. De forma predeterminada, esta es una tupla de 2 de las cadenas de separación (“,”, “:”), pero una alternativa común para JSON compacto es (“,”, “:”). Eche un vistazo al JSON de muestra nuevamente para ver dónde entran en juego estos separadores.

Deserializando JSON

¡Genial, parece que te has capturado algo de JSON salvaje! Ahora es el momento de ponerlo en forma. En la biblioteca json, encontrará load() y loads() para convertir datos codificados en JSON en objetos de Python.

Al igual que la serialización, hay una tabla de conversión simple para la deserialización, aunque probablemente ya puedas adivinar cómo se ve.

JSON	Python
object	dict
array	list
string	str
number (int)	int
number (real)	float
true	True
false	False
null	None

Técnicamente, esta conversión no es la inversa perfecta de la tabla de serialización. Básicamente, eso significa que si codifica un objeto ahora y luego lo decodifica nuevamente, es posible que no obtenga exactamente el mismo objeto. Me imagino que es un poco como la teletransportación: romper mis moléculas aquí y volver a juntarlas allá. ¿Sigo siendo la misma persona?

En realidad, probablemente sea más como pedirle a un amigo que traduzca algo al japonés y otro amigo que lo vuelva a traducir al inglés. Independientemente, el ejemplo más simple sería codificar una tupla y recuperar una lista después de decodificar, así:

>>> blackjack_hand = (8, "Q")
>>> encoded_hand = json.dumps(blackjack_hand)
>>> decoded_hand = json.loads(encoded_hand)

>>> blackjack_hand == decoded_hand
False
>>> type(blackjack_hand)
<class 'tuple'>
>>> type(decoded_hand)
<class 'list'>
>>> blackjack_hand == tuple(decoded_hand)
True

Un ejemplo de deserialización simple

Esta vez, imagina que tienes algunos datos almacenados en el disco que te gustaría manipular en la memoria. Todavía usará el administrador de contexto, pero esta vez abrirá el archivo_data.json existente en modo de lectura.

with open("archivo_data.json", "r") as read_file:
    data = json.load(read_file)

Las cosas son bastante sencillas aquí, pero tenga en cuenta que el resultado de este método podría devolver cualquiera de los tipos de datos permitidos de la tabla de conversión. Esto solo es importante si está cargando datos que no ha visto antes. En la mayoría de los casos, el objeto raíz será un dict o una lista.

Si ha extraído datos JSON de otro programa o ha obtenido una cadena de datos con formato JSON en Python, puede deserializarlos fácilmente con loads(), que naturalmente se carga desde una cadena:

json_string = """
{
    "researcher": {
        "name": "Ford Prefect",
        "species": "Betelgeusian",
        "relatives": [
            {
                "name": "Zaphod Beeblebrox",
                "species": "Betelgeusian"
            }
        ]
    }
}
"""
data = json.loads(json_string)

Voilà! Ha domesticado el JSON salvaje y ahora está bajo su control. Pero lo que hagas con ese poder depende de ti. Podrías alimentarlo, nutrirlo e incluso enseñarle trucos. No es que no confíe en ti… pero mantenlo a raya, ¿de acuerdo?