python写网页的库,python数据库数据生成网页
在计算机编程语言中，您可以使用泡菜模块将对象转换为文件并保存到磁盘，然后根据需要进行检索和恢复。具体使用方法如下。
泡菜是计算机编程语言库中常用的序列化工具，可以将内存对象以文本或二进制格式导出为字符串，也可以将其写入文档。然后，可以从文字或文档返回到内存对象。在新版本的计算机编程语言中用c再次实现了。被称为cPickle，性能更高。以下代码说明了如何使用泡菜库的常见界面。非常简单。
将泡菜作为泡菜导入
#转储和装载
#将内存对象倾销作为字符串，或将字符串负荷作为内存对象
极好的测试转储和加载() :
t={name: [v1 ， v2]}
打印t
o=pickle.dumps(t)))。
打印o
打印len o:"，Len(o))。
p=pickle.loads(o)))
打印p
对于最高_协议参数泡菜支持三种类型的协议.0,1,2 :
# http://堆栈溢出。com/questions/23582489/python-pickle-protocol-choice
#0: ascii协议，与早期版本的计算机编程语言兼容
# 1:二进制格式，与旧版本的计算机编程语言的兼容性
#2:在二进制格式、Python2.3或更高版本中首次更好地支持新系统类
ef test _ dumps _ and _ loads _ highest _ protocol():
打印最高_协议： ，泡菜.最高_协议
t={name: [v1 ， v2]}
打印t
o=pickle.dumps(t，pickle .最高_协议).
打印len o:"，Len(o))。
p=pickle.loads(o)))
打印p
#新式课堂
def test_new_sytle_class():
类（对象) :
def __init__(self，arg，**kwargs):
超级(TT，自我)。__init__))
self.arg=arg
self.kwargs=kwargs
默认（自己) :
打印self.arg
打印self.kwargs
# ascii协议
t=TT(测试，a=1，b=2))。
O1=pickle.dumps(t))。
打印一
打印O1 len:，len(O1))。
p=pickle.loads(O1))。
p.test())
#最高_协议改进了对新型班级的支持，从而提高了性能
O2=pickle.dumps(t，pickle .最高_协议).
打印O2 len:，len(O2))。
p=pickle.loads(O2))。
p.test())
#转储和装载
#序列化内存对象，并直接将其卸装到支持文件或文件接口的对象
对于转储，必须支持写接口并接受字符串（如斯特林吉奥)作为输入参数
对于负载，必须支持阅读接口，接受（同国际组织)国际组织输入参数，同时支持无输入参数的阅读线接口，如斯特林乔
#使用文件，ASCII编码
极好的测试转储和加载文件() :
t={name: [v1 ， v2]}
# ascii格式
withopen(test.txt ， w )作为fp:
pickle.dump(t，fp))。
withopen(test.txt ， r )作为fp:
p=pickle.load(FP))。
打印p
#使用文件、二进制代码
def测试转储和加载文件最高协议():
t={name: [v1 ， v2]}
withopen(测试箱),
WB’)作为fp:
pickle.dump(t，fp，pickle .最高_协议)
使用打开( test.bin ， rb )作为fp:
p=pickle.load(fp)
打印p
# 使用斯特林乔，二进制编码
def test _ dump _ and _ load _ with _ StringIO():
进口斯特林乔
t={name: [v1 ， v2]}
fp=StringIO .斯特林乔
pickle.dump(t，fp，pickle .最高_协议)
fp.seek(0)
p=pickle.load(fp)
打印p
fp.close()
# 使用自定义类
# 这里演示用户自定义类，只要实现了写、读、读行接口，
# 就可以用作倾倒、装载的文件参数
极好的测试转储和加载用户定义类():
进口斯特林乔
消防类（对象):
def __init__(self):
self.buf=StringIO .斯特林乔
定义写入（自身，秒):
自我缓冲写入
打印莱恩：，莱恩
定义读取（自身，n):
返回self.buf.read(n)
定义阅读行（自身):
返回self.buf.readline()
定义寻道（自身，位置，模式=0):
返回self.buf.seek(位置，模式)
定义关闭（自己):
self.buf.close()
fp=FF()
t={name: [v1 ， v2]}
pickle.dump(t，fp，pickle .最高_协议)
fp.seek(0)
p=pickle.load(fp)
打印p
fp.close()
# Pickler/Unpickler
# Pickler(文件，协议)。转储等价于泡菜.转储(对象，文件[,协议])
# Unpickler(文件)。负载()等价于pickle.load(文件)
# Pickler/Unpickler封装性更好，可以很方便的替换文件
def test_pickler_unpickler():
t={name: [v1 ， v2]}
f=文件( test.bin ， wb )
挑选=泡菜Pickler(f，pickle .最高_协议)
挑选。转储（吨)
f.close()
f=文件( test.bin ， rb )
拆线=腌菜。拆线器(六)
p=unpick.load()
打印p
f.close()
泡菜.转储(对象，文件[,协议])
这是将对象持久化的方法，参数的含义分别为：
obj:要持久化保存的对象；
文件：一个拥有写()方法的对象，并且这个写()方法能接收一个字符串作为参数。这个对象可以是一个以写模式打开的文件对象或者一个斯特林乔对象，或者其他自定义的满足条件的对象。
协议：这是一个可选的参数，默认为0 ,如果设置为一或没错，则以高压缩的二进制格式保存持久化后的对象，否则以美国信息交换标准代码格式保存。
对象被持久化后怎么还原呢？泡菜模块也提供了相应的方法，如下：
pickle.load(文件)
只有一个参数文件，对应于上面倾销方法中的文件参数。这个文件必须是一个拥有一个能接收一个整数为参数的阅读()方法以及一个不接收任何参数的读取线()方法，并且这两个方法的返回值都应该是字符串。这可以是一个打开为读的文件对象、斯特林乔对象或其他任何满足条件的对象。
下面是一个基本的用例：
# -*-编码：utf-8 -*-
进口泡菜
# 也可以这样：
#将泡菜作为泡菜导入
obj={a: 1， b: 2， c: 3}
# 将目标文件持久化保存到文件tmp.txt中
pickle.dump(obj，open(tmp.txt ， w ))
#做点别的.
# 从tmp.txt中读取并恢复目标文件对象
obj2=pickle.load(open(tmp.txt ， r ))
打印对象2
# -*-编码：utf-8 -*-
进口泡菜
# 也可以这样：
#将泡菜作为泡菜导入
obj={a: 1， b: 2， c: 3}
# 将目标文件持久化保存到文件tmp.txt中
pickle.dump(obj，open(tmp.txt ， w ))
#做点别的.
# 从tmp.txt中读取并恢复目标文件对象
obj2=pickle.load(open(tmp.txt ， r ))
打印对象2
不过实际应用中，我们可能还会有一些改进，比如用cPickle来代替泡菜，前者是后者的一个C语言实现版本，拥有更快的速度，另外，有时在倾销时也会将第三个参数设为真实的以提高压缩比。再来看下面的例子：
# -*-编码：utf-8 -*-
将泡菜作为泡菜导入
随机导入
导入操作系统
导入时间
长度=1024 * 10240
def main():
d={}
a=[]
对于范围内的我(长度):
a.append(random.randint(0，255))
d[a]=a
打印"转储."
t1=time.time()
pickle.dump(d，open(tmp1.dat ， wb )，True)
“打印”转储1:%。3 fs %(时间。时间()-t1)
t1=time.time()
pickle.dump(d，open(tmp2.dat ， w ))
“打印”转储2:%。3 fs %(时间。时间()-t1)
s1=os.stat(tmp1.dat ).st_size
s2=os.stat(tmp2.dat ).st_size
打印%d，%d，%.2f%% % (s1，s2，100.0 * s1/s2)
打印"正在加载."
t1=time.time()
泡菜。加载(打开( tmp 1。dat ， rb ))
“打印”装入1:%。3 fs %(时间。时间()-t1)
t1=time.time()
泡菜。加载(打开( tmp 2。dat ， r ))
“打印”装入2:%。3 fs %(时间。时间()-t1)
if __name__==__main__ :
主()
# -*-编码：utf-8 -*-
将泡菜作为泡菜导入
随机导入
导入操作系统
导入时间
长度=1024 * 10240
def main():
d={}
a=[]
对于范围内的我(长度):
a.append(random.randint(0，255))
d[a]=a
打印"转储."
t1=time.time()
pickle.dump(d，open(tmp1.dat ， wb )，True)
“打印”转储1:%。3 fs %(时间。时间()-t1)
t1=time.time()
pickle.dump(d，open(tmp2.dat ， w ))
“打印”转储2:%。3 fs %(时间。时间()-t1)
s1=os.stat(tmp1.dat ).st_size
s2=os.stat(tmp2.dat ).st_size
打印%d，%d，%.2f%% % (s1，s2，100.0 * s1/s2)
打印"正在加载."
t1=time.time()
泡菜。加载(打开( tmp 1。dat ， rb ))
“打印”装入1:%。3 fs %(时间。时间()-t1)
t1=time.time()
泡菜。加载(打开( tmp 2。dat ， r ))
“打印”装入2:%。3 fs %(时间。时间()-t1)
if __name__==__main__ :
主()
在我的电脑上执行的结果是：
转储…
转储1:1.297秒
转储2:4.750秒
20992503, 68894198, 30.47%
正在加载…
负载1:2.797秒
负载2:10.125秒
可以看出，如果转储时协议为真，压缩文件的大小仅为原文件的30%，转储或加载所需时间更少。因此，通常情况下，建议将该值设置为True。
此外，pickle模块还提供了dumps和loads两种方法，与上述方法类似，只是不需要输入file参数，输入输出都是string对象。在某些场景下使用这两种方式可能会更方便。
郑重声明：本文由网友发布，不代表盛行IT的观点，版权归原作者所有，仅为传播更多信息之目的，如有侵权请联系，我们将第一时间修改或删除，多谢。