Como analisar arquivos JSON com Python JSONPath

JSON é, atualmente, um dos formatos mais importantes para a troca de dados entre aplicações, especialmente on-line. JSONPath é uma linguagem de expressão que pode ser usada para ler dados específicos de objetos JSON. Neste artigo, acompanhe a implementação do Python JSONPath e aprenda a usá-lo com os nossos exemplos simplificados e fáceis de entender.

O que é Python JSONPath?

JSON é um formato de arquivo multiplataforma que pode ser usado para facilitar a troca de dados estruturados entre aplicações. Arquivos JSON consistem em pares de chave-valor listados. Esses valores podem aceitar diferentes tipos de dados, tanto valores primitivos quanto objetos. Objetos, por sua vez, podem conter seus próprios pares de chave-valor. Como o JSON é compreendido por quase todos os sistemas modernos, ele pode ser usado para trocas de dados entre quaisquer tipos de aplicação, tanto localmente quanto pela internet.

Nem toda aplicação, contudo, precisa de todos os dados capturados em um arquivo JSON. Para estas, o JSONPath é uma boa escolha. Como previamente mencionado, JSONPath é uma linguagem de expressão que pode ser usada para ler informações específicas de objetos JSON. Na maioria das linguagens de programação, o JSONPath precisa ser importado de uma biblioteca externa. Como essas bibliotecas precisam ser implementadas separadamente para cada linguagem, elas e o processo de implementação podem diferir ligeiramente.

Módulo Python JSONPath

A implementação Python mais comum do JSONPath é, provavelmente, jsonpath-ng, apesar de haver outras opções de implementação de JSONPath para Python, como jsonpath e jsonpath-rw. No entanto, essas opções são menos populares e oferecem funcionalidades mais limitadas, o que torna o jsonpath-ng a escolha mais recomendada..

Instalação

Você pode instalar o jsonpath-ng de forma muito simples pelo terminal. Basta inserir o comando pip install jsonpath-ng para começar.

Sintaxe

O JSONPath pode ser usado para executar consultas complexas em objetos JSON. No módulo, existem diferentes métodos, operadores e expressões atômicas que podem ser usados para selecionar e consultar dados específicos. Os dois métodos JSONPath mais importantes são parse() e find(). Com parse(), você define consultas, que podem ser referenciadas e repetidas quantas vezes for necessário. Com find(), você executa essas consultas em dados JSON para extrair valores concretos. O exemplo a seguir explica melhor:

import json
import jsonpath_ng as jp
raw_data = '''
{
    "name": "John",
    "age": 30,
    "place of residence": "New York"
}
'''
json_object = json.loads(raw_data)
name_query = jp.parse("$.name")
result = name_query.find(json_object)
print(result[0].value) # saída: John

No exemplo acima, dados JSON no formato de string foram convertidos em um dicionário, graças ao json.loads - este é o formato com o qual o Python funciona melhor. Ao criar o name_query, a consulta $.name foi definida, par retornar o valor de name. Isso foi então aplicado ao objeto JSON, com find(). O resultado da consulta foi armazenado na variável result e lido com result[0].value.

O método find não retorna apenas o valor solicitado, mas também outras informações contextuais, como o caminho para o valor procurado. Essa informação é retornada na forma de uma lista, na qual o valor procurado recebe o índice 0. Então, você poderá usar result[0].value para exibir o valor desejado.

No exemplo acima, o cifrão foi usado para definir a consulta. Este é um operador atômico que se refere ao objeto raiz do JSON. Todos os operadores e expressões atômicas estão listados na tabela a seguir.

Na implementação em Python do JSONPath, filtros podem ser usados para tornar sua pesquisa ainda mais específica. Essas consultas podem ser feitas com a ajuda de operadores Python. A tabela abaixo mostra todos os símbolos com exemplos:

Exemplo de aplicação de Python JSONPath

import json
import jsonpath_ng as jp
# Dados JSON como string
data = """
{
    "cities": [
        {
            "name": "Trenton",
            "state": "New Jersey",
            "residents": 90048,
            "iscapital": true,
            "neighborhood Central West": {
                "residents": 1394    
            }
        },
        {
            "name": "Hamburg",
            "state": "Hamburg",
            "residents": 1841000,
            "iscapital": false
        },
        {
            "name": "New York City",
            "state": "New York",
            "residents": 8804190,
            "iscapital": false
        },
        {
            "name": "Los Angeles",
            "state": "California",
            "residents": 3898767
        }
    ]
}
"""
# Converter dados de string para dicionário
json_data = json.loads(data)
# Consulta: Nomes de todas as cidades
query1 = jp.parse("cities[*].name")
for match in query1.find(json_data):
    print(match.value)  # saída: Trenton, Hamburg, New York City, Los Angeles
# Importar jsonpath_ng.ext para aplicar filtros
import jsonpath_ng.ext as jpx
# Consulta: Nomes de todas as cidades com menos de 1,5 milhão de habitantes
query2 = jpx.parse("$.cities[?(@.residents < 1500000)].name")
for match in query2.find(json_data):
    print(match.value)  # saída: Trenton
# Todos os campos rotulados como “residents”
query3 = jp.parse("$.cities..residents")
match = query3.find(json_data)
for i in match:
    print(i.value)  # saída: 1394, 1841000, 8804190, 3898767
# Os nomes de todas as cidades que não se chamam “Trenton”
query4 = jpx.parse('$.cities[?(@.name != "Trenton")].name')
for match in query4.find(json_data):
    print(match.value)  # saída: Hamburg, New York City, Los Angeles

No exemplo acima, os dados JSON são especificados como uma string e depois convertidos em um objeto dicionário, por loads(). Há apenas um único array no objeto raiz, que, por sua vez, contém 4 cidades. Cada cidade possui 4 campos com os seguintes dados:

• Nome da cidade
• Estado da cidade
• Número de habitantes
• Se a cidade é a capital ou não

New Jersey possui um campo adicional, chamado “Central West”, que também possui um número de habitantes.

Após os dados serem convertidos para um formato adequado, 4 consultas diferentes são executadas. Suas funções e saídas estão indicadas como comentários no exemplo. Você pode notar que cinco valores foram retornados na terceira consulta. Isso ocorre porque o operador “..” pesquisa recursivamente por campos correspondentes. Isso significa que todos os objetos são pesquisados, bem como todos os filhos desses objetos. Assim, o número de habitantes de Central West é listado ao lado do número de habitantes das cidades.