python_day25_序列化模块详解编程语言

回顾内置方法： 
__len__ len(obj)的结果依赖于obj.__len__()的结果，计算对象的长度 
__hash__ hash(obj)的结果依赖于obj.__hash__()的结果，计算对象的hash值 
__eq__  obj1 == obj2 的结果依赖于obj.__eq__()的结果,用来判断值相等 
__str__ str(obj) print(obj) '%s'%obj 的结果依赖于__str__,用来做输出、显示 
__repr__ repr(obj) '%r'%obj的结果依赖于__repr__,还可以做str的备胎 
__format__ format() 的结果依赖于__format__的结果，是对象格式化的 
__call__ obj()相当于调用__call__，实现了__call__的对象是callable的 
__new__  构造方法，在执行__init__之前执行，负责创建一个对象，在单例模式中有具体的应用 
__del__  析构方法，在对象删除的时候，删除这个对象之前执行，主要用来关闭在对象中打开的系统的资源 
item系列：对象［'值']触发 
__getitem__ 对象[]的形式对对象进行增删改查 
__setitem__ 
__delitem__ 
__delattr__ del obj.attr 用来自定义删除一个属性 一般不需要重写它 
 
解析一道面试题 
写一个类，定义100个对象，对象都拥有三个属性：name, age, sex。 
如果两个对象的name和sex完全相同，我们就认为这是一个对象。 
忽略age属性，做这100个对象的去重工作。 
 
class Person: 
    def __init__(self,name,age,sex): 
        self.name = name 
        self.age = age 
        self.sex = sex 
    def __hash__(self): 
        # hash算法本身就存在了 且直接在python中就能调用 
        # 姓名相同 性别相同的对象的hash值应该相等才行 
        # 姓名性别都是字符串 
        return hash(self.name+self.sex) 
    def __eq__(self, other): 
        if self.name == other.name and self.sex == other.sex: 
            return True 
 
思路： 
python2.7经典类中没有hash方法，直接对类中对象进行set去重会报错，# set([obj,obj])   unhashable 
哈希算法和数据可不可变类型没有任何关系，因为hash是一种算法。 
可变类型也可以进行哈希，但在一次程序中它会变化， 
所以进行hash得出的值也会变化，字典中就无法将其做为key。 
 
# key hash 数字 --》 内存地址 --》 value 
# set hash 数字 --》 内存地址 --》 set中的元素 
 
hash算法： 
一个值进行一系列的计算得出一个数字在一次程序执行中总是不变， 
每一个不同的值计算出的数字都不相等。 
 
set去重： 
set对一个对象序列的去重 依赖于这个对象的两个方法:__hash__, __eq__。 
如何判断这两个值是否相等，使用hash计算哈希值后再判断有相同哈希值的元素值是否相同会非常高效。 
 
验证： 
 
obj_lst = [] 
obj_lst.append(Person('alex',80,'male')) 
obj_lst.append(Person('alex',70,'male')) 
obj_lst.append(Person('alex',60,'male')) 
obj_lst.append(Person('boss_jin',50,'male')) 
obj_lst.append(Person('boss_jin',40,'male')) 
obj_lst.append(Person('boss_jin',30,'male')) 
obj_lst.append(Person('nezha',20,'male')) 
obj_lst.append(Person('nezha',10,'male')) 
obj_lst = set(obj_lst) 
for obj in obj_lst:print(obj.name) 
 
运行结果为8个实例对象去重后变成三个：nezha boss_jin alex

例： 
data = {'username':['李雷', '韩梅梅'], 'idenu':'student', 'age':14} 
json_dic2 = json.dumps(data, sort_keys=True, indent=4, separators=(',', ':'), ensure_ascii=False) 
print(json_dic2) 
 
显示效果： 
{ 
    "age":14, 
    "idenu":"student", 
    "username":[ 
        "李雷", 
        "韩梅梅" 
    ] 
} 
 
参数详解： 
sort_keys=True 对（键）字母进行排序； 
indent 行缩进几个字节； 
separators=(',', ':') 对字典以指定的符号进行分隔； 
ensure_ascii=False 显示中文。 
 
Serialize obj to a JSON formatted str.(字符串表示的json对象)  
 
Skipkeys：默认值是False， 
如果dict的keys内的数据不是python的基本类型(str,unicode,int,long,float,bool,None)，设置为False时， 
就会报TypeError的错误。此时设置成True，则会跳过这类key 。 
 
ensure_ascii:，当它为True的时候，所有非ASCII码字符显示为/uXXXX序列， 
只需在dump时将ensure_ascii设置为False即可，此时存入json的中文即可正常显示。)  
 
indent：应该是一个非负的整型，如果是0就是顶格分行显示，如果为空就是一行最紧凑显示， 
否则会换行且按照indent的数值显示前面的空白分行显示，这样打印出来的json数据也叫pretty-printed json  
 
separators：分隔符，实际上是(item_separator, dict_separator)的一个元组，默认的就是(‘,’,’:’)； 
这表示dictionary内keys之间用“,”隔开，而KEY和value之间用“：”隔开。  
 
sort_keys：将数据根据keys的值进行排序。 

import pickle 
# dumps 和 loads 在（网络传输）内存中互转 
dic = {(185, 90, '抠脚'):'大表哥'} 
ret = pickle.dumps(dic) 
# pickle序列化结果，不是一个可读的字符串，而是一个bytes类型 
print(ret) 
# 显示：b'/x80/x03}q/x00K/xb9KZX/x06/x00/x00/x00/xe6/x8a/xa0/xe8/x84/x9aq/x01/x87q/x02X/t/x00/x00/x00/xe5/xa4/xa7/xe8/xa1/xa8/xe5/x93/xa5q/x03s.' 
print(pickle.loads(ret)) 
# 显示回{(185, 90, '抠脚'): '大表哥'} 
 
# dump 和 load 在文件中写读操作 
dic2 = {(168, 52, '下棋'): '铁乐猫'} 
f = open('pickle', 'wb') 
# 使用pickle dump 必須以+b的形式打开文件 
pickle.dump(dic2, f) 
f.close() 
 
f = open('pickle', 'rb') 
res = pickle.load(f) 
# 使用load读取内容出来，且不需要再解码 
print(res) 
# 显示{(168, 52, '下棋'): '铁乐猫'}

例：人狗大战模拟读存档人物属性状态 
 
import pickle 
class Animal: 
    def __init__(self, name, hp, atk): 
        self.name = name 
        self.hp = hp 
        self.atk = atk 
 
class Person(Animal): 
    def __init__(self, name, hp, atk, sex): 
        super().__init__(name, hp, atk) 
        self.sex = sex 
    # 重写一下内置的双下str，让实例能被print打印出属性 
    def __str__(self): 
        return str(self.__dict__) 
 
class Dog(Animal): 
    def __init__(self, name, hp, atk, kind): 
        super().__init__(name, hp, atk) 
        self.kind = kind 
 
hero = Person('铁乐', 100, 10, '男') 
print(hero) 
# 重写双下str后打印出{'sex': '男', 'name': '铁乐', 'atk': 10, 'hp': 100} 
 
# 对象也可以被pickle序列化，这是在内存中操作的示例 
ret = pickle.dumps(hero) 
print(ret) 
# 显示bytes类型的字节： 
# b'/x80/x03c__main__/nPerson/nq/x00)/x81q/x01}q/x02(X/x03/x00/x00/x00atkq/x03K/nX/x04/x00/x00/x00nameq/x04X/x06/x00/x00/x00/xe9/x93/x81/xe4/xb9/x90q/x05X/x03/x00/x00/x00sexq/x06X/x03/x00/x00/x00/xe7/x94/xb7q/x07X/x02/x00/x00/x00hpq/x08Kdub.' 
res = pickle.loads(ret) 
print(type(res), res) 
# 重新输出成 <class '__main__.Person'> {'hp': 100, 'atk': 10, 'name': '铁乐', 'sex': '男'} 
 
# 假如将对象保存进文件中操作会怎样？模拟游戏中对角色的状态存档操作： 
f = open('save_hero', 'wb') 
# 实例在前，文件句柄在后 
pickle.dump(hero, f) 
# 对象以bytes类型存进了save_hero文件中 
f.close() 
 
# 模拟读档 
f1 = open('save_hero', 'rb') 
# 读取save_hero，下面的obj就相当于是之前的hero实例，或也可直接命名回hero实例名 
obj = pickle.load(f1) 
print(type(obj), obj) 
# <class '__main__.Person'> {'name': '铁乐', 'hp': 100, 'sex': '男', 'atk': 10}

def open(filename, flag='c', protocol=None, writeback=False): 
    """Open a persistent dictionary for reading and writing. 
       # 打开一个持久的字典，用于阅读和写作。 
    The filename parameter is the base filename for the underlying 
    database.  As a side-effect, an extension may be added to the 
    filename and more than one file may be created.  The optional flag 
    parameter has the same interpretation as the flag parameter of 
    dbm.open(). The optional protocol parameter specifies the 
    version of the pickle protocol (0, 1, or 2). 
 
    See the module's __doc__ string for an overview of the interface. 
    """ 
 
    return DbfilenameShelf(filename, flag, protocol, writeback) 
 
源码中的一些有关说明摘录： 
To summarize the interface (key is a string, data is an arbitrary 
object): 
 
        import shelve 
        d = shelve.open(filename) # open, with (g)dbm filename -- no suffix 
 
        d[key] = data   # store data at key (overwrites old data if 
                        # using an existing key) 
 
        文件句柄[key] = 你想存储的数据  #存储数据在键(如果使用现有的key，将会覆盖旧数据) 
 
        data = d[key]   # retrieve a COPY of the data at key (raise 
                        # KeyError if no such key) -- NOTE that this 
                        # access returns a *copy* of the entry! 
 
        在键上检索数据的副本(如果没有这样的键，就会抛出键错误)——注意，这个访问返回了条目的*拷贝* ! 
 
        del d[key]      # delete data stored at key (raises KeyError 
                        # if no such key) 
         
       删除存储在key中的数据(如果没有这样的键，就会出现KeyError) 
 
        flag = key in d    # true if the key exists  如果键存在，则为真。 
        list = d.keys()    # a list of all existing keys (slow!)   所有现有键的列表(注意：缓慢!) 
        d.close()          # close it 关闭文件句柄

import shelve 
db1 = shelve.open('shelve_db1') 
db1['dic'] = {'int':12, 'float':2.5, 'string':'shelve db'}   
#直接对文件句柄［key］操作，就可以存入数据 
db1.close() 
 
且重要的是它还会直接在打开的当前目录生成三个文件： 
shelve.db1.bak 
shelve.db1.dat 
shelve.db1.dir 
 
其中shelve.db1.dat 存储的就是b字节数据类型的数据， 
bak和dir后缀的就可能是和数据库相关的设计缓存之类的东西了。 
注：文件生成后，我们可以将前面的这一段生成shelve db的代码先行注释掉，不影响下面的继续测试操作。 
 
db1 = shelve.open('shelve_db1') 
existing = db1['dic']   
# 取出数据的时候也只需要直接用字典的操作方法获取即可，但是如果key不存在会报错 
db1.close() 
print(type(existing), existing) 
# <class 'dict'> {'string': 'Shelve db', 'float': 2.5, 'int': 12}

db1 = shelve.open('shelve_db1', flag='r') 
res1 = db1['dic']['int'] 
db1.close() 
print(type(res1), res1) 
# <class 'int'> 12 
 
由于shelve在默认情况下是不会记录对持久化对象（字典下的键的值-条目）做出修改的， 
所以在shelve.open()时候需要修改默认参数writeback=True， 
否则对象的条目修改不会'拷贝回写'来进行保存。 
 
import shelve 
db1 = shelve.open('shelve_db1', writeback=True) 
res2 = db1['dic']['date'] = '2018-4-20' 
db1.close() 
print(type(res2), res2) 
# <class 'str'> 2018-4-20 
 
当试图让shelve去自动捕获对象的变化时，应当在打开shelf的时候将writeback设置为True。 
而将writeback这个flag设置为True以后，shelf将会将所有从DB中读取的对象存放到一个内存缓存。 
当close() shelf的时候，缓存中所有的对象会被重新写入DB。 
 
关于key的数据类型： 
import shelve 
db2 = shelve.open('shelve_db2.dat') 
db2[(1, 2)] = {'lv1':'枪兵'} 
print(type(db2[(1, 2)]), db2[(1, 2)]) 
db2.close() 
 
以上会产生报错：AttributeError: 'tuple' object has no attribute 'encode' 
虽然看似shelve db是一个字典，但它的key得支持encode方法，所以 
在shelve模块中，key必须为字符串，而值可以是python所支持的数据类型。 
 
例：更详尽的测试说明 
import shelve 
list1 = ['tie', 'le', 'yu'] 
# 既然最终生成的文件会是dat格式的，何不一开始就指定后缀是dat 
db2 = shelve.open('shelve_db2.dat') 
db2['lis'] = list1 
# 文件句柄是通过字典的操作方式去拿里面的键值对，lis这个键对应的值是一个列表 
db2['lis'].append('mao') 
#　而此列表增加一个字符串元素后再打印，感觉不出有发生增加的变化 
print(type(db2['lis']), db2['lis']) 
# 返回列表：['tie', 'le', 'yu'] 
 
没有'mao' ，存储的'mao'到哪里去了呢？ 
其实很简单，lis 并没有写回，虽然把['tie','le','yu']存到了lis， 
但当你再次读取db2['lis']的时候，db2['lis']只是一个拷贝， 
而你没有用默认参数writeback将拷贝写回， 
当你再次读取db2['lis']的时候，它又从数据源中读取了一个拷贝， 
所以，你新修改的内容并不会出现在拷贝中，解决的办法最方便的就是使用默认参数writeback=True， 
然后还有一个方法是利用中间缓存的变量，如下所示： 
 
利用中间变量 
import shelve 
 
list2 = ['tie', 'le', 'yu'] 
 
db2 = shelve.open('shelve_db2.dat') 
db2['lis'] = list2 
temp = db2['lis'] 
temp.append('mao') 
db2['lis'] = temp #　这种属于直接赋值和拷贝写回无关，会生效 
print(type(db2['lis']), db2['lis']) 
返回的结果中有　<class 'list'> ['tie', 'le', 'yu', 'mao'] 
 
直接修改默认参数writeback=True 如下： 
import shelve 
 
list3 = ['a', 'b', 'c'] 
 
db2 = shelve.open('shelve_db2.dat', writeback=True) 
db2['lis2'] = list3 
db2['lis2'].append('d') 
for k, v in db2.items(): 
    print(k, v) 
 
# 显示从测试开始存在shelve_db2.dat数据文件中键和值如下，可以看到lis2也是成功添加了'd'的。 
# lis2 ['a', 'b', 'c', 'd'] 
# dic ['tie', 'le', 'yu'] 
# lis ['tie', 'le', 'yu', 'mao'] 
db2.close() 
 
import shelve 
db2 = shelve.open('shelve_db2.dat') 
db2['lis2'] = ['1', '2', '3'] # 这是直接赋值，新列表覆盖掉旧列表, 所以并不需要用到回写参数 
for k, v in db2.items(): 
    print(k, v) 
# 显示如下 
# lis ['tie', 'le', 'yu', 'mao'] 
# lis2 ['1', '2', '3'] 
# dic ['tie', 'le', 'yu'] 
db2.close() 
 
同理，以下想对字典进行添加的操作，实际上也是拷贝没有写回，所以看起来没有保存修改成功一样 
import shelve 
db2 = shelve.open('shelve_db2.dat') 
db2['dic2'] = {'name':'铁乐', 'age':18, 'sex':'男'} 
db2['dic2']['hobby'] = ['下棋'] 
# 此时虽然看似添加了一个新键值对，其实并没有做写回操作， 
# 下面再做打印操作时，显示的还是从源中取出的一个拷贝，不会有显示增加的键值 
print(type(db2['dic2']), db2['dic2']) 
db2.close() 
# 显示<class 'dict'> {'sex': '男', 'age': 18, 'name': '铁乐'}

import time 
import datetime 
import hashlib 
import shelve 
# 模拟一个网站登录，新用户先进行注册再登录， 
# 旧用户登录判断登录的时间，离上一次登录时间超过多长时间的就再也不能登录了。 
# 只适用于一些开放的临时登录的场景？ 
# 测试时设置登录超时的时间为6分钟，实际应用可以设时间久一点 
LOGIN_TIME_OUT = 0.60 
# 设置一个临时db，且允许拷贝写回 
db = shelve.open('user_shelve.db', writeback=True) 
#　新用户登录函数,后面测试后发现其实就是相当于新注册一个用户！ 
def newuser(): 
prompt = "login desired: " # prompt,提示 
while True: 
name = input(prompt).strip() 
if name in db: 
prompt = "name taken, try another: " #  用户己存在，请重新输入 
continue 
elif len(name) == 0: 
prompt = "name should not be empty, try another: "  # 用户名不应该是空的，请重新输入 
continue 
else: 
break 
pwd = input("password: ").strip() 
db[name] = {"password": md5_digest(pwd), "last_login_time": time.time()} 
# 判断用户有没有已存在登录及记录上一次登录时间的函数（现有用户） 
def olduser(): 
name = input("login: ").strip() 
pwd = input("password: ").strip() 
try: 
password = db.get(name).get('password') 
# 捕获一个异常，试图访问一个对象没有的属性，也就是处理用户输入不存在的用户时 
except AttributeError: 
print("/033[1;31;40mUsername '%s' doesn't existed/033[0m" % name) 
# 提示用户不存在 
return 
if md5_digest(pwd) == password: 
login_time = time.time()   # 当前登录时间 
print(login_time) 
last_login_time = db.get(name).get('last_login_time') # 上一次登录时间 
print(last_login_time) 
if login_time - last_login_time < LOGIN_TIME_OUT: # 如果登录没有超时 
print("/033[1;31;40mYou already logged in at: <%s>/033[0m" % datetime.datetime.fromtimestamp( 
last_login_time).isoformat()) # 显示你准备登录的时间 
db[name]['last_login_time'] = login_time # 写入登录时间到db 
print("/033[1;32;40mwelcome back/033[0m", name) # 显示欢迎回来 
else: 
print("/033[1;31;40mlogin incorrect/033[0m") # 否则显示登录失败 
#　md5摘要加密传输进来的明文密码 
def md5_digest(plain_pass): 
md5 = hashlib.md5() 
md5.update(plain_pass.encode('utf-8')) 
return md5.hexdigest() 
# 菜单 
def showmenu(): 
# 下面菜单分别是新用户登录，当前用户登录，退出 
prompt = """ 
(N)ew User Login 
(E)xisting User Login 
(Q)uit 
Enter choice: """ 
done = False #　完成 默认值false 
while not done: 
chosen = False # 选择 默认值false 
while not chosen: 
try: 
choice = input(prompt).strip()[0].lower() 
# 捕获异常选择直接变成选q退出程序 
except (EOFError, KeyboardInterrupt): 
choice = "q" 
print("/nYou picked: [%s]" % choice) # 提示你的选择是什么 
if choice not in "neq": 
print("invalid option, try again") # 当输入的不为neq时，提示输入有误请重新输入 
else: 
chosen = True # 选择 为真，中断循环 
if choice == "q": done = True # 选择为q,退出，中断循环 
if choice == "n": newuser() # 选择为n，执行newuser()函数 
if choice == "e": olduser() # 选择为e，执行olduser()函数 
db.close() # 关闭db文件句柄 
# 执行主程序 
showmenu() 
效果如下： 
(N)ew User Login 
(E)xisting User Login 
(Q)uit 
Enter choice: n 
# 之前测试己将tiele与mao用户存在临时db文件中 
You picked: [n] 
login desired: tiele 
name taken, try another: mao   
# 提示用户己存在，请重新再注册一个新用户 
name taken, try another: yue 
password: 123 
# 新注册了一个yue用户，密码123的在db里 
(N)ew User Login 
(E)xisting User Login 
(Q)uit 
Enter choice: e 
You picked: [e] 
login: tiele 
password: 123456 
welcome back tiele  
# 登录成功 
# 后面感觉扩展成不用再输密码，而是直接登录那种可能还贴近一些记住密码的场景？ 
You picked: [e] 
login: le 
password: 123 
Username 'le' doesn't existed 
# 提示用户不存在 
You picked: [e] 
login: mao 
password: 123456 
login incorrect  # 离上一次登录时间超时，用户登录失效