json — JSON 인코더와 디코더

json 모듈은 JavaScript 객체 리터럴 문법에서 영감을 받은 가벼운 데이터 교환 형식인 JSON(JavaScript Object Notation)을 인코딩하고 디코딩하는 도구를 제공해요. RFC 7159(기존 RFC 4627을 대체)와 ECMA-404에 정의된 형식이에요.

출처: Python 표준 라이브러리

본문

json 모듈은 표준 라이브러리의 marshal과 pickle 모듈 사용자에게 익숙한 API를 제공해요.

JSON 처리에서 "객체(object)"라는 용어가 헷갈릴 수 있어요. Python에서 모든 값은 객체죠. 하지만 JSON에서 객체(object)는 중괄호로 감싼 데이터를 의미하고, Python 딕셔너리와 비슷해요.

경고: 신뢰할 수 없는 출처의 JSON 데이터를 파싱할 때는 조심해야 해요. 악의적인 JSON 문자열이 디코더가 엄청난 CPU와 메모리 자원을 소모하게 만들 수 있으니, 파싱할 데이터 크기를 제한하는 걸 권장해요.

기본 Python 객체 계층 인코딩

>>> import json
>>> json.dumps(['foo', {'bar': ('baz', None, 1.0, 2)}])
'["foo", {"bar": ["baz", null, 1.0, 2]}]'
>>> print(json.dumps("\"foo\bar"))
"\"foo\bar"
>>> print(json.dumps('\u1234'))
"\u1234"
>>> print(json.dumps('\\'))
"\\"
>>> print(json.dumps({"c": 0, "b": 0, "a": 0}, sort_keys=True))
{"a": 0, "b": 0, "c": 0}
>>> from io import StringIO
>>> io = StringIO()
>>> json.dump(['streaming API'], io)
>>> io.getvalue()
'["streaming API"]'

압축 인코딩

>>> import json
>>> json.dumps([1, 2, 3, {'4': 5, '6': 7}], separators=(',', ':'))
'[1,2,3,{"4":5,"6":7}]'

예쁘게 출력하기

>>> import json
>>> print(json.dumps({'6': 7, '4': 5}, sort_keys=True, indent=4))
{
    "4": 5,
    "6": 7
}

JSON 객체 인코딩 커스터마이즈

>>> import json
>>> def custom_json(obj):
...     if isinstance(obj, complex):
...         return {'__complex__': True, 'real': obj.real, 'imag': obj.imag}
...     raise TypeError(f'Cannot serialize object of {type(obj)}')
...
>>> json.dumps(1 + 2j, default=custom_json)
'{"__complex__": true, "real": 1.0, "imag": 2.0}'

JSON 디코딩

>>> import json
>>> json.loads('["foo", {"bar":["baz", null, 1.0, 2]}]')
['foo', {'bar': ['baz', None, 1.0, 2]}]
>>> json.loads('"\\"foo\\bar"')
'"foo\x08ar'
>>> from io import StringIO
>>> io = StringIO('["streaming API"]')
>>> json.load(io)
['streaming API']

JSON 객체 디코딩 커스터마이즈

>>> import json
>>> def as_complex(dct):
...     if '__complex__' in dct:
...         return complex(dct['real'], dct['imag'])
...     return dct
...
>>> json.loads('{"__complex__": true, "real": 1, "imag": 2}',
...     object_hook=as_complex)
(1+2j)
>>> import decimal
>>> json.loads('1.1', parse_float=decimal.Decimal)
Decimal('1.1')

JSONEncoder 확장

>>> import json
>>> class ComplexEncoder(json.JSONEncoder):
...     def default(self, obj):
...         if isinstance(obj, complex):
...             return [obj.real, obj.imag]
...         # Let the base class default method raise the TypeError
...         return super().default(obj)
...
>>> json.dumps(2 + 1j, cls=ComplexEncoder)
'[2.0, 1.0]'
>>> ComplexEncoder().encode(2 + 1j)
'[2.0, 1.0]'
>>> list(ComplexEncoder().iterencode(2 + 1j))
['[2.0', ', 1.0', ']']

셸에서 json 사용해 검증·예쁘게 출력

$ echo '{"json":"obj"}' | python -m json
{
    "json": "obj"
}
$ echo '{1.2:3.4}' | python -m json
Expecting property name enclosed in double quotes: line 1 column 2 (char 1)

참고할 점이 몇 가지 있어요. JSON은 YAML 1.2의 부분집합이에요. 이 모듈의 기본 설정(특히 기본 separators 값)으로 만든 JSON은 YAML 1.0과 1.1의 부분집합이기도 해서, YAML 직렬화 도구로도 쓸 수 있어요. 그리고 이 모듈의 인코더·디코더는 기본적으로 입력과 출력 순서를 보존해요. 순서가 사라지는 건 밑바탕 컨테이너가 무순서일 때뿐이에요.

json.dump(obj, fp, *, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, cls=None, indent=None, separators=None, default=None, sort_keys=False, **kw)

obj를 Python→JSON 변환 표를 이용해 JSON 형식 스트림으로 fp(.write()를 지원하는 file-like 객체)에 직렬화해요.

참고: pickle이나 marshal과 달리 JSON은 프레임(framed) 프로토콜이 아니에요. 그래서 같은 fp에 dump()를 여러 번 호출해 여러 객체를 직렬화하려 하면 유효하지 않은 JSON 파일이 돼요.

매개변수:

obj (object) — 직렬화할 Python 객체.
fp (file-like 객체) — 직렬화 결과가 쓰일 file-like 객체. json 모듈은 항상 str 객체를 만들지 bytes는 아니므로, fp.write()가 str 입력을 지원해야 해요.
skipkeys (bool) — True면 기본 타입(str, int, float, bool, None)이 아닌 키를 TypeError 대신 건너뛰어요. 기본값 False.
ensure_ascii (bool) — True(기본값)면 모든 비-ASCII·비-출력 문자가 이스케이프된다고 보장해요. False면 이스케이프해야 하는 문자(큰따옴표, 역슬래시, U+0000~U+001F 제어 문자)를 빼고는 그대로 출력해요.
check_circular (bool) — False면 컨테이너 타입의 순환 참조 검사를 건너뛰고, 순환 참조가 있으면 RecursionError(또는 더 심각한 문제)가 나요. 기본값 True.
allow_nan (bool) — False면 범위 밖 float 값(nan, inf, -inf)을 직렬화할 때 JSON 명세를 엄격히 따라 ValueError가 나요. True(기본값)면 JavaScript 표현(NaN, Infinity, -Infinity)이 사용돼요.
cls (JSONEncoder 하위 클래스) — 설정하면 default() 메서드를 오버라이드한 커스텀 JSON 인코더를 써서 커스텀 데이터 타입으로 직렬화해요. None(기본값)이면 JSONEncoder가 사용돼요.
indent (int | str | None) — 양의 정수나 문자열이면 JSON 배열 요소와 객체 멤버를 그 들여쓰기 단계로 예쁘게 출력해요. 양의 정수는 레벨당 그만큼 공백을, 문자열(예: "\t")은 각 레벨 들여쓰기에 그 문자열을 사용해요. 0, 음수 또는 ""면 새 줄만 넣고, None(기본값)이면 새 줄을 넣지 않아요.
separators (tuple | None) — (item_separator, key_separator) 두 개짜리 튜플. None(기본값)이면 indent가 None일 때 (', ', ': '), 아니면 (',', ': ')로 기본 설정돼요. 가장 압축된 JSON을 원하면 (',', ':')를 지정해 공백을 없애요.
default (callable | None) — 달리 직렬화할 수 없는 객체에 대해 호출되는 함수. 객체의 JSON 인코딩 가능한 버전을 돌려주거나 TypeError를 일으켜야 해요. None(기본값)이면 TypeError가 나요.
sort_keys (bool) — True면 딕셔너리를 키 기준으로 정렬해 출력해요. 기본값 False.

버전 3.2에서 변경: indent에 정수뿐 아니라 문자열도 허용. 버전 3.4에서 변경: indent가 None이 아니면 기본값으로 (',', ': ')를 사용. 버전 3.6에서 변경: 모든 선택 매개변수가 이제 키워드 전용.

json.dumps(obj, *, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, cls=None, indent=None, separators=None, default=None, sort_keys=False, **kw)

obj를 변환 표를 이용해 JSON 형식 str로 직렬화해요. 인자의 의미는 dump()와 같아요.

참고: JSON의 키/값 쌍에서 키는 항상 str 타입이에요. 딕셔너리를 JSON으로 변환하면 모든 키가 문자열로 강제 변환돼요. 그래서 딕셔너리를 JSON으로 만들었다가 다시 딕셔너리로 되돌리면 원래와 같지 않을 수 있어요. 즉 문자열이 아닌 키가 있으면 loads(dumps(x)) != x가 돼요. sort_keys는 키를 문자열로 강제 변환하기 전에 정렬하므로, 숫자 키는 문자열 표현이 아니라 값 기준으로 정렬돼요.

json.load(fp, *, cls=None, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, object_pairs_hook=None, **kw)

fp를 JSON→Python 변환 표를 이용해 Python 객체로 역직렬화해요.

매개변수:

fp (file-like 객체) — 역직렬화할 JSON 문서를 담은 .read()를 지원하는 텍스트 또는 바이너리 파일.
cls (JSONDecoder 하위 클래스) — 설정하면 커스텀 JSON 디코더. load()에 전달된 추가 키워드 인자는 cls의 생성자로 전달돼요. None(기본값)이면 JSONDecoder가 사용돼요.
object_hook (callable | None) — 설정하면 디코딩된 모든 JSON 객체 리터럴(딕셔너리)의 결과로 호출되는 함수. 이 함수의 반환값이 그 딕셔너리 대신 사용돼요. 커스텀 디코더(예: JSON-RPC 클래스 힌팅)를 구현할 때 써요. 기본값 None.
object_pairs_hook (callable | None) — 설정하면 순서 있는 쌍 리스트로 디코딩된 모든 JSON 객체 리터럴의 결과로 호출되는 함수. 반환값이 딕셔너리 대신 사용돼요. object_hook도 설정돼 있으면 object_pairs_hook이 우선해요. 기본값 None.
parse_float (callable | None) — 설정하면 디코딩할 모든 JSON float의 문자열로 호출되는 함수. None(기본값)이면 float(num_str)과 동등해요. JSON float를 커스텀 타입(예: decimal.Decimal)으로 파싱할 때 써요.
parse_int (callable | None) — 설정하면 디코딩할 모든 JSON int의 문자열로 호출되는 함수. None(기본값)이면 int(num_str)과 동등해요. JSON 정수를 커스텀 타입(예: float)으로 파싱할 때 써요.
parse_constant (callable | None) — 설정하면 '-Infinity', 'Infinity', 'NaN' 중 하나의 문자열로 호출되는 함수. 유효하지 않은 JSON 숫자를 만났을 때 예외를 일으키는 데 쓸 수 있어요. 기본값 None.

발생 예외:

JSONDecodeError — 역직렬화하는 데이터가 유효한 JSON 문서가 아닐 때.
UnicodeDecodeError — 역직렬화하는 데이터에 UTF-8, UTF-16 또는 UTF-32 인코딩 데이터가 없을 때.

버전 3.1에서 변경: 선택적 object_pairs_hook 매개변수 추가. parse_constant는 이제 'null', 'true', 'false'에 호출되지 않음. 버전 3.6에서 변경: 모든 선택 매개변수가 이제 키워드 전용. fp가 이제 바이너리 파일 가능. 입력 인코딩은 UTF-8, UTF-16 또는 UTF-32여야 함. 버전 3.11에서 변경: 기본 parse_int인 int()가 이제 인터프리터의 정수 문자열 변환 길이 제한을 통해 정수 문자열의 최대 길이를 제한해 서비스 거부 공격을 막음.

json.loads(s, *, cls=None, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, object_pairs_hook=None, **kw)

load()와 같지만 file-like 객체 대신 JSON 문서를 담은 s(a str, bytes 또는 bytearray 인스턴스)를 변환 표로 역직렬화해요.

버전 3.6에서 변경: s가 이제 bytes 또는 bytearray 타입 가능. 입력 인코딩은 UTF-8, UTF-16 또는 UTF-32여야 함. 버전 3.9에서 변경: encoding 키워드 인자 제거.

인코더와 디코더

class json.JSONDecoder(*, object_hook=None, parse_float=None, parse_int=None, parse_constant=None, strict=True, object_pairs_hook=None)

간단한 JSON 디코더. 기본적으로 디코딩 시 다음 변환을 수행해요:

JSON	Python
object	dict
array	list
string	str
number (int)	int
number (real)	float
true	True
false	False
null	None

또한 JSON 명세 밖이지만 NaN, Infinity, -Infinity를 해당 float 값으로 이해해요.

object_hook은 디코딩된 모든 JSON 객체의 결과로 호출되는 선택 함수이고, 반환값이 주어진 딕셔너리 대신 사용돼요. 커스텀 역직렬화(예: JSON-RPC 클래스 힌팅 지원)를 제공하는 데 쓸 수 있어요. object_pairs_hook은 순서 있는 쌍 리스트로 디코딩된 모든 JSON 객체의 결과로 호출되는 선택 함수이고, 반환값이 딕셔너리 대신 사용돼요. object_hook도 정의돼 있으면 object_pairs_hook이 우선해요.

parse_float는 디코딩할 모든 JSON float의 문자열로 호출되는 선택 함수. 기본적으로 float(num_str)과 동등하고, JSON float에 다른 데이터 타입이나 파서(예: decimal.Decimal)를 쓰는 데 쓸 수 있어요. parse_int도 비슷하게 모든 JSON int의 문자열로 호출되고 기본적으로 int(num_str)과 동등해요(예: float). parse_constant는 '-Infinity', 'Infinity', 'NaN' 중 하나의 문자열로 호출되는 선택 함수로, 유효하지 않은 JSON 숫자를 만났을 때 예외를 일으키는 데 써요.

strict가 거짓이면(기본값 True), 문자열 안에 제어 문자가 허용돼요. 여기서 제어 문자는 문자 코드 0~31 범위의 '\t'(탭), '\n', '\r', '\0' 같은 것들이에요.

역직렬화하는 데이터가 유효한 JSON 문서가 아니면 JSONDecodeError가 나요.

버전 3.1에서 변경: object_pairs_hook 지원 추가. 버전 3.6에서 변경: 모든 매개변수가 이제 키워드 전용.

decode(s)

JSON 문서를 담은 s(a str 인스턴스)의 Python 표현을 돌려줘요. 주어진 JSON 문서가 유효하지 않으면 JSONDecodeError가 나요.

raw_decode(s)

JSON 문서로 시작하는 s(a str)에서 JSON 문서를 디코딩하고, Python 표현과 문서가 끝난 s 안의 인덱스의 2-튜플을 돌려줘요. 끝에 여분의 데이터가 있을 수 있는 문자열에서 JSON 문서를 디코딩할 때 쓸 수 있어요.

class json.JSONEncoder(*, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, sort_keys=False, indent=None, separators=None, default=None)

Python 데이터 구조용 확장 가능한 JSON 인코더. 기본적으로 다음 객체와 타입을 지원해요:

Python	JSON
dict	object
list, tuple	array
str	string
int, float, int·float 파생 Enum	number
True	true
False	false
None	null

버전 3.4에서 변경: int·float 파생 Enum 클래스 지원 추가.

다른 객체를 인식하도록 확장하려면 하위 클래스를 만들고, 가능하면 o에 대해 직렬화 가능한 객체를 돌려주고 아니면 상위 클래스 구현을 호출해(TypeError) default() 메서드를 구현해요.

skipkeys가 거짓(기본값)이면 str, int, float, bool 또는 None이 아닌 키를 인코딩하려 할 때 TypeError가 나요. 참이면 그런 항목은 그냥 건너뛰어요.

ensure_ascii가 참(기본값)이면 출력에서 모든 비-ASCII·비-출력 문자가 이스케이프된다고 보장해요. 거짓이면 이스케이프해야 하는 문자(큰따옴표, 역슬래시, U+0000~U+001F 제어 문자)만 빼고 그대로 출력해요.

check_circular가 참(기본값)이면 인코딩 중 리스트, 딕셔너리, 커스텀 인코딩 객체에서 순환 참조를 검사해 무한 재귀(RecursionError)를 막아요. 아니면 그런 검사를 하지 않아요.

allow_nan이 참(기본값)이면 NaN, Infinity, -Infinity를 그대로 인코딩해요. 이 동작은 JSON 명세를 따르지 않지만 대부분의 JavaScript 기반 인코더·디코더와 일관돼요. 아니면 그런 float를 인코딩하면 ValueError가 나요.

sort_keys가 참이면(기본값 False) 딕셔너리 출력이 키 기준으로 정렬돼요. 회귀 테스트에서 JSON 직렬화를 매일 비교할 수 있게 할 때 유용해요.

indent가 음이 아닌 정수나 문자열이면 JSON 배열 요소와 객체 멤버를 그 들여쓰기 단계로 예쁘게 출력해요. 들여쓰기 단계 0, 음수, 또는 ""는 새 줄만 넣어요. None(기본값)은 가장 압축된 표현을 선택해요. 양의 정수 들여쓰기는 레벨당 그만큼 공백을 넣고, 문자열(예: "\t")이면 각 레벨에 그 문자열을 사용해요.

버전 3.2에서 변경: indent에 정수뿐 아니라 문자열도 허용.

지정하면 separators는 (item_separator, key_separator) 튜플이어야 해요. 기본값은 indent가 None이면 (', ', ': '), 아니면 (',', ': ')예요. 가장 압축된 JSON을 얻으려면 (',', ':')를 지정해 공백을 없애야 해요.

버전 3.4에서 변경: indent가 None이 아니면 기본값으로 (',', ': ')를 사용.

지정하면 default는 달리 직렬화할 수 없는 객체에 대해 호출되는 함수여야 해요. 객체의 JSON 인코딩 가능한 버전을 돌려주거나 TypeError를 일으켜야 해요. 지정하지 않으면 TypeError가 나요.

버전 3.6에서 변경: 모든 매개변수가 이제 키워드 전용.

default(o)

하위 클래스에서 o에 대해 직렬화 가능한 객체를 돌려주거나, 기본 구현을 호출해(TypeError) 이 메서드를 구현해요. 예를 들어 임의의 이터레이터를 지원하려면 default()를 이렇게 구현할 수 있어요:

def default(self, o):
   try:
       iterable = iter(o)
   except TypeError:
       pass
   else:
       return list(iterable)
   # Let the base class default method raise the TypeError
   return super().default(o)

encode(o)

Python 데이터 구조 o의 JSON 문자열 표현을 돌려줘요. 예:

>>> json.JSONEncoder().encode({"foo": ["bar", "baz"]})
'{"foo": ["bar", "baz"]}'

iterencode(o)

주어진 객체 o를 인코딩하고 각 문자열 표현을 사용 가능할 때마다 yield해요. 예:

for chunk in json.JSONEncoder().iterencode(bigobject):
    mysocket.write(chunk)

예외

exception json.JSONDecodeError(msg, doc, pos)

ValueError의 하위 클래스로, 다음 추가 속성이 있어요:

msg — 형식이 잡히지 않은 오류 메시지.
doc — 파싱 중인 JSON 문서.
pos — 파싱이 실패한 doc의 시작 인덱스.
lineno — pos에 해당하는 줄.
colno — pos에 해당하는 열.

버전 3.5에 추가됨.

표준 준수와 상호운용성

JSON 형식은 RFC 7159와 ECMA-404로 지정돼요. 이 섹션은 이 모듈의 RFC 준수 수준을 설명해요.

이 모듈은 RFC를 엄격하게 따르지는 않고, 유효한 JavaScript지만 유효한 JSON이 아닌 일부 확장을 구현해요. 특히:

무한대와 NaN 숫자 값을 받아들이고 출력해요.
객체 안의 이름 중복을 받아들이고, 마지막 name-value 쌍의 값만 사용해요.

RFC가 RFC 준수 파서에게 RFC를 따르지 않는 입력 텍스트를 받도록 허용하므로, 이 모듈의 역직렬화기는 기본 설정에서 기술적으로 RFC를 준수해요.

문자 인코딩

RFC는 JSON을 UTF-8, UTF-16 또는 UTF-32로 표현하도록 요구하고, 최대 상호운용성을 위해 UTF-8을 권장 기본으로 해요. RFC가 허용(의무는 아님)하는 대로, 이 모듈의 직렬화기는 기본적으로 ensure_ascii=True를 설정해 오직 인쇄 가능한 ASCII 문자만 담도록 출력을 이스케이프해요.

ensure_ascii 매개변수를 제외하면 이 모듈은 Python 객체와 유니코드 문자열 사이의 변환으로만 정의되고, 문자 인코딩 문제를 직접 다루지는 않아요.

RFC는 JSON 텍스트 시작에 BOM(byte order mark)을 추가하는 걸 금지하고, 이 모듈의 직렬화기는 출력에 BOM을 넣지 않아요. RFC는 JSON 역직렬화기가 입력의 초기 BOM을 무시하는 걸 허용하지만 의무는 아니에요. 이 모듈의 역직렬화기는 초기 BOM이 있으면 ValueError를 일으켜요.

RFC는 유효한 유니코드 문자에 해당하지 않는 바이트 시퀀스(예: 짝지어지지 않은 UTF-16 서로게이트)를 담은 JSON 문자열을 명시적으로 금지하진 않지만, 상호운용성 문제를 일으킬 수 있다고 지적해요. 기본적으로 이 모듈은 그런 시퀀스에 대한 코드 포인트를(원래 str에 있을 때) 받아들이고 출력해요.

무한대와 NaN 숫자 값

RFC는 무한대나 NaN 숫자 값을 나타내는 걸 허용하지 않아요. 그럼에도 기본적으로 이 모듈은 Infinity, -Infinity, NaN을 유효한 JSON 숫자 리터럴처럼 받아들이고 출력해요:

>>> # Neither of these calls raises an exception, but the results are not valid JSON
>>> json.dumps(float('-inf'))
'-Infinity'
>>> json.dumps(float('nan'))
'NaN'
>>> # Same when deserializing
>>> json.loads('-Infinity')
-inf
>>> json.loads('NaN')
nan

직렬화기에서는 allow_nan 매개변수로, 역직렬화기에서는 parse_constant 매개변수로 이 동작을 바꿀 수 있어요.

객체 안의 이름 중복

RFC는 JSON 객체 안의 이름이 고유해야 한다고 지정하지만, 중복 이름을 어떻게 처리할지는 규정하지 않아요. 기본적으로 이 모듈은 예외를 일으키지 않고, 주어진 이름에 대한 마지막 name-value 쌍을 제외한 모두를 무시해요:

>>> weird_json = '{"x": 1, "x": 2, "x": 3}'
>>> json.loads(weird_json)
{'x': 3}

object_pairs_hook 매개변수로 이 동작을 바꿀 수 있어요.

최상위의 객체·배열이 아닌 값

폐기된 RFC 4627이 지정한 옛 JSON 버전은 JSON 텍스트의 최상위 값이 JSON 객체나 배열(Python dict 또는 list)이어야 하고, JSON null, 불리언, 숫자, 문자열 값이면 안 된다고 요구했어요. RFC 7159가 그 제한을 없앴고, 이 모듈은 직렬화기와 역직렬화기 어디에서도 그 제한을 구현하지 않았고 앞으로도 없어요. 그래도 최대 상호운용성을 위해 스스로 그 제한을 지키고 싶을 수 있어요.

구현 제한

일부 JSON 역직렬화 구현은 다음을 제한할 수 있어요: 허용되는 JSON 텍스트의 크기, JSON 객체·배열의 최대 중첩 수준, JSON 숫자의 범위와 정밀도, JSON 문자열의 내용과 최대 길이.

이 모듈은 관련 Python 데이터 타입이나 인터프리터 자체의 제한 외에는 그런 제한을 두지 않아요. JSON으로 직렬화할 때는 여러분의 JSON을 소비할 앱의 그런 제한을 주의해야 해요. 특히 JSON 숫자는 흔히 IEEE 754 배정밀도 숫자로 역직렬화돼 그 표현의 범위·정밀도 제한을 받아요. 이는 매우 큰 크기의 Python int 값이나 decimal.Decimal 같은 "이색적인" 숫자 타입 인스턴스를 직렬화할 때 특히 관련돼요.

명령줄 인터페이스

json 모듈은 스크립트로써 python -m json으로 호출해 JSON 객체를 검증하고 예쁘게 출력할 수 있어요. json.tool 하위 모듈이 이 인터페이스를 구현해요.

선택적 infile, outfile 인자를 지정하지 않으면 각각 sys.stdin과 sys.stdout이 사용돼요:

$ echo '{"json": "obj"}' | python -m json
{
    "json": "obj"
}
$ echo '{1.2:3.4}' | python -m json
Expecting property name enclosed in double quotes: line 1 column 2 (char 1)

버전 3.5에서 변경: 출력이 이제 입력과 같은 순서. --sort-keys 옵션으로 딕셔너리 출력을 키 알파벳순으로 정렬. 버전 3.14에서 변경: json 모듈을 이제 python -m json으로 직접 실행 가능. 하위 호환을 위해 python -m json.tool로 CLI를 호출하는 것도 계속 지원.

명령줄 옵션

infile — 검증하거나 예쁘게 출력할 JSON 파일:

$ python -m json mp_films.json
[
    {
        "title": "And Now for Something Completely Different",
        "year": 1971
    },
    {
        "title": "Monty Python and the Holy Grail",
        "year": 1975
    }
]

infile을 지정하지 않으면 sys.stdin에서 읽어요.

outfile — infile의 출력을 주어진 outfile에 써요. 아니면 sys.stdout에 써요.
--sort-keys — 딕셔너리 출력을 키 알파벳순으로 정렬. 버전 3.5에 추가됨.
--no-ensure-ascii — 비-ASCII 문자 이스케이프 비활성화. 자세한 내용은 json.dumps() 참고. 버전 3.9에 추가됨.
--json-lines — 각 입력 줄을 별도의 JSON 객체로 파싱. 버전 3.8에 추가됨.
--indent, --tab, --no-indent, --compact — 공백 제어를 위한 상호 배타적 옵션. 버전 3.9에 추가됨.
-h, --help — 도움말 메시지를 보여 줘요.

더 알아보기

marshal, pickle — 객체 직렬화의 다른 방식.
RFC 7159 — 계승된 JSON 사양. RFC 4627을 폐기했어요.
ECMA-404 — 현재 JSON 사양.