python中包的解释，用法。json&pickle模块，以及哈希用法

2020.7.29：一起Python零基础走天下哈

1.包的使用（4*）

1.什么是包

官网解释

包是一种通过使用‘.模块名’来组织python模块名称空间的方式。

我们的理解具体为

包就是一个包含有init.py文件的文件夹，所以其实我们创建包的目的就是为了用文件夹将文件/模块组织起来

需要强调的是

1. 在python3中，即使包下没有init.py文件，import 包仍然不会报错，而在python2中，包下一定要有该文件，否则import 包报错
　　2. 创建包的目的不是为了运行，而是被导入使用，记住，包只是模块的一种形式而已，包的本质就是一种模块

为什么我们要使用包

• 包的本质就是一个文件夹，那么文件夹唯一的功能就是将文件组织起来
• 随着功能越写越多，我们无法将所以功能都放到一个文件中，
• 于是我们使用模块去组织功能，而随着模块越来越多，
• 我们就需要用文件夹将模块文件组织起来，以此来提高程序的结构性和可维护性

使用包所需要注意的地方

• 1.关于包相关的导入语句也分为import和from … import …两种，但是无论哪种，无论在什么位置，在导入时都必须遵循一个原则：

  在导入时带点的，点的左边都必须是一个包，否则非法。可以带有一连串的点，

• 2、import导入文件时，产生名称空间中的名字来源于文件，import 包，产生的名称空间的名字同样来源于文件，即包下的__init__.py，导入包本质就是在导入该文件

• 3、包A和包B下有同名模块也不会冲突，如A.a与B.a来自俩个命名空间

2.包的使用之import

基于此结构使用的示例：

示例：在aaa文件下的init.py文件里使用import操作

#牢记点：
     #单独导入包名称时不会导入包中所有包含的所有子模块

#aaa的init.py文件中的代码
import aaa.m1
#执行文件中代码
import aaa
aaa.f1()

#结果
Traceback (most recent call last):
  File "E:/code/s15-20day/1  .包的使用.py", line 8, in <module>
    aaa.f1()
AttributeError: module 'aaa' has no attribute 'f1'
 #错误原因就是上述的原因

解决方法：

#aaa的init.py文件中的代码
from .m1 import f1
#执行文件中代码
import aaa
aaa.f1()

#结果
m1.f1

3.包的使用之from … import …

• 需要注意的是from后import导入的模块，必须是明确的一个不能带点，否则会有语法错误，如：from a import b.c是错误语法

  基于此结构使用的示例：

示例：在aaa文件下的init.py文件里使用import操作

#aaa的init.py文件中的代码
from aaa.m1 import * #*就代表所有函数，也可以在m1文件内设置能被*拿取的函数名是哪些。下同
from aaa.m2 import *
from aaa.m3 import *
from aaa.bbb.mm1 import *
from aaa.bbb.mm2 import *
from aaa.bbb.mm3 import *
#执行文件中代码
print('')
print('m1','='*20)
print('')
aaa.f1()
aaa.f2()
aaa.f3()
print('')
print('m2','='*20)
print('')
aaa.ff1()
aaa.ff2()
aaa.ff3()
print('')
print('m3','='*20)
print('')
aaa.fff1()
aaa.fff2()
aaa.fff3()
print('')
print('mm11','='*20)
print('')
aaa.m1()
aaa.m2()
aaa.m3()
aaa.m4()
print('')
print('mm2','='*20)
print('')
aaa.mm1()
aaa.mm2()
aaa.mm3()
aaa.mm4()
print('')
print('mm3','='*20)
print('')
aaa.mmm1()
aaa.mmm2()
aaa.mmm3()
aaa.mmm4()

#结果
==================== 惊喜加惊讶 ====================

m1 ====================

m1.f1
m1.f2
m1.f3

m2 ====================

m2.ff1
m2.ff2
m2.ff3

m3 ====================

m3.fff1
m3.fff2
m3.fff3

mm11 ====================

mm1.m1
mm1.m2
mm1.m3
mm1.m4

mm2 ====================

mm2.mm1
mm2.mm2
mm2.mm3
mm2.mm4

mm3 =========fd===========

mm3.mmm1
mm3.mmm2
mm3.mmm3
mm3.mmm4

Process finished with exit code 0

4.绝对导入和相对导入

• 我们的最顶级包aaa是写给别人用的，然后在aaa包内部也会有彼此之间互相导入的需求，这时候就有绝对导入和相对导入两种方式：

• 1.绝对导入：以aaa作为起始

• 相对导入：用.或者…的方式最为起始（只能在一个包中使用，不能用于不同目录内）

  基于此结构使用的示例：

• 例如：

  #绝对导入
  
  #在mm2中想要调用m2
  from aaa.m2 import *
  #相对导入
  
  #在mm1中想要调用m1
  from ..m1 import *
  

5、包以及包所包含的模块都是用来被导入的，而不是被直接执行的。而环境变量都是以执行文件为准的

6.绝对导入与相对导入总结

绝对导入与相对导入

# 绝对导入: 以执行文件的sys.path为起始点开始导入,称之为绝对导入
#        优点: 执行文件与被导入的模块中都可以使用
#        缺点: 所有导入都是以sys.path为起始点,导入麻烦

# 相对导入: 参照当前所在文件的文件夹为起始开始查找,称之为相对导入
#        符号: .代表当前所在文件的文件加,..代表上一级文件夹,...代表上一级的上一级文件夹
#        优点: 导入更加简单
#        缺点: 只能在导入包中的模块时才能使用
　　　　  #注意:
　　　　　　　　1. 相对导入只能用于包内部模块之间的相互导入,导入者与被导入者都必须存在于一个包内
　　　　　　　　2. attempted relative import beyond top-level package # 试图在顶级包之外使用相对导入是错误的,言外之意,必须在顶级包内使用相对导入,每增加一个.代表跳到上一级文件夹,而上一级不应该超出顶级包

2.json&pickle模块

1、什么是序列化与反序列化

• 内存中某一类的数据---------------》特殊的格式
• 内存中某一类的数据《---------------特殊的格式

2、为何要序列化

​ 1、存档：把内存中的数据持久化到硬盘**
​ 2、跨平台交互数据**

• 在python中：
  存档=》推荐用pickle格式
  跨平台交互=》推荐用json格式

3、如何序列化

一.以前的序列化方法：比较low的

1.序列化
items=["圣剑","蝴蝶","BKB"]

dic_str=str(items)

with open('db.txt',mode='wt',encoding="utf-8") as f:
    f.write(dic_str)

2.反序列化
with open('db.txt',mode='rt',encoding='utf-8') as f:
    data=f.read()  # "['圣剑', '蝴蝶', 'BKB']"

    items=eval(data)
    print(items[0])

二：现在的序列化方法：json

• 优点：跨平台交互数据
• 缺点：无法识别所有的python数据类型
• 注意：json格式的字符串里不能包含单引号

import json  #盗用json 模块
序列化方式一： #dumps 与loads 合用
t={"a":1,"b":2}  # 字典=======》json格式的字符串：{"a":1,"b":2}
res=json.dumps(t)
print(res,type(res))
with open("a.json",mode='wt',encoding='utf-8') as f:
    f.write(res)
json反序列化方式一：
with open("a.json",mode='rt',encoding='utf-8') as f:
    data=f.read()
    dic=json.loads(data)
    print(dic,type(dic))
    
json序列化方式二： #dump 与load 合用
t={"a":1,"b":2}  # 字典=======》json格式的字符串："[1,2,3]"
with open("b.json",mode='wt',encoding='utf-8') as f:
    json.dump(t,f)
json反序列化方式二：
with open("b.json",mode='rt',encoding='utf-8') as f:
    dic=json.load(f)
    print(dic,type(dic))

三:现在的序列化方法:pickle

• 优点：可以识别所有python类型

• 缺点：只能用于python中，无法跨平台交互

  具体操作与json格式是一样的，这里就不多做累赘的解释了。

3.hashlib模块

hash是一种算法（md5sha256sha512等），我们为该算法传入内容，该算法会计算得到一串hash值

hash值具备以下三个特点：

• 1、如果传入的内容一样，并且采用hash算法也一样，那么得到个hash值一定是一样的
• 2、hash值的长度取决于采用的算法，与传入的文本内容的大小无关
• 3、hash值不可逆

输入字符不变情况下：

执行文件一：

import hashlib
m=hashlib.md5()
m.update("你好".encode('utf-8'))
m.update("egon".encode('utf-8'))
m.update("哈哈哈".encode('utf-8'))  # "你好egon哈哈哈"
res=m.hexdigest()
print(res)

结果：

824cb1b104e36de8f98ef38fbee759a5

执行文件二：

import hashlib
m1=hashlib.md5("你".encode('utf-8'))
m1.update("好eg".encode('utf-8'))
m1.update("on哈哈哈".encode('utf-8'))  # "你好egon哈哈哈"
res=m1.hexdigest()
print(res)

结果：

824cb1b104e36de8f98ef38fbee759a5

数据修改的情况下

执行文件三：

import hashlib
m1=hashlib.md5("你".encode('utf-8'))
m1.update("好eg".encode('utf-8'))
m1.update("on".encode('utf-8'))
m1.update("_sb哈哈哈".encode('utf-8'))  # "你好egon_sb哈哈哈"
res=m1.hexdigest()
print(res)

结果：

81fc3b364325cdd079f9baff7a8b6c95

图片的哈希值

执行文件四：

import hashlib
m2=hashlib.md5()
with open('aaa.png',mode='rb') as f:
    for line in f:
        m2.update(line)
print(m2.hexdigest())

结果：

14c1bbbb06ba99319a42e89074346d5d

对哈希值进行加密

执行文件五：

pwd="123"
m3=hashlib.md5()
m3.update("天王盖地虎".encode('utf-8'))
m3.update(pwd.encode('utf-8')) # "天王盖地虎123小鸡炖蘑菇"
m3.update("小鸡炖蘑菇".encode('utf-8'))
print(m3.hexdigest())

结果：

11d69510db5f5a4a87f56b7fc58dc8d2