JSON Formatter Python — json.dumps() Guide

Maria Santos·Backend Developer·Granskad avDmitri Volkov·Publicerad 2026-03-10

Använd det kostnadsfria JSON Formatter & Beautifier direkt i webbläsaren — ingen installation krävs.

Prova JSON Formatter & Beautifier online →

När jag felsöker en Python API-klient är det första jag tar till python pretty print json — ett anrop till json.dumps(data, indent=4) och en oläslig enradsklump blir direkt navigerbar. Pythons inbyggda json modul hanterar detta helt i standardbiblioteket — ingen tredjepartsinstallation krävs. Om du bara behöver ett snabbt resultat utan att skriva kod gör ToolDecks JSON Formatter det omedelbart. Den här guiden täcker alla praktiska metoder: json.dumps() med alla dess parametrar, pprint, orjson för högpresterande formatering, CLI:n json.tool, och verkliga scenarier som formatering av API-svar och läsning från disk — allt med Python 3.8+-kompatibel kod. Det täcker även serialisering av anpassade typer som datetime och UUID, streaming av gigabyte-stora filer med ijson, och syntaxmarkering i terminalen med rich.

Viktiga punkter

→json.dumps(data, indent=4) är inbyggt i Pythons stdlib sedan 2.6 — ingen installation behövs.
→Skicka ensure_ascii=False när din data innehåller å, ä, ö, CJK-tecken eller emoji.
→För datetime, UUID eller anpassade klasser, använd parametern default= eller subklassa json.JSONEncoder.
→separators=(',', ':') tar bort alla mellanslag — används för nätverksöverföring eller URL-inbäddning.
→orjson är 5–10× snabbare än stdlib och hanterar datetime och uuid.UUID nativt.
→pprint.pprint() ger Python-syntax (True/None), inte giltig JSON — använd aldrig för filer eller API-svar.
→För JSON-filer större än 50 MB, strömma med ijson istället för json.load() för att undvika MemoryError.

Vad är JSON Pretty Printing?

Pretty printing omvandlar en tät, minifierad JSON-sträng till ett lättläst format med konsekvent indragning och radbrytningar. Omvandlingen är rent kosmetisk: data är identisk, bara presentationen ändras. Pythons json modul hanterar detta helt i standardbiblioteket — inget att installera.

Before · json

After · json

{"id":"usr_9f3a2b","name":"Erik Andersson","roles":["admin","editor"],"prefs":{"theme":"dark","lang":"sv"}}

{
    "id": "usr_9f3a2b",
    "name": "Erik Andersson",
    "roles": [
        "admin",
        "editor"
    ],
    "prefs": {
        "theme": "dark",
        "lang": "sv"
    }
}

json.dumps() — Standardsättet att formatera JSON

json.dumps() är en del av Pythons standardbibliotek sedan Python 2.6 — bara import json, ingen installation behövs. Den serialiserar valfritt JSON-kompatibelt Python-objekt till en formaterad sträng. Nyckelparametern är indent: sätt den till 4 (eller 2) för läsbar utdata.

Python 3.8+ — minimalt exempel

import json

anvandare = {
    "id": "usr_9f3a2b",
    "name": "Erik Andersson",
    "roles": ["admin", "editor"],
    "prefs": {"theme": "dark", "lang": "sv"}
}

print(json.dumps(anvandare, indent=4, ensure_ascii=False))
# Utdata:
# {
#     "id": "usr_9f3a2b",
#     "name": "Erik Andersson",
#     "roles": [
#         "admin",
#         "editor"
#     ],
#     "prefs": {
#         "theme": "dark",
#         "lang": "sv"
#     }
# }

I produktionsbruk vill du ofta ha sort_keys=True (konsekvent utdata mellan körningar) och ensure_ascii=False (bevara svenska tecken):

Python 3.8+ — med sort_keys och ensure_ascii

import json

api_svar = {
    "timestamp": "2024-05-01T10:30:00Z",
    "status": "success",
    "data": {
        "user_id": "usr_9f3a2b",
        "display_name": "Maja Nilsson",
        "stad": "Göteborg",
        "poang": 4892.5,
        "tags": ["python", "backend", "api"]
    }
}

print(json.dumps(api_svar, indent=4, sort_keys=True, ensure_ascii=False))
# Utdata (nycklar sorterade, svenska tecken bevarade):
# {
#     "data": {
#         "display_name": "Maja Nilsson",
#         "poang": 4892.5,
#         "stad": "Göteborg",
#         "tags": ["api", "backend", "python"],
#         "user_id": "usr_9f3a2b"
#     },
#     "status": "success",
#     "timestamp": "2024-05-01T10:30:00Z"
# }

OBS:json.dumps() returnerar en sträng. För att skriva formaterad JSON direkt till en fil, använd json.dump(data, f, indent=4) (utan s) — den skriver till ett filobjekt och undviker att skapa en mellanliggande sträng i minnet.

Parameterreferens för json.dumps()

Alla parametrar är valfria utom objektet självt. Standardvärdena ger kompakt, ASCII-säker JSON — skicka parametrar explicit för läsbar utdata.

Parameter

Typ

Standard

Beskrivning

obj

any

—

Python-objekt att serialisera till en JSON-formaterad sträng.

indent

int | str | None

None

Mellanslag per indragnivå. None = kompakt enrad, 0 = endast radbrytningar, 4 = standard.

sort_keys

bool

False

Sortera ordlistans nycklar alfabetiskt på alla inbäddade nivåer.

ensure_ascii

bool

True

Escape non-ASCII-tecken till \uXXXX. Sätt False för att bevara Unicode-tecken som de är.

separators

tuple | None

None

Par (item_sep, key_sep). Använd (",", ":") för maximalt kompakt utdata utan mellanslag.

default

callable | None

None

Anropas för typer som inte går att serialisera som standard. Kasta TypeError för att avvisa värdet.

allow_nan

bool

True

Serialisera float("nan") och float("inf") som JS-litteraler. Sätt False för att kasta ValueError.

Kompakt JSON-utdata med parametern separators

Som standard separerar json.dumps() objekt med ", " och nycklar från värden med ": ". Parametern separators åsidosätter båda. Att skicka (',', ':') tar bort alla mellanslag för att producera den mest kompakta giltiga JSON som möjligt — användbart för nätverksöverföring, URL-inbäddning eller lagring av JSON i en databaskolumn där varje byte räknas.

Python 3.8+

import json

payload = {
    "endpoint": "/api/v2/events",
    "filters": {"status": "active", "limit": 100},
    "sort": "desc"
}

# Standard — mellanslag efter separatorer (läsbar)
default_out = json.dumps(payload)
# {"endpoint": "/api/v2/events", "filters": {"status": "active", "limit": 100}, "sort": "desc"}
# len = 88

# Kompakt — inget mellanslag alls
compact_out = json.dumps(payload, separators=(',', ':'))
# {"endpoint":"/api/v2/events","filters":{"status":"active","limit":100},"sort":"desc"}
# len = 80  (9% mindre; besparingen ökar på större, djupt nästlade payloads)

# Kompakt + sorterade nycklar för reproducerbara cachenycklar eller innehållshashar
canonical = json.dumps(payload, separators=(',', ':'), sort_keys=True)
print(canonical)
# {"endpoint":"/api/v2/events","filters":{"limit":100,"status":"active"},"sort":"desc"}

OBS:När du skickar indent= tillsammans med separators=, styr separators-argumentet bara de inline separatorerna — radbrytningar och indragning från indent bevaras. Om du vill ha kompakt enradsutdata, utelämna indent (eller skicka None) och sätt separators=(',', ':').

Serialisera anpassade Python-objekt med parametern default

Standard json modulen serialiserar dicts, listor, strängar, tal, booleaner och None — men kastarTypeError för alla andra typer. De två vanligaste bovarna i produktionskod är datetime-objekt och UUID.

Python 3.8+ — TypeError utan anpassad hantering

import json
from datetime import datetime, timezone
import uuid

bestallning = {
    "bestallning_id": uuid.uuid4(),              # ❌ TypeError: UUID is not JSON serializable
    "lagd_kl": datetime.now(timezone.utc),       # ❌ TypeError: datetime is not JSON serializable
    "total_sek": 1249.00,
    "items": ["pro-subscription", "addon-storage"]
}

json.dumps(bestallning)  # kastar TypeError

Metod 1 — parametern default=

Skicka ett anropbart objekt till default=. json.dumps() anropar det för varje objekt det inte kan hantera. Returnera en serialiserbar representation, eller kasta TypeError för typer du inte uttryckligen stöder — ignorera aldrig okända typer tyst.

Python 3.8+

import json
from datetime import datetime, timezone, date
import uuid
from decimal import Decimal

def json_default(obj):
    if isinstance(obj, (datetime, date)):
        return obj.isoformat()
    if isinstance(obj, uuid.UUID):
        return str(obj)
    if isinstance(obj, Decimal):
        return float(obj)
    raise TypeError(f"Typen {type(obj).__name__!r} är inte JSON-serialiserbar")

bestallning = {
    "bestallning_id": uuid.uuid4(),
    "lagd_kl": datetime(2024, 5, 1, 10, 30, 0, tzinfo=timezone.utc),
    "total_sek": Decimal("1249.00"),
    "items": ["pro-subscription", "addon-storage"]
}

print(json.dumps(bestallning, indent=4, default=json_default, ensure_ascii=False))
# {
#     "bestallning_id": "a3f1c2d4-e5b6-7890-abcd-ef1234567890",
#     "lagd_kl": "2024-05-01T10:30:00+00:00",
#     "total_sek": 1249.0,
#     "items": ["pro-subscription", "addon-storage"]
# }

Metod 2 — subklassa json.JSONEncoder

För återanvändbar kodningslogik som delas över flera moduler är det renare att subklassa json.JSONEncoder än att skicka en default-funktion överallt. Åsidosätt metoden default och anropa super().default(obj) som sista reserv — detta bevarar korrekt felbeteende för typer som inte stöds.

Python 3.8+

import json
from datetime import datetime, timezone
import uuid
from decimal import Decimal

class AppEncoder(json.JSONEncoder):
    def default(self, obj):
        if isinstance(obj, datetime):
            return obj.isoformat()
        if isinstance(obj, uuid.UUID):
            return str(obj)
        if isinstance(obj, Decimal):
            return float(obj)
        return super().default(obj)  # kastar TypeError för okända typer

bestallning = {
    "bestallning_id": uuid.uuid4(),
    "lagd_kl": datetime(2024, 5, 1, 10, 30, 0, tzinfo=timezone.utc),
    "total_sek": Decimal("1249.00"),
}

# Skicka encoder-klassen via cls=
print(json.dumps(bestallning, indent=4, cls=AppEncoder, ensure_ascii=False))
# Identisk utdata som default=-metoden ovan

OBS:Anropa alltid super().default(obj) (eller kasta TypeError explicit) för okända typer. Att tyst returnera str(obj) för allt kommer att korrumpera objekt som borde ha kastat ett fel — ett svårspårat bug i produktion.

Avkodning tillbaka — object_hook

Kodning är bara halva historien. För att återskapa ett anpassat Python-objekt från JSON, skicka en object_hook-funktion till json.loads() eller json.load(). Hooken anropas för varje avkodat JSON-objekt (dict) och kan returnera vilket Python-värde som helst i dess ställe — vilket ger dig en fullständig encode ↔ decode-cykel.

Python 3.8+

import json
from datetime import datetime
from dataclasses import dataclass

@dataclass
class Event:
    name: str
    occurred_at: datetime
    user_id: str

def encode_event(obj):
    if isinstance(obj, Event):
        return {
            "__type__": "Event",
            "name": obj.name,
            "occurred_at": obj.occurred_at.isoformat(),
            "user_id": obj.user_id,
        }
    raise TypeError(f"Kan inte serialisera {type(obj)}")

def decode_event(d):
    if d.get("__type__") == "Event":
        return Event(
            name=d["name"],
            occurred_at=datetime.fromisoformat(d["occurred_at"]),
            user_id=d["user_id"],
        )
    return d

# Koda
event = Event("login", datetime(2024, 5, 1, 10, 30), "usr_9f3a2b")
json_str = json.dumps(event, default=encode_event, indent=4)

# Avkoda tillbaka till en Event-instans
restored = json.loads(json_str, object_hook=decode_event)
print(type(restored))           # <class 'Event'>
print(restored.occurred_at)     # 2024-05-01 10:30:00

OBS:object_hook anropas för varje nästlad dict i dokumentet — inte bara på toppnivå. Inkludera ett diskriminatorfält (som "__type__") så att hooken kan skilja dina anpassade objekt från vanliga dicts som ska lämnas som de är.

pprint — Den alternativa modulen (och när du inte ska använda den)

Pythons pprint modul (pretty printer) formaterar Python-datastrukturer för läsbarhet i terminalen. Den arbetar med parsade Python-objekt, inte JSON-strängar — och dess utdata använder Python-syntax, inte JSON-syntax.

Python 3.8+

import json, pprint

raw = '{"sensor_id":"s-441","readings":[23.1,23.4,22.9],"unit":"celsius","active":true}'
data = json.loads(raw)

# pprint — giltig Python repr, INTE giltig JSON
pprint.pprint(data, sort_dicts=False)
# {'sensor_id': 's-441',
#  'readings': [23.1, 23.4, 22.9],
#  'unit': 'celsius',
#  'active': True}        ← Python True, inte JSON true

# json.dumps — giltig JSON
print(json.dumps(data, indent=4))
# {
#     "sensor_id": "s-441",
#     "readings": [23.1, 23.4, 22.9],
#     "unit": "celsius",
#     "active": true      ← giltig JSON
# }

Varning:Skicka aldrig pprint-utdata till en API-endpoint eller skriv den till en .json-fil — det kommer att bryta alla JSON-parsers som förväntar sig standardsyntax. Använd json.dumps(indent=4) för all utdata som måste vara giltig JSON.

När pprint är vettigt: snabb terminalinspektion av Python-objekt i en REPL eller debug-logg, särskilt när objektet innehåller typer som inte är JSON-serialiserbara (sets, anpassade klassinstanser, dataklasser före konvertering).

Hur man gör pretty print av ett JSON-svar från Requests

Det vanligaste verkliga scenariot: du har en JSON-fil på disk eller ett HTTP-svar från ett API och vill formatera det för felsökning eller loggning. Båda fallen använder samma tillvägagångssätt — parsa till en Python-dict och formatera sedan med json.dumps().

Läsa från en fil

Python 3.8+

import json

try:
    with open("config.json", "r", encoding="utf-8") as f:
        data = json.load(f)

    # Pretty-printa till konsolen
    print(json.dumps(data, indent=4, ensure_ascii=False))

    # Eller skriv den formaterade versionen tillbaka till disk
    with open("config.pretty.json", "w", encoding="utf-8") as f:
        json.dump(data, f, indent=4, ensure_ascii=False)

except json.JSONDecodeError as e:
    print(f"Ogiltig JSON: {e}")
except FileNotFoundError:
    print(f"Fil hittades inte: config.json")

Formatera ett API-svar

Python 3.8+ (kräver: pip install requests)

import json, requests
from requests.exceptions import HTTPError, ConnectionError, Timeout

def pretty_print_api(url: str) -> None:
    try:
        resp = requests.get(url, timeout=10)
        resp.raise_for_status()
        print(json.dumps(resp.json(), indent=4, ensure_ascii=False))
    except HTTPError as e:
        print(f"HTTP {e.response.status_code}: {e}")
    except (ConnectionError, Timeout) as e:
        print(f"Nätverksfel: {e}")
    except json.JSONDecodeError:
        print(f"Svarstexten är inte JSON:\n{resp.text[:500]}")

pretty_print_api("https://api.github.com/repos/python/cpython")

OBS:response.json() parsar redan svarstexten — du behöver inte anropa json.loads() separat. Lägg alltid till raise_for_status() innan du anropar .json() för att fånga 4xx/5xx-fel innan de orsakar ett förvirrande parsningsfel.

Pretty printing från kommandoraden

Python levereras med json.tool, en CLI-modul för att formatera JSON direkt från terminalen — inget Python-skript behövs. Den finns tillgänglig på alla maskiner med Python installerat.

bash

# Formatera en lokal fil
python -m json.tool config.json

# Skicka API-svar genom formateraren
curl -s https://api.github.com/users/gvanrossum | python -m json.tool

# Formatera från stdin
echo '{"service":"api-gateway","version":"2.1.0","healthy":true}' | python -m json.tool

# Sortera nycklar alfabetiskt
python -m json.tool --sort-keys data.json

# Anpassad indragning (Python 3.9+)
python -m json.tool --indent 2 data.json

OBS:Python 3.9 lade till flaggorna --indent och --no-indent. För kraftfullare terminal-JSON-filtrering, överväg jq — men python -m json.tool täcker formateringsbehovet utan extra beroenden.

Om du inte alls är i en terminal — när du klistrar in ett Postman-svar eller en loggfil — låter ToolDeck JSON Formatter dig klistra in, formatera och kopiera i ett steg med inbyggd syntaxmarkering och validering.

Alternativa bibliotek: orjson och rich

orjson — 5–10× snabbare med inbyggt typstöd

Standard json modulen är tillräckligt snabb för de flesta användningsfall, men om du serialiserar tusentals objekt per sekund — loggningspipelines, högenergis-API:er, stora dataexporter — är orjson 5–10× snabbare. Den hanterar även nativt typer som standardbiblioteket inte kan serialisera utan en anpassad default-funktion: datetime, uuid.UUID, numpy-arrayer och dataklasser.

bash — installation

pip install orjson

Python 3.8+

import orjson
from datetime import datetime, timezone
import uuid

event = {
    "event_id": uuid.uuid4(),                  # ingen str() behövs — orjson hanterar UUID
    "timestamp": datetime.now(timezone.utc),   # ingen isoformat() behövs
    "service": "auth-service",
    "level": "INFO",
    "payload": {
        "user_id": "usr_9f3a2b",
        "action": "login",
        "ip": "192.168.1.42",
        "latency_ms": 34
    }
}

# orjson.dumps returnerar bytes; .decode() konverterar till str
print(orjson.dumps(event, option=orjson.OPT_INDENT_2).decode())
# {
#   "event_id": "a3f1c2d4-e5b6-7890-abcd-ef1234567890",
#   "timestamp": "2024-05-01T10:30:00+00:00",
#   "service": "auth-service",
#   ...
# }

Två saker att känna till: orjson.dumps() returnerar bytes, inte en sträng — anropa .decode() om du behöver en sträng. Den stöder bara 2-stegs indragning via OPT_INDENT_2; för 4-stegs utdata, använd standard json.dumps(indent=4).

rich — Syntaxmarkering i terminalen

Om du regelbundet inspekterar JSON i en terminal eller REPL, rich renderar färgkodad, syntaxmarkerad utdata som gör djupt nästlade strukturer läsbara på ett ögonblick. Nycklar, strängar, tal och booleaner får var sin färg — mycket lättare att skumma än en vägg av monokrom text. Det är ett debug-tidverktyg endast, inte för produktionsseralisering.

bash — installation

pip install rich

Python 3.8+

from rich import print_json
import json

# print_json() tar emot en JSON-sträng
raw = '{"event":"login","user_id":"usr_9f3a2b","timestamp":"2024-05-01T10:30:00Z","success":true,"meta":{"ip":"192.168.1.42","attempts":1}}'
print_json(raw)

# För att pretty-printa en Python-dict, konvertera till sträng först
data = {
    "status": "success",
    "count": 42,
    "tags": ["python", "api", "backend"]
}
print_json(json.dumps(data))

Varning:rich.print_json() matar ut ANSI escape-koder för terminalfärg — fånga aldrig denna utdata och skriv den till en .json-fil eller skicka den som ett API-svar. Använd json.dumps(indent=4) för all maskinläsbar utdata.

simplejson — Drop-in-kompatibel ersättning

simplejson är biblioteket som blev Pythons standard json modul — det underhålls fortfarande oberoende och ligger steget före stdlib i mindre funktioner. Det är en sann drop-in-ersättning: byt ut importen och resten av din kod förblir oförändrad. Användbart när du behöver Decimal stöd utan en anpassad encoder, eller när du riktar in dig på äldre Python-miljöer.

bash — installation

pip install simplejson

Python 3.8+

import simplejson as json  # identiskt API med stdlib
from decimal import Decimal

bestallning = {
    "item": "API-prenumeration",
    "pris": Decimal("149.99"),   # stdlib json kastar TypeError här
    "antal": 3,
}

# simplejson serialiserar Decimal nativt — ingen default= behövs
print(json.dumps(bestallning, indent=4, use_decimal=True, ensure_ascii=False))
# {
#     "item": "API-prenumeration",
#     "pris": 149.99,
#     "antal": 3
# }

OBS:För ren prestanda är orjson det bättre valet. Välj simplejson när du behöver native Decimal-serialisering utan att skriva en anpassad encoder, eller när du underhåller en kodbas som redan använder det.

Bearbeta stora JSON-filer utan att minnet tar slut

json.load() läser hela filen i minnet innan du kan komma åt ett enda fält. På en fil med miljontals poster eller en payload över en gigabyte orsakar det ett MemoryError — eller tvingar i bästa fall processen att swappa till disk och krypa.

Streaming med ijson

ijson är en streaming JSON-parser som genererar objekt ett i taget från ett filobjekt. Du itererar över arrayelement utan att någonsin hålla hela datasetet i minnet — toppminnet förblir proportionellt mot ett enskilt objekt, inte filstorleken.

bash — installation

pip install ijson

Python 3.8+

import ijson
from decimal import Decimal

# events.json struktur: {"events": [...miljontals objekt...]}
total_intakt = Decimal("0")
login_antal = 0

with open("events.json", "rb") as f:   # ijson kräver binärt läge
    for event in ijson.items(f, "events.item"):
        if event.get("type") == "purchase":
            total_intakt += Decimal(str(event["amount_sek"]))
        elif event.get("type") == "login":
            login_antal += 1

print(f"Intäkt: {total_intakt:,.2f} SEK  |  Inloggningar: {login_antal}")
# Bearbetar en 2 GB fil med ~30 MB toppminnesanvändning

OBS:Byt från json.load() till ijson när din fil överstiger ungefär 50–100 MB. Under den tröskeln är json.load() enklare och avsevärt snabbare eftersom den använder en C-extensions-parser internt. Över 100 MB uppväger minnesbesparingarna från streaming den extra kostnaden.

NDJSON — ett JSON-objekt per rad

NDJSON (Newline Delimited JSON, även kallat JSON Lines eller .jsonl) lagrar ett komplett JSON-objekt per rad. Loggexporterare, Kafka-konsumenter och datapipelines producerar ofta detta format eftersom varje rad kan läggas till och läsas oberoende — du behöver inte parsa hela filen för att lägga till en post. Standardbiblioteket hanterar det utan några extra beroenden.

Python 3.8+

import json
from pathlib import Path

# Skriv NDJSON — ett event per rad
events = [
    {"ts": "2024-05-01T10:00:00Z", "user": "usr_9f3a2b", "action": "login"},
    {"ts": "2024-05-01T10:01:03Z", "user": "usr_9f3a2b", "action": "purchase", "sku": "pro-plan"},
    {"ts": "2024-05-01T10:15:42Z", "user": "usr_4ab1d9", "action": "login"},
]

with open("events.ndjson", "w", encoding="utf-8") as f:
    for event in events:
        f.write(json.dumps(event, ensure_ascii=False) + "\n")

# Läs NDJSON — konstant minne oavsett hur stor filen är
kop_antal = 0
with open("events.ndjson", "r", encoding="utf-8") as f:
    for rad in f:
        rad = rad.strip()
        if not rad:           # hoppa över tomma rader
            continue
        event = json.loads(rad)
        if event.get("action") == "purchase":
            kop_antal += 1
            print(f"{event['ts']} — {event['user']} köpte {event['sku']}")

Vanliga misstag

Jag har sett dessa fyra misstag i nästan varje kodgranskning som rör JSON serialisering — särskilt från utvecklare som kommer från JavaScript där JSON.stringify hanterar kodning automatiskt.

❌ Använda print(data) istället för json.dumps()

Problem: print() på en dict använder Python repr — utdata visar True/None (Python-syntax), inte true/null (JSON-syntax). Det är inte giltig JSON.

Lösning: Använd alltid json.dumps(data, indent=4) för giltig, läsbar JSON-utdata.

Before · Python

After · Python

data = {"aktiv": True, "antal": None}
print(data)
# {'aktiv': True, 'antal': None}

print(json.dumps(data, indent=4))
# {
#     "aktiv": true,
#     "antal": null
# }

❌ Glömma ensure_ascii=False med icke-ASCII-text

Problem: Specialtecken (å, ä, ö, emoji) escapes till \\uXXXX-sekvenser och gör utdata oläslig.

Lösning: Skicka ensure_ascii=False för att bevara de ursprungliga Unicode-tecknen.

Before · Python

After · Python

anvandare = {"namn": "Maja Nilsson", "stad": "Göteborg"}
json.dumps(anvandare, indent=2)
# {"namn": "Maja Nilsson", "stad": "G\u00f6teborg"}

json.dumps(anvandare, indent=2, ensure_ascii=False)
# {"namn": "Maja Nilsson", "stad": "Göteborg"}

❌ Använda json.dumps() för att skriva till fil

Problem: json.dumps() returnerar en sträng; du behöver ett separat f.write()-anrop och skapar en onödig mellanliggande sträng.

Lösning: Använd json.dump(data, f, indent=4) — det skriver direkt till filobjektet.

Before · Python

After · Python

with open("ut.json", "w") as f:
    f.write(json.dumps(data, indent=4))

with open("ut.json", "w", encoding="utf-8") as f:
    json.dump(data, f, indent=4, ensure_ascii=False)

❌ Pretty-printa med pprint och förvänta sig giltig JSON

Problem: pprint.pprint() använder Python-syntax (True, None, enkla citattecken) som JSON-parsers avvisar.

Lösning: Använd json.dumps(indent=4) för all utdata som måste kunna parsas som JSON.

Before · Python

After · Python

import pprint
pprint.pprint({"kör": True, "senaste_fel": None})
# {'kör': True, 'senaste_fel': None}

import json
print(json.dumps({"kör": True, "senaste_fel": None}, indent=4))
# {"kör": true, "senaste_fel": null}

Metodjämförelse — json.dumps, orjson, simplejson, rich

Använd json.dumps() för vardagsformatering och filskrivning — det täcker 95% av användningsfallen med noll beroenden. Ta till orjson när du serialiserar i en het väg eller när dina objekt innehåller datetime och UUID-fält. Använd simplejson när du behöver drop-in stdlib-kompatibilitet med Decimal stöd direkt. Reservera rich.print_json() och pprint strikt för lokal terminalinspektion — ingen av dem producerar maskinläsbar utdata.

Metod

Utdata

Giltig JSON

Hastighet

Non-ASCII

Anpassade typer

Installation

json.dumps(indent=4)

Sträng

✅

Standard

ensure_ascii=False

default= / JSONEncoder

Inbyggd

json.dump(f, indent=4)

Fil

✅

Standard

ensure_ascii=False

default= / JSONEncoder

Inbyggd

pprint.pprint()

Python repr

❌

Standard

Native

✅ (valfri repr)

Inbyggd

orjson.dumps(OPT_INDENT_2)

Bytes

✅

5–10× snabbare

Native

datetime, UUID, numpy

pip install orjson

python -m json.tool

CLI stdout

✅

Standard

✅

❌

Inbyggd

simplejson.dumps()

Sträng

✅

~1.5× snabbare

ensure_ascii=False

Decimal nativt

pip install simplejson

rich.print_json()

Endast terminal

✅ (indata)

Standard

✅

❌

pip install rich

Vanliga frågor

Hur gör man pretty print av JSON i Python?

Anropa json.dumps(data, indent=4). Parametern indent anger antalet mellanslag per inbäddningsnivå. Importera json-modulen först — den ingår i Pythons standardbibliotek och kräver ingen pip install. Skicka ensure_ascii=False om din data innehåller icke-ASCII-tecken som å, ä, ö eller CJK-tecken.

python

import json

anvandare = {"username": "erikanders", "plan": "enterprise", "permissions": ["read", "write", "deploy"]}
print(json.dumps(anvandare, indent=4, ensure_ascii=False))

Vad är skillnaden mellan json.dumps() och json.dump()?

json.dumps() (med "s") returnerar en formaterad sträng i minnet. json.dump() (utan "s") skriver direkt till ett filobjekt — skicka det öppna filhandtaget som andra argument. För att skriva formaterad JSON till disk är json.dump(data, f, indent=4) det idiomatiska sättet och undviker en mellanliggande sträng.

python

# dumps → sträng i minnet
formaterad = json.dumps(data, indent=4)

# dump → skriv direkt till fil
with open('output.json', 'w', encoding='utf-8') as f:
    json.dump(data, f, indent=4)

Varför visar json.dumps() \u00e5\u00e4\u00f6 istället för det faktiska tecknet?

Som standard escaper ensure_ascii=True varje icke-ASCII-tecken till en \uXXXX-sekvens. Sätt ensure_ascii=False för att bevara de ursprungliga Unicode-tecknen. Detta är särskilt viktigt för namn, adresser och användarskapat innehåll på svenska eller andra icke-latinska teckenuppsättningar.

python

data = {"stad": "Göteborg", "halsning": "Hej!", "land": "Sverige"}

# Standard — escapad
json.dumps(data, indent=4)
# {"stad": "G\u00f6teborg", "halsning": "Hej!", ...}

# Läsbar
json.dumps(data, indent=4, ensure_ascii=False)
# {"stad": "Göteborg", "halsning": "Hej!", "land": "Sverige"}

Hur gör man pretty print av en JSON-sträng (inte en dict)?

Parsa först strängen med json.loads(), formatera sedan med json.dumps(). De två anropen kan kedjas ihop på en rad för snabb terminalinspektion.

python

import json

raw = '{"endpoint":"/api/v2/users","timeout":30,"retry":true}'
print(json.dumps(json.loads(raw), indent=4))

Kan jag använda pprint för att formatera JSON i Python?

pprint.pprint() producerar Python-objektrepresentation, inte giltig JSON. Den använder True/False/None (Python-syntax) istället för true/false/null (JSON-syntax). Skicka aldrig pprint-utdata till ett API eller en JSON-parser — använd json.dumps(indent=4) för allt som måste vara giltig JSON.

python

import pprint, json

data = {"aktiv": True, "poang": None}

pprint.pprint(data)     # {'aktiv': True, 'poang': None}  ← inte JSON
json.dumps(data, indent=4)  # {"aktiv": true, "poang": null}  ← giltig JSON

Hur sorterar man JSON-nycklar alfabetiskt i Python?

Lägg till sort_keys=True i json.dumps(). På kommandoraden, använd python -m json.tool --sort-keys data.json. Sorterade nycklar gör JSON-diffs läsliga och hjälper till att snabbt hitta ändrade värden.

python

import json

server = {"workers": 4, "host": "0.0.0.0", "port": 8080, "debug": False}
print(json.dumps(server, indent=4, sort_keys=True))
# {
#     "debug": false,
#     "host": "0.0.0.0",
#     "port": 8080,
#     "workers": 4
# }

Python ger dig full kontroll — anpassade serialisatorer, streaming, pipeline-integration. När du bara behöver inspektera eller dela ett formaterat kodavsnitt är ToolDecks JSON Formatter den snabbare vägen: klistra in din JSON och få ett indraget, markerat resultat utan någon miljökonfiguration.

Relaterade verktyg

JSON Formatter

Formatera vilken JSON som helst direkt i webbläsaren — ingen Python-miljö behövs. Klistra in, formatera och kopiera med ett klick.

JSON Validator

Validera din JSON-struktur innan formatering — fångar syntaxfel som skulle få json.loads() att kasta JSONDecodeError.

JSON Diff

Jämför två JSON-svar sida vid sida för att se vad som ändrats mellan API-versioner eller config-driftsättningar.

JWT Decoder

Avkoda och inspektera JWT-tokens som returneras av ditt API — användbart tillsammans med JSON-formatering vid felsökning av autentiseringsflöden.

YAML to JSON

Konvertera YAML-konfigurationsfiler till JSON — användbart när du behöver pretty-printa ett YAML-baserat API-svar som JSON.

Finns även på:Go JavaScript Bash

Maria SantosBackend Developer

Maria is a backend developer specialising in Python and API integration. She has broad experience with data pipelines, serialisation formats, and building reliable server-side services. She is an active member of the Python community and enjoys writing practical, example-driven guides that help developers solve real problems without unnecessary theory.

Dmitri VolkovTeknisk granskare

Dmitri is a DevOps engineer who relies on Python as his primary scripting and automation language. He builds internal tooling, CI/CD pipelines, and infrastructure automation scripts that run in production across distributed teams. He writes about the Python standard library, subprocess management, file processing, encoding utilities, and the practical shell-adjacent Python that DevOps engineers use every day.