0Pricing
Python Academy · Lezione

Gestione delle strutture JSON annidate

Esplori e trasformi oggetti JSON complessi e annidati.

Gestione delle strutture JSON annidate è una lezione Python Academy gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Python Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Python Academy include 4 lezioni in totale.

Introduzione

Il JSON del mondo reale è profondamente annidato. Saper navigare, trasformare e convalidare strutture annidate è essenziale.

Accesso alle chiavi annidate

data['user']['address']['city'] consente di navigare nei dict annidati. Utilizzi .get() a ogni livello per gestire le chiavi mancanti.
import json
data = {'user': {'address': {'city': 'NYC', 'zip': '10001'}}}
print(data['user']['address']['city'])

Accesso sicuro ai dati annidati

data.get('user', {}).get('address', {}).get('city') concatena chiamate a .get() in modo sicuro.
data = {'user': {'name': 'Alice'}}
city = data.get('user', {}).get('address', {}).get('city', 'unknown')
print(city)

Iterazione su array di oggetti

Gli array JSON di oggetti sono liste di dict. Li iteri con un ciclo for.
import json
data = json.loads('[{"name":"Alice"},{"name":"Bob"}]')
for user in data:
    print(user['name'])

Appiattimento del JSON annidato

Scriva una funzione ricorsiva per appiattire i dict annidati in un dict piatto con chiavi separate da punti.
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}))

Filtraggio degli array

[user for user in data if user.get('active')] filtra un array JSON in base a una condizione.
data = [{'name':'A','active':True},{'name':'B','active':False}]
active = [u for u in data if u.get('active')]
print(active)

Trasformazione dei dati annidati

Estragga un campo da ogni oggetto annidato: [item['name'] for item in data]
data = [{'id': 1, 'name': 'Alice'}, {'id': 2, 'name': 'Bob'}]
names = [d['name'] for d in data]
print(names)

Convalida dello schema con jsonschema

pip install jsonschema. jsonschema.validate(instance, schema) genera ValidationError quando i dati non sono validi.
# from jsonschema import validate
# schema = {'type':'object','required':['name']}
# validate({'name':'Alice'}, schema)  # OK
# validate({}, schema)  # raises ValidationError
print('schema validation demo')

Aggiornamento profondo dei dict annidati

dict.update() superficiale non unisce i dict annidati. Scriva una funzione ricorsiva deep_update per eseguire un'unione profonda.
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)

Query in stile jq con Python

Per le query complesse, utilizzi la libreria jq o una ricerca ricorsiva personalizzata: 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')))

Serializzazione in NDJSON

JSON delimitato da newline (NDJSON): un oggetto JSON per riga. Scriva con 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 rapida

Che cosa restituisce data.get('key', {}).get('nested') quando 'key' non è presente?

Riepilogo

JSON annidato: concateni .get() per un accesso sicuro. Iteri sugli array con for. Appiattisca i dati con la ricorsione. Filtri con le list comprehension. Utilizzi jsonschema per la validazione.

Continui

Continui così! Passi alla lezione successiva.

Domande Frequenti

La lezione «Gestione delle strutture JSON annidate» è gratuita?

Sì — il testo completo di «Gestione delle strutture JSON annidate» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Python Academy, passa a CoddyKit PRO. Il corso Python Academy include 4 lezioni in totale.

Cosa imparerò in «Gestione delle strutture JSON annidate»?

Esplori e trasformi oggetti JSON complessi e annidati. Eserciti Python Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Python Academy?

Non è richiesta alcuna esperienza precedente. Python Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.

Quanto tempo richiede la lezione «Gestione delle strutture JSON annidate»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Python Academy?

Sì. Ogni lezione Python Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Codifica e decodifica JSON
  2. Gestione delle strutture JSON annidate
  3. Lettura dei CSV con csv.reader
  4. Scrittura dei CSV con csv.DictWriter
← Torna a Python Academy