python__种类化模块,类别化与数码持久化

多少持久化的法子有:

python:系列化与数量持久化,python连串化

多少持久化的章程有:

一.家常文书无格式写入:将数据直接写入到文件中

二.一般性连串化写入:json,pickle

3.DBM方式:shelve,dbm

 

 

哪些叫种类化——将原本的字典、列表等剧情转换来3个字符串的进程就叫做序列化

一.常常文书无格式写入:将数据直接写入到文件中

连带内容:

  • json
  • pickle
  • shelve
  • dbm

 

头阵时间:201捌-0二-2三 20:52

 


***collections 扩充数据类型***

       
比如,大家在python代码中计算的一个多少要求给其余壹段程序使用,那大家怎么给?
今后大家能体会通晓的点子正是存在文件里,然后另一个python程序再从文件里读出来。
然而大家都驾驭,对于文本来说是不曾字典这么些定义的,所以大家不得不将数据转换到字典放到文件中。
你势必会问,将字典转换到2个字符串很粗大略,就是str(dic)就能够办到了,为啥我们还要学习种类化模块呢?
没有错系列化的经过即便从dic
变成str(dic)的历程。未来你能够由此str(dic),将2个名称叫dic的字典转换来一个字符串,
不过你要怎么把2个字符串转换到字典呢?
精晓的你势必想到了eval(),借使大家将1个字符串类型的字典str_dic传给eval,就会得到1个赶回的字典类型了。
eval()函数11分精锐,可是eval是做什么样的?e官方demo解释为:将字符串str当成有效的表明式来求值并赶回总括结果。
BUT!强大的函数有代价。安全性是其最大的缺陷。
想像一下,借使大家从文件中读出的不是3个数据结构,而是一句”删除文件”类似的破坏性语句,那么后果实在不堪设设想。
而利用eval就要担那么些危害。
因此,大家并不引入用eval方法来进展反连串化操作(将str转换到python中的数据结构)

二.屡见不鲜连串化写入:json,pickle

json:

***re 正则相关操作 正则 相称字符串***

缘何要有种类化模块

3.DBM方式:shelve,dbm

介绍:

根据钦命格式【比如格式是字典,那么文件中正是字典】将数据领悟写入到文件中,类型是bytes的,比如”中文“就会变成Unicode编码

***time 时间相关
二种格式:时间戳,格式化时间(字符串),时间元组(结构化时间).
***
“`python
#时刻戳: timestamp 从一九66年5月17日00:00上马按秒计算偏移量.
time.time()

python__种类化模块,类别化与数码持久化。系列化的目标

 

用法:

  • 第3要导入模块import json
  • 序列化:

    • json.dump(类别化对象,文件对象)
    • json.dumps(类别化对象),重回值是一个字符串,须要手动将以此字符串写入到文件中

      print("------json序列化--------")
      import json
      import time
      info={
          'date':time.localtime(),
          'name':'中文'
      }
      f=open("test.txt","w")
      
      print("---------dump---------")
      # json.dump(info,f)
      # f.close()
      print("---------dumps,---------")
      f.write(json.dumps(info))
      f.close()
      
  • 反体系化:

    • json.load(文件对象)
    • json.loads(字符串)

      print("------反序列化--------")
      import json
      f=open("test.txt","r")
      
      print("-------load----------")
      # data=json.load(f)#1
      # print(data)
      print("-------loads----------")
      d2=json.loads(f.read())
      print(d2)
      f.close()
      

 

 

#格式化时间: (Format String) 1995-1二-十
%Y-%m-%d_%a %H:%M:S
%y 两位数的年份表示(00-9九)
%Y 四人数的年度表示(000-999玖)
%m 月份(01-12)
%d 月内中的一天(0-3一)
%H 2四时辰制时辰数(0-二三)
%I 12小时制时辰数(01-1贰)
%M 分钟数(00=59)
%S 秒(00-59)
%a 本地简化星期名称
%A 本地完整星期名称
%b 本地简化的月份名称
%B 当地完整的月度名称
%c 当地相应的日子表示和时间表示
%j 年内的1天(001-36六)
%p 本地A.M.或P.M.的等价符
%U 一年中的星期数(00-5三)星期三为星期的伊始
%w 星期(0-6),星期5为星期的初叶
%W 一年中的星期数(00-53)星期1为星期的初步
%x 本地相应的日子表示
%X 本地相应的光阴表示
%Z 当前时区的称谓
%% %号本身

1、以某种存款和储蓄格局使自定义指标持久化;

有关内容:

  • json
  • pickle
  • shelve
  • dbm

 

头阵时间:201八-0二-二3 20:52

 


 

#光阴元组: (结构化时间)Stack_Time 包涵七个要素:年 月 日 时 分 秒
二零一玖年第几周 今年的第几天 夏令时
“`
“`
#时光戳–>时间元组(结构化时间)
time.gmtime(#填时间戳) #UTC时间
time.localtime(#填时间戳) #地面时间

2、将目的从3个地点传递到另多个地点。

json:

对于频仍dump\dumps,如何load\loads取出来:

  • 亟需在dump的时候,手动对数码开始展览分割

print("------json序列化--------")
import json
import time
info={
    'date':time.localtime(),
    'name':'中文'
   # 'func':hello #注:json不可序列化函数
}
info2=['1',2,3,4]
f=open("test.txt","w")

print("---------dumps,---------")#用'\n'来区分两份数据
f.write(json.dumps(info)+"\n")
f.write(json.dumps(info2)+"\n")

f.close()

import json
with open("test.txt") as f:
    a=json.loads(f.readline())
    b=json.loads(f.readline())
    print(a,b)

** 


#时间元组–>时间戳
time.mktime(#日子元组)

叁、使程序更具维护性。

介绍:

依照钦命格式【比如格式是字典,那么文件中就是字典】将数据理解写入到文件中,类型是bytes的,比如”汉语“就会变成Unicode编码

美高梅开户网址 1

pickle:

#时刻元组–>字符串
time.strftime(‘格式定义’,’时间元组’) #若不传参数,则显示当前时间
time.strftime(“%Y-%m-%d”,time.localtime(1500000000))
‘2017-07-14’

美高梅开户网址 2

用法:

  • 率先要导入模块import json
  • 序列化:

    • json.dump(连串化对象,文件对象)
    • json.dumps(体系化对象),再次回到值是2个字符串,须要手动将以此字符串写入到文件中

      print("------json序列化--------")
      import json
      import time
      info={
          'date':time.localtime(),
          'name':'中文'
      }
      f=open("test.txt","w")
      
      print("---------dump---------")
      # json.dump(info,f)
      # f.close()
      print("---------dumps,---------")
      f.write(json.dumps(info))
      f.close()
      
  • 反连串化:

    • json.load(文件对象)
    • json.loads(字符串)

      print("------反序列化--------")
      import json
      f=open("test.txt","r")
      
      print("-------load----------")
      # data=json.load(f)#1
      # print(data)
      print("-------loads----------")
      d2=json.loads(f.read())
      print(d2)
      f.close()
      

 

 

介绍:

  • 用以落实Python数据类型与Python特定二进制格式之间的转移
  • 参数protocol规定了种类化的说道版本,暗许情状下选择pikkle系列化数据是bytes的,打开文件的艺术必须为2进制格式

import time
#字符串–>时间元组
#time.strptime(‘时间字符串’,’字符串格式’)
l = time.strptime(‘1992-10-10′,’%Y-%m-%d’)
print(l)
#光阴元组–>字符串
# time.strftime(‘格式定义’,’时间元组’)
#若不传时间元组,就显示当前时间.
l1 = time.strftime(‘%Y-%m-%d’)
print(l1)

 

 

用法:

  • 第3导入模块import pickle
  • 序列化:

    • pickle.dump(体系化对象,文件对象)
    • pickle.dumps(种类化对象),再次来到值是贰个字符串,须求手动将以此字符串写入到文件中

      import pickle
      
      info={
          'name':'1',
          'age':2,
      }
      
      f=open("test2.txt","wb")
      pickle.dump(info,f)#序列化方法1
      # f.write(pickle.dumps(info))#序列化方法2
      f.close()
      
  • 反种类化:

    • pickle.load(文件对象)
    • pickle.loads(字符串)

      print("------反序列化--------")
      import pickle
      
        f=open("test2.txt","rb")
        data=pickle.loads(f.read())#反序列方法1
        print(data)


        # data=pickle.load(f)#反序列方法2
        # print(data)
        f.close()

 


l2 = time.strftime(‘%Y-%m-%d’,time.localtime(1500000000))
print(l2)

json

Json模块提供了八个职能:dumps、dump、loads、load

loads和dumps

import json
dic = {‘k1′:’v1′,’k2′:’v2′,’k3′:’v3’}
str_dic = json.dumps(dic) #系列化:将三个字典转换到三个字符串
print(type(str_dic),str_dic) #<class ‘str’> {“k3”: “v3”, “k1”:
“v1”, “k2”: “v2”}
#只顾,json转换完的字符串类型的字典中的字符串是由””表示的

dic2 = json.loads(str_dic)
#反体系化:将三个字符串格式的字典转换到一个字典
#只顾,要用json的loads成效处理的字符串类型的字典中的字符串必须由””表示
print(type(dic2),dic2) #<class ‘dict’> {‘k1’: ‘v1’, ‘k2’: ‘v2’,
‘k3’: ‘v3’}

list_dic = [1,[‘a’,’b’,’c’],3,{‘k1′:’v1′,’k2′:’v2’}]
str_dic = json.dumps(list_dic) #也足以处理嵌套的数据类型
print(type(str_dic),str_dic) #<class ‘str’> [1, [“a”, “b”,
“c”], 3, {“k1”: “v1”, “k2”: “v2”}]
list_dic2 = json.loads(str_dic)
print(type(list_dic2),list_dic2) #<class ‘list’> [1, [‘a’,
‘b’, ‘c’], 3, {‘k1’: ‘v1’, ‘k2’: ‘v2’}]

load和dump

import json
f = open(‘json_file’,’w’)
dic = {‘k1′:’v1′,’k2′:’v2′,’k3′:’v3’}
json.dump(dic,f)
#dump方法接收一个文本句柄,间接将字典转换来json字符串写入文件
f.close()

f = open(‘json_file’)
dic2 = json.load(f)
#load方法接收三个文件句柄,直接将文件中的json字符串转换来数据结构重回
f.close()
print(type(dic2),dic2)

 

 

对于频仍dump\dumps,如何load\loads取出来:

  • 亟需在dump的时候,手动对数据开始展览剪切

    print(“——json序列化——–“)
    import json
    import time
    info={

    'date':time.localtime(),
    'name':'中文'
    

    # ‘func’:hello #注:json不可体系化函数
    }
    info2=[‘1’,2,3,4]
    f=open(“test.txt”,”w”)

    print(“———dumps,———“)#用’\n’来区分两份数据
    f.write(json.dumps(info)+”\n”)
    f.write(json.dumps(info2)+”\n”)

    f.close()

    import json
    with open(“test.txt”) as f:

    a=json.loads(f.readline())
    b=json.loads(f.readline())
    print(a,b)
    

** 


shelve:

 

pickle

 

pickle:

介绍:

  • 特意用来将Python数据类型的数目持久化到磁盘,操作看似于dict

“`

json & pickle 模块

 

用于类别化的三个模块

 

  • json,用于字符串 和 python数据类型间开始展览转换
  • pickle,用于python特有的类型 和 python的数据类型间开展转移

 

pickle模块提供了七个职能:dumps、dump(系列化,存)、loads(反系列化,读)、load
 (不仅能够种类化字典,列表…能够把python中随心所欲的数据类型种类化

 

import pickle
dic = {‘k1′:’v1′,’k2′:’v2′,’k3′:’v3’}
str_dic = pickle.dumps(dic)
print(str_dic) #一串贰进制内容

dic2 = pickle.loads(str_dic)
print(dic2) #字典

import time
struct_time = time.localtime(1000000000)
print(struct_time)
f = open(‘pickle_file’,’wb’)
pickle.dump(struct_time,f)
f.close()

f = open(‘pickle_file’,’rb’)
struct_time2 = pickle.load(f)
print(struct_time.tm_year)

pickle

 

介绍:

  • 用以落实Python数据类型与Python特定二进制格式之间的变换
  • 参数protocol规定了系列化的磋商版本,私下认可景况下利用pikkle种类化数据是bytes的,打开文件的点子必须为二进制格式

用法:

  • 率发轫入模块import
  • shelve打开一个文本: shelve文件对象 = shelve.open(文件名)
  • 写入:shelve文件对象[key]=value
  • 读出:shelve文件对象.get(key)

import shelve,time

d = shelve.open('shelve_test')  # 打开一个文件

print("----------写----------")

info ={"name":'lilei',"sex":"man"}
name = ["autuman", "zhangsan", "lisi"]

d["teacher"] = name
d["student"] = info
d["date"] = time.ctime()

print("--------读------------")
print(d.get("teacher"))
print(d.get("student"))
print(d.get("date"))


d.close()

 

shelve可以很有利的连串化自定义的数据类型、函数:

import shelve,time


class A:
    def hello(self):
        print("123")
d = shelve.open('shelve_test')  # 打开一个文件

print("----------写----------")

d['class'] =A

print("--------读------------")

a=d.get('class')()
a.hello()

d.close()

***os 和操作系统有关的***

shelve

shelve也是python提供给大家的种类化工具,比pickle用起来更简便易行一些。
shelve只提供给大家三个open方法,是用key来访问的,使用起来和字典类似。

import shelve
f = shelve.open(‘shelve_file’)
f[‘key’] = {‘int’:10, ‘float’:9.5, ‘string’:’Sample data’}
#直接对文件句柄操作,就足以存入数据
f.close()

import shelve
f1 = shelve.open(‘shelve_file’)
existing = f1[‘key’]
#取出数据的时候也只须求直接用key获取即可,可是只要key不存在会报错
f1.close()
print(existing)

shelve

 

以此模块有个限制,它不协理七个使用同暂且间往同3个DB举行写操作。所以当大家精通我们的应用若是只实行读操作,我们能够让shelve通过只读情势打开DB

import shelve
f = shelve.open('shelve_file', flag='r')
existing = f['key']
f.close()
print(existing)

 

是因为shelve在默许情状下是不会记录待持久化对象的其余修改的,所以大家在shelve.open()时候须求修改暗中同意参数,不然对象的修改不会保留。

import shelve
f1 = shelve.open(‘shelve_file’)
print(f1[‘key’])
f1[‘key’][‘new_value’] = ‘this was not here before’
f1.close()

f2 = shelve.open(‘shelve_file’, writeback=True)
print(f2[‘key’])
f2[‘key’][‘new_value’] = ‘this was not here before’
f2.close()

设置writeback

writeback情势有亮点也有通病。优点是削减了我们失误的票房价值,并且让对象的持久化对用户越发的透明了;但那种方法并不是装有的境况下都亟需,首先,使用writeback以往,shelf在open()的时候会大增额外的内部存款和储蓄器消耗,并且当DB在close()的时候会将缓存中的每五个目的都写入到DB,那也会带来极度的等候时间。因为shelve未有章程知道缓存中如何对象修改了,哪些对象未有改动,由此全部的对象都会被写入。

用法:

  • 率开端入模块import pickle
  • 序列化:

    • pickle.dump(类别化对象,文件对象)
    • pickle.dumps(连串化对象),再次回到值是三个字符串,须要手动将以此字符串写入到文件中

      import pickle
      
      info={
          'name':'1',
          'age':2,
      }
      
      f=open("test2.txt","wb")
      pickle.dump(info,f)#序列化方法1
      # f.write(pickle.dumps(info))#序列化方法2
      f.close()
      
  • 反连串化:
    • pickle.load(文件对象)
    • pickle.loads(字符串)
      print("------反序列化--------")
      import pickle
      
        f=open("test2.txt","rb")
        data=pickle.loads(f.read())#反序列方法1
        print(data)


        # data=pickle.load(f)#反序列方法2
        # print(data)
        f.close()

 


dbm:

 

shelve:

介绍:

  • dbm与shelve相当接近,但dbm的键和值必须是字符串类型
  • dbm暗中认可写入的数目是bytes的,将装有字符串都连串化成bytes的

 

介绍:

  • 特意用于将Python数据类型的多少持久化到磁盘,操作看似于dict

用法:

  • 首起首入模块imort
    dbm【注意的是由许八个不等的dbm,能够选拔来利用,那里运用暗中同意】
  • 开拓文件:dbm对象=dbm.open(文件名,打开格局)

  • 写入:dbm对象[key]=value

  • 读取: dbm对象[key]

import dbm

db=dbm.open("test.txt","c")

print("写".center(50,'-'))
db["name"]="1111111111112"
db["name2"]="2222222222222"

print("读".center(50,'-'))
print(db["name"])
print(db["name2"])

db.close()

 


数据持久化的办法有: 壹.司空见惯文书无格式写入:将数据直接写入到文件中
二.普通种类化写入:js…

***sys 和 python 解释器交互的***

用法:

  • 第贰导入模块import
  • shelve打开1个文书: shelve文件对象 = shelve.open(文件名)
  • 写入:shelve文件对象[key]=value
  • 读出:shelve文件对象.get(key)

    import shelve,time

    d = shelve.open(‘shelve_test’) # 打开一个文本

    print(“———-写———-“)

    info ={“name”:’lilei’,”sex”:”man”}
    name = [“autuman”, “zhangsan”, “lisi”]

    d[“teacher”] = name
    d[“student”] = info
    d[“date”] = time.ctime()

    print(“——–读————“)
    print(d.get(“teacher”))
    print(d.get(“student”))
    print(d.get(“date”))

d.close()

 

shelve能够很便利的系列化自定义的数据类型、函数:

import shelve,time


class A:
    def hello(self):
        print("123")
d = shelve.open('shelve_test')  # 打开一个文件

print("----------写----------")

d['class'] =A

print("--------读------------")

a=d.get('class')()
a.hello()

d.close()

 

dbm:

 

介绍:

  • dbm与shelve相当周围,但dbm的键和值必须是字符串类型
  • dbm暗中认可写入的数量是bytes的,将持有字符串都体系化成bytes的

***系列化模块 将python 中的数据结构转化成 str.
什么样叫种类化? 将原先的字典/列表等内容,转化成1个字符串的进度***

用法:

  • 先是导入模块imort
    dbm【注意的是由许四个例外的dbm,能够选拔来利用,这里运用暗中认可】
  • 打开文件:dbm对象=dbm.open(文件名,打开情势)
    • 美高梅开户网址 3
  • 写入:dbm对象[key]=value
  • 读取: dbm对象[key]

    import dbm

    db=dbm.open(“test.txt”,”c”)

    print(“写”.center(50,’-‘))
    db[“name”]=”1111111111112″
    db[“name2″]=”2222222222222”

    print(“读”.center(50,’-‘))
    print(db[“name”])
    print(db[“name2”])

    db.close()

 


***json json 通用的数据结构 在 python 里表现的是字典和列表***

## json :four_leaf_clover:

用以字符串和python数据类型之间举行更换 , 因为json代表出来正是2个字符串

json模块提供了八个艺术

方法 描述
dump 选取三个文件句柄 , 将原数据类型转换到字符串写入文件
load 收到三个文书句柄 , 将文件中的字符串转换成原数据类型重回
dumps 接到2个数据类型 , 将其转换来字符串
loads 收取一个字符串 , 将其转换到原数据类型

dump 和 load 实例

“`python
# 导入json模块
import json
# 创制三个文本句柄
f = open(‘json_file’,’w’)
# 创设五个字典
dic = {‘k1′:’v1′,’k2′:’v2’}
# 将字典转换到字符串写入文件
json.dump(dic,f)
# 关闭文件
f.close()
# 创立3个文件句柄
f = open(‘json_file’)
# 将文件中的字符串读出并转换来原数据类型
dic2 = json.load(f)
# 关闭文件句柄
f.close()
# 打字与印刷项目和结果
print(type(dic2),dic2)
# <class ‘dict’> {‘k1’: ‘v1’, ‘k2’: ‘v2’}
“`

dumps 和 loads 实例

“`python
# 导入json模块
import json
# 创设二个新列表
lst = [‘1′,’2′,’3′,’4’]
# 将列表转换来字符串,用j_d来接收再次回到值
j_d = json.dumps(lst)
# 将字符串转换成原数据类型,用j_s来接收重回值
j_s = json.loads(j_d)
# 打印j_d的值以及项目
print(j_d,type(j_d))
# [“1”, “2”, “3”, “4”] <class ‘str’>
# 打印j_s的值以及项目
print(j_s,type(j_s))
# [‘1’, ‘2’, ‘3’, ‘4’] <class ‘list’>
“`

loads的奇特别情报形

“`python
# 导入json模块
import json
# 成立二个字符串,内部为2个字典
dic_s = “{‘k1′:’v1′,’k2′:’v2′,’k3’:3}”
# 将字符串转换成字典
json.loads(dic_s)
# 解释器出现报错
# json.decoder.JSONDecodeError: Expecting property name enclosed in
double quotes: line 1 column 2 (char 1)
”’
报错原因,用json的loads效能时,字符串类型的字典中的字符串必须由 “” 表示
即下边的dic_s应该改为 ‘{“k一”:”v一”,”k二”:”v2″,”k三”:三}’

结论:用json的loads成效时,字符串类型的字典中的字符串必须由 “” 表示
”’
“`

PS : json可用于差别语言之间的数据交换

 

 

***pickle 在 python 里专用的,能够对其余数据类型做连串化,结果是 bytes
类型***

***shelve 只提供三个 open 方法,操作有点像字典.***

 

 

 ## pickle :four_leaf_clover:

用于python特有的连串和python的数据类型间展开转移

pickle模块也提供了多个方法 , 与json一样 dumps , dump , loads , load

鉴于pickle是对于python特有的品种 , 所以 load 和 loads方法不但帮衬字典 ,
列表 , 它仍是能够把python中随心所欲的数据类型进行种类化

“`python
——-dumps和loads——–
# 导入pickle模块
import pickle
# 成立一个字典
dic = {‘k1′:’v1′,’k2′:’v2’}
# 将字典转换到2进制内容
p_d = pickle.dumps(dic)
# 将二进制内容转换到字典
p_l = pickle.loads(p_d)
# 打印p_d
print(p_d)
#
b’\x80\x03}q\x00(X\x02\x00\x00\x00k2q\x01X\x02\x00\x00\x00v2q\x02X\x02\x00\x00\x00k1q\x03X\x02\x00\x00\x00v1q\x04u.’
# 打印p_d的类型
print(type(p_d))
# <class ‘bytes’>
# 打印p_l
print(p_l)
# {‘k2’: ‘v2’, ‘k1’: ‘v1’}
# 打印p_l的类型
print(type(p_l))
# <class ‘dict’>
———dump 和 load———
# 创造二个文书句柄
f = open(‘pickle_file’,’wb’)
# 写入内容
pickle.dump(‘lyon’,f)
# 关闭文件
f.close()
# 创立一个文件句柄
f = open(‘pickle_file’,’rb’)
# 读出内容
p_f = pickle.load(f)
# 关闭文件
f.close()
# 打印
print(p_美高梅开户网址,f)
# lyon
“`

**然而pickle仅仅只可以对python中的数据实行种类化 ,
反种类化时此外语言就不恐怕读懂了这是怎么了** ,
所以大家1般用引进应用json

 

## shelve :four_leaf_clover:

shelve也是python提要求大家的系列化学工业具 , 比pickle用起来大约1些

shelve只提要求咱们贰个open方法 , 是用key来访问的 , 使用起来和字典类似

“`python
# 导入shelve模块
import shelve
# shelve提供open方法
f = shelve.open(‘shelve_file’)
# 直接对文件句柄进行操作,就足以写入文件中
f[‘key’] = {‘int’:10, ‘float’:9.5, ‘string’:’Sample data’}
# 关闭文件
f.close()
# 打开文件
f1 = shelve.open(‘shelve_file’)
# 直接用key取值,key不存在就报错
existing = f1[‘key’]
# 关闭文件
f1.close()
# 打字与印刷结果
print(existing)
# {‘float’: 9.5, ‘int’: 10, ‘string’: ‘Sample data’}
“`

shelve不扶助七个使用还要往贰个数据库进行操作 ,
所以当大家领会大家的行使假诺只举行操作 , 大家得以设置shelve.open()
方法的参数来进展

shelve.open(filename, flag=’c’, protocol=None, writeback=False)

“`python
import shelve
# flag参数为设置操作形式,r 设置只读情势
f = shelve.open(‘shelve_file’, flag=’r’)
existing = f[‘key’]
f.close()
print(existing)
“`

` writeback `参数 , 能够削减大家失误的票房价值 ,
并且让对象的持久化对用户越来越的晶莹了 ;
但那种情势并不是有着的景观下都亟需 , 首先 , 使用writeback现在 ,
shelf在open()的时候会追加额外的内存消耗 ,
并且当数据库在close()的时候会将缓存中的每2个对象都写入到多少库 ,
那也会带来额外的守候时间 , 因为shelve没有章程知道缓存中如何对象修改了 ,
哪些对象未有改动 , 由此全数的对象都会被写入

“`python
import shelve
f1 = shelve.open(‘shelve_file’)
print(f1[‘key’])
f1[‘key’][‘new_value’] = ‘this was not here before’
f1.close()
# 设置writeback
f2 = shelve.open(‘shelve_file’, writeback=True)
print(f2[‘key’])
f2[‘key’][‘new_value’] = ‘this was not here before’
f2.close()
“`

发表评论

电子邮件地址不会被公开。 必填项已用*标注

网站地图xml地图