python 全栈开发，Day25(复习,序列化模块json,pickle,shelve,hashlib模块)

一、复习

反射必须会必须能看懂必须知道在哪儿用
　　hasattr getattr setattr delattr
内置方法必须能看懂能用尽量用
__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__ 析构方法，在对象删除的时候，删除这个对象之前执行，主要用来关闭在对象中打开的系统的资源

class A:
    def __getitem__(self, item):
        print(item)
a = A()
a['bbb']    # 对象['值'] 触发了__getitem__

执行输出：

bbb

__getitem__ 对象[]的形式对对象进行增删改查
__setitem__
__delitem__
__delattr__   del obj.attr 用来自定义删除一个属性的方法

单例模式

只有一个对象只开了一个内存空间
创建一个类单例模式中的对象属性编程类中的静态属性，所有的方法变成类方法

java的单例模式，是依赖__new__来完成的

设计模式 —— java
python中的单例模式是使用__new__

只要执行了析构函数，说明对象要删除了

delattr不需要重写，python自带

面试题：

写一个类定义100个对象
拥有三个属性 name age sex
如果两个对象的name 和 sex完全相同
我们就认为这是一个对象
忽略age属性
做这100个对象的去重工作

可哈希，跟不可变没有直接关系

开发这个算法的人，叫哈希

hash算法一个值进行一系列的计算得出一个数字在一次程序执行中总是不变
来让每一个不同的值计算出的数字都不相等

创建一个对象

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
 
obj_lst = []
#手动创建8个对象，将对象写入列表
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)

执行输出：

alex
boss_jin
nezha

set对一个序列对象（有索引的对象）去重，依赖于这个对象的两个方法 hash和wq

key hash 数字 --》内存地址 --》 value
set hash 数字 --》内存地址 --》 set中的元素
'aaa' hash A

如果值存在，则覆盖

那么问题来了：

判断第100个元素时，需要做100次__eq__

set 对一个对象序列去重，如何判断这2个值是否相等

值a进行hash --> 存值
值b进行hash --> 判断值是否相等 -相等-> 说明是一样的
不相等-> 在开辟一个空间来存放b

因为set依赖__hash__和__eq__

所以在类里面，重新定义这2个方法，可以做个性化需求

最终得到我们想要的结果。

二、序列化模块json,pickle,shelve

什么是模块？
常见的场景：一个模块就是一个包含了python定义和声明的文件，文件名就是模块名字加上.py的后缀。

简单来说，py文件就是模块

python之所以好用，就是因为模块多

比如:

itchat 微信模块，模拟微信操作，自动回复
beautiful soap 爬虫工具
selenium 网页自动化测试工具
diango tornado web前段框架

所有和python有关的模块，都在这个网站上面
https://pypi.org/

python模块分为3种：

1.内置模块 python安装时自带的

2.扩展模块比如上面提到的itchat 等等

3.自定义模块自己写的模块

什么叫序列化——将原本的字典、列表等内容转换成一个字符串的过程就叫做序列化。

序列化的目的

1、以某种存储形式使自定义对象持久化；
2、将对象从一个地方传递到另一个地方。
3、使程序更具维护性。

比如a发送一个数据给b

由于发送数据，必须是二进制的。所以需要经历编码到解码的过程

dic = {'a':(1,2,3)}
s = str(dic).encode(encoding='utf-8')  # 编码
ret = s.decode(encoding='utf-8')  # 解码
print(ret)  # 查看数据
print(type(ret))  # 查看类型
print(type(eval(ret)))  # 还原为字典　

执行输出：

{'a': (1, 2, 3)}
<class 'str'>
<class 'dict'>

使用eval不安全，有可能是病毒，接收方，啪的一些，就执行了。

这个时候，就需要用到序列化了。

dic --> 字符串序列化
字符串 --> dic 反序列化
序列化 == 创造一个序列 ==》创造一个字符串
实例化 == 创造一个实例

python中的序列化模块
　　json 所有的编程语言都通用的序列化格式
　　　　它支持的数据类型非常有限数字字符串列表字典
　　pickle 只能在python语言的程序之间传递数据用的
　　　　pickle支持python中所有的数据类型
　　shelve python3.* 之后才有的

Json

Json模块提供了四个功能：dumps、dump、loads、load

序列化

import json  # 导入模块
dic = {"慕容美雪":(170,60,'赏花')}
ret = json.dumps(dic)  # 序列化
print(type(dic),dic)  # 查看原始数据类型
print(type(ret),ret)  # 查看序列化后的数据

执行输出：

<class 'dict'> {'慕容美雪': (170, 60, '赏花')}
<class 'str'> {"\u6155\u5bb9\u7f8e\u96ea": [170, 60, "\u8d4f\u82b1"]}

从结果中，可以看出：

原始数据类型是字典，序列化之后，就是字符串类型。而且中文变成了看不懂的字符串。

这是因为json.dumps 序列化时对中文默认使用的ascii编码。

想输出真正的中文需要指定ensure_ascii=False

import json  # 导入模块
dic = {"慕容美雪":(170,60,'赏花')}
ret = json.dumps(dic,ensure_ascii=False)  # 序列化时，不使用ascii码
print(type(dic),dic)  # 查看原始数据类型
print(type(ret),ret)  # 查看序列化后的数据

执行输出：

<class 'dict'> {'慕容美雪': (170, 60, '赏花')}
<class 'str'> {"慕容美雪": [170, 60, "赏花"]}

由于json不识别元组，json认为元组和列表是一回事，所以变成了列表。

在json中，引号，统一使用双引号

反序列化

import json  # 导入模块
dic = {"慕容美雪":(170,60,'赏花')}
ret = json.dumps(dic,ensure_ascii=False)  # 序列化时，不使用ascii码
res = json.loads(ret)  # 反序列化
print(type(res),res)  # 查看反序列化后的数据

执行输出：

<class 'dict'> {'慕容美雪': [170, 60, '赏花']}

从结果中，可以看出，原来的单引号由还原回来了。

反序列化，比eval要安全。所以eval尽量少用。

dump和load 是直接将对象序列化之后写入文件
依赖一个文件句柄

dump 将序列化内容写入文件

import json  # 导入模块
dic = {"慕容美雪":(170,60,'赏花')}
f = open('美雪','w',encoding='utf-8')
json.dump(dic,f)  # 先接收要序列化的对象，再接收文件句柄
f.close()

执行程序，查看文件美雪内容为：

{"\u6155\u5bb9\u7f8e\u96ea": [170, 60, "\u8d4f\u82b1"]}

要想文件写入中文，可以加参数ensure_ascii=False

import json  # 导入模块
dic = {"慕容美雪":(170,60,'赏花')}
f = open('美雪','w',encoding='utf-8')
json.dump(dic,f,ensure_ascii=False)  # 先接收要序列化的对象，再接收文件句柄
f.close()

执行程序，再次查看文件内容：

{"慕容美雪": [170, 60, "赏花"]}

load 读取文件中的序列化内容

import json  # 导入模块
dic = {"慕容美雪":(170,60,'赏花')}
f = open('美雪','r',encoding='utf-8')
ret = json.load(f)  #接收文件句柄
print(ret)  # 查看内容
print(type(ret))  # 查看变量类型
f.close()  # 最后记得关闭文件句柄

执行输出：

{'慕容美雪': [170, 60, '赏花']}
<class 'dict'>

其他参数

import json
data = {'username':['李华','二愣子'],'sex':'male','age':16}
json_dic2 = json.dumps(data,sort_keys=True,indent=4,separators=(',',':'),ensure_ascii=False)
print(json_dic2)

执行输出：

{
    "age":16,
    "sex":"male",
    "username":[
        "李华",
        "二愣子"
    ]
}

执行结果和PHP的pre输出很相似，也是格式化输出

参数说明：

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的值进行排序。

下面有3个字典，如何写入文件？

dic1 = {"S":(170,60,'唱歌')}
dic2 = {"H":(170,60,'唱歌')}
dic3 = {"E":(170,60,'唱歌')}

使用常规方法json.dump一行行写入，再次读取时，会报错。

下面介绍正确做法

写入多行

import json
dic1 = {"S":(170,60,'唱歌')}
dic2 = {"H":(170,60,'唱歌')}
dic3 = {"E":(170,60,'唱歌')}
f = open('she','a',encoding='utf-8')
f.write(json.dumps(dic1)+'\n')  # 写入一行内容，注意，一定要加换行符
f.write(json.dumps(dic2)+'\n')
f.write(json.dumps(dic3)+'\n')
f.close()  # 关闭文件句柄

执行程序，查看文件she内容：

{"S": [170, 60, "\u5531\u6b4c"]}
{"H": [170, 60, "\u5531\u6b4c"]}
{"E": [170, 60, "\u5531\u6b4c"]}

读取多行文件内容

import json
f = open('she','r',encoding='utf-8')
for i in f:
    print(json.loads(i.strip()))
f.close()

执行输出：

{'S': [170, 60, '唱歌']}
{'H': [170, 60, '唱歌']}
{'E': [170, 60, '唱歌']}

总结：

dumps序列化 loads反序列化只在内存中操作数据主要用于网络传输和多个数据与文件打交道
dump序列化 load反序列化主要用于一个数据直接存在文件里—— 直接和文件打交道

看下面一段代码：

import json
dic = {(170,60,'唱歌'):"S"}
print(json.dumps(dic))

执行报错：

get新知识点：

看python代码错误，要从下向上看。

第一个行，一般是错误点，看到蓝色的字体没有？鼠标单击一下，就会跳转，直接定位到错误在具体的哪一行

点击之后，看到是print这一行报错了

json不支持元组不支持除了str数据类型之外的key

pickle

用于python特有的类型和 python的数据类型间进行转换
pickle模块提供了四个功能：dumps、dump(序列化，存）、loads（反序列化，读）、load （不仅可以序列化字典，列表...可以把python中任意的数据类型序列化）

pickle的方法，和json是一样的，有4个

上一个例子的代码，pickle可以序列化

dumps 序列化

import pickle
dic = {(170,60,'唱歌'):"S"}
print(pickle.dumps(dic))

执行输出：

b'\x80\x03}q\x00K\xaaK<X\x06\x00\x00\x00\xe5\x94\xb1\xe6\xad\x8cq\x01\x87q\x02X\x01\x00\x00\x00Sq\x03s.'

输出结果是bytes类型的

dump 写入文件

文件模式必须带b，因为它是bytes类型

import pickle
dic = {(170,60,'唱歌'):"S"}
f = open('s','wb') #使用dump必须以+b的形式打开文件,编码不需要指定，因为是bytes类型
pickle.dump(dic,f)
f.close()  # 注意要关闭文件句柄

执行程序，查看文件，文件内容是乱码的

load 读取文件内容

import pickle
f = open('s','rb')  # bytes类型不需要指定编码
print(pickle.load(f))
f.close()  # 注意要关闭文件句柄

执行输出：

{(170, 60, '唱歌'): 'S'}

dump 写入多行内容

import pickle
dic1 = {"张靓颖":(170,60,'唱歌')}
dic2 = {"张韶涵":(170,60,'唱歌')}
dic3 = {"梁静茹":(170,60,'唱歌')}
f = open('singer','wb')
pickle.dump(dic1,f)
pickle.dump(dic2,f)
pickle.dump(dic3,f)
f.close()

执行程序，查看文件内容，是乱码的

load 读取文件内容

import pickle
f = open('singer','rb')
print(pickle.load(f))
print(pickle.load(f))
print(pickle.load(f))
print(pickle.load(f))  # 多读取一行，就会报错
f.close()

执行输出：

为了解决这个问题，需要用到while循环+try

import pickle
f = open('singer','rb')
while True:
    try:
        print(pickle.load(f))
    except Exception:  # 接收一切错误
        break  # 跳出循环
f.close()

执行输出：

{'张靓颖': (170, 60, '唱歌')}
{'张韶涵': (170, 60, '唱歌')}
{'梁静茹': (170, 60, '唱歌')}

总结：

json 在写入多次dump的时候不能对应执行多次load来取出数据，pickle可以
json 如果要写入多个元素可以先将元素dumps序列化，f.write(序列化+'\n')写入文件
　　读出元素的时候，应该先按行读文件，在使用loads将读出来的字符串转换成对应的数据类型

关于序列化自定义类的对象

class A:
    def __init__(self,name,age):
        self.name=name
        self.age=age
a = A('alex',80)
import json
json.dumps(a)

执行报错：

TypeError: <__main__.A object at 0x0000022B1BB2BF28> is not JSON serializable

json不能序列化对象

使用pickle序列化

import pickle
class A:
    def __init__(self,name,age):
        self.name=name
        self.age=age
a = A('alex',80)
ret = pickle.dumps(a)  # 序列化对象
print(ret)
obj = pickle.loads(ret)  # 反序列化
print(obj.__dict__)  # 查看对象属性<br>f.close()

执行输出：

b'\x80\x03c__main__\nA\nq\x00)\x81q\x01}q\x02(X\x04\x00\x00\x00nameq\x03X\x04\x00\x00\x00alexq\x04X\x03\x00\x00\x00ageq\x05KPub.'
{'name': 'alex', 'age': 80}

将对象a写入文件

import pickle
class A:
    def __init__(self,name,age):
        self.name=name
        self.age=age
a = A('alex',80)
f = open('a','wb')
obj = pickle.dump(a,f)
f.close()

执行程序，查看文件内容，是乱码的

假设是一款python游戏，就可以将人物的属性，写入文件。

再次登录时，就可以重新加载了。用pickle就比较方便了。

当删除一个类的时候（注释代码），再次读取文件，就会报错

import pickle
# class A:
#     def __init__(self,name,age):
#         self.name=name
#         self.age=age
# a = A('alex',80)
f = open('a','rb')
obj = pickle.load(f)
print(obj.__dict__)
f.close()

执行报错

AttributeError: Can't get attribute 'A' on <module '__main__' from 'E:/python_script/day25/test.py'>

提示找不到类A

将对象反序列时，必须保证该对象的类必须存在，否则读取报错

再次打开注释，执行以下，就正常了。

三、shelve

shelve也是python提供给我们的序列化工具，比pickle用起来更简单一些。
shelve只提供给我们一个open方法，是用key来访问的，使用起来和字典类似。

特点：

1、shelve模块是一个简单的key，value将内存数据通过文件持久化的模块。
2、shelve模块可以持久化任何pickle可支持的python数据格式。
3、shelve就是pickle模块的一个封装。
4、shelve模块是可以多次dump和load。

优点：轻量级，键值存储系统；

缺点：
适合读，不适合更新，在writeback时会把所有的数据都重新写入，结果就是可能消耗内存很多，写入耗时；
不能并发的读写，不过可以使用Unix文件锁进行控制（fcntl）；

import shelve  # python专有的序列化模块
f = shelve.open('shelve_file')  # 打开文件
f['key'] = {'int':10, 'float':9.5, 'string':'Sample data'}  #直接对文件句柄操作，就可以存入数据
f.close()

执行程序，会产生3个文件

shelve_file.bak

shelve_file.dat

shelve_file.dir

这和MySQL的MyISAM表，有点类似。创建一个表时，也会创建3个文件。

读取文件

import shelve
f1 = shelve.open('shelve_file')
existing = f1['key']  #取出数据的时候也只需要直接用key获取即可，但是如果key不存在会报错
f1.close()
print(existing)

执行输出：

{'string': 'Sample data', 'int': 10, 'float': 9.5}

这个模块有个限制，它不支持多个应用同一时间往同一个DB进行写操作。所以当我们知道我们的应用如果只进行读操作，我们可以让shelve通过只读方式打开DB

import shelve
f = shelve.open('shelve_file', flag='r')  # flag = 'r' 表示只读方式
existing = f['key']
f.close()
print(existing)

执行输出：

{'float': 9.5, 'int': 10, 'string': 'Sample data'}

修改变量

import shelve
f = shelve.open('shelve_file', flag='r')
f['key']['int'] = 50  # 修改一个值
existing = f['key']  # 取值
f.close()
print(existing)  # 打印结果

执行输出：

{'string': 'Sample data', 'int': 10, 'float': 9.5}

从结果上来，并没有改变，因为此时是只读模式

先把数据覆盖一次

import shelve
f = shelve.open('shelve_file')
f['key'] = {'int':10, 'float':9.5, 'string':'Sample data'}
f.close()

但是下面一种情况，是可以改变的

import shelve
f = shelve.open('shelve_file', flag='r')
f['key']['int'] = 50  # 不能修改已有结构中的值
f['key']['new'] = 'new'  # 不能在已有的结构中添加新的项
f['key'] = 'new'  # 但是可以覆盖原来的结构
existing = f['key']  # 取值
f.close()
print(existing)  # 打印结果

执行输出：

new

明明是只读，却可以改。说明有bug

shelve 尽量少用，有坑

新增一个属性

import shelve
#重新覆盖数据
f = shelve.open('shelve_file')
f['key'] = {'int':10, 'float':9.5, 'string':'Sample data'}  #直接对文件句柄操作，就可以存入数据
f.close()
 
#新增一个属性
f1 = shelve.open('shelve_file')
f1['key']['new_value'] = 'this was not here before'
print(f1['key'])
f1.close()

执行输出：

{'float': 9.5, 'int': 10, 'string': 'Sample data'}

发现新增的属性没有

由于shelve在默认情况下是不会记录待持久化对象的任何修改的，所以我们在shelve.open()时候需要修改默认参数，否则对象的修改不会保存。

import shelve
#新增一个属性
f1 = shelve.open('shelve_file', writeback=True)
f1['key']['new_value'] = 'this was not here before'
print(f1['key'])
f1.close()

执行输出：

{'new_value': 'this was not here before', 'string': 'Sample data', 'int': 10, 'float': 9.5}

新增的属性就出现了

writeback方式有优点也有缺点。优点是减少了我们出错的概率，并且让对象的持久化对用户更加的透明了；但这种方式并不是所有的情况下都需要，首先，使用writeback以后，shelf在open()的时候会增加额外的内存消耗，并且当DB在close()的时候会将缓存中的每一个对象都写入到DB，这也会带来额外的等待时间。因为shelve没有办法知道缓存中哪些对象修改了，哪些对象没有修改，因此所有的对象都会被写入。

shelve由很多坑，不建议使用
推荐使用Json和picker

三、hashlib模块

Python的hashlib提供了常见的摘要算法，如MD5，SHA1等等。

什么是摘要算法呢？摘要算法又称哈希算法、散列算法。它通过一个函数，把任意长度的数据转换为一个长度固定的数据串（通常用16进制的字符串表示）。

摘要算法就是通过摘要函数f()对任意长度的数据data计算出固定长度的摘要digest，目的是为了发现原始数据是否被人篡改过。

摘要算法之所以能指出数据是否被篡改过，就是因为摘要函数是一个单向函数，计算f(data)很容易，但通过digest反推data却非常困难。而且，对原始数据做一个bit的修改，都会导致计算出的摘要完全不同。

hash算法，每次执行，都会变。跟时间有关系

hash 哈希算法可hash数据类型——>数字的过程

hashlib —— 摘要算法
也是一些算法的集合，有好多算法
字符串 --> 数字
不同的字符串 --> 数字一定不同
无论在哪台机器上，在什么时候计算，对相同的字符串结果总是一样的
摘要过程不可逆

用法：
　　文件的一致性校验
　　密文验证的时候加密

比如文件下载

通过对文件做SHA1算法，判断下载的文件，和服务器的文件是否一致。就能知道文件是否下载完成。

密码验证

有一个密码文件，内容如下：

下划线左边是用户名，右边是密码

ALEX|ALEX3714
EGON|123456
NAZHA|9876543

假如这个文件泄露了，那么别人就可以直接登录了。

所有的密码，都不应该明文存储，必须通过算法转换才行
比如把ALEX3714转换成f58be8e9cb357ad3d59ec47b165c2b19

这段32位字符串，是无法解密成ALEX3714的

因为摘要过程不可逆

那么登录的时候，把密码通过算法转换，和文件的内容值做对比。如果一致，则登录成功。

下面介绍2种常用的算法

md5算法通用的算法
sha算法安全系数更高,sha算法有很多种，后面的数字越大安全系数越高，
　　得到的数字结果越长，计算的时间越长。目前最高是sha512

加密密码ALEX3714

import hashlib
m = hashlib.md5()
m.update('ALEX3714'.encode('utf-8'))  # update只接收bytes类型
print(m.hexdigest())  # 返回摘要,作为十六进制数据字符串值

执行输出：

f58be8e9cb357ad3d59ec47b165c2b19

返回结果是一个32位长度的十六进制数据字符串，结果是定长的。

hexdigest 这个单词，Pycharm没有自动补全。怎么记呢？hex表示十六进制，digest表示摘要

理论上来讲，md5不能反解

无论在哪台机器上，在什么时候计算，对相同的字符串结果总是一样的

针对这个特点，有专门的md5破解网站，将所有常见的密码，进行md5计算

将返回的摘要结果写入数据库，比如

123 -> 202cb962ac59075b964b07152d234b70
123456 -> e10adc3949ba59abbe56e057f20f883e
abc -> 900150983cd24fb0d6963f7d28e17f72
...

那么就可以通过摘要反向得出对应的密码

这种行为称之为暴力破解和撞库

为了确保存储的用户口令不是那些已经被计算出来的常用口令的MD5
通过对原始口令加一个复杂字符串来实现，俗称"加盐"：

1	`hashlib.md5("salt".encode("utf8"))`

经过Salt处理的MD5口令，只要Salt不被黑客知道，即使用户输入简单口令，也很难通过MD5反推明文口令。

对12345做加盐处理

import hashlib
m = hashlib.md5('wahaha'.encode('utf-8'))
m.update('123456'.encode('utf-8'))
print(m.hexdigest())

执行输出：

d1c59b7f2928f9b1d63898133294ad2c

将这段密文复制到一下网站

http://www.cmd5.com/

就不那么容易反解出来了

我擦勒，特么的，计算出来了？？？

请忽略我说的上一句话

注册和登录校验，都要用加盐
就算数据库泄露，也不影响，因为加盐了
除非盐被泄露了，才能破解登录

黑客注册500个用户，密码都不一样
只要拿到数据库，通过一定的规律，也可以反解出来加密盐
那怎么办呢？

有更高级的办法，动态加盐

import hashlib
username = 'alex'  # 用户名
m = hashlib.md5(username.encode('utf-8'))  # 密码盐为用户名
m.update('123456'.encode('utf-8'))
print(m.hexdigest())

执行输出：

94e4ccf5e2749b0bfe0428603738c0f9

因为每个用户名是不一样的,即便是注册了500个账号,也不能随便破解

再高级一点的密码盐

import hashlib
username = 'alex'  # 用户名
m = hashlib.md5(username[:2:2].encode('utf-8'))  # 密码盐为用户名
m.update('123456'.encode('utf-8'))
print(m.hexdigest())

执行输出：

dc483e80a7a0bd9ef71d8cf973673924

再试一波看看

卧槽！不行，我得再升级一下

双层密码盐

import hashlib
username = 'alex'  # 用户名
salt = 'what the fuck!叫你破解!叫你破解!你来啊!!!'
m = hashlib.md5((username+salt).encode('utf-8'))  # 双层密码盐
m.update('123456'.encode('utf-8'))
print(m.hexdigest())

我就不信这个邪!

看吧，破解不了吧。

只要加盐方法，不被泄露就行。登录以及注册，务必要加盐。

posted @ 2018-04-20 16:40 肖祥阅读(677) 评论(0) 编辑收藏举报

刷新页面返回顶部

登录后才能查看或发表评论，立即登录或者逛逛博客园首页

公告

凛冬将至,群狼可活,孤狼必死!

独立博客：
http://www.py3study.com

昵称：肖祥
园龄： 7年
粉丝： 382
关注： 15

+加关注

2025年3月

日

一

二

三

四

五

六

肖祥

python 全栈开发，Day25(复习,序列化模块json,pickle,shelve,hashlib模块)

一、复习

二、序列化模块json,pickle,shelve

三、shelve

三、hashlib模块

公告

搜索

常用链接

我的标签

随笔分类

随笔档案

阅读排行榜

评论排行榜

推荐排行榜

最新评论