Python och JSON är ett naturligt par. Oavsett om du bygger ett REST-API med FastAPI eller Django, bearbetar datapipelines eller bara läser en konfigurationsfil — du kommer att arbeta med JSON hela tiden. Den goda nyheten: Pythons standardbibliotek har allt du behöver i json-modulen. Ingen pip install krävs.

De fyra funktionerna du faktiskt använder

Modulen json ger dig fyra funktioner för det dagliga arbetet:

  • json.loads(str) — tolkar en JSON-sträng till ett Python-objekt
  • json.dumps(obj) — konverterar ett Python-objekt till en JSON-sträng
  • json.load(file) — tolkar JSON direkt från ett fil-objekt
  • json.dump(obj, file) — skriver ett Python-objekt som JSON till en fil

Bokstaven s i loads / dumps står för string (sträng). De utan s arbetar med filobjekt. Lätt att komma ihåg när du väl känner till regeln.

json.loads() — Tolka en JSON-sträng

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'>

Notera typmappningen: JSON true blir Python True, JSON false blir Python False, JSON null blir Python None. JSON-objekt blir Python-dict, JSON-arrayer blir Python-list.

json.dumps() — Serialisera till en JSON-sträng

python
import json

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

# Kompakt (bra för nätverksöverföring)
compact = json.dumps(user)
print(compact)
# {"name": "Bob", "age": 25, "roles": ["admin", "editor"], "active": true, "extra": null}

# Snyggt formaterat (bra för loggar och mänsklig granskning)
pretty = json.dumps(user, indent=2)
print(pretty)
# {
#   "name": "Bob",
#   "age": 25,
#   "roles": [
#     "admin",
#     "editor"
#   ],
#   "active": true,
#   "extra": null
# }

Notera den omvända typmappningen: Python True → JSON true, Python None → JSON null. Python hanterar detta automatiskt.

Läsa JSON från en fil

Det här är förmodligen det vanligaste användningsfallet — läsa en konfigurationsfil eller datafil vid uppstart:

python
import json

# Läs och tolka 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

Ange alltid encoding="utf-8" när du öppnar JSON-filer. JSON är specificerat som UTF-8 av RFC 8259, och att utelämna det kan orsaka problem på Windows där standardkodningen ibland är cp1252.

Skriva JSON till 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 felhantering

json.loads() kastar json.JSONDecodeError (en underklass till ValueError) när indata inte är giltig JSON. Hantera alltid detta när du tolkar data du inte kontrollerar:

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"}')   # fungerar bra
bad  = safe_parse('not json at all')     # skriver ut fel, returnerar None
also_bad = safe_parse('{"key": }')       # skriver ut fel med positionsinformation

JSONDecodeError ger dig exakt rad och kolumn där tolkningen misslyckades — användbart vid felsökning av stora JSON-filer.

Användbara alternativ för dumps()

python
import json

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

# Sortera nycklar alfabetiskt (bra för reproducerbar utdata / diff)
print(json.dumps(data, sort_keys=True, indent=2))
# {
#   "a_key": 2,
#   "price": 9.999999999,
#   "z_key": 1
# }

# Bevara icke-ASCII-tecken (standard: escaped till \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 är något jag alltid lägger till när jag skriver JSON-filer som innehåller icke-ASCII-text. Den escapade versionen är tekniskt sett giltig JSON men mycket svårare att läsa i en textredigerare.

Serialisera anpassade objekt

Som standard kan json.dumps() inte serialisera anpassade klassinstanser eller datetime-objekt. Du har två alternativ: ärva från json.JSONEncoder, eller konvertera till en dict först:

python
import json
from datetime import datetime, date

# Alternativ 1: anpassad kodarklass
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: parametern default= (enklare för engångskonverteringar)
print(json.dumps(data, default=str, indent=2))  # konverterar allt okänt till str

Ett praktiskt mönster: ladda konfigurationsfil

Här är ett verklighetsnära mönster som jag använder i nästan varje Python-projekt — en konfigurationsladdare som läser en JSON-konfigfil med vettiga standardvärden:

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)
                # Djup sammanslagning: användarinställningar åsidosätter standardvärden
                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 åsidosatt värde)

Sammanfattning

Pythons json-modul täcker allt du behöver utan några beroenden. Nyckelreglerna: använd loads()/dumps() för strängar, load()/dump() för filer, hantera alltid JSONDecodeError när du tolkar extern data, och lägg till ensure_ascii=False när din data innehåller icke-latinska tecken. För att felsöka JSON-data kan JSON Formatter och JSON Validator spara dig mycket tid.

← All JSON articles Browse all categories →