python模块介绍-json

xian123

　　#参考资料：《The Python Standard Library by Example》
　　12.9 json 模块
　　JSON就是JavaScript Object Notation，这个模块完成了python对象和JSON字符串的互相转换。适用于Python的版本2.6和更高版本。   
json模块提供了一个类似pickle的API，转换内存中的Python对象为JavaScript对象符号（JSON）序列。JSON具有有许多语言的实现（尤其是JavaScript）。在AJAX应用中，广泛的使用在Web服务器和客户端之间，
　　12.9.1 编码解码简单数据类型
　　JSON编码识别python的如下类型：(string, unicode, int,float, list, tuple, and dict)，比如：
　　import json
　　data = [ { 'a':'A', 'b':(2, 4), 'c':3.0 } ]
　　print 'DATA:', repr(data)
　　data_string = json.dumps(data)
　　print 'JSON:', data_string
　　执行结果：
　　$ python json_simple_types.py
　　DATA: [{'a': 'A', 'c': 3.0, 'b': (2, 4)}]
　　JSON: [{"a": "A", "c": 3.0, "b": [2, 4]}]
　　可以json的表示和python的repr差不多。这里还要注意一点，字典中，把可变对象往后靠，是不是有什么规则？
　　下例进行编码再解码：
　　import json
　　data = [ { ’a’:’A’, ’b’:(2, 4), ’c’:3.0 } ]
　　print ’DATA :’, data
　　data_string = json.dumps(data)
　　print ’ENCODED:’, data_string
　　decoded = json.loads(data_string)
　　print ’DECODED:’, decoded
　　print ’ORIGINAL:’, type(data[0][’b’])
　　print ’DECODED :’, type(decoded[0][’b’])
　　执行结果：
　　$ python json_simple_types_decode.py
　　DATA : [{’a’: ’A’, ’c’: 3.0, ’b’: (2, 4)}]
　　ENCODED: [{"a": "A", "c": 3.0, "b": [2, 4]}]
　　DECODED: [{’a’: ’A’, ’c’: 3.0, ’b’: [2, 4]}]
　　ORIGINAL:
　　DECODED :
　　这里元组:(2, 4), 编码再解码之后，成了列表
　　12.9.2 编码解码简单数据类型
　　JSON跟pickle比的另一个好处是结果的可读性比较好。pickle函数接受多个参数，以使输出甚至更好。下例实现了排序功能：
　　import json
　　data = [ { ’a’:’A’, ’b’:(2, 4), ’c’:3.0 } ]
　　print ’DATA:’, repr(data)
　　unsorted = json.dumps(data)
　　print ’JSON:’, json.dumps(data)
　　print ’SORT:’, json.dumps(data, sort_keys=True)
　　first = json.dumps(data, sort_keys=True)
　　second = json.dumps(data, sort_keys=True)
　　print ’UNSORTED MATCH:’, unsorted == first
　　print ’SORTED MATCH :’, first == second
　　执行结果：
　　$ python json_sort_keys.py
　　DATA: [{’a’: ’A’, ’c’: 3.0, ’b’: (2, 4)}]
　　JSON: [{"a": "A", "c": 3.0, "b": [2, 4]}]
　　SORT: [{"a": "A", "b": [2, 4], "c": 3.0}]
　　UNSORTED MATCH: False
　　SORTED MATCH : True
　　对于多层嵌套的数据结构，还可以使用缩进：
　　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
　　12.9.3 编码字典
　　JSON字典的键值是字符串。试图编码非字符串作为键值会产生一个例外，是TypeError 或者ValueError，取决于加载的模块是纯Python版本加载还是C的加速版本，可以让json忽略这些非字符串的键值。
　　import json
　　data = [ { ’a’:’A’, ’b’:(2, 4), ’c’:3.0, (’d’,):’D tuple’ } ]
　　print ’First attempt’
　　try:
　　print json.dumps(data)
　　except (TypeError, ValueError), err:
　　print ’ERROR:’, err
　　print
　　print ’Second attempt’
　　print json.dumps(data, skipkeys=True)
　　执行结果：
　　import json
　　data = [ { ’a’:’A’, ’b’:(2, 4), ’c’:3.0, (’d’,):’D tuple’ } ]
　　print ’First attempt’
　　try:
　　print json.dumps(data)
　　except (TypeError, ValueError), err:
　　print ’ERROR:’, err
　　print
　　print ’Second attempt’
　　print json.dumps(data, skipkeys=True)
　　12.9.4 自定义类型
　　到目前为止，所有的例子使用了Python的内置类型，因为这些都是由JSON本身支持的。如果需要编码自定义类，有两种方法。比如有如下对象：
　　class MyObj(object):
　　def __init__(self, s):
　　self.s = s
　　def __repr__(self):
　　return ’’ % self.s
　　编码MyObj实例的最简单的方法是定义一个函数来转换未知类型为已知类型。它不需要做编码，因此它应该只是转换一个对象到另一个。
　　import json
　　import json_myobj
　　obj = json_myobj.MyObj(’instance value goes here’)
　　print ’First attempt’
　　try:
　　print json.dumps(obj)
　　except TypeError, err:
　　print ’ERROR:’, err
　　def convert_to_builtin_type(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
　　print
　　print ’With default’
　　print json.dumps(obj, default=convert_to_builtin_type)
　　执行结果：
　　$ python json_dump_default.py
　　First attempt
　　ERROR:  is not JSON serializable
　　With default
　　default(  )
　　{"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:
　　INSTANCE ARGS: {’s’: ’instance value goes here’}
　　[]
　　由于JSON字符串值转换为Unicode对象，他们需要重新编码   
为ASCII字符串，才可以作为类构造的关键字参数。
　　12.9.5 编码和解码类
　　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
　　
　　default(  )
　　{"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:
　　INSTANCE ARGS: {’s’: ’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
　　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
　　注意，对象必须在输入的开始
　　其他参考资料：
　　json (http://docs.python.org/library/json.html)
　　JavaScript Object Notation (http://json.org/)
　　simplejson (http://code.google.com/p/simplejson/)
　　simplejson (http://code.google.com/p/simplejson/)