Parsing og behandling av JSON- og XML-data.
Når programmer skal utveksle data, trenger de et felles format som begge forstår. De to mest brukte formatene for datautveksling er JSON (JavaScript Object Notation) og XML (eXtensible Markup Language).
I dette kapittelet skal vi se nærmere på:
- Hvordan JSON og XML er strukturert
- Parsing (lesing) av JSON og XML i Python
- Serialisering (skriving) av data til JSON
- Når du bør velge JSON vs XML
- Arbeid med nestede datastrukturer
Serialisering betyr å konvertere Python-objekter til et tekstformat (som JSON eller XML) som kan lagres eller sendes over nettverket.
- JSON → Python: Parsing
- Python → JSON: Serialisering
Python har en innebygd json-modul som gjør det enkelt å arbeide med JSON-data.
Viktige funksjoner:
- json.loads() – Parse JSON-string til Python-objekt
- json.dumps() – Serialiser Python-objekt til JSON-string
- json.load() – Les JSON fra fil
- json.dump() – Skriv JSON til fil
JSON-typer → Python-typer:
JSON Python
------------------
object → dict
array → list
string → str
number → int/float
true → True
false → False
null → NoneLa oss parse en JSON-string til et Python-objekt:
import json
# JSON-string
json_data = '''
{
"navn": "Emma Hansen",
"alder": 18,
"fag": ["Matematikk", "IT", "Fysikk"],
"aktiv": true,
"karakter": null
}
'''
# Parse JSON til Python dictionary
student = json.loads(json_data)
# Nå kan vi jobbe med det som et vanlig Python-objekt
print(f"Navn: {student['navn']}")
print(f"Alder: {student['alder']}")
print(f"Fag: {', '.join(student['fag'])}")
print(f"Aktiv: {student['aktiv']}")
print(f"Type: {type(student)}")Output:
Navn: Emma Hansen
Alder: 18
Fag: Matematikk, IT, Fysikk
Aktiv: True
Type: <class 'dict'>JSON-objektet ble konvertert til en Python dictionary.
Nå skal vi konvertere et Python-objekt til JSON:
import json
# Python dictionary
student = {
'navn': 'Lars Olsen',
'alder': 17,
'fag': ['Norsk', 'Engelsk', 'Historie'],
'aktiv': True,
'karakter': None
}
# Konverter til JSON-string
json_string = json.dumps(student)
print(json_string)
# Med formatering for bedre lesbarhet
json_formatert = json.dumps(student, indent=2, ensure_ascii=False)
print("\nFormatert:")
print(json_formatert)Output:
{"navn": "Lars Olsen", "alder": 17, "fag": ["Norsk", "Engelsk", "Historie"], "aktiv": true, "karakter": null}
Formatert:
{
"navn": "Lars Olsen",
"alder": 17,
"fag": [
"Norsk",
"Engelsk",
"Historie"
],
"aktiv": true,
"karakter": null
}Parametre:
- indent=2: Legger til innrykk for lesbarhet
- ensure_ascii=False: Beholder norske tegn (æ, ø, å)
Her er hvordan vi arbeider med JSON-filer:
import json
# Data vi vil lagre
data = {
'skole': 'Oslo Videregående',
'elever': [
{'navn': 'Emma', 'alder': 18, 'trinn': 'VG3'},
{'navn': 'Lars', 'alder': 17, 'trinn': 'VG2'},
{'navn': 'Sara', 'alder': 16, 'trinn': 'VG1'}
],
'antall': 3
}
# Skriv til fil
with open('skoledata.json', 'w', encoding='utf-8') as f:
json.dump(data, f, indent=2, ensure_ascii=False)
print("Data lagret til skoledata.json")
# Les fra fil
with open('skoledata.json', 'r', encoding='utf-8') as f:
innlest_data = json.load(f)
print(f"\nSkole: {innlest_data['skole']}")
print(f"Antall elever: {innlest_data['antall']}")
for elev in innlest_data['elever']:
print(f"- {elev['navn']} ({elev['trinn']})")Output:
Data lagret til skoledata.json
Skole: Oslo Videregående
Antall elever: 3
- Emma (VG3)
- Lars (VG2)
- Sara (VG1)Dette er nyttig for å lagre konfigurasjoner eller data lokalt.
JSON kan ha nestede objekter og lister, som gjør det mulig å representere komplekse datastrukturer.
Eksempel på nestet JSON:
{
"skole": "Oslo VGS",
"klasser": [
{
"navn": "3A",
"elever": [
{"navn": "Emma", "karakterer": [5, 6, 5]},
{"navn": "Lars", "karakterer": [4, 5, 6]}
]
}
]
}Tilgang til nestede data:
data = json.loads(json_string)
# Tilgang til nestet data
klasse_navn = data['klasser'][0]['navn']
første_elev = data['klasser'][0]['elever'][0]['navn']
første_karakter = data['klasser'][0]['elever'][0]['karakterer'][0]
print(f"Klasse: {klasse_navn}")
print(f"Første elev: {første_elev}")
print(f"Første karakter: {første_karakter}")Du navigerer gjennom strukturen ved å bruke [] for lister og ['key'] for dictionaries.
Eksempel:
<?xml version="1.0" encoding="UTF-8"?>
<student>
<navn>Emma Hansen</navn>
<alder>18</alder>
<fag>
<fag>Matematikk</fag>
<fag>IT</fag>
</fag>
</student>Egenskaper:
- Mer verbose (ordrik) enn JSON
- Støtter attributter: <elev id="123">
- Brukes mye i eldre systemer og bedriftsapplikasjoner
- Støtter kommentarer: <!-- kommentar -->
Python har en innebygd modul for XML: xml.etree.ElementTree
import xml.etree.ElementTree as ET
# XML-data
xml_data = '''
<?xml version="1.0"?>
<skole>
<elev id="1">
<navn>Emma Hansen</navn>
<alder>18</alder>
<karakter>5</karakter>
</elev>
<elev id="2">
<navn>Lars Olsen</navn>
<alder>17</alder>
<karakter>6</karakter>
</elev>
</skole>
'''
# Parse XML
root = ET.fromstring(xml_data)
# Iterer over elever
for elev in root.findall('elev'):
elev_id = elev.get('id') # Hent attributt
navn = elev.find('navn').text
alder = elev.find('alder').text
karakter = elev.find('karakter').text
print(f"ID: {elev_id} - {navn}, {alder} år, karakter: {karakter}")Output:
ID: 1 - Emma Hansen, 18 år, karakter: 5
ID: 2 - Lars Olsen, 17 år, karakter: 6XML er mer komplisert å jobbe med enn JSON, men nødvendig for mange API-er og datasystemer.
✅ Enklere og mer kompakt
✅ Lettere å lese for mennesker
✅ Naturlig mapping til Python-objekter
✅ Standard for moderne web-API-er
✅ Raskere å parse
❌ Ingen støtte for kommentarer
❌ Ingen dokumentskjemaer (XSD)
XML:
✅ Støtter attributter
✅ Støtter kommentarer
✅ Skjemavalidering (XSD, DTD)
✅ Bedre for dokumentorientert data
❌ Mer verbose (tar mer plass)
❌ Vanskeligere å parse
❌ Mindre egnet for web-API-er
Tommelfingerregel:
- Bruk JSON for moderne web-API-er og enkle datastrukturer
- Bruk XML når du må (eldre systemer, SOAP, RSS-feeds)
La oss hente værdata fra et API og lagre det som JSON:
import requests
import json
from datetime import datetime
def hent_og_lagre_vaer(by):
"""Hent værdata og lagre til JSON-fil"""
url = 'https://api.open-meteo.com/v1/forecast'
params = {
'latitude': 59.91 if by == 'Oslo' else 60.39,
'longitude': 10.75 if by == 'Oslo' else 5.32,
'current_weather': True
}
response = requests.get(url, params=params)
if response.status_code == 200:
data = response.json()
# Lag strukturert data
vaerdata = {
'by': by,
'tidspunkt': datetime.now().isoformat(),
'temperatur': data['current_weather']['temperature'],
'vindhastighet': data['current_weather']['windspeed'],
'vaerkode': data['current_weather']['weathercode']
}
# Lagre til fil
filnavn = f'{by.lower()}_vaer.json'
with open(filnavn, 'w', encoding='utf-8') as f:
json.dump(vaerdata, f, indent=2, ensure_ascii=False)
print(f"Værdata for {by} lagret i {filnavn}")
return vaerdata
else:
print(f"Kunne ikke hente værdata: {response.status_code}")
return None
# Test
oslo_vaer = hent_og_lagre_vaer('Oslo')
if oslo_vaer:
print(f"\nTemperatur i Oslo: {oslo_vaer['temperatur']}°C")Dette viser praktisk bruk av både API-kall og JSON-filhåndtering.
Oppsummering
I dette kapittelet har du lært:
- Parsing: lese et format (JSON/XML) til Python-objekter.
- Serialisering: konvertere Python-objekter til et format.
- JSON: vanligste dataformat, lese/skrive med json-modulen.
- XML: markup-språk med tagger for å strukturere data.
- Filhaandtering: lese og skrive JSON-filer.
Noekkelbegreper
| Begrep | Forklaring |
|---|---|
| Parsing | Å lese og tolke data til objekter |
| Serialisering | Å konvertere objekter til et lagringsformat |
| XML | Markup-språk for strukturerte data |
Oppgaver
Dette kapitlet er skrevet av Anthropics toppmodeller (Claude Opus og Claude Fable) og er foreløpig ikke manuelt gjennomgått — kvalitetskontrollen gjøres av uavhengige KI-agenter, og innmeldte feil rettes fortløpende. Funnet en feil? Meld fra, så retter vi den. Les mer om hvordan innholdet lages.