0Pricing
Python Academy · Aula

Tratamento de estruturas JSON aninhadas

Navegue e transforme objetos JSON aninhados e complexos.

Tratamento de estruturas JSON aninhadas é uma aula grátis de Python Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Python Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Python Academy inclui 4 aulas no total.

Introdução

O JSON do mundo real é profundamente aninhado. Saber navegar, transformar e validar estruturas aninhadas é essencial.

Acessando chaves aninhadas

data['user']['address']['city'] navega por dicionários aninhados. Use .get() em cada nível para lidar com chaves ausentes.
import json
data = {'user': {'address': {'city': 'NYC', 'zip': '10001'}}}
print(data['user']['address']['city'])

Acesso seguro a dados aninhados

data.get('user', {}).get('address', {}).get('city') encadeia chamadas .get() com segurança.
data = {'user': {'name': 'Alice'}}
city = data.get('user', {}).get('address', {}).get('city', 'unknown')
print(city)

Iterando por arrays de objetos

Arrays JSON de objetos são listas de dicionários. Use um laço for para iterar por eles.
import json
data = json.loads('[{"name":"Alice"},{"name":"Bob"}]')
for user in data:
    print(user['name'])

Achatar JSON aninhado

Escreva uma função recursiva para achatar dicionários aninhados em um dicionário simples com chaves separadas por pontos.
def flatten(d, prefix=''):
    result = {}
    for k, v in d.items():
        key = f'{prefix}.{k}' if prefix else k
        if isinstance(v, dict):
            result.update(flatten(v, key))
        else:
            result[key] = v
    return result
print(flatten({'a': {'b': {'c': 1}}, 'd': 2}))

Filtrando arrays

[user for user in data if user.get('active')] filtra um array JSON por uma condição.
data = [{'name':'A','active':True},{'name':'B','active':False}]
active = [u for u in data if u.get('active')]
print(active)

Transformando dados aninhados

Extraia um campo de cada objeto aninhado: [item['name'] for item in data]
data = [{'id': 1, 'name': 'Alice'}, {'id': 2, 'name': 'Bob'}]
names = [d['name'] for d in data]
print(names)

Validação de esquema com jsonschema

pip install jsonschema. jsonschema.validate(instance, schema) gera ValidationError quando os dados são inválidos.
# from jsonschema import validate
# schema = {'type':'object','required':['name']}
# validate({'name':'Alice'}, schema)  # OK
# validate({}, schema)  # raises ValidationError
print('schema validation demo')

Atualizando profundamente dicionários aninhados

dict.update() superficial não mescla dicionários aninhados. Escreva uma função recursiva deep_update para mesclar estruturas aninhadas.
def deep_update(base, override):
    for k, v in override.items():
        if isinstance(v, dict) and isinstance(base.get(k), dict):
            deep_update(base[k], v)
        else:
            base[k] = v
    return base
result = deep_update({'a': {'x': 1}}, {'a': {'y': 2}})
print(result)

Consultas no estilo jq com Python

Para consultas complexas, use a biblioteca jq ou uma pesquisa recursiva personalizada: find_all(data, 'key').
def find_all(obj, key):
    if isinstance(obj, dict):
        if key in obj: yield obj[key]
        for v in obj.values(): yield from find_all(v, key)
    elif isinstance(obj, list):
        for item in obj: yield from find_all(item, key)
data = {'a': {'name': 'x'}, 'b': [{'name': 'y'}]}
print(list(find_all(data, 'name')))

Serialização para NDJSON

JSON delimitado por quebras de linha (NDJSON): um objeto JSON por linha. Escreva com json.dumps(obj) + '\n'.
import json
objects = [{'id': 1}, {'id': 2}, {'id': 3}]
ndjson = '\n'.join(json.dumps(o) for o in objects)
print(ndjson)

Verificação rápida

O que data.get('key', {}).get('nested') retorna quando 'key' está ausente?

Recapitulação

JSON aninhado: encadeie .get() para um acesso seguro. Percorra matrizes com for. Achate com recursão. Filtre com compreensão de listas. Use jsonschema para validação.

Continue

Muito bem! Passe para a próxima lição.

Perguntas Frequentes

A aula “Tratamento de estruturas JSON aninhadas” é grátis?

Sim — o texto completo de “Tratamento de estruturas JSON aninhadas” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Python Academy, atualize para CoddyKit PRO. O curso de Python Academy inclui 4 aulas no total.

O que vou aprender em “Tratamento de estruturas JSON aninhadas”?

Navegue e transforme objetos JSON aninhados e complexos. Você pratica Python Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Python Academy?

Nenhuma experiência prévia é necessária. Python Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “Tratamento de estruturas JSON aninhadas”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Python Academy?

Sim. Cada aula de Python Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Codificação e decodificação de JSON
  2. Tratamento de estruturas JSON aninhadas
  3. Leitura de CSV com csv.reader
  4. Escrita de CSV com csv.DictWriter
← Voltar para Python Academy