python基础学习：json模块

python json模块

网上找的一些资料,进行了总结：

 

（一）什么是json：

JSON(JavaScript Object Notation) 是一种轻量级的数据交换格式。易于人阅读和编写。同时也易于机器解析和生成。它基于JavaScript Programming Language, Standard ECMA-262 3rd Edition - December 1999的一个子集。JSON采用完全独立于语言的文本格式，但是也使用了类似于C语言家族的习惯（包括C, C++, C#, Java, JavaScript, Perl, Python等）。这些特性使JSON成为理想的数据交换语言。

 

JSON建构于两种结构：

“名称/值”对的集合（A collection of name/value pairs）。不同的语言中，它被理解为对象（object），纪录（record），结构（struct），字典（dictionary），哈希表（hash table），有键列表（keyed list），或者关联数组 （associative array）。 

值的有序列表（An ordered list of values）。在大部分语言中，它被理解为数组（array）。 

这些都是常见的数据结构。事实上大部分现代计算机语言都以某种形式支持它们。这使得一种数据格式在同样基于这些结构的编程语言之间交换成为可能。

 

(二)Python JSON模块

Python2.6开始加入了JSON模块，无需另外下载，Python的Json模块序列化与反序列化的过程分别是 encoding和 decoding。

encoding-把一个Python对象编码转换成Json字符串；

decoding-把Json格式字符串解码转换成Python对象。

 

1，简单数据类型的处理

对简单数据类型的encoding 和 decoding：

 

1.1 encoding：python对象转换成json对象

Python JSON模块可以直接处理简单数据类型（string、unicode、int、float、list、tuple、dict）。 

json字符串中的字典类型的key必须要用双引号“”json.loads()才能正常解析

Encode过程，是把python对象转换成json对象的一个过程，常用的两个函数是dumps和dump函数。两个函数的唯一区别就是dump把python对象转换成json对象生成一个fp的文件流，而dumps则是生成了一个字符串：

 

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, 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]}]

 

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

 

#json.dumps方法提供了很多好用的参数可供选择，

#比较常用的有sort_keys（对dict对象进行排序，我们知道默认dict是无序存放的），separators，indent等参数。

#sort_keys：将数据根据keys的值进行排序。排序功能使得存储的数据更加有利于观察，也使得对json输出的对象进行比较，例如：

 

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

 

输出：

{"a": 123, "b": 789, "c": 456} 

{"a": 123, "c": 456, "b": 789} 

{"a": 123, "b": 789, "c": 456} 

False 

True

 

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

 

#indent：应该是一个非负的整型，如果是0，或者为空，则一行显示数据，否则会换行且按照indent的数量显示前面的空白，这样打印出来的json数据也叫pretty-printed json

 

data1 = {'b':789,'c':456,'a':123}

d1 = json.dumps(data1,sort_keys=True,indent=4)

print d1

输出：

 

{ 

    "a": 123, 

    "b": 789, 

    "c": 456 

}

#separators：分隔符，实际上是(item_separator, dict_separator)的一个元组，默认的就是(',',':')；这表示dictionary内keys之间用“,”隔开，而KEY和value之间用“：”隔开。

 

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=(',',':')))

输出：

 

DATA: {'a': 123, 'c': 456, 'b': 789} 

repr(data)             : 30 

dumps(data)            : 30 

dumps(data, indent=2)  : 46 

dumps(data, separators): 25

 

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

 

#Skipkeys：默认值是False，如果dict的keys内的数据不是python的基本类型(str,unicode,int,long,float,bool,None)，设置为False时，就会报TypeError的错误。此时设置成True，则会跳过这类key

 

data = {'b':789,'c':456,(1,2):123}

print json.dumps(data,skipkeys=True)

输出：

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

 

#ensure_ascii：默认值True，如果dict内含有non-ASCII的字符，则会类似\uXXXX的显示数据，设置成False后，就能正常显示

#encoding：默认是UTF-8，设置json数据的编码方式。

#

1.2 decoding：json对象转换成python对象

Decode过程，是把json对象转换成python对象的一个过程，常用的两个函数是loads和load函数。区别跟dump和dumps是一样的。

 

decodejson = json.loads(encodedjson)

print type(decodejson)

print decodejson[4]['key1']

print decodejson

输出：

 

<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类型。

 

1.3 Json处理中文问题：

 

第一：Python 2.7.11的默认编码格式是ascii编码，而python3的已经是unicode，在学习编解码的时，有出现乱码的问题，也有出现list或者dictionary或者tuple类型内的中文显示为unicode的问题。出现乱码的时候，应该先看下当前字符编码格式是什么，再看下当前文件编码格式是什么，或者没有设置文件格式时，查看下IDE的默认编码格式是什么。最推崇的方式当然是每次编码，都对文件编码格式进行指定，如在文件前 设置# coding= utf-8。

第二：字符串在Python内部的表示是unicode编码，因此，在做编码转换时，通常需要以unicode作为中间编码，即先将其他编码的字符串解码（decode）成unicode，再从unicode编码（encode）成另一种编码。decode的作用是将其他编码的字符串转换成unicode编码，如str1.decode('gb2312')，表示将gb2312编码的字符串str1转换成unicode编码。encode的作用是将unicode编码转换成其他编码的字符串，如str2.encode('gb2312')，表示将unicode编码的字符串str2转换成gb2312编码。因此，转码的时候一定要先搞明白，字符串str是什么编码，然后decode成unicode，然后再encode成其他编码

第三：将json数据转换成python数据后，一般会得到一个dict类型的变量，此时内部的数据都是unicode编码，所以中文的显示看着很痛苦，但是对于dict得到每个key的value后，中文就能正常显示了，如下所示：

 

# coding= utf-8

import json

import sys

 

if __name__ == '__main__':

    # 将python对象test转换json对象

    test = {"username":"测试","age":16}

    print type(test)

    python_to_json = json.dumps(test,ensure_ascii=False)

    print python_to_json

    print type(python_to_json)

 

    # 将json对象转换成python对象

    json_to_python = json.loads(python_to_json)

    print type(json_to_python)

    print json_to_python['username']

 

2，JSON处理自定义数据类型

 

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

首先，我们定义一个类Person。

 

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，然后再进行处理。这里，有两种方法可以使用。

 

方法一：自己写转化函数

 

自定义object类型和dict类型进行转化：encode-定义函数 object2dict()将对象模块名、类名以及__dict__存储在一个字典并返回;decode-定义dict2object()解析出模块名、类名、参数，创建新的对象并返回。在json.dumps()中通过default参数指定转化过程中调用的函数；json.loads()则通过 object_hook指定转化函数。

 

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函数进行转化，我们可以重载该方法。对于JSONDecoder，亦然。

 

    #handling private data type   

    #define class   

    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)   

           

           

    #define transfer functions   

    def object2dict(obj):   

        #convert object to a dict   

        d = {'__class__':obj.__class__.__name__, '__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)   

            print 'the module is:', module   

            class_ = getattr(module,class_name)   

            args = dict((key.encode('ascii'), value) for key, value in d.items()) #get args  

            print 'the atrribute:', repr(args)   

            inst = class_(**args) #create new instance   

        else:   

            inst = d   

        return inst   

    #recreate the default method   

    class LocalEncoder(json.JSONEncoder):   

        def default(self,obj):   

            #convert object to a dict   

            d = {'__class__':obj.__class__.__name__, '__module__':obj.__module__}   

            d.update(obj.__dict__)   

            return d   

        

    class LocalDecoder(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   

    #test function   

    if __name__  == '__main__':   

        p = Person('Aidan',22)   

        print p   

        #json.dumps(p)#error will be throwed   

        d = object2dict(p)   

        print 'method-json encode:', d   

        

        o = dict2object(d)   

        print 'the decoded obj type: %s, obj:%s' % (type(o),repr(o))   

        

        dump = json.dumps(p,default=object2dict)   

        print 'dumps(default = object2dict):',dump   

        load = json.loads(dump,object_hook = dict2object)   

        print 'loads(object_hook = dict2object):',load   

        d = LocalEncoder().encode(p)   

        o =  LocalDecoder().decode(d)   

        

        print 'recereated encode method: ',d   

        print 'recereated decode method: ',type(o),o  

输出：

 

Person Object name : Aidan , age : 22   

method-json encode: {'age': 22, '__module__': '__main__', '__class__': 'Person', 'name': 'Aidan'}   

the module is: <module '__main__' from 'D:/Project/Python/study_json'>   

the atrribute: {'age': 22, 'name': 'Aidan'}   

the decoded obj type: <class '__main__.Person'>, obj:Person Object name : Aidan , age : 22   

dumps(default = object2dict): {"age": 22, "__module__": "__main__", "__class__": "Person", "name": "Aidan"}   

the module is: <module '__main__' from 'D:/Project/Python/study_json'>   

the atrribute: {'age': 22, 'name': u'Aidan'}   

loads(object_hook = dict2object): Person Object name : Aidan , age : 22   

recereated encode method:  {"age": 22, "__module__": "__main__", "__class__": "Person", "name": "Aidan"}   

recereated decode method:  <class '__main__.Person'> Person Object name : Aid