一、复习

反射 必须会 必须能看懂 必须知道在哪儿用

　　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 Trueobj_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 jsondata = {'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 jsondic1 = {"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 jsonf = 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 jsondic = {(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 pickledic = {(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 pickledic = {(170,60,'唱歌'):"S"}f = open('s','wb') #使用dump必须以+b的形式打开文件,编码不需要指定，因为是bytes类型pickle.dump(dic,f)f.close()  # 注意要关闭文件句柄

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

 

 load 读取文件内容

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

执行输出：

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

 

dump 写入多行内容

import pickledic1 = {"张靓颖":(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 picklef = open('singer','rb')print(pickle.load(f))print(pickle.load(f))print(pickle.load(f))print(pickle.load(f))  # 多读取一行，就会报错f.close()

执行输出：

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

import picklef = 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=agea = A('alex',80)import jsonjson.dumps(a)

执行报错：

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

json不能序列化对象

 

使用pickle序列化

import pickleclass A:    def __init__(self,name,age):        self.name=name        self.age=agea = A('alex',80)ret = pickle.dumps(a)  # 序列化对象print(ret)obj = pickle.loads(ret)  # 反序列化print(obj.__dict__)  # 查看对象属性 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 pickleclass A:    def __init__(self,name,age):        self.name=name        self.age=agea = 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 shelvef1 = 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 shelvef = shelve.open('shelve_file', flag='r')  # flag = 'r' 表示只读方式existing = f['key']f.close()print(existing)

执行输出：

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

 

修改变量

import shelvef = 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 shelvef = shelve.open('shelve_file')f['key'] = {'int':10, 'float':9.5, 'string':'Sample data'}f.close()

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

import shelvef = 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|ALEX3714EGON|123456NAZHA|9876543

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

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

比如把ALEX3714转换成f58be8e9cb357ad3d59ec47b165c2b19

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

因为摘要过程不可逆

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

 

下面介绍2种常用的算法

md5算法 通用的算法

sha算法 安全系数更高,sha算法有很多种，后面的数字越大安全系数越高，

　　得到的数字结果越长，计算的时间越长。目前最高是sha512

 

加密密码ALEX3714

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

执行输出：

f58be8e9cb357ad3d59ec47b165c2b19

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

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

 

理论上来讲，md5不能反解

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

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

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

123 -> 202cb962ac59075b964b07152d234b70123456 -> e10adc3949ba59abbe56e057f20f883eabc -> 900150983cd24fb0d6963f7d28e17f72...

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

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

为了确保存储的用户口令不是那些已经被计算出来的常用口令的MD5

通过对原始口令加一个复杂字符串来实现，俗称"加盐"：

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

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

对12345做加盐处理

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

执行输出：

d1c59b7f2928f9b1d63898133294ad2c

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

http://www.cmd5.com/

就不那么容易反解出来了

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

请忽略我说的上一句话

 

注册和登录校验，都要用加盐

就算数据库泄露，也不影响，因为加盐了

除非盐被泄露了，才能破解登录

 

黑客注册500个用户，密码都不一样

只要拿到数据库，通过一定的规律，也可以反解出来加密盐

那怎么办呢？

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

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

执行输出：

94e4ccf5e2749b0bfe0428603738c0f9

 

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

 

再高级一点的密码盐

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

执行输出：

dc483e80a7a0bd9ef71d8cf973673924

再试一波看看

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

 

双层密码盐

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

我就不信这个邪!

看吧，破解不了吧。

 

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