--- title: "Cómo analizar JSON en Python" slug: parse-json-data-with-python date: 2022-05-09T11:22:09+00:00 modified: 2025-09-16T16:44:03+00:00 permalink: https://brightdata.es/blog/procedimientos/parse-json-data-with-python type: blog --- [ Blog ](https://brightdata.es/blog "Blog") / [Procedimientos](https://brightdata.es/blog/procedimientos) [Procedimientos](https://brightdata.es/blog/procedimientos) # Cómo analizar JSON en Python Esta guía tiene el propósito de guiarles en el proceso de importar json y usarlo para analizar JSON en Python, con una tabla útil de transformación JSON-Python. Tanto si se es un desarrollador experimentado en Python como si se está empezando, este tutorial paso a paso mostrará cómo analizar JSON como profesionales. 12 min de lectura [ ![Antonello Zanini](https://media.brightdata.es/2022/12/Antonello-Zanini-2-50x50.jpg) ](https://brightdata.com/blog/authors/antonello-zanini) [Antonello Zanini Technical Writer ](https://brightdata.com/blog/authors/antonello-zanini) ![How to parse JSON data with Python](https://media.brightdata.es/2022/05/How-to-parse-JSON-data-with-Python.svg) En este tutorial, se explica: - Qué es JSON y cómo manejarlo en Python - Cómo analizar JSON en Python con el módulo json - Si json es la mejor opción para analizar JSON ## Introducción a JSON en Python Antes de profundizar en el análisis JSON con Python, vamos a entender qué es JSON y cómo usarlo en Python. ### ¿Qué es JSON? [JSON](https://en.wikipedia.org/wiki/JSON), abreviatura de JavaScript Object Notation, es un formato ligero de intercambio de datos. Es sencillo de leer y escribir para los humanos y fácil de analizar y generar para las máquinas. Esto lo convierte en uno de los formatos de datos más populares. Concretamente, JSON se ha convertido en el “lenguaje de la web” porque se utiliza habitualmente para transmitir datos entre servidores y aplicaciones web a través de API. He aquí un ejemplo de JSON: ```none { "name": "Maria Smith", "age": 32, "isMarried": true, "hobbies": ["reading", "jogging"], "address": { "street": "123 Main St", "city": "San Francisco", "state": "CA", "zip": "12345" }, "phoneNumbers": [ { "type": "home", "number": "555-555-1234" }, { "type": "work", "number": "555-555-5678" } ], "notes": null } ``` Como se puede ver, JSON consiste en pares clave-valor. Cada clave es una cadena y cada valor puede ser una cadena, un número, un booleano, un null, un array o un objeto. Aunque es similar a un objeto JavaScript, JSON puede utilizarse con cualquier lenguaje de programación, incluyendo Python. ### Cómo tratar con JSON en Python Python soporta [JSON](https://docs.python.org/3/library/json.html) de forma nativa a través del módulo json, que forma parte de la [Biblioteca Estándar de Python](https://docs.python.org/3/library/index.html). Esto significa que no es necesario instalar ninguna biblioteca adicional para trabajar con JSON en Python. Se puede importar json de la siguiente manera: ```none import json ``` La biblioteca Python json incorporada expone una API completa para tratar con JSON. En particular, tiene dos funciones clave: `loads` y `load`. La función loads permite analizar datos JSON a partir de una cadena. Tengamos en cuenta que, a pesar de que su nombre parece ser plural, la terminación “s” significa “cadena”. Por lo tanto, debe leerse como “load-s”. Por otro lado, la función load es para analizar datos JSON en bytes. A través de estos dos métodos, `json` ofrece la posibilidad de convertir datos JSON en objetos Python equivalentes, como [diccionarios](https://docs.python.org/3/tutorial/datastructures.html#dictionaries) y [listas](https://docs.python.org/3/tutorial/datastructures.html#more-on-lists), y viceversa. Además, el módulo json permite crear codificadores y decodificadores personalizados para manejar tipos de datos específicos. Continúe leyendo y descubra cómo utilizar la biblioteca `json` para analizar datos JSON en Python. ## Análisis sintáctico de datos JSON con Python Veamos algunos ejemplos verídicos y aprendamos a analizar datos JSON de diferentes fuentes en diferentes estructuras de datos Python. ## Convertir una Cadena JSON en un Diccionario Python Supongamos que disponemos de algunos datos JSON almacenados en una cadena y queremos convertirlos en un diccionario Python. Así es como se ven los datos JSON: ```none { "name": "iPear 23", "colors": ["black", "white", "red", "blue"], "price": 999.99, "inStock": true } ``` Y esta es su representación en Python: ```none smartphone_json = '{"name": "iPear 23", "colors": ["black", "white", "red", "blue"], "price": 999.99, "inStock": true}' ``` Considere usar la convención de Python de comillas triples para almacenar cadenas JSON largas de varias líneas. Se puede verificar que smartphone contiene una cadena válida en Python con la línea de abajo: ```none print(type(smartphone)) ``` Esto imprimirá: ```none ``` [`str`](https://docs.python.org/3/library/stdtypes.html#text-sequence-type-str) significa “cadena” y significa que la variable smartphone tiene el tipo de secuencia de texto. Analice la cadena JSON contenida en smartphone en un diccionario Python con el método json.loads() de la siguiente manera: ```none import json # JSON string smartphone_json = '{"name": "iPear 23", "colors": ["black", "white", "red", "blue"], "price": 999.99, "inStock": true}' # from JSON string to Python dict smartphone_dict = json.loads(smartphone_json) # verify the type of the resulting variable print(type(smartphone_dict)) # dict ``` Si se ejecuta este fragmento, se obtendría: ```none ``` ¡Fantástico! ¡`smartphone_dict` contiene ahora un diccionario Python válido! Así, todo lo que es necesario hacer para convertir una cadena JSON en un diccionario Python es pasar una cadena JSON válida a `json.loads()` Ahora se puede acceder a los campos del diccionario resultante de la forma habitual: ```none product = smartphone_dict['product'] # smartphone priced = smartphone['price'] # 999.99 colors = smartphone['colors'] # ['black', 'white', 'red', 'blue'] ``` Sin embargo, tenga en cuenta que la función `json.loads()` no siempre devuelve un diccionario. En concreto, el tipo de datos devuelto depende de la cadena de entrada. Por ejemplo, si la cadena JSON contiene un valor plano, se convertirá al valor primitivo Python correspondiente: ```none import json json_string = '15.5' float_var = json.loads(json_string) print(type(float_var)) # ``` Del mismo modo, una cadena JSON que contenga una lista de matrices se convertirá en una lista de Python: ```none import json json_string = '[1, 2, 3]' list_var = json.loads(json_string) print(json_string) # ``` Echa un vistazo a la [tabla de conversión](https://docs.python.org/3/library/json.html#json-to-py-table) a continuación para ver cómo los valores de JSON se convierten en datos de Python mediante `json`: **Valor JSON****Datos Python**`string``str``number (integer)``int``number (real)``float``true``True``false``False``null``None``array``list``object``dict`### Transformando una Respuesta API JSON en un Diccionario Python Consideremos que necesitamos realizar una API y convertir su respuesta JSON en un diccionario Python. En el siguiente ejemplo, llamaremos al siguiente endpoint de la API desde el proyecto[ {JSON}](https://jsonplaceholder.typicode.com/) para obtener algunos datos JSON falsos: ```none https://jsonplaceholder.typicode.com/todos/1 ``` Esa API RESTFul devuelve la respuesta JSON de abajo: ```none { "userId": 1, "id": 1, "title": "delectus aut autem", "completed": false } ``` Se puede llamar a esa API con el módulo [`urllib`](https://docs.python.org/3/library/urllib.html) de la Biblioteca Estándar y convertir el JSON resultante en un diccionario Python de la siguiente manera: ```none import urllib.request import json url = "https://jsonplaceholder.typicode.com/todos/1" with urllib.request.urlopen(url) as response: body_json = response.read() body_dict = json.loads(body_json) user_id = body_dict['userId'] # 1 ``` `urllib.request.urlopen()` realiza la llamada a la API y devuelve un objeto `HTTPResponse`. Su método `read()` se utiliza para obtener el cuerpo de la respuesta body\_json, que contiene la respuesta de la API como una cadena JSON. Finalmente, esa cadena puede analizarse en un diccionario Python a través de json.loads(), como se explicó anteriormente. De igual manera, se puede lograr el mismo resultado con `requests:` ```none import requests import json url = "https://jsonplaceholder.typicode.com/todos/1" response = requests.get(url) body_dict = response.json() user_id = body_dict['userId'] # 1 ``` Ten en cuenta que el método `.json()` transforma automáticamente el objeto de respuesta que contiene datos JSON en la estructura de datos de Python correspondiente. ¡Genial! Así es como se analiza una respuesta JSON de la API en Python, tanto con `urllib` como con `requests`. ### Cargando un Archivo JSON en un Diccionario Python Supongamos que existen algunos datos JSON almacenados en un archivo `smartphone.json` como el que se muestra a continuación: ```none { "name": "iPear 23", "colors": ["black", "white", "red", "blue"], "price": 999.99, "inStock": true, "dimensions": { "width": 2.82, "height": 5.78, "depth": 0.30 }, "features": [ "5G", "HD display", "Dual camera" ] } ``` El objetivo es leer el archivo JSON y cargarlo en un diccionario Python. Para ello, emplearemos el siguiente fragmento de código: ```none import json with open('smartphone.json') as file: smartphone_dict = json.load(file) print(type(smartphone_dict)) # features = smartphone_dict['features'] # ['5G', 'HD display', 'Dual camera'] ``` La biblioteca incorporada `open()` permite cargar un archivo y obtener su correspondiente [objeto archivo](https://docs.python.org/3/glossary.html#term-file-object). A continuación, el método `json.read()` deserializa el [archivo de texto](https://docs.python.org/3/glossary.html#term-text-file) o [binario](https://docs.python.org/3/glossary.html#term-binary-file) que contiene un documento JSON al objeto Python equivalente. En este caso, `smartphone.json` se convierte en un diccionario Python. Perfecto, ¡analizar un archivo JSON en Python sólo requiere unas cuantas líneas de código! ### De Datos JSON a Objeto Python Personalizado Ahora, quieres analizar algunos datos JSON en una clase personalizada de Python. Así es como se ve tu clase personalizada de Python para `Smartphone`: ```none class Smartphone: def __init__(self, name, colors, price, in_stock): self.name = name self.colors = colors self.price = price self.in_stock = in_stock ``` Aquí, el objetivo es convertir la siguiente cadena JSON en una instancia de `Smartphone`: ```none { "name": "iPear 23 Plus", "colors": ["black", "white", "gold"], "price": 1299.99, "inStock": false } ``` Para realizar esta tarea, se requiere crear un decodificador personalizado. En concreto, extender la clase `JSONDecoder` y establecer el parámetro `object_hook` en el método `__init__`. Se le asigna el nombre del método de la clase que contiene la lógica de análisis personalizada. En ese método de análisis, se pueden utilizar los valores contenidos en el diccionario estándar devuelto por `json.read()` para instanciar un objeto `Smartphone`. A continuación, se define un `SmartphoneDecoder` personalizado: ```none import json class SmartphoneDecoder(json.JSONDecoder): def __init__(self, object_hook=None, *args, **kwargs): # set the custom object_hook method super().__init__(object_hook=self.object_hook, *args, **kwargs) # class method containing the # custom parsing logic def object_hook(self, json_dict): new_smartphone = Smartphone( json_dict.get('name'), json_dict.get('colors'), json_dict.get('price'), json_dict.get('inStock'), ) return new_smartphone ``` Nótese que se debe utilizar el método `get()` para leer los valores del diccionario dentro del método personalizado `object_hook()`. Esto asegurará que no se produzcan `KeyErrors` si falta una clave en el diccionario. En su lugar, se devolverán los valores `None`. Ahora se puede pasar la clase `SmartphoneDecoder` al parámetro `cls` en `json.loads()` para convertir una cadena JSON en un objeto `Smartphone`: ```none import json # class Smartphone: # ... # class SmartphoneDecoder(json.JSONDecoder): # ... smartphone_json = '{"name": "iPear 23 Plus", "colors": ["black", "white", "gold"], "price": 1299.99, "inStock": false}' smartphone = json.loads(smartphone_json, cls=SmartphoneDecoder) print(type(smartphone)) # name = smartphone.name # iPear 23 Plus ``` Del mismo modo, se puede utilizar `SmartphoneDecoder` con `json.load()`: ```none smartphone = json.load(smartphone_json_file, cls=SmartphoneDecoder) ``` ¡Et voilà! Así es como se convierte datos JSON en objetos Python personalizados. ## Datos Python a JSON También puede hacerse a la inversa y convertir estructuras de datos y primitivas de Python a JSON. Esto es posible gracias a las funciones `json.dump()` y` json.dumps()`, que se muestran en la siguiente [tabla de conversión](https://docs.python.org/3/library/json.html#py-to-json-table): **Datos Python****Valor JSON**`str``string ``int``number (integer)``float``number (real)``True``true``False ``false``None ``null ``list``array``dict``object``Null `Ninguno `json.dump()` permite escribir una cadena JSON en un archivo, como en el siguiente ejemplo: ```none import json user_dict = { "name": "John", "surname": "Williams", "age": 48, "city": "New York" } # serializing the sample dictionary to a JSON file with open("user.json", "w") as json_file: json.dump(user_dict, json_file) ``` Este fragmento serializará la variable `user_dict` de Python en el archivo `user.json`. De la misma manera, `json.dumps()` convierte una variable Python en su cadena JSON equivalente: ```none import json user_dict = { "name": "John", "surname": "Williams", "age": 48, "city": "New York" } user_json_string = json.dumps(user_dict) print(user_json_string) ``` Ejecute este fragmento y obtendrá: Esta es exactamente la representación JSON del dict Python. Cabe destacar que también es posible especificar un codificador personalizado, pero mostrar cómo hacerlo no es el propósito de este artículo. Siga la[ documentación oficial](https://docs.python.org/3/library/json.html#json.JSONEncoder) para aprender más. ### ¿Es el Módulo Estándar `json` el Mejor Recurso para Analizar JSON en Python? Como sucede en general con el [análisis sintáctico de datos](https://brightdata.es/blog/datos-web/what-is-data-parsing), el análisis sintáctico de JSON presenta desafíos que no pueden pasarse por alto. Por ejemplo, en caso de JSON inválido, roto o no estándar, el módulo `json` de Python se quedaría corto. Además, es necesario tener cuidado al analizar datos JSON de fuentes no confiables. Esto se debe a que una cadena JSON maliciosa puede hacer que el analizador se rompa o consuma una gran cantidad de recursos. Este es sólo uno de los retos que un analizador JSON de Python debe tener en cuenta. Se podría introducir lógica personalizada para tratar estos casos particulares. Al mismo tiempo, eso podría llevar demasiado tiempo y resultar en un código complejo y poco fiable. Por esta razón, es recomendable considerar una herramienta comercial que facilite el análisis JSON, como el [IDE Web Scraper](https://brightdata.es/products/web-scraper). El IDE Web Scraper está diseñado específicamente para desarrolladores y viene con una amplia gama de características para analizar contenido JSON y más. Esta herramienta puede ahorrarle mucho tiempo y ayudarle a asegurar su proceso de análisis JSON. Además, viene con capacidades de proxy de desbloqueo de Bright Data para llamar a APIs JSON de forma anónima. Si tiene prisa, podría también interesarle nuestra oferta Data as a Service. A través de este servicio, puede pedir a Bright Data que le proporcione un [conjunto de datos personalizado](https://brightdata.es/products/datasets) que se ajuste a sus necesidades específicas. Bright Data se encargará de todo, desde el rendimiento hasta la calidad de los datos. ¡Analizar datos JSON nunca ha sido tan fácil! ## Conclusión Python le permite analizar datos JSON de forma nativa a través del módulo estándar `json`. Esto expone una potente API para serializar y deserializar contenido JSON. Específicamente, ofrece los métodos `json.read()` y `json.reads()` para tratar con archivos JSON y cadenas JSON, respectivamente. En este artículo, se ha explicado cómo utilizarlos para analizar datos JSON en Python en varios ejemplos reales. También se abordaron las limitaciones de este enfoque. Por ello, es posible que sea conveniente probar una solución comercial de vanguardia, con todas las funciones, para el análisis sintáctico de datos, como el IDE Web Scraper de Bright Data. Contactar ventasPrueba gratuita![google social icon](/wp-content/themes/brightdata/assets/images/ic_google.svg) Tabla de Contenidos [ ](https://news.ycombinator.com/submitlink?t=C%C3%B3mo+analizar+JSON+en+Python&u=https://brightdata.es/blog/procedimientos/parse-json-data-with-python) [ ](https://www.linkedin.com/shareArticle?mini=true&title=C%C3%B3mo+analizar+JSON+en+Python&url=https://brightdata.es/blog/procedimientos/parse-json-data-with-python) [ ](http://www.reddit.com/submit?title=C%C3%B3mo+analizar+JSON+en+Python&url=https://brightdata.es/blog/procedimientos/parse-json-data-with-python) ## Usted también puede estar interesado en [ ![Cheerio vs. Puppeteer featured image](https://media.brightdata.es/2023/02/Cheerio-vs.-Puppeteer-featured-image.svg) ](https://brightdata.es/blog/datos-web/cheerio-vs-puppeteer "Cheerio vs. Puppeteer para raspado de datos web") [Datos web ![White number one with a flame on top.](https://media.brightdata.es/2023/03/Favicon-2-1-50x50.png) Gints Dreimanis ### Cheerio vs. Puppeteer para raspado de datos web Una mirada a las diferencias entre Puppeteer y Cheerio al construir un raspador web con ambos. 09-Feb-2023 12 min de lectura ](https://brightdata.es/blog/datos-web/cheerio-vs-puppeteer) [ ![People coding at computers with data and media icons.](https://media.brightdata.es/2023/01/Web-scraping-with-R.png) ](https://brightdata.es/blog/procedimientos/web-scraping-with-r "Guía práctica para raspado web en R") [Procedimientos ![Man with beard smiling, wearing black shirt.](https://media.brightdata.es/2021/07/avivb-50x50.png) Aviv Besinsky ### Guía práctica para raspado web en R En este tutorial, recorreremos todos los pasos necesarios para hacer raspado web en R con rvest, con el objetivo de extraer reseñas de productos de una URL de acceso público del sitio web de Amazon. 09-Jan-2023 9 min de lectura ](https://brightdata.es/blog/procedimientos/web-scraping-with-r) [ ![](https://media.brightdata.es/2022/11/How-to-Scrape-with-Python.svg) ](https://brightdata.es/blog/procedimientos/web-scraping-with-python "Raspado web con Python – Guía paso a paso") [Procedimientos ![Antonello Zanini](https://media.brightdata.es/2022/12/Antonello-Zanini-2-50x50.jpg) Antonello Zanini Technical Writer ### Raspado web con Python – Guía paso a paso Aprenda a realizar raspado de datos con Python para recolectar datos de múltiples sitios web rápidamente, ahorrando tiempo y esfuerzo. 29-Nov-2022 23 min de lectura ](https://brightdata.es/blog/procedimientos/web-scraping-with-python)