python json

类：

在成员面前加上__可以使其成为私有成员

obj = [[1,2,3],123,123.123,'abc',{'key1':(1,2,3),'key2':(4,5,6)}]
encodejson = json.dumps(obj)
print repr(obj)
print encodejson

在JSON编码过程中，会存在从python原始类型向json类型的转化过程。json.dumps()方法返回了一个str对象encodedjson。

接下来再对encodedjson进行decode，得到原始数据，需要使用的json.loads()函数

decodejson = json.loads(encodejson)
print type(decodejson)
print decodejson

loads方法返回了原始的对象，但是仍然发生了一些数据类型的变化。

json.dumps方法提供了很多好用的方法，比较常用的有sort_keys（对dict对象进行排序，默认dict是无序存放的）。

indent参数是缩进的意思，可以使数据存储的格式变得更加优雅

json主要是作为一种通信的格式存在的，而网络通信是很在乎数据的大小的，无用的空格会占据很多通信带宽，所以适当时候也要对数据进行压缩。

separator参数可以起到这样的作用，该参数传递的是一个元组，包含分割对象的字符串。

另一个比较常用的dumps参数是skipkeys，默认为False。dumps方法存储dict对象时，key必须是str类型，如果出现了其他类型的话，那么会产生TypeError异常，如果开启该参数，设为True，则会比较优雅的过度。

data = {'b':789,'c':456,(1,2):123}
print json.dumps(data,skipkeys=True)

# -*- coding: utf-8 -*-
"""
Created on Sat Dec 26 13:48:42 2015

@author: Think
"""

import json

#obj = [[1,2,3],123,123.123,'abc',{'key1':(1,2,3),'key2':(4,5,6)}]
#encodejson = json.dumps(obj)
#print repr(obj)
#print encodejson
#
#decodejson = json.loads(encodejson)
#print type(decodejson)
#print decodejson
#
#data1 = {'b':789,'c':456,'a':123}
#data2 = {'a':123,'b':789,'c':456}
#d1 = json.dumps(data1, sort_keys=True)
#d2 = json.dumps(data2)
#d3 = json.dumps(data2, sort_keys=True)
#d = json.dumps(data1, separators=(',',':'))
#print d1
#print d

class Person(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def __repr__(self):
        return 'Person Object name: %s, age: %d' % (self.name, self.age)
#方法一
def object2dict(obj):
    #convert object to dict
    d = {}
    d['__class__'] = obj.__class__.__name__
    d['__module__'] = obj.__module__
    d.update(obj.__dict__)
    return d
def dict2object(d):
    if '__class__' in d:
        class_name = d.pop('__class__')
        module_name = d.pop('__module__')
        module = __import__(module_name)
        class_ = getattr(module, class_name)
        args = dict((key.encode('ascii'), value) for key, value in d.items())
        inst = class_(**args)
    else:
        inst = d
    return inst
#方法二 继承JSONEncoder和JSONDecoder类，覆写相关方法
#JSONEncoder类负责编码，主要是通过其default函数进行转化，我们可以override该方法。同理对于JSONDecoder。
class MyEncoder(json.JSONEncoder):
    def default(self, obj):
        d = {}
        d['__class__'] = obj.__class__.__name__
        d['__module__'] = obj.__module__
        d.update(obj.__dict__)
        return d
class MyDecoder(json.JSONDecoder):
    def __init__(self):
        json.JSONDecoder.__init__(self, object_hook=)
    def dict2object(self, d):
        if '__class__' in d:
            class_name = d.pop('__class__')
            module_name = d.pop('__module__')
            module = __import__(module_name)
            class_ = getattr(module, class_name)
            args = dict((key.encode('ascii'), value) for key, value in d.items())
            inst = class_(**args)
        else:
            inst = d
        return inst
if __name__ == '__main__':
    p = Person('Peter', 22)
    print p
    #person = json.dumps(p) 
    '''如果直接通过json.dumps方法对Person的实例进行处理的话,会报错，因为json无法支持
    这样的自动化转化。通过json和python的类型转化对照表，可以发现object类型是和dict相关联的
    所以我们需要将我们自定义的类型转化为dict，然后再进行处理
    '''
    d = object2dict(p)
    print d
    o = dict2object(d)
    
    dump = json.dumps(p, default=object2dict)
    print dump
    
    load = json.loads(dump, object_hook=dict2object)
    print load
    
    '''
        实质就是自定义oject类型的dict类型进行转化。object2dict函数将对象模块名，类名以及
        __dict__存储在dict对象里，并返回。dict2object函数则是反解出模块名，类名，参数，创建新的对象并返回
        json.dumps方法中增加default参数，该参数表示在转化过程中调用指定的函数，同样在decode过程中json.loads()指定
        object_hook方法，指定转换函数
    '''
    
    d = MyEncoder().encode(p)
    o = MyDecoder().decode(d)