Python og JSON er et naturlig par. Enten du bygger et REST API med FastAPI eller Django, behandler datapipelines eller bare leser en konfigurasjonsfil — du vil jobbe med JSON hele tiden. Den gode nyheten: Pythons standardbibliotek har alt du trenger i json-modulen. Ingen pip install nødvendig.

De fire funksjonene du faktisk bruker

Modulen json gir deg fire funksjoner for det daglige arbeidet:

  • json.loads(str) — parser en JSON-streng til et Python-objekt
  • json.dumps(obj) — konverterer et Python-objekt til en JSON-streng
  • json.load(file) — parser JSON direkte fra et fil-objekt
  • json.dump(obj, file) — skriver et Python-objekt som JSON til en fil

Bokstaven s i loads / dumps står for string (streng). De uten s jobber med filobjekter. Lett å huske når du kjenner regelen.

json.loads() — Parser en JSON-streng

python
import json

json_string = '{"name": "Alice", "age": 30, "active": true, "score": 98.5}'

user = json.loads(json_string)

print(user["name"])    # Alice
print(user["age"])     # 30
print(user["active"])  # True
print(type(user))      # <class 'dict'>

Legg merke til type-mappingen: JSON true blir Python True, JSON false blir Python False, JSON null blir Python None. JSON-objekter blir Python-dict, JSON-arrayer blir Python-list.

json.dumps() — Serialisering til en JSON-streng

python
import json

user = {
    "name": "Bob",
    "age": 25,
    "roles": ["admin", "editor"],
    "active": True,
    "extra": None
}

# Kompakt (bra for nettverksoverføring)
compact = json.dumps(user)
print(compact)
# {"name": "Bob", "age": 25, "roles": ["admin", "editor"], "active": true, "extra": null}

# Pent formatert (bra for logger og menneskelig inspeksjon)
pretty = json.dumps(user, indent=2)
print(pretty)
# {
#   "name": "Bob",
#   "age": 25,
#   "roles": [
#     "admin",
#     "editor"
#   ],
#   "active": true,
#   "extra": null
# }

Legg merke til den omvendte type-mappingen: Python True → JSON true, Python None → JSON null. Python håndterer dette automatisk.

Lese JSON fra en fil

Dette er sannsynligvis det vanligste brukstilfellet — lese en konfigurasjonsfil eller datafil ved oppstart:

python
import json

# Les og parser i ett steg
with open("config.json", "r", encoding="utf-8") as f:
    config = json.load(f)

print(config["database"]["host"])  # localhost
print(config["database"]["port"])  # 5432

Angi alltid encoding="utf-8" når du åpner JSON-filer. JSON er spesifisert som UTF-8 av RFC 8259, og å utelate det kan forårsake problemer på Windows der standardkodingen noen ganger er cp1252.

Skrive JSON til en fil

python
import json

results = {
    "timestamp": "2024-01-15T09:30:00Z",
    "total": 1523,
    "processed": 1521,
    "failed": 2,
    "errors": [
        {"id": 42, "reason": "missing field"},
        {"id": 99, "reason": "invalid format"}
    ]
}

with open("results.json", "w", encoding="utf-8") as f:
    json.dump(results, f, indent=2)

print("Results saved to results.json")

Korrekt feilhåndtering

json.loads() kaster json.JSONDecodeError (en underklasse av ValueError) når inndataene ikke er gyldig JSON. Håndter alltid dette når du parser data du ikke kontrollerer:

python
import json

def safe_parse(json_str):
    try:
        return json.loads(json_str)
    except json.JSONDecodeError as e:
        print(f"Invalid JSON at line {e.lineno}, column {e.colno}: {e.msg}")
        return None

data = safe_parse('{"name": "Alice"}')   # fungerer fint
bad  = safe_parse('not json at all')     # skriver ut feil, returnerer None
also_bad = safe_parse('{"key": }')       # skriver ut feil med posisjonsinformasjon

JSONDecodeError gir deg den eksakte linjen og kolonnen der parsingen mislyktes — nyttig ved feilsøking av store JSON-filer.

Nyttige dumps()-alternativer

python
import json

data = {
    "z_key": 1,
    "a_key": 2,
    "price": 9.999999999
}

# Sorter nøkler alfabetisk (bra for reproduserbar utdata / diff)
print(json.dumps(data, sort_keys=True, indent=2))
# {
#   "a_key": 2,
#   "price": 9.999999999,
#   "z_key": 1
# }

# Bevar ikke-ASCII-tegn (standard: escaped til \uXXXX)
data2 = {"city": "Münich", "greeting": "こんにちは"}
print(json.dumps(data2, ensure_ascii=False))
# {"city": "Münich", "greeting": "こんにちは"}

# Med ensure_ascii=True (standard):
print(json.dumps(data2))
# {"city": "M\u00fcnich", "greeting": "\u3053\u3093\u306b\u3061\u306f"}

ensure_ascii=False er noe jeg alltid legger til når jeg skriver JSON-filer som inneholder ikke-ASCII-tekst. Den escapede versjonen er teknisk sett gyldig JSON, men mye vanskeligere å lese i en teksteditor.

Serialisering av egendefinerte objekter

Som standard kan ikke json.dumps() serialisere egendefinerte klasseinstanser eller datetime-objekter. Du har to alternativer: arv fra json.JSONEncoder, eller konverter til en dict først:

python
import json
from datetime import datetime, date

# Alternativ 1: egendefinert koderklasse
class AppEncoder(json.JSONEncoder):
    def default(self, obj):
        if isinstance(obj, (datetime, date)):
            return obj.isoformat()
        return super().default(obj)

data = {"name": "Alice", "created_at": datetime(2024, 1, 15, 9, 30)}
print(json.dumps(data, cls=AppEncoder, indent=2))
# {
#   "name": "Alice",
#   "created_at": "2024-01-15T09:30:00"
# }

# Alternativ 2: parameteren default= (enklere for engangkonverteringer)
print(json.dumps(data, default=str, indent=2))  # konverterer alt ukjent til str

Et praktisk mønster: laste konfigurasjonsfil

Her er et virkelighetsnært mønster jeg bruker i nesten alle Python-prosjekter — en konfigurasjonsinnlaster som leser en JSON-konfig-fil med fornuftige standardverdier:

python
import json
import os
from pathlib import Path

DEFAULTS = {
    "database": {"host": "localhost", "port": 5432},
    "debug": False,
    "log_level": "INFO"
}

def load_config(path="config.json"):
    config = DEFAULTS.copy()

    config_path = Path(path)
    if config_path.exists():
        with open(config_path, "r", encoding="utf-8") as f:
            try:
                user_config = json.load(f)
                # Dyp sammenslåing: brukerinnstillinger overstyrer standarder
                for key, value in user_config.items():
                    if isinstance(value, dict) and key in config:
                        config[key].update(value)
                    else:
                        config[key] = value
            except json.JSONDecodeError as e:
                print(f"Warning: config.json is invalid ({e.msg}), using defaults")

    return config

config = load_config()
print(config["database"]["host"])  # localhost (eller overstyrt verdi)

Oppsummering

Pythons json-modul dekker alt du trenger uten noen avhengigheter. Nøkkelreglene: bruk loads()/dumps() for strenger, load()/dump() for filer, håndter alltid JSONDecodeError ved parsing av eksterne data, og legg til ensure_ascii=False når dataene dine inneholder ikke-latinske tegn. For feilsøking av JSON-data kan JSON Formatter og JSON Validator spare deg mye tid.

← All JSON articles Browse all categories →