Python第十四天序列化 pickle模块 cPickle模块 JSON模块 API的两种格式-CSDN博客

Python第十四天序列化 pickle模块 cPickle模块 JSON模块 API的两种格式

python中的任何数据类型都可以dump成json格式

简单序列化
序列化
将对象的状态信息转换为可以存储或传输的形式的过程
内存里面有一个数据结构，你希望把它保存下来重用，或者发送给其他人。
很多游戏允许你在退出的时候保存进度，然后你再次启动的时候回到上次退出的地方

常用的一些序列化
pickle、cPickle 这两个模块用法差不多，cpickle模块，C语言实现，速度是pickle的1000倍
JSON
Shelve
YAML

-----------------------------------------------------------------------------------------

pickle模块
所有python支持的类型都可以用pickle做序列化

dump(obj, file, protocol=None)
obj：表示序列化的对象，处理循环，递归引用对象，类，函数，类的实例
file：支持write（）方法的文件句柄，可以是真实文件，也可以StringIO对象
protocol：序列化协议，0表示ascii协议，ascii码表示，1表示老的二进制协议，2表示新二进制协议，默认为0

load(file)
文件中对象恢复为原来对象，反序列化

终端一：
>>> entry = {'a':11, 'b':22}
>>> import pickle
>>> with open('entry.pickle', 'wb') as f: 以二进制方式打开，文件名是entry.pickle
... pickle.dump(entry, f)

pickle的方法
dump保存到磁盘
dumps保存到内存
load 读到磁盘
loads 读到内存

从磁盘反序列化对象
终端二
>>> import pickle
>>> with open('entry.pickle', 'rb') as f: 文件名是entry.pickle
... entry = pickle.load(f)
>>> entry
{'a': 11, 'b': 22}

序列化到内存
>>> b = pickle.dumps(entry)
>>> entry3 = pickle.loads(b)

---------------------------------------------------------------------------------------

json模块

序列化对象供其他语言读写
JavaScript Object Notation
Json是被设计为跨语言使用的
Json是字符串格式
默认utf-8方式存储

javascript，json的key必须用用双引号引住字符串，不能用单引号

json序列化
json.dump() 其他格式数据转为json到磁盘
json.dumps() 其他格式数据转为json到内存

ensure_ascii=True：json只能ascii编码，同样，pickle模块的dump(obj, file, protocol=None)，protocol：序列化协议，0表示ascii协议，ascii码表示，默认为0
indent：缩进，让打印出来的json字符串更好看print json.dumps(data, indent=2)
encoding='utf-8'：默认utf-8编码，utf-8传进来-》ascii
def 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):

json.load() 从磁盘读json转为其他格式数据
json.loads() 从内存读json转为其他格式数据

encoding=None：load方法可能无法处理中文字符，需要通过encoding参数指定字符编码，如果dumps()方法encoding时候的不是utf-8，需要指定一下编码
def loads(s, encoding=None, cls=None, object_hook=None, parse_float=None,
        parse_int=None, parse_constant=None, object_pairs_hook=None, **kw):

数据保存至JSON文件

import json
序列化
d = {}
d['a'] = 'a'
d['b'] = 235
d['c'] = ('c1','c2')
d['d'] = True
d['e'] = None
with open('/tmp/d.json', mode='w') as fd:
json.dump(d, fd)
cat /tmp/d.json

反序列化
with open('/tmp/d.json') as fd:
d1 = json.load(fd)

传递json格式的数据
定义url和方法
def collectjson(req):
if req.POST:
jsonobj = json.loads(req.body)
host = Host()
host.hostname = jsonobj['hostname']
host.vendor = jsonobj['vendor']
host.product = jsonobj['product']
……
host.save()

命令行访问数据库
python manager.py shell
from hostinfo.models import *
hg = HostGroup.objects.all()[0]
hg.groupname
hg.members.all()
h = hg.members.all()[0]
ip = h.ip
host = Host.object.get(hostname='agent03')
host.ip = '192.168.1.113' //修改记录
host.save()

--------------------------------------------------------------------

API的两种格式

----json 格式
{groupname: "web",members:[]}

[
{ groupanme: ‘web’,
members: [
{ hostname: ‘agent01’,
ip: ‘192.168.1.1’ },
]
},
]

----shell 格式
组名主机名 ip地址
web agent02 192.168.3.163
web agent01 192.168.3.164

vim views.py
from django.shortcuts import render
from django.http import HttpResponse
from hostinfo.models import Host,HostGroup
import pickle
import json

# Create your views here.

def collect(req):
if req.POST:
#obj = pickle.loads(req.body)
obj = json.loads(req.body)
hostname = obj['hostname']
ip = obj['ip']
osver = obj['osver']
vendor = obj['vendor']
product = obj['product']
cpu_model = obj['cpu_model']
cpu_num = obj['cpu_num']
memory = obj['memory']
sn = obj['sn']
try:
host = Host.objects.get(sn=sn)
except:
host = Host()
host.hostname = hostname
host.ip = ip
host.osver = osver
host.vendor = vendor
host.product = product
host.cpu_model = cpu_model
host.cpu_num = cpu_num
host.memory = memory
host.sn = sn
host.save()
return HttpResponse('OK')
else:
return HttpResponse('not data')

def getjson(req):
ret_list = []
hg = HostGroup.objects.all()
for g in hg:
ret = {'groupname':g.groupname,'members':[]}
for h in g.members.all():
ret_h = {'hostname':h.hostname,'ip':h.ip}
ret['members'].append(ret_h)
ret_list.append(ret)
return HttpResponse(json.dumps(ret_list))

def gettxt(req):
res = ''
hg = HostGroup.objects.all()
for g in hg:
groupname = g.groupname
for h in g.members.all():
hostname = h.hostname
ip = h.ip
res += groupname+' '+hostname+' '+ip+'\n'
return HttpResponse(res)

json.dumps(ret_list)返回的是值是字符串类型
d1 = json.load(fd)
type(d1)

时间转为json解决方法

两个

To use a custom ``JSONEncoder`` subclass (e.g. one that overrides the
``.default()`` method to serialize additional types), specify it with
the ``cls`` kwarg; otherwise ``JSONEncoder`` is used.cls代表类本身

``default(obj)`` is a function that should return a serializable version
of obj or raise TypeError. The default simply raises TypeError.

1、用类

def test(self):
    js = {
        'test5': datetime.datetime.now(),
    }
    print(js)
    result = json.dumps(js, cls=CJsonEncoder)
    print(result)



class CJsonEncoder(json.JSONEncoder):
    def default(self, obj):
        if isinstance(obj, datetime.datetime):
            return obj.strftime('%Y-%m-%d %H:%M:%S')
        elif isinstance(obj, datetime.date):
            return obj.strftime('%Y-%m-%d')
        else:
            return json.JSONEncoder.default(self, obj)

2、用函数

def json_serial(obj):
    if isinstance(obj,datetime.datetime):
        serial=obj.isoformat()
        return serial
    elif isinstance(obj,datetime.date):
        serial=obj.isoformat()
        return serial
    else:
        return json.JSONEncoder.default(obj)



js = {
    'test5': datetime.datetime.now(),
}
print json.dumps(js, default=json_serial)