Python Academy · Lektion

Hantera nästlade JSON-strukturer

Navigera i och omforma komplexa nästlade JSON-objekt.

Lektion 2 av 414 steg

Hantera nästlade JSON-strukturer är en gratis lektion i Python Academy på CoddyKit. Detta är lektion 2 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Python Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Python Academy innehåller totalt 4 lektioner.

Introduktion

JSON-data från verkligheten är djupt nästlad. Det är viktigt att kunna navigera i, omvandla och validera nästlade strukturer.

Åtkomst till nästlade nycklar

data['user']['address']['city'] navigerar genom nästlade dict-objekt. Använd .get() på varje nivå för att hantera saknade nycklar.

import json
data = {'user': {'address': {'city': 'NYC', 'zip': '10001'}}}
print(data['user']['address']['city'])

Säker åtkomst till nästlade data

data.get('user', {}).get('address', {}).get('city') kedjar .get()-anrop på ett säkert sätt.

data = {'user': {'name': 'Alice'}}
city = data.get('user', {}).get('address', {}).get('city', 'unknown')
print(city)

Iterera över arrayer med objekt

JSON-arrayer med objekt är listor med dict-objekt. Iterera över dem med en for-loop.

import json
data = json.loads('[{"name":"Alice"},{"name":"Bob"}]')
for user in data:
    print(user['name'])

Platta ut nästlad JSON

Skriv en rekursiv funktion som plattar ut nästlade dict-objekt till en platt dict med punktseparerade nycklar.

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}))

Filtrera arrayer

[user for user in data if user.get('active')] filtrerar en JSON-array utifrån ett villkor.

data = [{'name':'A','active':True},{'name':'B','active':False}]
active = [u for u in data if u.get('active')]
print(active)

Omvandla nästlade data

Extrahera ett fält från varje nästlat objekt: [item['name'] for item in data]

data = [{'id': 1, 'name': 'Alice'}, {'id': 2, 'name': 'Bob'}]
names = [d['name'] for d in data]
print(names)

Sche validering med jsonschema

pip install jsonschema. jsonschema.validate(instance, schema) orsakar ValidationError för ogiltiga data.

# from jsonschema import validate
# schema = {'type':'object','required':['name']}
# validate({'name':'Alice'}, schema)  # OK
# validate({}, schema)  # raises ValidationError
print('schema validation demo')

Djupuppdatera nästlade dict-objekt

Shallow dict.update() slår inte ihop nästlade dict-objekt. Skriv en rekursiv deep_update för att slå ihop nästlade strukturer.

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)

jq-liknande frågor med Python

För komplexa frågor använder ni jq-biblioteket eller en anpassad rekursiv sökning: 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')))

Serialisering till NDJSON

Newline-delimited JSON (NDJSON): ett JSON-objekt per rad. Skriv med 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)

Snabbkontroll

Vad returnerar data.get('key', {}).get('nested') när 'key' saknas?

Besvara frågan i den interaktiva lektionen

Sammanfattning

Kapslad JSON: kedja .get() för säker åtkomst. Iterera över arrayer med for. Platta till med rekursion. Filtrera med list comprehensions. Använd jsonschema för validering.

Fortsätt

Fortsätt så! Gå vidare till nästa lektion.

Gratis att börja

Lär dig Python med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 76
Lektioner: 320

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Hantera nästlade JSON-strukturer” gratis?

Ja – hela texten till ”Hantera nästlade JSON-strukturer” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Python Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i Python Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Hantera nästlade JSON-strukturer”?

Navigera i och omforma komplexa nästlade JSON-objekt. Ni övar på Python Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Python Academy?

Du behöver inga förkunskaper. Utbildningen i Python Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 2 av 4.

Hur lång tid tar lektionen ”Hantera nästlade JSON-strukturer”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Python Academy-lektionen?

Ja. Varje Python Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till Python Academy