Python Language
JSON 모듈

비고

# my_json module

import json
from functools import partial

def serialise_object(obj):
    # Do something to produce json-serialisable data
    return dict_obj

dump = partial(json.dump, default=serialise_object)
dumps = partial(json.dumps, default=serialise_object)

# my_json module

import json
from functools import partial

def deserialise_object(dict_obj):
    # Do something custom
    return obj

def deserialise_float(str_obj):
    # Do something custom
    return obj

load = partial(json.load, object_hook=deserialise_object, parse_float=deserialise_float)
loads = partial(json.loads, object_hook=deserialise_object, parse_float=deserialise_float)

# my_json module

import json
from functools import partial

class MyEncoder(json.JSONEncoder):
    # Do something custom

class MyDecoder(json.JSONDecoder):
    # Do something custom

dump = partial(json.dump, cls=MyEncoder)
dumps = partial(json.dumps, cls=MyEncoder)
load = partial(json.load, cls=MyDecoder)
loads = partial(json.loads, cls=MyDecoder)

Python dict에서 JSON 만들기

import json
d = {
    'foo': 'bar',
    'alice': 1,
    'wonderland': [1, 2, 3]
}
json.dumps(d)

위의 스 니펫은 다음을 반환합니다.

'{"wonderland": [1, 2, 3], "foo": "bar", "alice": 1}'

JSON에서 Python dict 만들기

import json
s = '{"wonderland": [1, 2, 3], "foo": "bar", "alice": 1}'
json.loads(s)

위의 스 니펫은 다음을 반환합니다.

{u'alice': 1, u'foo': u'bar', u'wonderland': [1, 2, 3]}

파일에 데이터 저장

다음 스 니펫은 d 에 저장된 데이터를 JSON으로 인코딩하고이를 파일에 저장합니다 ( filename 을 filename 의 실제 이름으로 대체).

import json

d = {
    'foo': 'bar',
    'alice': 1,
    'wonderland': [1, 2, 3]
}

with open(filename, 'w') as f:
    json.dump(d, f)

파일에서 데이터 검색

다음 스 니펫은 JSON 인코딩 파일을 열고 ( filename 을 실제 파일 이름으로 바꿉니다) 파일에 저장된 객체를 반환합니다.

import json

with open(filename, 'r') as f:
    d = json.load(f)

`로드`대`로드`,`덤프`대`덤프`

json 모듈에는 유니 코드 문자열을 읽고 쓰는 기능과 파일을 읽거나 쓰는 기능이 있습니다. 이들은 함수 이름에서 후행 s 에 의해 구별됩니다. 이 예제에서는 StringIO 객체를 사용하지만 파일과 같은 객체에는 동일한 함수가 적용됩니다.

다음은 문자열 기반 함수를 사용합니다.

import json

data = {u"foo": u"bar", u"baz": []}
json_string = json.dumps(data)
# u'{"foo": "bar", "baz": []}'
json.loads(json_string)
# {u"foo": u"bar", u"baz": []}

여기에서는 파일 기반 함수를 사용합니다.

import json

from io import StringIO

json_file = StringIO()
data = {u"foo": u"bar", u"baz": []}
json.dump(data, json_file)
json_file.seek(0)  # Seek back to the start of the file before reading
json_file_content = json_file.read()
# u'{"foo": "bar", "baz": []}'
json_file.seek(0)  # Seek back to the start of the file before reading
json.load(json_file)
# {u"foo": u"bar", u"baz": []}

주된 차이점을 알 수 있듯이 json 데이터를 덤프 할 때 반환 값을 캡처하는 대신 파일 핸들을 함수에 전달해야합니다. 또한 주목할만한 점은 데이터 손상을 피하기 위해 읽기 또는 쓰기 전에 파일 시작 부분을 찾아야한다는 것입니다. 파일을 열 때 커서가 위치 0 배치되므로 아래도 작동합니다.

import json

json_file_path = './data.json'
data = {u"foo": u"bar", u"baz": []}

with open(json_file_path, 'w') as json_file:
    json.dump(data, json_file)

with open(json_file_path) as json_file:
    json_file_content = json_file.read()
    # u'{"foo": "bar", "baz": []}'

with open(json_file_path) as json_file:
    json.load(json_file)
    # {u"foo": u"bar", u"baz": []}

json 데이터를 다루는 두 가지 방법을 사용하면 pyspark 의 json-per-line과 같이 json을 기반으로하는 형식으로 관용적으로 효율적으로 작업 할 수 있습니다.

# loading from a file
data = [json.loads(line) for line in open(file_path).splitlines()]

# dumping to a file
with open(file_path, 'w') as json_file:
    for item in data:
        json.dump(item, json_file)
        json_file.write('\n')

커맨드 라인에서`json.tool`을 호출하여 JSON 출력을 예쁜 것으로 출력합니다.

주어진 JSON 파일 "foo.json"은 다음과 같습니다.

{"foo": {"bar": {"baz": 1}}}

명령 줄에서 모듈을 직접 호출하여 (파일 이름을 인수로 전달하여) 예쁜 인쇄를 할 수 있습니다.

$ python -m json.tool foo.json
{
    "foo": {
        "bar": {
            "baz": 1
        }
    }
}

모듈은 STDOUT으로부터 입력을받습니다. 그래서 (Bash에서) 우리는 똑같이 할 수 있습니다 :

$ cat foo.json | python -m json.tool

JSON 출력 포맷

다음 데이터가 있다고 가정 해 보겠습니다.

>>> data = {"cats": [{"name": "Tubbs", "color": "white"}, {"name": "Pepper", "color": "black"}]}

JSON으로 이것을 그냥 버리면 여기서는 특별한 것이 없습니다.

>>> print(json.dumps(data))
{"cats": [{"name": "Tubbs", "color": "white"}, {"name": "Pepper", "color": "black"}]}

들여 쓰기 설정을 통해 출력 향상

꽤 인쇄하기를 원하면 indent 크기를 설정할 수 있습니다 :

>>> print(json.dumps(data, indent=2))
{
  "cats": [
    {
      "name": "Tubbs",
      "color": "white"
    },
    {
      "name": "Pepper",
      "color": "black"
    }
  ]
}

일관된 출력을 얻기 위해 사전 순으로 키 정렬

기본적으로 출력의 키 순서는 정의되지 않습니다. 우리는 항상 같은 결과물을 얻을 수 있도록 알파벳 순서로 얻을 수 있습니다 :

>>> print(json.dumps(data, sort_keys=True))
{"cats": [{"color": "white", "name": "Tubbs"}, {"color": "black", "name": "Pepper"}]}

콤팩트 출력을 얻기위한 공백 제거

우리는 불필요한 공백을 제거하기를 원할 것입니다. 분리 문자는 ', ' 및 ': ' 와는 다른 구분 기호 문자열을 설정하여 수행됩니다.

>>>print(json.dumps(data, separators=(',', ':')))
{"cats":[{"name":"Tubbs","color":"white"},{"name":"Pepper","color":"black"}]}

JSON 인코딩 사용자 정의 객체

다음을 시도해보십시오.

import json
from datetime import datetime
data = {'datetime': datetime(2016, 9, 26, 4, 44, 0)}
print(json.dumps(data))

우리는 TypeError: datetime.datetime(2016, 9, 26, 4, 44) is not JSON serializable 오류가 발생합니다.

datetime 객체를 제대로 직렬화하려면 변환 방법에 대한 사용자 정의 코드를 작성해야합니다.

class DatetimeJSONEncoder(json.JSONEncoder):
    def default(self, obj):
        try:
            return obj.isoformat()
        except AttributeError:
            # obj has no isoformat method; let the builtin JSON encoder handle it
            return super(DatetimeJSONEncoder, self).default(obj)

json.dumps 대신이 인코더 클래스를 사용하십시오.

encoder = DatetimeJSONEncoder()
print(encoder.encode(data))
# prints {"datetime": "2016-09-26T04:44:00"}