Atualmente, o JSON é um dos formatos mais importantes para a troca de dados entre aplicativos, especialmente on-line. JSONPath é uma linguagem de expressão que pode ser usada para ler dados específicos de objetos JSON. Aqui, veremos a implementação Python do JSONPath e onde usá-lo usando exemplos fáceis de entender.

O que é Python JSONPath?

JSON é um formato de arquivo entre sistemas que pode ser usado para facilitar a troca de dados estruturados entre aplicativos. Os arquivos JSON consistem em pares de valores-chave listados. Os valores podem aceitar diferentes tipos de dados, tanto valores primitivos quanto objetos. Os objetos, por sua vez, podem conter seus próprios pares de valores-chave. Como o JSON é compreendido por quase todos os sistemas modernos, ele pode ser usado para troca de dados entre qualquer tipo de aplicativo, tanto localmente na máquina quanto pela Internet.

Mas nem todo aplicativo precisa de todos os seus dados capturados em um arquivo JSON. Nesses casos, o JSONPath é uma boa opção. 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, as bibliotecas ou implementações podem ser ligeiramente diferentes.

O módulo Python jsonpath-ng

jsonpath-ng é provavelmente a implementação Python mais comum do JSONPath. Há também outras implementações do JSONPath para Python, como jsonpath e jsonpath-rw. Mas esses são menos populares e abrangentes, portanto, vamos nos concentrar exclusivamente no jsonpath-ng aqui.

Instalação

Você pode instalar o jsonpath-ng muito facilmente a partir do seu shell. Basta digitar o comando pip install jsonpath-ng para iniciar.

Nota

A instalação é feita por meio do gerenciador de pacotes pip, que é usado por padrão para o Python. Caso não tenha esse gerenciador de pacotes instalado, você precisará baixá-lo primeiro. Mais informações podem ser encontradas no Pip website.

Sintaxe

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

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) # output: John
Python

No exemplo acima, os dados JSON na forma de uma cadeia de caracteres foram convertidos em um objeto de dicionário * usando* json.loads. Esse é o formato com o qual o Python funciona melhor. Ao criar name_query, foi definida a solicitação $.name , que deve retornar o valor de name. Isso foi então aplicado ao objeto JSON com find(). O resultado da solicitação foi armazenado na variável result e lido com result[0].value.

Nota

Para que o Python possa ler dados JSON de uma string ou de um arquivo JSON, o módulo Python json deve ser incluído, como no exemplo acima. As strings e os arquivos podem então ser convertidos em um formato legível em Python usando loads() ou load().

O método find não retorna apenas o valor solicitado, mas também outras informações contextuais, como o caminho para o valor pesquisado. Essas informações são retornadas na forma de uma lista, em que o valor que você está procurando tem um índice 0. Agora você pode usar result[0].value para gerar o valor que está procurando.

No exemplo acima, o cifrão foi usado ao definir a solicitação. Essa é uma expressão atômica que é usada para se referir ao objeto raiz do JSON. Todos os operadores e expressões atômicas estão listados na tabela a seguir.

Expression/Operator Meaning Example Explanation
$ Root-object $.marcus.age Pesquisa o valor da chave “age” do objeto “marcus”.
. Campo de um objeto $.marcus Pesquisa “marcus”, em que “marcus” é um campo do objeto raiz.
.. Pesquisa recursiva de um campo. Os campos em subobjetos também são pesquisados. $.people..age Retorna todas as ocorrências do campo “age” em people e seus subobjetos.
[x] Elemento em uma matriz $.people[5] Procura o sexto elemento (no índice 5) na matriz “people”.
\* Substituto de número, usado principalmente em conexão com loops for ‘$.people[*]’ Procura um campo em “people”. Combinado com um loop for, cada campo é retornado por vez.

Além de expressões e operadores, há filtros que você pode usar para tornar sua pesquisa ainda mais específica. Na implementação Python do JSONPath, eles podem ser executados com operadores Python. Todos os símbolos que podem ser usados com filtros são mostrados com exemplos na tabela a seguir.

Symbols Meaning Example Explanation
.[?(filter)] Sintaxe geral para filtros. Os colchetes podem ser deixados de fora. $.people[?(@.name == "Anne")] Pesquisa pessoas cujo nome é “Anne”.
@ Objeto que está sendo pesquisado no momento, frequentemente usado em conexão com loops for. $.people[?(@.age < 50)] Pesquisa campos em “people” cujo valor para “age” seja menor que 50.
<, >, <=, >=, == und != Operadores de comparação que podem ser usados para filtrar resultados de pesquisa específicos. $.people[@.age < 50 & @.age > 20] Pesquisas de pessoas com idade entre 20 e 50 anos.
& Lógica E. $.people[?(@.place of residence == Newark & @.age > 40)] Pesquisa por pessoas com mais de 40 anos e que moram em Newark.
Nota

Se quiser usar filtros, você precisará incluir o módulo jsonpath_ng.ext e fazer referência a ele ao chamar parse().

Caso de uso do Python JSONPath

import json
import jsonpath_ng as jp
# JSON data as string
import json
import jsonpath_ng as jp
# JSON data as 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
        }
    ]
}
"""
# Convert data from String to dictionary
json_data = json.loads(data)
# Inquiry: Names of all cities
query1 = jp.parse("cities[*].name")
for match in query1.find(json_data):
    print(match.value)     # output: Trenton, Hamburg, New York City, Los Angeles
# jsonpath_ng.ext import to apply filters
import jsonpath_ng.ext as jpx
# Anfrage: Names of all cities with less than 1.5 million residents 
query2 = jpx.parse("$.cities[?@.residents < 1500000].name")
for match in query2.find(json_data):
    print(match.value)     # output: Trenton
# All fields labeled “residents” 
query3 = jp.parse("$.cities..residents")
match = query3.find(json_data)
for i in match:
    print(i.value)     # output: 1394, 1841000, 8804190, 3898767
# The names of all cities that are not called “Trenton”
query4 = jpx.parse('$.cities[?(@.name != "Trenton")].name')
for match in query4.find(json_data):
    print(match.value)     # output: Hamburg, New York City, Los Angeles
Python

Neste exemplo, os dados JSON são especificados como uma cadeia de caracteres e, em seguida, convertidos em um objeto de dicionário usando loads(). Há apenas uma única matriz no objeto raiz, que, por sua vez, contém 4 cidades. Cada cidade tem 4 campos que contêm os seguintes dados:

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

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

Após a conversão dos dados em um formato adequado, são executadas quatro consultas diferentes. Suas funções e resultados são deixados como comentários no exemplo. Você pode notar que cinco valores retornaram na terceira solicitação. Isso se deve ao fato de que o operador “…” ** busca recursivamente os campos correspondentes**. Isso significa que todos os objetos são pesquisados, bem como todos os filhos desses objetos. Dessa forma, o número de habitantes do Centro-Oeste é listado ao lado do número de habitantes das cidades.

Dica

Combinados, JSON e Python formam uma ferramenta versátil para programação na Internet. Se você tem um aplicativo da Web que deseja publicar de forma rápida, fácil e diretamente do Git, Deploy Now from IONOS pode ser a solução ideal.

Este artigo foi útil?
Ir para o menu principal