对于多层嵌套的数据结构，还可以使用缩进：
import json
data = [ { ’a’:’A’, ’b’:(2, 4), ’c’:3.0 } ]
print ’DATA:’, repr(data)
print ’NORMAL:’, json.dumps(data, sort_keys=True)
print ’INDENT:’, json.dumps(data, sort_keys=True, indent=2)
执行结果：
$ python json_indent.py
DATA: [{’a’: ’A’, ’c’: 3.0, ’b’: (2, 4)}]
NORMAL: [{"a": "A", "b": [2, 4], "c": 3.0}]
INDENT: [
{
"a": "A",
"b": [
2,
4
],
"c": 3.0
}
]
当缩进不是负数的时候，和pprint的效果差不多。
像这样详细的输出，因此它不适合在产品环境中使用。可以调整分离编码输出数据使它甚至超过了默认的紧凑。
import json
data = [ { ’a’:’A’, ’b’:(2, 4), ’c’:3.0 } ]
print ’DATA:’, repr(data)
print ’repr(data) :’, len(repr(data))
plain_dump = json.dumps(data)
print ’dumps(data) :’, len(plain_dump)
small_indent = json.dumps(data, indent=2)
print ’dumps(data, indent=2) :’, len(small_indent)
with_separators = json.dumps(data, separators=(’,’,’:’))
print ’dumps(data, separators):’, len(with_separators)
执行结果：
$ python json_compact_encoding.py
DATA: [{’a’: ’A’, ’c’: 3.0, ’b’: (2, 4)}]
repr(data) : 35
dumps(data) : 35
dumps(data, indent=2) : 76
dumps(data, separators): 29
"a": "A",
"b": [
2,
4
],
"c": 3.0
}
]
当缩进不是负数的时候，和pprint的效果差不多。
像这样详细的输出，因此它不适合在产品环境中使用。可以调整分离编码输出数据使它甚至超过了默认的紧凑。
import json
data = [ { ’a’:’A’, ’b’:(2, 4), ’c’:3.0 } ]
print ’DATA:’, repr(data)
print ’repr(data) :’, len(repr(data))
plain_dump = json.dumps(data)
print ’dumps(data) :’, len(plain_dump)
small_indent = json.dumps(data, indent=2)
print ’dumps(data, indent=2) :’, len(small_indent)
with_separators = json.dumps(data, separators=(’,’,’:’))
print ’dumps(data, separators):’, len(with_separators)
执行结果：
$ python json_compact_encoding.py
DATA: [{’a’: ’A’, ’c’: 3.0, ’b’: (2, 4)}]
repr(data) : 35
dumps(data) : 35
dumps(data, indent=2) : 76
dumps(data, separators): 29
print ’default(’, repr(obj), ’)’
# Convert objects to a dictionary of their representation
d = { ’__class__’:obj.__class__.__name__,
’__module__’:obj.__module__,
}
d.update(obj.__dict__)
return d
print ’With default’
print json.dumps(obj, default=convert_to_builtin_type)
执行结果：
$ python json_dump_default.py
First attempt
ERROR: <MyObj(instance value goes here)> is not JSON serializable
With default
default( <MyObj(instance value goes here)> )
{"s": "instance value goes here", "__module__": "json_myobj",
"__class__": "MyObj"}
要解码的结果并创建一个MyObj中（）实例，使用object_hook参数到loads()绑上给解码器，这样的类可以从模块导入并用来创建实例。
每个从输入数据流中解码的字典调用object_hook，把字典转换为其他数据类型。Hook函数程序应该接收的对象而不是字典。
import json
def dict_to_object(d):
if '__class__' in d:
class_name = d.pop('__class__')
module_name = d.pop('__module__')
module = __import__(module_name)
print 'MODULE:', module.__name__
class_ = getattr(module, class_name)
print 'CLASS:', class_
args = dict( (key.encode('ascii'), value)
for key, value in d.items())
print 'INSTANCE ARGS:', args
inst = class_(**args)
else:
inst = d
return inst
encoded_object = '''
[{"s": "instance value goes here",
"__module__": "json_myobj", "__class__": "MyObj"}]
'''
myobj_instance = json.loads(encoded_object,
object_hook=dict_to_object)
print myobj_instance
运行结果：
$ python json_load_object_hook.py
MODULE: json_myobj
CLASS: <class ’json_myobj.MyObj’>
INSTANCE ARGS: {’s’: ’instance value goes here’}
[<MyObj(instance value goes here)>]
由于JSON字符串值转换为Unicode对象，他们需要重新编码
为ASCII字符串，才可以作为类构造的关键字参数。
"a": "A",
"b": [
2,
4
],
"c": 3.0
}
]
当缩进不是负数的时候，和pprint的效果差不多。
像这样详细的输出，因此它不适合在产品环境中使用。可以调整分离编码输出数据使它甚至超过了默认的紧凑。
import json
data = [ { ’a’:’A’, ’b’:(2, 4), ’c’:3.0 } ]
print ’DATA:’, repr(data)
print ’repr(data) :’, len(repr(data))
plain_dump = json.dumps(data)
print ’dumps(data) :’, len(plain_dump)
small_indent = json.dumps(data, indent=2)
print ’dumps(data, indent=2) :’, len(small_indent)
with_separators = json.dumps(data, separators=(’,’,’:’))
print ’dumps(data, separators):’, len(with_separators)
执行结果：
$ python json_compact_encoding.py
DATA: [{’a’: ’A’, ’c’: 3.0, ’b’: (2, 4)}]
repr(data) : 35
dumps(data) : 35
dumps(data, indent=2) : 76
dumps(data, separators): 29
print ’default(’, repr(obj), ’)’
# Convert objects to a dictionary of their representation
d = { ’__class__’:obj.__class__.__name__,
’__module__’:obj.__module__,
}
d.update(obj.__dict__)
return d
print ’With default’
print json.dumps(obj, default=convert_to_builtin_type)
执行结果：
$ python json_dump_default.py
First attempt
ERROR: <MyObj(instance value goes here)> is not JSON serializable
With default
default( <MyObj(instance value goes here)> )
{"s": "instance value goes here", "__module__": "json_myobj",
"__class__": "MyObj"}
要解码的结果并创建一个MyObj中（）实例，使用object_hook参数到loads()绑上给解码器，这样的类可以从模块导入并用来创建实例。
每个从输入数据流中解码的字典调用object_hook，把字典转换为其他数据类型。Hook函数程序应该接收的对象而不是字典。
import json
def dict_to_object(d):
if '__class__' in d:
class_name = d.pop('__class__')
module_name = d.pop('__module__')
module = __import__(module_name)
print 'MODULE:', module.__name__
class_ = getattr(module, class_name)
print 'CLASS:', class_
args = dict( (key.encode('ascii'), value)
for key, value in d.items())
print 'INSTANCE ARGS:', args
inst = class_(**args)
else:
inst = d
return inst
encoded_object = '''
[{"s": "instance value goes here",
"__module__": "json_myobj", "__class__": "MyObj"}]
'''
myobj_instance = json.loads(encoded_object,
object_hook=dict_to_object)
print myobj_instance
运行结果：
$ python json_load_object_hook.py
MODULE: json_myobj
CLASS: <class ’json_myobj.MyObj’>
INSTANCE ARGS: {’s’: ’instance value goes here’}
[<MyObj(instance value goes here)>]
由于JSON字符串值转换为Unicode对象，他们需要重新编码
为ASCII字符串，才可以作为类构造的关键字参数。
json模块提供了编码和解码类。使用这些类可访问额外的API来定制自己的行为。
JSONEncoder使用了一个可迭代接口编码数据的“chunks”，从而在不需要在内存表示整个数据，更加容易写文件或网络socket。
import json
encoder = json.JSONEncoder()
data = [ { ’a’:’A’, ’b’:(2, 4), ’c’:3.0 } ]
for part in encoder.iterencode(data):
print ’PART:’, part
执行结果：
$ python json_encoder_iterable.py
PART: [
PART: {
PART: "a"
PART: :
PART: "A"
PART: ,
PART: "c"
PART: :
PART: 3.0
PART: ,
PART: "b"
PART: :
PART: [2
PART: , 4
PART: ]
PART: }
PART: ]
encode()方法基本上等同于’ ’.join(encoder.iterencode())，不过事先多了一些错误检查。要编码的任意对象，使用前面类似convert_to_builtin_type的方法重载default()。
import json
import json_myobj
class MyEncoder(json.JSONEncoder):
def default(self, obj):
print 'default(', repr(obj), ')'
# Convert objects to a dictionary of their representation
d = { '__class__':obj.__class__.__name__,
'__module__':obj.__module__,
}
d.update(obj.__dict__)
return d
obj = json_myobj.MyObj('internal data')
print obj
print MyEncoder().encode(obj)
执行结果：
$ python json_encoder_default.py
<MyObj(internal data)>
default( <MyObj(internal data)> )
{"s": "internal data", "__module__": "json_myobj", "__class__":
"MyObj"}
解码文本，然后转换对象到字典，比之前的实现要稍微多一点步骤
import json
class MyDecoder(json.JSONDecoder):
def __init__(self):
json.JSONDecoder.__init__(self,
object_hook=self.dict_to_object)
def dict_to_object(self, d):
if ’__class__’ in d:
class_name = d.pop(’__class__’)
module_name = d.pop(’__module__’)
module = __import__(module_name)
print ’MODULE:’, module.__name__
class_ = getattr(module, class_name)
print ’CLASS:’, class_
args = dict( (key.encode(’ascii’), value)
for key, value in d.items())
print ’INSTANCE ARGS:’, args
inst = class_(**args)
else:
inst = d
return inst
encoded_object = ’’’
[{"s": "instance value goes here",
"__module__": "json_myobj", "__class__": "MyObj"}]
’’’
myobj_instance = MyDecoder().decode(encoded_object)
print myobj_instance。
执行结果：
$ python json_decoder_object_hook.py
MODULE: json_myobj
CLASS: <class ’json_myobj.MyObj’>
INSTANCE ARGS: {’s’: ’instance value goes here’}
[<MyObj(instance value goes here)>]
12.9.6 流和文件
函数load() 和dump()用于读写文件类似的对象。
import json
from StringIO import StringIO
data = [ { ’a’:’A’, ’b’:(2, 4), ’c’:3.0 } ]
f = StringIO()
json.dump(data, f)
print f.getvalue()
执行结果：
$ python json_dump_file.py
[{"a": "A", "c": 3.0, "b": [2, 4]}]
虽然不优化为一次只读取的部分数据，load()提供了从流输入生成对象逻辑。
import json
from StringIO import StringIO
f = StringIO(’[{"a": "A", "c": 3.0, "b": [2, 4]}]’)
print json.load(f)
执行结果：
$ python json_load_file.py
[{’a’: ’A’, ’c’: 3.0, ’b’: [2, 4]}]
12.9.7 混合数据流
JSONDecoder包括raw_decode（），这个方法可以解码包含更多数据的数据结构
，比如带后续文本的JSON数据。返回值是解码后的输入数据和索引。
(obj, end, remaining)
encoded_object = ’[{"a": "A", "c": 3.0, "b": [2, 4]}]’
extra_text = ’This text is not JSON.’
print ’JSON first:’
data = ’ ’.join([encoded_object, extra_text])
obj, end, remaining = get_decoded_and_remainder(data)
print ’Object :’, obj
print ’End of parsed input :’, end
print ’Remaining text :’, repr(remaining)
print ’JSON embedded:’
try:
data = ’ ’.join([extra_text, encoded_object, extra_text])
obj, end, remaining = get_decoded_and_remainder(data)
except ValueError, err:
print ’ERROR:’, err
执行结果：
$ python json_mixed_data.py
JSON first:
Object : [{’a’: ’A’, ’c’: 3.0, ’b’: [2, 4]}]
End of parsed input : 35
Remaining text : ’ This text is not JSON.’
JSON embedded:
ERROR: No JSON object could be decoded
注意，对象必须在输入的开始
来自：http://www.cnblogs.com/sunny5156/archive/2012/10/29/2745068.html
"a": "A",
"b": [
2,
4
],
"c": 3.0
}
]
当缩进不是负数的时候，和pprint的效果差不多。
像这样详细的输出，因此它不适合在产品环境中使用。可以调整分离编码输出数据使它甚至超过了默认的紧凑。
import json
data = [ { ’a’:’A’, ’b’:(2, 4), ’c’:3.0 } ]
print ’DATA:’, repr(data)
print ’repr(data) :’, len(repr(data))
plain_dump = json.dumps(data)
print ’dumps(data) :’, len(plain_dump)
small_indent = json.dumps(data, indent=2)
print ’dumps(data, indent=2) :’, len(small_indent)
with_separators = json.dumps(data, separators=(’,’,’:’))
print ’dumps(data, separators):’, len(with_separators)
执行结果：
$ python json_compact_encoding.py
DATA: [{’a’: ’A’, ’c’: 3.0, ’b’: (2, 4)}]
repr(data) : 35
dumps(data) : 35
dumps(data, indent=2) : 76
dumps(data, separators): 29
print ’default(’, repr(obj), ’)’
# Convert objects to a dictionary of their representation
d = { ’__class__’:obj.__class__.__name__,
’__module__’:obj.__module__,
}
d.update(obj.__dict__)
return d
print ’With default’
print json.dumps(obj, default=convert_to_builtin_type)
执行结果：
$ python json_dump_default.py
First attempt
ERROR: <MyObj(instance value goes here)> is not JSON serializable
With default
default( <MyObj(instance value goes here)> )
{"s": "instance value goes here", "__module__": "json_myobj",
"__class__": "MyObj"}
要解码的结果并创建一个MyObj中（）实例，使用object_hook参数到loads()绑上给解码器，这样的类可以从模块导入并用来创建实例。
每个从输入数据流中解码的字典调用object_hook，把字典转换为其他数据类型。Hook函数程序应该接收的对象而不是字典。
import json
def dict_to_object(d):
if '__class__' in d:
class_name = d.pop('__class__')
module_name = d.pop('__module__')
module = __import__(module_name)
print 'MODULE:', module.__name__
class_ = getattr(module, class_name)
print 'CLASS:', class_
args = dict( (key.encode('ascii'), value)
for key, value in d.items())
print 'INSTANCE ARGS:', args
inst = class_(**args)
else:
inst = d
return inst
encoded_object = '''
[{"s": "instance value goes here",
"__module__": "json_myobj", "__class__": "MyObj"}]
'''
myobj_instance = json.loads(encoded_object,
object_hook=dict_to_object)
print myobj_instance
运行结果：
$ python json_load_object_hook.py
MODULE: json_myobj
CLASS: <class ’json_myobj.MyObj’>
INSTANCE ARGS: {’s’: ’instance value goes here’}
[<MyObj(instance value goes here)>]
由于JSON字符串值转换为Unicode对象，他们需要重新编码
为ASCII字符串，才可以作为类构造的关键字参数。
扫一扫
4736
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
