JSON Formatter Python — json.dumps() 가이드

import json

user = {
    "id": "usr_9f3a2b",
    "name": "김민수",
    "roles": ["admin", "editor"],
    "prefs": {"theme": "dark", "lang": "ko"}
}

print(json.dumps(user, indent=4, ensure_ascii=False))
# 출력:
# {
#     "id": "usr_9f3a2b",
#     "name": "김민수",
#     "roles": [
#         "admin",
#         "editor"
#     ],
#     "prefs": {
#         "theme": "dark",
#         "lang": "ko"
#     }
# }

import json

api_response = {
    "timestamp": "2024-05-01T10:30:00Z",
    "status": "success",
    "data": {
        "user_id": "usr_9f3a2b",
        "display_name": "이지현",
        "city": "서울",
        "score": 4892.5,
        "tags": ["python", "backend", "api"]
    }
}

print(json.dumps(api_response, indent=4, sort_keys=True, ensure_ascii=False))
# 출력 (키 정렬, 한글 보존):
# {
#     "data": {
#         "city": "서울",
#         "display_name": "이지현",
#         "score": 4892.5,
#         "tags": ["api", "backend", "python"],
#         "user_id": "usr_9f3a2b"
#     },
#     "status": "success",
#     "timestamp": "2024-05-01T10:30:00Z"
# }

import json

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

# 기본 — 구분자 뒤에 공백 있음 (읽기 쉬움)
default_out = json.dumps(payload)
# {"endpoint": "/api/v2/events", "filters": {"status": "active", "limit": 100}, "sort": "desc"}
# len = 88

# 컴팩트 — 공백 없음
compact_out = json.dumps(payload, separators=(',', ':'))
# {"endpoint":"/api/v2/events","filters":{"status":"active","limit":100},"sort":"desc"}
# len = 80  (9% 절감; 더 크고 깊이 중첩된 payload에서 절감이 커짐)

# 컴팩트 + 정렬된 키 (재현 가능한 캐시 키 또는 콘텐츠 해시용)
canonical = json.dumps(payload, separators=(',', ':'), sort_keys=True)
print(canonical)
# {"endpoint":"/api/v2/events","filters":{"limit":100,"status":"active"},"sort":"desc"}

import json
from datetime import datetime, timezone
import uuid

order = {
    "order_id": uuid.uuid4(),            # ❌ TypeError: UUID is not JSON serializable
    "placed_at": datetime.now(timezone.utc),  # ❌ TypeError: datetime is not JSON serializable
    "total_usd": 142.50,
    "items": ["pro-subscription", "addon-storage"]
}

json.dumps(order)  # TypeError 발생

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"Type {type(obj).__name__!r} is not JSON serializable")

order = {
    "order_id": uuid.uuid4(),
    "placed_at": datetime(2024, 5, 1, 10, 30, 0, tzinfo=timezone.utc),
    "total_usd": Decimal("142.50"),
    "items": ["pro-subscription", "addon-storage"]
}

print(json.dumps(order, indent=4, default=json_default))
# {
#     "order_id": "a3f1c2d4-e5b6-7890-abcd-ef1234567890",
#     "placed_at": "2024-05-01T10:30:00+00:00",
#     "total_usd": 142.5,
#     "items": ["pro-subscription", "addon-storage"]
# }

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)  # 알 수 없는 타입에는 TypeError 발생

order = {
    "order_id": uuid.uuid4(),
    "placed_at": datetime(2024, 5, 1, 10, 30, 0, tzinfo=timezone.utc),
    "total_usd": Decimal("142.50"),
}

# cls= 로 인코더 클래스 전달
print(json.dumps(order, indent=4, cls=AppEncoder))
# default= 방법과 동일한 출력

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"Cannot serialize {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

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

# Event 인스턴스로 다시 디코딩
restored = json.loads(json_str, object_hook=decode_event)
print(type(restored))           # <class 'Event'>
print(restored.occurred_at)     # 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 — 유효한 Python repr, 유효한 JSON이 아님
pprint.pprint(data, sort_dicts=False)
# {'sensor_id': 's-441',
#  'readings': [23.1, 23.4, 22.9],
#  'unit': 'celsius',
#  'active': True}        ← Python True, JSON true가 아님

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

import json

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

    # 콘솔에 보기 좋게 출력
    print(json.dumps(data, indent=4, ensure_ascii=False))

    # 또는 포맷된 버전을 디스크에 다시 쓰기
    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"유효하지 않은 JSON: {e}")
except FileNotFoundError:
    print(f"파일을 찾을 수 없음: config.json")

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"네트워크 오류: {e}")
    except json.JSONDecodeError:
        print(f"응답 본문이 JSON이 아닙니다:\n{resp.text[:500]}")

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

# 로컬 파일 포맷
python -m json.tool config.json

# API 응답을 포맷터로 파이프
curl -s https://api.github.com/users/gvanrossum | python -m json.tool

# stdin에서 포맷
echo '{"service":"api-gateway","version":"2.1.0","healthy":true}' | python -m json.tool

# 키를 알파벳순으로 정렬
python -m json.tool --sort-keys data.json

# 커스텀 들여쓰기 (Python 3.9+)
python -m json.tool --indent 2 data.json

pip install orjson

import orjson
from datetime import datetime, timezone
import uuid

event = {
    "event_id": uuid.uuid4(),                  # str() 불필요 — orjson이 UUID 처리
    "timestamp": datetime.now(timezone.utc),   # isoformat() 불필요
    "service": "auth-service",
    "level": "INFO",
    "payload": {
        "user_id": "usr_9f3a2b",
        "action": "login",
        "ip": "192.168.1.42",
        "latency_ms": 34
    }
}

# orjson.dumps는 bytes를 반환; .decode()로 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",
#   ...
# }

pip install rich

from rich import print_json
import json

# print_json()은 JSON 문자열을 받음
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)

# Python dict를 출력하려면 먼저 문자열로 변환
data = {
    "status": "success",
    "count": 42,
    "tags": ["python", "api", "backend"]
}
print_json(json.dumps(data))

pip install simplejson

import simplejson as json  # stdlib와 동일한 API
from decimal import Decimal

order = {
    "item": "API subscription",
    "price": Decimal("49.99"),   # stdlib json은 여기서 TypeError 발생
    "quantity": 3,
}

# simplejson은 Decimal을 네이티브로 직렬화 — default= 불필요
print(json.dumps(order, indent=4, use_decimal=True))
# {
#     "item": "API subscription",
#     "price": 49.99,
#     "quantity": 3
# }

pip install ijson

import ijson
from decimal import Decimal

# events.json 구조: {"events": [...수백만 개의 객체...]}
total_revenue = Decimal("0")
login_count = 0

with open("events.json", "rb") as f:   # ijson은 바이너리 모드 필요
    for event in ijson.items(f, "events.item"):
        if event.get("type") == "purchase":
            total_revenue += Decimal(str(event["amount_usd"]))
        elif event.get("type") == "login":
            login_count += 1

print(f"Revenue: ${total_revenue:.2f}  |  Logins: {login_count}")
# 2 GB 파일을 ~30 MB 최대 메모리 사용량으로 처리

import json
from pathlib import Path

# NDJSON 쓰기 — 이벤트당 한 줄
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")

# NDJSON 읽기 — 파일 크기에 관계없이 일정한 메모리
purchase_count = 0
with open("events.ndjson", "r", encoding="utf-8") as f:
    for line in f:
        line = line.strip()
        if not line:           # 빈 줄 건너뛰기
            continue
        event = json.loads(line)
        if event.get("action") == "purchase":
            purchase_count += 1
            print(f"{event['ts']} — {event['user']} bought {event['sku']}")