多少持久化的不贰秘诀有:

python:体系化与数据持久化,python体系化

数码持久化的法门有:

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

二.平常系列化写入:json,pickle

3.DBM方式:shelve,dbm

 

 

什么样叫种类化——将原先的字典、列表等内容转换成1个字符串的进度就称为序列化

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

连带内容:

  • json
  • pickle
  • shelve
  • dbm

 

首发时间:2018-0二-二三 20:52

 


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

       
比如,大家在python代码中计算的叁个数目要求给此外1段程序使用,那大家怎么给?
明日大家能想到的不二法门正是存在文件里,然后另三个python程序再从文件里读出来。
唯独大家都明白,对于文本来说是未曾字典那些定义的,所以我们只可以将数据转换到字典放到文件中。
您早晚会问,将字典转换来三个字符串很简单,正是str(dic)就足以办到了,为啥我们还要学习系列化模块呢?
没有错连串化的进程便是从dic
变成str(dic)的经过。现在你能够通过str(dic),将一个名字为dic的字典转换到二个字符串,
然则你要怎么把二个字符串转换到字典呢?
聪慧的你肯定想到了eval(),假使大家将三个字符串类型的字典str_dic传给eval,就会获取1个回来的字典类型了。
eval()函数10分无敌,不过eval是做哪些的?e官方demo解释为:将字符串str当成有效的表明式来求值并赶回计算结果。
BUT!强大的函数有代价。安全性是其最大的欠缺。
想象一下,假如大家从文件中读出的不是二个数据结构,而是一句”删除文件”类似的破坏性语句,那么后果实在不堪设设想。
而选用eval就要担这么些危害。
故此,大家并不引入用eval方法来开始展览反种类化操作(将str转换来python中的数据结构)

二.惯常体系化写入:json,pickle

json:

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

干什么要有体系化模块

3.DBM方式:shelve,dbm

介绍:

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

***time 时间相关
二种格式:时间戳,格式化时间(字符串),时间元组(结构化时间).
***
“`python
#光阴戳: timestamp 从196八年七月二日00:00起首按秒总计偏移量.
time.time()

系列化的目标

 

用法:

  • 先是要导入模块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) 壹九91-1二-10
%Y-%m-%d_%a %H:%M:S
%y 两位数的年份表示(00-9九)
%Y 4个人数的年度表示(000-999九)
%m 月份(01-12)
%d 月内中的壹天(0-31)
%H 二四小时制时辰数(0-2叁)
%I 1二时辰制小时数(0一-1二)
%M 分钟数(00=59)
%S 秒(00-59)
%a 本地简化星期名称
%A 本地完整星期名称
%b 本地简化的月份名称
%B 本地完整的月份名称
%c 本地相应的日期表示和岁月代表
%j 年内的一天(001-36六)
%p 本地A.M.或P.M.的等价符
%U 一年中的星期数(00-5三)星期三为星期的发端
%w 星期(0-6),周日为星期的始发
%W 一年中的星期数(00-伍三)星期1为星期的初阶
%x 本地相应的日期表示
%X 本地相应的日子代表
%Z 当前时区的称号
%% %号本身

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

有关内容:

  • json
  • pickle
  • shelve
  • dbm

 

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

 


 

#日子元组: (结构化时间)Stack_Time 包蕴八个元素:年 月 日 时 分 秒
今年第几周 二零一九年的第几天 夏令时
“`
“`
#日子戳–>时间元组(结构化时间)
time.gmtime(#填时间戳) #UTC时间
time.localtime(#填时间戳) #本土时间

2、将对象从叁个地方传递到另1个地方。

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编码

金沙注册送58 1

pickle:

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

金沙注册送58 2

用法:

  • 首先要导入模块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()
      

 

 

介绍:

  • 用以落到实处Python数据类型与Python特定二进制格式之间的变换
  • 参数protocol规定了连串化的磋商版本,暗中同意情形下利用pikkle系列化数据是bytes的,打开文件的法子必须为贰进制格式

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)

 

 

用法:

  • 先是导入模块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) #体系化:将1个字典转换到一个字符串
print(type(str_dic),str_dic) #<class ‘str’> {“k3”: “v3”, “k1”:
“v1”, “k2”: “v2”}
#注意,json转换完的字符串类型的字典中的字符串是由””表示的

dic2 = json.loads(str_dic)
#反体系化:将3个字符串格式的字典转换来一个字典
#只顾,要用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方法接收1个文件句柄,直接将字典转换来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不可体系化函数
    }
    info二=[‘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) #壹串2进制内容

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

 

介绍:

  • 金沙注册送58 ,用于落到实处Python数据类型与Python特定二进制格式之间的转移
  • 参数protocol规定了连串化的合计版本,暗许意况下行使pikkle类别化数据是bytes的,打开文件的办法必须为二进制格式

用法:

  • 第3导入模块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只提必要大家3个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

 

那些模块有个限制,它不协助多少个使用同近年来间往同贰个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()的时候会将缓存中的每2个目的都写入到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打开二个文本: 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.
如何叫连串化? 将原来的字典/列表等情节,转化成贰个字符串的经过***

用法:

  • 首起头入模块imort
    dbm【注意的是由众多少个分化的dbm,能够选用来行使,那里运用默许】
  • 开辟文件:dbm对象=dbm.open(文件名,打开方式)
    • 金沙注册送58 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代表出来就是一个字符串

json模块提供了七个点子

方法 描述
dump 接到1个文本句柄 , 将原数据类型转换来字符串写入文件
load 收取2个文件句柄 , 将文件中的字符串转换来原数据类型再次回到
dumps 选拔一个数据类型 , 将其转换到字符串
loads 收到多个字符串 , 将其转换来原数据类型

dump 和 load 实例

“`python
# 导入json模块
import json
# 创造三个文本句柄
f = open(‘json_file’,’w’)
# 创制1个字典
dic = {‘k1′:’v1′,’k2′:’v2’}
# 将字典转换到字符串写入文件
json.dump(dic,f)
# 关闭文件
f.close()
# 创制三个文书句柄
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
# 创造叁个字符串,内部为一个字典
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″,”k3″:三}’

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

PS : json可用于分裂语言之间的数据沟通

 

 

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

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

 

 

 ## pickle :four_leaf_clover:

用于python特有的类型和python的数据类型间开始展览转换

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

鉴于pickle是对此python特有的门类 , 所以 load 和 loads方法不仅帮助字典 ,
列表 , 它还是可以够把python中随心所欲的数据类型举行连串化

“`python
——-dumps和loads——–
# 导入pickle模块
import pickle
# 创立叁个字典
dic = {‘k1′:’v1′,’k2′:’v2’}
# 将字典转换来二进制内容
p_d = pickle.dumps(dic)
# 将2进制内容转换到字典
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中的数据进行系列化 ,
反连串化时其它语言就不能读懂了那是什么了** ,
所以大家一般用引入应用json

 

## shelve :four_leaf_clover:

shelve也是python提供给我们的类别化学工业具 , 比pickle用起来差不多1些

shelve只提须求大家2个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()的时候会将缓存中的每多少个指标都写入到数码库 ,
这也会带动额外的守候时间 , 因为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地图