威尼斯人线上娱乐

【威尼斯人线上娱乐】体系化与数码持久化,各样模块的简易总结

12 4月 , 2019  

数码持久化的艺术有:

python:系列化与数码持久化,python种类化

数码持久化的办法有:

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

2.平日体系化写入:json,pickle

3.DBM方式:shelve,dbm

 

 

何以叫连串化——将原本的字典、列表等情节转换来2个字符串的长河就称为序列化

1.司空眼惯文书无格式写入:将数据直接写入到文件中

相关内容:

  • json
  • pickle
  • shelve
  • dbm

 

首发时间:201八-02-二3 20:5二

 


***collections 扩展数据类型***

       
比如,我们在python代码中计算的三个多少必要给此外壹段程序使用,那我们怎么给?
当今我们能想到的章程正是存在文件里,然后另三个python程序再从文件里读出来。
只是大家都精通,对于文本来说是尚未字典那一个定义的,所以我们不得不将数据转换来字典放到文件中。
你一定会问,将字典转换到三个字符串很简短,就是str(dic)就能够办到了,为何大家还要学习系列化模块呢?
没错体系化的经过便是从dic
变成str(dic)的历程。今后您能够经过str(dic),将三个名称叫dic的字典转换到三个字符串,
然则你要怎么把3个字符串转换到字典呢?
聪明的你势必想到了eval(),假如大家将贰个字符串类型的字典str_dic传给eval,就会赢得1个回到的字典类型了。
eval()函数12分强硬,不过eval是做怎么着的?e官方demo解释为:将字符串str当成有效的表明式来求值并重临计算结果。
BUT!强大的函数有代价。安全性是其最大的毛病。
想象一下,若是大家从文件中读出的不是贰个数据结构,而是一句”删除文件”类似的破坏性语句,那么后果实在不堪设设想。
而利用eval就要担那几个危害。
就此,大家并不引入用eval方法来实行反体系化操作(将str转换到python中的数据结构)

2.平淡无奇系列化写入: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) 一99三-12-拾
%Y-%m-%d_%a %H:%M:S
%y 两位数的年份表示(00-9玖)
%Y 二位数的年度表示(000-999九)
%m 月份(01-12)
%d 月内中的壹天(0-3一)
%H 二4时辰制小时数(0-二三)
%I 1二小时制时辰数(01-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-陆),星期一为星期的发端
%W 一年中的星期数(00-五三)星期壹为星期的初叶
%x 本地相应的日子表示
%X 本地相应的年月代表
%Z 当前时区的名目
%% %号本身

一、以某种存款和储蓄情势使自定义目的持久化;

连带内容:

  • json
  • pickle
  • shelve
  • dbm

 

首发时间:201八-0二-二3 20:5二

 


 

#时光元组: (结构化时间)Stack_Time 包括七个要素:年 月 日 时 分 秒
二〇一9年第几周 二〇一9年的第几天 夏令时
“`
“`
#时光戳–>时间元组(结构化时间)
time.gmtime(#填时间戳) #UTC时间
time.localtime(#填时间戳) #本土时间

2、将指标从一个地方传递到另三个地方。

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(种类化对象),重回值是二个字符串,须要手动将这几个字符串写入到文件中

      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特定2进制格式之间的更换
  • 参数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)

 

 

用法:

  • 率开始入模块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)
#反系列化:将3个字符串格式的字典转换到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方法接收贰个文件句柄,间接将字典转换来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

 

介绍:

  • 用于落到实处Python数据类型与Python特定2进制格式之间的转移
  • 参数protocol规定了系列化的情商版本,私下认可情况下选择pikkle连串化数据是bytes的,打开文件的点子必须为二进制格式

用法:

  • 第3导入模块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()

***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

 

本条模块有个限制,它不扶助八个使用同权且间往同四个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()

 


数据持久化的章程有: 1.不乏先例文书无格式写入:将数据间接写入到文件中
二.普通连串化写入:js…

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

用法:

  • 率起首入模块import
  • shelve打开3个文书: 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.
什么样叫类别化? 将原先的字典/列表等内容,转化成3个字符串的历程***

用法:

  • 先是导入模块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表示出来正是3个字符串

json模块提供了八个措施

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

dump 和 load 实例

“`python
# 导入json模块
import json
# 创设2个文书句柄
f = open(‘json_file’,’w’)
# 创立二个字典
dic = {‘k1′:’v1′,’k2′:’v2’}
# 将字典转换来字符串写入文件
json.dump(dic,f)
# 关闭文件
f.close()
# 创制1个文书句柄
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
# 成立三个字符串,内部为3个字典
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二”:”v贰”,”k三”:三}’

敲定:用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只提须要我们一个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地图