python模块介绍-json

2011-07-02 磁针石

#承接软件自动化实施与培训等gtalk： ouyangchongwu#gmail.com qq 37391319 博客:testing.blog.chinaunix.net

#版权所有，转载刊登请来函联系

#自动化测试和python群组：

#python qq group: 深圳自动化测试python群：113938272

#武冈深圳qq群：66250781

#参考资料：《The Python Standard Library by Example》

 

12.9 json 模块

JSON就是JavaScript Object Notation，这个模块完成了python对象和JSON字符串的互相转换。适用于Python的版本2.6和更高版本。
        json模块提供了一个类似的API，转换内存中的Python对象为JavaScript对象符号（JSON）序列。JSON具有有许多语言的实现（尤其是JavaScript）。在AJAX应用中，广泛的使用在Web服务器和客户端之间，

编码解码简单数据类型

         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’’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), 编码再解码之后，成了列表

 

编码解码简单数据类型

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

 

编码字典

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)

 

自定义类型

到目前为止，所有的例子使用了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字符串，才可以作为类构造的关键字参数。
       

 

编码和解码类

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’}

[]

 

流和文件

         函数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 ()

JavaScript Object Notation ()

simplejson ()

simplejson ()