python json基础学习01

# -*- coding: utf-8 -*-

# python:2.x

__author__ = 'Administrator'

import json

#全称(javascript object notation)是一种轻量级数据交换格式，特点：角球阅读和编写，同时角球机器解析和生成，基于javascript program ming language,standard ecma-262

# 3rd editon -december 1999一个子集,json采用完全独立于语言文本格式，但是也使用了类似于c语言家庭习惯（包括c++,c,c#javajs,python等）

"""

JSON建构于两种结构：

'名称/值'对的集合（a collection of name/value pairs）不同的语言中，被理解为对象，纪录，结构，字典，哈希列表或者关联数组

jso官方说明参见：http://json.org/

Python操作json的标准api库参考：http://docs.python.org/library/json.html

"""

#简单的数据类型encoding和decoding进行编码处理如下:

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

encodingjson=json.dumps(obj)

print repr(obj)

print encodingjson

#encode和原始repr()输出的结果非常相似，但是有些数据类型进行改变，例如上面的元素则转换成列表了,在json编码过程中，会存在从python原始类型向json类型转换过程

#对应如下表:

"""

python    json

dict      object

list,tuple  array(数组)

str,unicode string

int,long,float number

True          true

False         false

None          null

"""

print

#json.dumps()方法返回了一个str对象的encodedjson,如果想要得到原始数据，可以使用json.loads()函数，如下:

decodejson=json.loads(encodingjson)

print type(decodejson)

print decodejson[4]['key1']

print decodejson

#loads方法返回了原始对象，但是仍然发现了一些数据类型转换，如上面的'abc'转换成unicode类型，从json到python类型转换如下

"""

json       python

object       dict

array        list

string       unicode

number(int)/number(real)     int,long/float

true/false     True/False

null           None

"""

#json.dumps方法还提供了很多好用的参数，比较常用的是sort_keys(对dict对象进行排序，dict是无序存放的)，separators(分离器),indent(缩进)等参数

#排序

print

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

"""

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

"""

print

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

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

#dumps(obj, skipkeys=False, ensure_ascii=True, check_circular=True, allow_nan=True, \

# cls=None, indent=None, separators=None, encoding='utf-8', default=None, sort_keys=False, **kw)

print d1

print

"""

输出的数据被格式化之后，变得可读性更强，但是却是通过增加一些冗余的空白格来进行填充的。json主要是作为一种数据通信的格式存在的，而网络通信是很在乎数据的大小的，无用的空格会占据很多通信带宽，所以适当时候也要对数据进行压缩。separator参数可以起到这样的作用，该参数传递是一个元组，包含分割对象的字符串。

"""

print 'data:',repr(data1)

print 'repr(data)               :',len(repr(data1))

print 'dumps(data)              :',len(json.dumps(data1))

print 'dumps(data,indent=2)     :',len(json.dumps(data1,indent=4))

print 'dumps(data,separators):    ',len(json.dumps(data1,separators=(',',':')))

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

print

"""

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

"""

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

print json.dumps(data,skipkeys=True)

print

print

print

print

# #处理自己的数据类型

# #如下:

# class P(object):

#     def __init__(self,name,age):

#         self.name=name

#         self.age=age

#     def __repr__(self):

#         return 'P object name %s and age %s'%(self.name,self.age)

# if __name__=='__main__':

#     p1=P('Peter',22)

#     print p1

"""

当直接通过json.dumps方法对P的实例进行处理的话，会报错，因为json无法通过这样的自动转换，因为object类型和dict类型相似，所以把自定义类型转换为dict

然后再进行处理，有2种方法

"""

#方法1L自己写转换函数

print

#如下:

import Pa

p=Pa.P('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 'Pa.P'> P object name Peter and age 22

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

print dump#{"age": 22, "__module__": "Pa", "__class__": "P", "name": "Peter"}

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

print load#P object name Peter and age 22

"""

质就是自定义object类型和dict类型进行转化。object2dict函数将对象模块名、类名以及__dict__存储在dict对象里，并返回。dict2object函数则是反解出模块名、类名、参数，创建新的对象并返回。在json.dumps 方法中增加default参数，

该参数表示在转化过程中调用指定的函数，同样在decode过程中json.loads方法增加object_hook,指定转化函数

"""

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

"""

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

"""

p =Pa.P('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