Como Processar Dados JSON com Polars: Um Guia Rápido
Published on
Você sonha em processar dados JSON como um profissional? Bem-vindo a bordo! Hoje, exploraremos o Polars, uma biblioteca superpoderosa de DataFrame em Python e Rust, com um destaque especial para o manejo de dados JSON. Com seu desempenho ultrarrápido e métodos fáceis de usar, você verá por que o Polars está se tornando rapidamente a escolha preferida dos cientistas de dados ao redor do mundo.
Convertendo Coluna de Strings JSON para Dicionário em Polars
Frequentemente, você pode se deparar com um DataFrame em que uma coluna contém strings JSON. Digamos que você queira filtrar esse DataFrame com base em chaves ou valores específicos dentro dessas strings JSON. A maneira mais robusta de lidar com isso seria converter as strings JSON em dicionários. No entanto, o Polars não trabalha com dicionários genéricos. Em vez disso, ele usa um conceito conhecido como 'structs', onde cada chave do dicionário é mapeada para um 'nome do campo' da struct e o valor correspondente do dicionário se torna o valor desse campo.
No entanto, há um porém: a criação de uma série do tipo struct tem duas principais restrições:
- Todos os structs devem ter os mesmos nomes de campos.
- Os nomes dos campos devem ser listados na mesma ordem.
Mas não se preocupe! O Polars fornece uma função chamada json_path_match que extrai valores com base na sintaxe do JSONPath. Com isso, você pode verificar se uma chave existe e recuperar seu valor. Veja como fazer isso:
import polars as pl
json_list = [
"""{"name": "Maria", "position": "developer", "office": "Seattle"}""",
"""{"name": "Josh", "position": "analyst", "termination_date": "2020-01-01"}""",
"""{"name": "Jorge", "position": "architect", "office": "", "manager_st_dt": "2020-01-01"}""",
]
df = pl.DataFrame(
{
"tags": json_list,
}
).with_row_count("id", 1)
df = df.with_columns([
pl.col('tags').str.json_path_match(r"$.name").alias('name'),
pl.col('tags').str.json_path_match(r"$.office").alias('location'),
pl.col('tags').str.json_path_match(r"$.manager_st_dt").alias('data de início do gerente'),
])No exemplo acima, criamos um DataFrame com uma coluna chamada 'tags' contendo strings JSON. Em seguida, usamos a função json_path_match para extrair valores específicos. Esses valores são então atribuídos a novas colunas ('name', 'location', 'data de início do gerente') em nosso DataFrame.
Observe que se uma chave não for encontrada, o json_path_match retornará nulo. Podemos usar esse fato para filtrar nosso DataFrame com base na presença de uma determinada chave.
df = df.filter(pl.col('tags').str.json_path_match(r"$.manager_st_dt").is_not_null())Na linha de código acima, estamos filtrando nosso DataFrame para incluir somente linhas em que a chave 'manager_st_dt' está presente na string JSON.
Lendo Arquivos JSON Grandes como um DataFrame em Polars
Ao trabalhar com arquivos JSON grandes, você pode encontrar o seguinte erro: "RuntimeError: BindingsError: "ComputeError(Owned("InvalidEOF"))". Pode haver várias razões para esse erro, mas uma causa comum é o Polars tentando inferir o esquema das primeiras 1000 linhas do arquivo JSON e, em seguida, encontrando um esquema diferente mais adiante no arquivo. Isso geralmente ocorre devido a algumas entradas terem chaves adicionais que não estavam presentes nas 1000 linhas iniciais.
Para lidar com essas situações, podemos instruir o Polars a usar um esquema específico ao ler o arquivo, ou podemos forçar o Polars a analisar o arquivo inteiro para inferir o esquema. A opção posterior pode levar mais tempo, especialmente para arquivos grandes, mas evitará o erro "InvalidEOF".
df = pl.read_json("arquivo_grande.json", infer_schema_length=None)Definir infer_schema_length como None força o Polars a analisar todo o arquivo ao inferir o esquema. Essa operação pode levar mais tempo, mas garante que o Polars reconheça com precisão o esquema de todo o arquivo, eliminando possíveis erros.
Com essas técnicas, você pode lidar de forma eficaz com tarefas de processamento de dados JSON no Polars, desde transformar strings JSON até gerenciar arquivos JSON grandes. O Polars realmente abre novas possibilidades para o processamento eficiente de dados.
Visualize seu DataFrame Polars com o PyGWalker
PyGWalker (opens in a new tab) é uma biblioteca python de código aberto que pode ajudá-lo a criar visualizações de dados a partir do seu DataFrame Polars com facilidade.
Não é mais necessário realizar processamentos complicados com programação Python, basta importar seus dados e arrastar e soltar variáveis para criar todo tipo de visualização de dados! Aqui está um vídeo de demonstração rápida sobre a operação:
Veja como usar o PyGWalker em seu Jupyter Notebook:
pip install pygwalker
import pygwalker as pyg
gwalker = pyg.walk(df)Ou experimente no Kaggle Notebook/Google Colab:
PyGWalker é construído com o suporte da nossa comunidade de código aberto. Não se esqueça de verificar o PyGWalker GitHub (opens in a new tab) e nos dar uma estrela!
Perguntas Frequentes
Aqui estão algumas perguntas frequentes relacionadas ao manuseio de dados JSON no Polars:
P: Por que preciso converter strings JSON em dicionário no Polars?
R: O Polars não trabalha diretamente com dicionários Python. Em vez disso, ele usa o conceito de 'structs'. Converter strings JSON em structs ajuda a realizar operações com base em chaves ou valores específicos dentro dessas strings JSON.
P: O que o parâmetro 'infer_schema_length' faz na função 'read_json'?
R: O parâmetro 'infer_schema_length' define quantas linhas o Polars deve examinar a partir do início do seu arquivo JSON para inferir seu esquema. Se definido como None, o Polars examinará todo o arquivo, garantindo uma compreensão abrangente do esquema em detrimento de tempos de carregamento mais longos.
P: O que acontece se uma chave não for encontrada ao usar a função 'json_path_match'?
R: Se a função 'json_path_match' não encontrar uma chave, ela retorna null. Esse comportamento pode ser utilizado para filtrar dados com base na presença ou ausência de chaves específicas.