python对JSON的相关操作

        JSON: JavaScript Object Notation(JavaScript 对象表示法)

        JSON 是存储和交换文本信息的语法。类似 XML。

        JSON 比 XML 更小、更快，更易解析。

1
2
3
4
5
6
7
{
"sites": [
{ "name":"百度" , "url":"www.baidu.com" }, 
{ "name":"google" , "url":"www.google.com" }, 
{ "name":"微博" , "url":"www.weibo.com" }
]
}

        这个sites对象是包含3个站点记录（对象）的数组。

什么是JSON

  • JSON 指的是 JavaScript 对象表示法（JavaScript Object Notation）
  • JSON 是轻量级的文本数据交换格式
  • JSON 独立于语言：JSON 使用 Javascript语法来描述数据对象，但是 JSON 仍然独立于语言和平台。JSON 解析器和 JSON 库支持许多不同的编程语言。 目前非常多的动态（PHP，JSP，.NET）编程语言都支持JSON。
  • JSON 具有自我描述性，更易理解

简单数据类型的转换

  • json.loads ： 将python字符串 转换为 python字典/列表
  • json.dumps : 将python字典/列表 转换为 python字符串

        使用简单的json.dumps方法对简单数据 类型进行编码。

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

        输出

1
2
[[1, 2, 3], 123, 123.123, 'abc', {'key2': (4, 5, 6), 'key1': (1, 2, 3)}] 
[[1, 2, 3], 123, 123.123, "abc", {"key2": [4, 5, 6], "key1": [1, 2, 3]}]

        通过输出的结果可以看出，简单类型通过编码之后跟其原始的repe()输出结果非常像是，但是有些数据类型进行了改变，上例中元组则转换为了列表。在json的编码过程中，会存在从python原始类型向json类型的转化过程，具体转化对照

Python JSON
dict object
list,tuple array
str,unicode string
int,long,float number
True true
Flase flase
None null

        json.dumps()方法换回了一个str对象encodedjson，接下来对encodedjson进行解码，得到原始数据，需要使用jsonloads() 函数

1
2
3
4
decodejson = json.loads(encodedjson)
print type(decodejson)
print decodejson[4]['key1']
print decodejson

        输出

1
2
3
4
<type 'list'> 
[1, 2, 3]
[[1, 2, 3], 123, 123.123, u'abc', {u'key2': [4, 5, 6], u'key1': [1, 2, 3]}]

        loads方法返回了原始的对象，但是仍然发生了一些数据类型的转化。上例中'abc'转化为了unicode类型。从json到python的类型转化对照

JSON Python
object dict
array list
string unicode
nuumber(int) int,long
number(real) foat
true True
flase Flase
null None

        json.dumps方法提供了好用的参数可供选择，比较常用的有sort_keys（对dict对象进行排序，默认dict是无需存放的），separators，indent等参数。

        排序功能使得存储的数据更加有利于观察，也使得对json输出的对象进行比较

1
2
3
4
5
6
7
8
9
10
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)
print d1
print d2
print d3
print d1==d2
print d1==d3

        输出

1
2
3
4
5
{"a": 123, "b": 789, "c": 456} 
{"a": 123, "c": 456, "b": 789} 
{"a": 123, "b": 789, "c": 456} 
False 
True

        本来data1和data2数据应该是一样的，但是由于dict促出的无序特性，造成两者无法比较。因此两者可以通过排序后的结果进行存储就避免了数据比较不一致的情况发生，但是排序后再进行存储，系统必定要多做一些事情，也一定会因此造成一定的性能小号，所以适当排序是很重要的。

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

1
2
3
data1 = {'b':789,'c':456,'a':123}
d1 = json.dumps(data1,sort_keys=True,indent=4)
print d1

        输出

1
2
3
4
5
{ 
    "a": 123, 
    "b": 789, 
    "c": 456 
}

        输出的数据被格式化之后，变得可读性更强，但是却是通过增加一些冗余的空白格来进行填充的。json主要是作为一种数据通信的格式存在的，而网络通信是很在乎数据的大小的，无用的空格会占用很多通信带宽，所以适当时候也要对数据进行压缩。

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

1
2
3
4
5
print 'DATA:', repr(data)
print 'repr(data)             :', len(repr(data))
print 'dumps(data)            :', len(json.dumps(data))
print 'dumps(data, indent=2)  :', len(json.dumps(data, indent=4))
print 'dumps(data, separators):', len(json.dumps(data, separators=(',',':')))

        输出

1
2
3
4
5
DATA: {'a': 123, 'c': 456, 'b': 789} 
repr(data)             : 30 
dumps(data)            : 30 
dumps(data, indent=2)  : 46 
dumps(data, separators): 25

        通过移除多余的空白符，达到了压缩数据的目的，而且效果还是比较明显的。

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

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

        输出

1
{"c": 456, "b": 789}

处理自己的数据类型

        json模块不仅可以处理普通的python内置类型，也可以处理自定义的数据类型，而往往处理自定义的对象是很常用的。

        首先，定义一个类Person。

1
2
3
4
5
6
7
8
9
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)
if __name__  == '__main__':
    p = Person('Peter',22)
    print p

        如果直接通过json.dumps方法对Person的实例进行处理的话，会报错，因为json无法支持这样的自动转化。通过上面所提到的json和python的类型转化对照表，可以发现，object类型是和dict相关联的，所以需要把我们自定义的类型转化为dict，然后再进行处理。这里，有两种方法可以使用。

方法一：自己写转化函数

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
'''
Created on 2011-12-14
@author: Peter
'''
import Person
import json
 
p = Person.Person('Peter',22)
 
def object2dict(obj):
    #convert object to a dict
    d = {}
    d['__class__'] = obj.__class__.__name__
    d['__module__'] = obj.__module__
    d.update(obj.__dict__)
    return d
 
def dict2object(d):
    #convert dict to object
    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()) #get args
        inst = class_(**args) #create new instance
    else:
        inst = d
    return inst
 
d = object2dict(p)
print d
#{'age': 22, '__module__': 'Person', '__class__': 'Person', 'name': 'Peter'}
 
o = dict2object(d)
print type(o),o
#<class 'Person.Person'> Person Object name : Peter , age : 22
 
dump = json.dumps(p,default=object2dict)
print dump
#{"age": 22, "__module__": "Person", "__class__": "Person", "name": "Peter"}
 
load = json.loads(dump,object_hook = dict2object)
print load
#Person Object name : Peter , age : 22

        上面代码已经写的很清楚了，实质就是自定义object类型和dict类型进行转化。object2dict函数将对象模块名、类名以及__dict__存储在dict对象里，并返回。dict2object函数则是反解出模块名、类名、参数，创建新的对象并返回。在json.dumps 方法中增加default参数，该参数表示在转化过程中调用指定的函数，同样在decode过程中json.loads方法增加object_hook,指定转化函数。

方法二：继承JSONEncoder和JSONDecoder类，覆写相关方法

        JSONEncoder类负责编码，主要是通过其default函数进行转化，我们可以override该方法。同理对于JSONDecoder。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
'''
Created on 2011-12-14
@author: Peter
'''
import Person
import json
 
p = Person.Person('Peter',22)
 
class MyEncoder(json.JSONEncoder):
    def default(self,obj):
        #convert object to a dict
        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=self.dict2object)
    def dict2object(self,d):
        #convert dict to object
        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()) #get args
            inst = class_(**args) #create new instance
        else:
            inst = d
        return inst
 
 
d = MyEncoder().encode(p)
o =  MyDecoder().decode(d)
 
print d
print type(o), o

        对于JSONDecoder类方法，稍微有点不同，但是改写起来也不是很麻烦。看代码应该就比较清楚了。