体系化与数据持久化,python__类别化模块

By admin in 4858.com on 2019年3月29日

数码持久化的章程有:

python:系列化与数码持久化,python序列化

数码持久化的格局有:

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

2.常常种类化写入:json,pickle

3.DBM方式:shelve,dbm

 

 

何以叫连串化——将原本的字典、列表等内容转换到两个字符串的历程就称为序列化

1.平淡无奇文书无格式写入:将数据直接写入到文件中

相关内容:

  • json
  • pickle
  • shelve
  • dbm

 

头阵时间:2018-02-23 20:52

 


***collections 扩张数据类型***

       
比如,大家在python代码中总结的二个数额须要给此外一段程序使用,那我们怎么给?
明日我们能想到的艺术正是存在文件里,然后另三个python程序再从文件里读出来。
不过我们都了解,对于文本来说是尚未字典这几个概念的,所以大家不得不将数据转换到字典放到文件中。
您肯定会问,将字典转换来三个字符串非常粗大略,就是str(dic)就能够办到了,为何我们还要学习种类化模块呢?
没错系列化的进度正是从dic
变成str(dic)的历程。以后您能够透过str(dic),将2个名为dic的字典转换来一个字符串,
唯独你要怎么把三个字符串转换来字典呢?
聪明的你一定想到了eval(),如若大家将一个字符串类型的字典str_dic传给eval,就会赢得多个赶回的字典类型了。
eval()函数13分精锐,不过eval是做咋样的?e官方demo解释为:将字符串str当成有效的表明式来求值并回到总计结果。
BUT!强大的函数有代价。安全性是其最大的缺点。
想像一下,如若我们从文件中读出的不是三个数据结构,而是一句”删除文件”类似的破坏性语句,那么结果实在不堪设设想。
而选拔eval就要担那一个风险。
故而,大家并不引进用eval方法来进行反体系化操作(将str转换到python中的数据结构)

2.一般类别化写入:json,pickle

json:

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

怎么要有系列化模块

3.DBM方式:shelve,dbm

介绍:

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

***time 时间相关
三种格式:时间戳,格式化时间(字符串),时间元组(结构化时间).
***
“`python
#岁月戳: timestamp 从一九七零年3月八日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) 1992-12-10
%Y-%m-%d_%a %H:%M:S
%y 两位数的年度表示(00-99)
%Y 贰人数的年度表示(000-9999)
%m 月份(01-12)
%d 月内中的一天(0-31)
%H 24小时制小时数(0-23)
4858.com ,%I 12小时制小时数(01-12)
%M 分钟数(00=59)
%S 秒(00-59)
%a 本地简化星期名称
%A 本地完整星期名称
%b 本地简化的月度名称
%B 本地完整的月度名称
%c 本地相应的日子表示和时间表示
%j 年内的一天(001-366)
%p 本地A.M.或P.M.的等价符
%U 一年中的星期数(00-53)礼拜一为星期的启幕
%w 星期(0-6),星期二为星期的始发
%W 一年中的星期数(00-53)星期三为星期的发端
%x 本地相应的日子表示
%X 本地相应的年华代表
%Z 当前时区的名目
%% %号本身

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

有关内容:

  • json
  • pickle
  • shelve
  • dbm

 

首发时间:2018-02-23 20:52

 


 

#时光元组: (结构化时间)Stack_Time 包蕴多少个因素:年 月 日 时 分 秒
二零一九年第几周 二〇一九年的第几天 夏令时
“`
“`
#时光戳–>时间元组(结构化时间)
time.gmtime(#填时间戳) #UTC时间
time.localtime(#填时间戳) #地面时间

贰 、将目的从贰个地点传递到另三个地方。

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

4858.com 1

pickle:

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

4858.com 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(文件对象)
    • 体系化与数据持久化,python__类别化模块。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)
#反类别化:将一个字符串格式的字典转换到三个字典
#小心,要用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方法接收2个文件句柄,直接将字典转换来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只提要求大家1个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

用法:

  • 第1导入模块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.家常文书无格式写入:将数据间接写入到文件中
2.常备体系化写入: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.
什么叫体系化? 将原先的字典/列表等内容,转化成多个字符串的进度***

用法:

  • 先是导入模块imort
    dbm【注意的是由众四个例外的dbm,可以采取来使用,那里运用暗中认可】
  • 打开文件:dbm对象=dbm.open(文件名,打开形式)
    • 4858.com 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 收到三个文本句柄 , 将原数据类型转换到字符串写入文件
load 接到3个文本句柄 , 将文件中的字符串转换到原数据类型重临
dumps 收取二个数据类型 , 将其转换来字符串
loads 接受二个字符串 , 将其转换来原数据类型

dump 和 load 实例

“`python
# 导入json模块
import json
# 创立八个文件句柄
f = open(‘json_file’,’w’)
# 创立二个字典
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
# 创设1个字符串,内部为一个字典
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应该改为 ‘{“k1″:”v1″,”k2″:”v2″,”k3”:3}’

敲定:用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’}
# 将字典转换来二进制内容
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中的数据举行连串化 ,
反体系化时别的语言就不可能读懂了那是怎么了** ,
所以我们一般用引进使用json

 

## shelve :four_leaf_clover:

shelve也是python提要求大家的连串化学工业具 , 比pickle用起来大约一些

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地图
Copyright @ 2010-2019 美高梅手机版4858 版权所有