솔루션 object_hook

import json

def json_load_byteified(file_handle):
    return _byteify(
        json.load(file_handle, object_hook=_byteify),
        ignore_dicts=True
    )

def json_loads_byteified(json_text):
    return _byteify(
        json.loads(json_text, object_hook=_byteify),
        ignore_dicts=True
    )

def _byteify(data, ignore_dicts = False):
    # if this is a unicode string, return its string representation
    if isinstance(data, unicode):
        return data.encode('utf-8')
    # if this is a list of values, return list of byteified values
    if isinstance(data, list):
        return [ _byteify(item, ignore_dicts=True) for item in data ]
    # if this is a dictionary, return dictionary of byteified keys and values
    # but only if we haven't already byteified it
    if isinstance(data, dict) and not ignore_dicts:
        return {
            _byteify(key, ignore_dicts=True): _byteify(value, ignore_dicts=True)
            for key, value in data.iteritems()
        }
    # if it's anything else, return it in its original form
    return data

사용법 예 :

>>> json_loads_byteified('{"Hello": "World"}')
{'Hello': 'World'}
>>> json_loads_byteified('"I am a top-level string"')
'I am a top-level string'
>>> json_loads_byteified('7')
7
>>> json_loads_byteified('["I am inside a list"]')
['I am inside a list']
>>> json_loads_byteified('[[[[[[[["I am inside a big nest of lists"]]]]]]]]')
[[[[[[[['I am inside a big nest of lists']]]]]]]]
>>> json_loads_byteified('{"foo": "bar", "things": [7, {"qux": "baz", "moo": {"cow": ["milk"]}}]}')
{'things': [7, {'qux': 'baz', 'moo': {'cow': ['milk']}}], 'foo': 'bar'}
>>> json_load_byteified(open('somefile.json'))
{'more json': 'from a file'}

어떻게 작동하며 왜 사용합니까?

마크 애 머리의 기능 은이 보다 짧고 명확합니다. 그렇다면 요점은 무엇입니까? 왜 그것들을 사용하고 싶습니까?

순수한 성능 . Mark의 답변은 먼저 유니 코드 문자열로 JSON 텍스트를 완전히 디코딩 한 다음 디코딩 된 전체 값을 반복하여 모든 문자열을 바이트 문자열로 변환합니다. 이것은 바람직하지 않은 몇 가지 영향을 미칩니다.

• 전체 디코딩 구조의 복사본이 메모리에 생성됩니다.
• JSON 객체가 실제로 깊게 중첩되어 있으면 (500 레벨 이상) Python의 최대 재귀 깊이에 도달합니다

이 답변 object_hook은 json.load및 매개 변수를 사용하여 이러한 성능 문제를 모두 완화합니다 json.loads. 에서 워드 프로세서 :

object_hook(a dict) 객체 리터럴 디코딩 결과로 호출되는 선택적 함수입니다 . 대신에 object_hook의 반환 값이 사용됩니다 dict. 이 기능은 커스텀 디코더를 구현하는 데 사용할 수 있습니다

다른 딕셔너리에 많은 레벨이 중첩 된 딕셔너리 object_hook 는 디코딩 될 때 전달되기 때문에 , 그 시점에서 그 안에 문자열이나리스트를 바이트 화하고 나중에 깊은 재귀가 필요하지 않도록 할 수 있습니다.

Mark의 답변은 object_hook중첩 된 사전으로 되풀이되므로 그대로 사용하기에 적합하지 않습니다 . 우리는이 대답에 그 재귀 방지 ignore_dicts에 대한 매개 변수를 _byteify항상 그것에 전달되는, 제외 하면 object_hook이 새로운 전달 dictbyteify 할 수 있습니다. ignore_dicts플래그는 말한다_byteify 무시 dict이미 byteified 된 이후들.

마지막으로, 디코딩되는 JSON 텍스트가 최상위 레벨에 없는 경우를 처리 하거나 반환 된 결과에 대해 (with )를 구현 json_load_byteified하고 json_loads_byteified호출 합니다._byteifyignore_dicts=Truejson.loadjson.loadsdict

답변

>>> import json
>>> import yaml
>>> list_org = ['a', 'b']
>>> list_dump = json.dumps(list_org)
>>> list_dump
'["a", "b"]'
>>> json.loads(list_dump)
[u'a', u'b']
>>> yaml.safe_load(list_dump)
['a', 'b']

def byteify(input):
    if isinstance(input, dict):
        return {byteify(key): byteify(value)
                for key, value in input.iteritems()}
    elif isinstance(input, list):
        return [byteify(element) for element in input]
    elif isinstance(input, unicode):
        return input.encode('utf-8')
    else:
        return input

def _decode_list(data):
    rv = []
    for item in data:
        if isinstance(item, unicode):
            item = item.encode('utf-8')
        elif isinstance(item, list):
            item = _decode_list(item)
        elif isinstance(item, dict):
            item = _decode_dict(item)
        rv.append(item)
    return rv

def _decode_dict(data):
    rv = {}
    for key, value in data.iteritems():
        if isinstance(key, unicode):
            key = key.encode('utf-8')
        if isinstance(value, unicode):
            value = value.encode('utf-8')
        elif isinstance(value, list):
            value = _decode_list(value)
        elif isinstance(value, dict):
            value = _decode_dict(value)
        rv[key] = value
    return rv

obj = json.loads(s, object_hook=_decode_dict)

>>> nl = json.loads(js)
>>> nl
[u'a', u'b']
>>> nl = [s.encode('utf-8') for s in nl]
>>> nl
['a', 'b']

import json, ast
d = { 'field' : 'value' }
print "JSON Fail: ", json.loads(json.dumps(d))
print "AST Win:", ast.literal_eval(json.dumps(d))

JSON Fail:  {u'field': u'value'}
AST Win: {'field': 'value'}

def deunicodify_hook(pairs):
    new_pairs = []
    for key, value in pairs:
        if isinstance(value, unicode):
            value = value.encode('utf-8')
        if isinstance(key, unicode):
            key = key.encode('utf-8')
        new_pairs.append((key, value))
    return dict(new_pairs)

In [52]: open('test.json').read()
Out[52]: '{"1": "hello", "abc": [1, 2, 3], "def": {"hi": "mom"}, "boo": [1, "hi", "moo", {"5": "some"}]}'

In [53]: json.load(open('test.json'))
Out[53]:
{u'1': u'hello',
 u'abc': [1, 2, 3],
 u'boo': [1, u'hi', u'moo', {u'5': u'some'}],
 u'def': {u'hi': u'mom'}}

In [54]: json.load(open('test.json'), object_pairs_hook=deunicodify_hook)
Out[54]:
{'1': 'hello',
 'abc': [1, 2, 3],
 'boo': [1, 'hi', 'moo', {'5': 'some'}],
 'def': {'hi': 'mom'}}

for key, value in pairs:

for key, value in pairs.iteritems():

In [66]: json.load(open('test.json'), object_hook=deunicodify_hook)
Out[66]:
{'1': 'hello',
 'abc': [1, 2, 3],
 'boo': [1, 'hi', 'moo', {'5': 'some'}],
 'def': {'hi': 'mom'}}