JSON Formatter Python — Poradnik json.dumps()

import json

uzytkownik = {
    "id": "usr_9f3a2b",
    "name": "Piotr Kowalski",
    "roles": ["admin", "editor"],
    "prefs": {"theme": "dark", "lang": "pl"}
}

print(json.dumps(uzytkownik, indent=4, ensure_ascii=False))
# Wyjście:
# {
#     "id": "usr_9f3a2b",
#     "name": "Piotr Kowalski",
#     "roles": [
#         "admin",
#         "editor"
#     ],
#     "prefs": {
#         "theme": "dark",
#         "lang": "pl"
#     }
# }

import json

odpowiedz_api = {
    "timestamp": "2024-05-01T10:30:00Z",
    "status": "sukces",
    "dane": {
        "user_id": "usr_9f3a2b",
        "nazwa_uzytkownika": "Anna Wiśniewska",
        "miasto": "Warszawa",
        "wynik": 4892.5,
        "tagi": ["python", "backend", "api"]
    }
}

print(json.dumps(odpowiedz_api, indent=4, sort_keys=True, ensure_ascii=False))
# Wyjście (klucze posortowane, polskie znaki zachowane):
# {
#     "dane": {
#         "miasto": "Warszawa",
#         "nazwa_uzytkownika": "Anna Wiśniewska",
#         "tagi": ["api", "backend", "python"],
#         "user_id": "usr_9f3a2b",
#         "wynik": 4892.5
#     },
#     "status": "sukces",
#     "timestamp": "2024-05-01T10:30:00Z"
# }

import json

ladunek = {
    "endpoint": "/api/v2/zdarzenia",
    "filtry": {"status": "aktywny", "limit": 100},
    "sortowanie": "desc"
}

# Domyślnie — spacje po separatorach (czytelny)
wyjscie_domyslne = json.dumps(ladunek, ensure_ascii=False)
# {"endpoint": "/api/v2/zdarzenia", "filtry": {"status": "aktywny", "limit": 100}, "sortowanie": "desc"}
# len = 88

# Kompaktowy — bez spacji
wyjscie_kompaktowe = json.dumps(ladunek, separators=(',', ':'), ensure_ascii=False)
# {"endpoint":"/api/v2/zdarzenia","filtry":{"status":"aktywny","limit":100},"sortowanie":"desc"}
# len = 80  (9% mniejszy; oszczędności rosną przy większych, głębiej zagnieżdżonych ładunkach)

# Kompaktowy + posortowane klucze dla odtwarzalnych kluczy cache
kanoniczny = json.dumps(ladunek, separators=(',', ':'), sort_keys=True, ensure_ascii=False)
print(kanoniczny)
# {"endpoint":"/api/v2/zdarzenia","filtry":{"limit":100,"status":"aktywny"},"sortowanie":"desc"}

import json
from datetime import datetime, timezone
import uuid

zamowienie = {
    "zamowienie_id": uuid.uuid4(),              # ❌ TypeError: UUID is not JSON serializable
    "utworzone_o": datetime.now(timezone.utc),  # ❌ TypeError: datetime is not JSON serializable
    "suma_pln": 142.50,
    "pozycje": ["subskrypcja-pro", "dodatek-pamiec"]
}

json.dumps(zamowienie)  # rzuca TypeError

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

def json_domyslny(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"Typ {type(obj).__name__!r} nie jest serializowalny do JSON")

zamowienie = {
    "zamowienie_id": uuid.uuid4(),
    "utworzone_o": datetime(2024, 5, 1, 10, 30, 0, tzinfo=timezone.utc),
    "suma_pln": Decimal("142.50"),
    "pozycje": ["subskrypcja-pro", "dodatek-pamiec"]
}

print(json.dumps(zamowienie, indent=4, default=json_domyslny, ensure_ascii=False))
# {
#     "zamowienie_id": "a3f1c2d4-e5b6-7890-abcd-ef1234567890",
#     "utworzone_o": "2024-05-01T10:30:00+00:00",
#     "suma_pln": 142.5,
#     "pozycje": ["subskrypcja-pro", "dodatek-pamiec"]
# }

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)  # rzuca TypeError dla nieznanych typów

zamowienie = {
    "zamowienie_id": uuid.uuid4(),
    "utworzone_o": datetime(2024, 5, 1, 10, 30, 0, tzinfo=timezone.utc),
    "suma_pln": Decimal("142.50"),
}

# Przekaż klasę enkodera przez cls=
print(json.dumps(zamowienie, indent=4, cls=AppEncoder, ensure_ascii=False))
# Identyczne wyjście jak przy podejściu z default=

import json
from datetime import datetime
from dataclasses import dataclass

@dataclass
class Zdarzenie:
    nazwa: str
    wystapilo_o: datetime
    user_id: str

def koduj_zdarzenie(obj):
    if isinstance(obj, Zdarzenie):
        return {
            "__typ__": "Zdarzenie",
            "nazwa": obj.nazwa,
            "wystapilo_o": obj.wystapilo_o.isoformat(),
            "user_id": obj.user_id,
        }
    raise TypeError(f"Nie można serializować {type(obj)}")

def dekoduj_zdarzenie(d):
    if d.get("__typ__") == "Zdarzenie":
        return Zdarzenie(
            nazwa=d["nazwa"],
            wystapilo_o=datetime.fromisoformat(d["wystapilo_o"]),
            user_id=d["user_id"],
        )
    return d

# Koduj
zdarzenie = Zdarzenie("logowanie", datetime(2024, 5, 1, 10, 30), "usr_9f3a2b")
json_str = json.dumps(zdarzenie, default=koduj_zdarzenie, indent=4)

# Dekoduj z powrotem do instancji Zdarzenie
przywrocony = json.loads(json_str, object_hook=dekoduj_zdarzenie)
print(type(przywrocony))           # <class 'Zdarzenie'>
print(przywrocony.wystapilo_o)     # 2024-05-01 10:30:00

import json, pprint

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

# pprint — prawidłowy repr Pythona, NIE prawidłowy JSON
pprint.pprint(data, sort_dicts=False)
# {'sensor_id': 's-441',
#  'readings': [23.1, 23.4, 22.9],
#  'unit': 'celsius',
#  'active': True}        ← Python True, nie JSON true

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

import json

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

    # Ładnie wydrukuj do konsoli
    print(json.dumps(data, indent=4, ensure_ascii=False))

    # Lub zapisz sformatowaną wersję z powrotem na dysk
    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"Nieprawidłowy JSON: {e}")
except FileNotFoundError:
    print(f"Plik nie znaleziony: config.json")

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

def ladnie_wydrukuj_api(url: str) -> None:
    try:
        odp = requests.get(url, timeout=10)
        odp.raise_for_status()
        print(json.dumps(odp.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"Błąd sieci: {e}")
    except json.JSONDecodeError:
        print(f"Treść odpowiedzi nie jest JSON:\n{odp.text[:500]}")

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

# Formatuj lokalny plik
python -m json.tool config.json

# Przepuść odpowiedź API przez formater
curl -s https://api.github.com/users/gvanrossum | python -m json.tool

# Formatuj ze stdin
echo '{"serwis":"api-gateway","wersja":"2.1.0","zdrowy":true}' | python -m json.tool

# Sortuj klucze alfabetycznie
python -m json.tool --sort-keys data.json

# Niestandardowe wcięcie (Python 3.9+)
python -m json.tool --indent 2 data.json

pip install orjson

import orjson
from datetime import datetime, timezone
import uuid

zdarzenie = {
    "zdarzenie_id": uuid.uuid4(),              # nie trzeba str() — orjson obsługuje UUID
    "timestamp": datetime.now(timezone.utc),   # nie trzeba isoformat()
    "serwis": "auth-service",
    "poziom": "INFO",
    "ladunek": {
        "user_id": "usr_9f3a2b",
        "akcja": "logowanie",
        "ip": "192.168.1.42",
        "opoznienie_ms": 34
    }
}

# orjson.dumps zwraca bajty; .decode() konwertuje do str
print(orjson.dumps(zdarzenie, option=orjson.OPT_INDENT_2).decode())
# {
#   "zdarzenie_id": "a3f1c2d4-e5b6-7890-abcd-ef1234567890",
#   "timestamp": "2024-05-01T10:30:00+00:00",
#   "serwis": "auth-service",
#   ...
# }

pip install rich

from rich import print_json
import json

# print_json() przyjmuje ciąg JSON
raw = '{"zdarzenie":"logowanie","user_id":"usr_9f3a2b","timestamp":"2024-05-01T10:30:00Z","sukces":true,"meta":{"ip":"192.168.1.42","proby":1}}'
print_json(raw)

# Aby ładnie wydrukować słownik Pythona, najpierw przekonwertuj na ciąg
dane = {
    "status": "sukces",
    "liczba": 42,
    "tagi": ["python", "api", "backend"]
}
print_json(json.dumps(dane, ensure_ascii=False))

pip install simplejson

import simplejson as json  # identyczne API jak stdlib
from decimal import Decimal

zamowienie = {
    "pozycja": "Subskrypcja API Kraków",
    "cena": Decimal("49.99"),   # stdlib json rzuciłby tu TypeError
    "ilosc": 3,
}

# simplejson serializuje Decimal natywnie — nie potrzeba default=
print(json.dumps(zamowienie, indent=4, use_decimal=True, ensure_ascii=False))
# {
#     "pozycja": "Subskrypcja API Kraków",
#     "cena": 49.99,
#     "ilosc": 3
# }

pip install ijson

import ijson
from decimal import Decimal

# zdarzenia.json ma strukturę: {"zdarzenia": [...miliony obiektów...]}
calkowity_przychod = Decimal("0")
liczba_logowan = 0

with open("zdarzenia.json", "rb") as f:   # ijson wymaga trybu binarnego
    for zdarzenie in ijson.items(f, "zdarzenia.item"):
        if zdarzenie.get("typ") == "zakup":
            calkowity_przychod += Decimal(str(zdarzenie["kwota_pln"]))
        elif zdarzenie.get("typ") == "logowanie":
            liczba_logowan += 1

print(f"Przychód: {calkowity_przychod:.2f} PLN  |  Logowania: {liczba_logowan}")
# Przetwarza plik 2 GB z ~30 MB szczytowego użycia pamięci

import json
from pathlib import Path

# Zapisz NDJSON — jedno zdarzenie na linię
zdarzenia = [
    {"ts": "2024-05-01T10:00:00Z", "uzytkownik": "usr_9f3a2b", "akcja": "logowanie"},
    {"ts": "2024-05-01T10:01:03Z", "uzytkownik": "usr_9f3a2b", "akcja": "zakup", "sku": "pro-plan"},
    {"ts": "2024-05-01T10:15:42Z", "uzytkownik": "usr_4ab1d9", "akcja": "logowanie"},
]

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

# Odczytaj NDJSON — stała pamięć, niezależnie od rozmiaru pliku
liczba_zakupow = 0
with open("zdarzenia.ndjson", "r", encoding="utf-8") as f:
    for linia in f:
        linia = linia.strip()
        if not linia:           # pomiń puste linie
            continue
        zdarzenie = json.loads(linia)
        if zdarzenie.get("akcja") == "zakup":
            liczba_zakupow += 1
            print(f"{zdarzenie['ts']} — {zdarzenie['uzytkownik']} kupił {zdarzenie['sku']}")