返回顶部

模块

  1. 自定义模块

  2. 模块是什么？

    抖音：40万行20万行代码全部放在一个py文件中?

    为什么不行?

    1. 代码太多，读取代码耗时太长。
    2. 代码不易维护。

    所以我们怎么样？

    一个py文件拆分100个文件，100个py文件又具有相似相同的功能，冗余.此时你要将100个py文件中相似相同的函数提取出来, input 功能,print()功能, time.time() os.path.....放在一个文件，当你想用这个功能拿来即用，类似这个py文件：常用的相似的功能集合，模块。

  3. 为什么要有模块?

    • 拿来主义,提高开发效率.
    • 便于管理维护.
    • 什么是脚本？
      • 脚本就是py文件，长期保存代码的文件

  4. 模块的分类

    1. 内置模块200种左右，python解释器自带的模块，time os sys hashlib等等

    2. 第三方模块6000种 ，一些大牛大神写的，非常好用

      pip install 需要这个指令安装的模块，Beautiful_soup,request,Django,flask等等

    3. 自定义模块，自己写的一个py文件

  5. import 的使用

    import 模块 先要怎么样?

    import tbjx 执行一次tbjx这个模块里面的所有代码,

    第一次引用tbjx这个模块,会将这个模块里面的所有代码加载到内存,只要你的程序没有结束,接下来你在引用多少次,它会先从内存中寻找有没有此模块,如果已经加载到内存,就不在重复加载.

    • 第一次导入模块执行的三件事***

        1. 在内存中创建一个以 tbjx命名的名称空间
        2. 执行此名称空间所有的可执行代码（将tbjx.py文件中所有的变量与值的对应加载到这个名称空间）
        3. 通过tbjx.的方式引用模块里面的代码。
        import tbjx
print(tbjx.name)
tbjx.read1()

      • 被导入模块有独立的名称空间***

      import tbjx
# name = 'alex'
# print(name)
# print(tbjx.name)

#
# def read1():
#     print(666)
# tbjx.read1()
#

# name = '日天'
# tbjx.change()
# print(name)  # 日天
# print(tbjx.name)  # barry

    • 为模块起别名**

        1. 简单，便捷
        import hhhhhhadj as ho
print(ho.name)
        1. 有利于代码的简化
        # 原始写法
# result = input('请输入')
# if result == 'mysql':
#     import mysql1
#     mysql1.mysql()
# elif result == 'oracle':
#     import oracle1
#     oracle1.oracle()
# list.index()
# str.index()
# tuple.index()
# 起别名
result = input('请输入：')
if result =='mysql':
	import mysql1 as sm
elif result == 'oracle':
     import oracle1 as sm
# ''' 后面还有很多'''
# sm.db()  # 统一接口,归一化思想

      • 导入多个模块

        import time,os,sys#这样写不好
#应该像下面这样写
import time
import os
import sys

  6. from ... import...的使用

    # from tbjx import name
# from tbjx import read1
# from tbjx import read2
# print(name)
# print(globals())
# read1()

    • from ... import ... 与import对比 ***

      1. from.. import 用起来更方便
      from tbjx import name
print(name)
      1. from ...import 容易与本文件的名字产生冲突
      容易产生冲突，后者将前者覆盖
# name = 'alex'
# from tbjx import name
# print(name)
      1. 当前位置直接使用read1和read2 ，执行时仍然以tbjx.py文件全局名称空间***
      # from tbjx import read1
#
# def read1():
#     print(666)

# name = '大壮'
# read1()
# print(globals())

from tbjx import change
name = 'Alex'
print(name)  # 'Alex'
change()  # 'barry'
from tbjx import name
print(name)

    • 一行导入多个

      from tbjx import name,read1,read2  # 这样不好
from tbjx import name
from tbjx import read1

    • from ... import *

    • 模块循环导入的问题

    • py文件的两种功能

      1. 自己用脚本
      2. 被别人应用，模块使用

prrint('from the tbjx.py')

__all__ = ['name','read1']
 name = '太白金星'

 def read1():
     print('tbjx模块：', name)

def read2() :print('tbjx模块') read1()

def change():
	global name
	name = 'holting'
	print(name)

print(__name__)
当作为脚本： __name__ == __main__ 返回True
当作为模块： __name__ == 模块名 
# __name__ 根据文件的扮演的角色(脚本,模块)不同而得到不同的结果
 #1 模块需要调试时，加上 if __name__ =='__main__':
 import time
 change()#测试代码
if __name == '__main__':
	change()
2 作为项目的启动文件需要用
  • 模块的搜索路径***
import holting
import abc
#python 解释器会自动将一些内置内容(内置函数，内置模块等等)加载到内存中
import sys
print(sys.modules) # 内置内容(内置函数,内置模块等等)
import time

print(sys.path)
#['D:\\python_22\\day17', 'C:\\Python\\Python36\\python36.zip', 'C:\\Python\\Python36\\DLLs', 'C:\\Python\\Python36\\lib', 'C:\\Python\\Python36', 'C:\\Python\\Python36\\lib\\site-packages']
# 'D:\\python_22\\day17' 路径是当前执行文件的相对路径

如果你想要引用你自定义的模块：
要不你就将这个模块放到当前目录下面，要不你就手动添加到sys.path

import sys
sys.path.append(r'D:\python_22\day1')
#sys.path 会将你的 当前目录的路径加载到列表中
import holting
  • import holting
    1. 先从内存中寻找有没有已经存在的以 holting 命名的名称空间.
    2. 它会从内置的模块中找. time,sys,os,等等.
    3. 他从sys.path中寻找.

  1. json pickle 模块

    序列化模块：将一种数据结构（list tuple dict ...）转化成特殊的序列

    为什么存在序列化？

    数据----> bytes

    只有字符串和bytes 可以互换

    dict , list...--->str <------> bytes

    数据存储在文件中，str （bytes类型）形式存储，比如字典

    数据通过网络传输（bytes类型）str不能还原回去

    特殊的字符串：序列化

    序列化模块：

json模块：

  1. 不同语言都遵循的一种数据转化格式，即不同语言都使用的特殊字符串。（比如Python的一个列表[1, 2, 3]利用json转化成特殊的字符串，然后在编码成bytes发送给php的开发者，php的开发者就可以解码成特殊的字符串，然后在反解成原数组(列表): [1, 2, 3]）

  2. json序列化只支持部分Python数据库结构： dict,list,tuple,str,int,float,Ture,False,None

    l1 = [i for i in range(10000)]
# l1 --->bytes
# b1 = l1.encode('utf-8')  # 不能直接转换
#l1转化为字符串再转化成bytes
s1 = str(l1)
b1 = s1.encode('utf-8')
print(b1)

s2 = b1.decode('utf-8')
print(s2,type(s2))


# dic = {'username': '太白', 'password': 123,'status': True}
import json
## dumps loads 主要用于网络传输，但是也可以读写文件
特殊的字符串
st = json.dumps(dic,ensure_ascii=False)不使用ASCII
 print(st,type(st))
#反转回去
dic1 = json.loads(st)
print(dic1,type(dic1))

import json
# 写入文件
# l1 = [1, 2, 3, {'name': 'alex'}]
# 转化成特殊的字符串写入文件
# with open('json文件',encoding='utf-8',mode='w') as f1:
#     st = json.dumps(l1)
#     f1.write(st)

# 读取出来还原回去
# with open('json文件',encoding='utf-8') as f2:
#     st = f2.read()
#     l1 = json.loads(st)
#     print(l1,type(l1))
# 特殊的参数
# l1 = [1, 2, 3, {'name': 'alex'}]
# #dump load 只能写入文件，只能写入一个数据结构
# with open('json文件1',encoding='utf-8',mode='w') as f1:
#     json.dump(l1,f1)
#
# #读取数据
# with open('json文件1',encoding='utf-8') as f2:
#     l1 = json.load(f2)
#     print(l1,type)

 #dump load 只能写入文件，只能写入一个数据结构
# 一次写入文件多个数据怎么做?dumps loads

# 错误示例:
# dic1 = {'username': 'alex'}
# dic2 = {'username': '太白'}
# dic3 = {'username': '大壮'}
# with open('json文件1',encoding='utf-8',mode='w') as f1:
#     json.dump(dic1,f1)
#     json.dump(dic2,f1)
#     json.dump(dic3,f1)

# 读取数据
# with open('json文件1',encoding='utf-8') as f1:
#     print(json.load(f1))
    # print(json.load(f1))
    # print(json.load(f1))


# 正确写法:

dic1 = {'username': 'alex'}
dic2 = {'username': '太白'}
dic3 = {'username': '大壮'}
with open('json文件1',encoding='utf-8',mode='w') as f1:
    f1.write(json.dumps(dic1) + '\n')
    f1.write(json.dumps(dic2) + '\n')
    f1.write(json.dumps(dic3) + '\n')

with open('json文件1',encoding='utf-8') as f2:
    for i in f2:
        print(json.loads(i))

    pickle 模块：

    1. 只能是Python 语言遵循的一种数据转化格式，只能在Python语言中使用。
    2. 支持Python 所有的数据类型包括实例化对象。
    l1 = [1, 2, 3, {'name': 'alex'}]

# dumps loads 只能用于网络传输
# import pickle
# st = pickle.dumps(l1)
# print(st)  # bytes
#
# l2 = pickle.loads(st)
# print(l2,type(l2))

# dump load 直接写入文件
# import pickle
# dic1 = {'name':'oldboy1'}
# dic2 = {'name':'oldboy2'}
# dic3 = {'name':'oldboy3'}
#
# f = open('pick多数据',mode='wb')
# pickle.dump(dic1,f)
# pickle.dump(dic2,f)
# pickle.dump(dic3,f)
# f.close()
# import pickle
# f = open('pick多数据',mode='rb')
# print(pickle.load(f))
# print(pickle.load(f))
# print(pickle.load(f))
# f.close()

import pickle
def func():
    print('in func')

# f = open('pick对象',mode='wb')
# pickle.dump(func,f)
# f.close()

# f = open('pick对象', mode='rb')
# ret = pickle.load(f)
# print(ret)
# ret()

    1. hashlib模块

      包含很多的加密算法，MD5，sha1,sha256 sha512......

      用途：

      1. 密码加密，不能以明文的形式存储面，密文的形式
      2. 文件的校检

      用法：

      1. 将bytes类型字节 转化成 固定的16进制数字组成的字符串
      2. 不同的bytes利用相同的算法(MD5)转化结果不一定相同
      3. 相同的bytes利用相同的算法(MD5)转化成的结果一定相同.
      4. hashlib算法不可逆(MD5中国王晓云破解了).
      # import hashlib
# s1 ='holting'
# ret = hashlib.md5()
# ret.update(s1.encode('utf-8'))
# print(ret.hexdigest())#4172617e54212b022cb08dfc97ba9699

#相关练习
# import hashlib
# def MD5(pwd):
#     ret = hashlib.md5()
#     ret.update(pwd.encode('utf-8'))
#     return ret.hexdigest()

# def register():
#     usename = input('请输入用户名：').strip()
#     password = input('请输入密码：').strip()
#     password_md5 = MD5(password)
#     with open('register',encoding='utf-8',mode='a') as f:
#         f.write(f'\n{usename}|{password}')
# register()

# def login():
#     username = input('请输入用户名:').strip()
#     password = input('请输入密码:').strip()
#     password_md5 = MD5(password)

#普通加密
import hashlib
# s1 = 'kfdslfjasdlfgjsdlgkhsdafkshdafjksdfsdkfhjsdafj老fhdskafhsdkjfdsa男孩教育'
# s2 = 'kfdslfjasdlfgjsdlgkhsdafkshdafjksdfsdkfhjsdafj老fhdskafhsdkjfdsa男孩教育'
# ret = hashlib.md5()
# ret.update(s1.encode('utf-8'))#18f127c24462dd59287798ea5c0c0c2f
# print(ret.hexdigest())

# s2 = '19890425'
# ret = hashlib.md5()
# ret.update(s2.encode('utf-8'))
# print(ret.hexdigest())  # 6e942d04cf7ceeeba09e3f2c7c03dc44

#加盐
s2 = '19890425'
ret = hashlib.md5('holting'.encode('utf-8'))
ret.update(s2.encode('utf-8'))
print(ret.hexdigest())  # 5da2c13f97e5fe77150d1d7fad9a4813

#动态的盐
s2 = '19890425'
ret = hashlib.md5('holting'[::2].encode('utf-8'))
ret.update(s2.encode('utf-8'))
print(ret.hexdigest())  # 709fc064795ec01c6869e01cd518df46


# sha系列  金融类,安全类.用这个级别.
# 随着sha系列数字越高,加密越复杂,越不易破解,但是耗时越长.
s2 = '198fdsl;fdsklgfjsdlgdsjlfkjsdalfksjdal90425'
ret1 = hashlib.sha3_384()
ret1.update(s2.encode('utf-8'))
print(ret1.hexdigest())#60f72e38bb13b449c4cc8fe7882d3215fc6ae47e9e9e2fb571bae632bf1be14150625d2b802467eb5f74b482091962d2

# 文件的校验

# linux中一切皆文件: 文本文件,非文本文件,音频,视频,图片....
# 无论你下载的视频,还是软件(国外的软件),往往都会有一个md5值

# 6217ce726fc8ccd48ec76e9f92d15feecd20422c30367c6dc8c222ab352a3ec6  *pycharm-professional-2019.1.2.exe

s1 = '我叫holting 今年180岁'
# rett = hashlib.sha3_224()
# rett.update(s1.encode('utf-8'))
# print(rett.hexdigest())#da1c778d08cf1b4479c5ff33813ff7341ac894fa7a4e5e7862a8b4bb

rett = hashlib.sha3_224()
rett.update('我叫'.encode('utf-8'))
rett.update('holting 今年'.encode('utf-8'))
rett.update('180岁'.encode('utf-8'))
print(rett.hexdigest())#da1c778d08cf1b4479c5ff33813ff7341ac894fa7a4e5e7862a8b4bb

#low版效验：
def file_md5(path):
    rret = hashlib.sha256()
    with open(path,mode='rb') as f1:
        b1= f1.read()
        print(b1)
        ret.update(b1)
    return rret.hexdigest()
result =file_md5('pycharm-professional-2019.1.2.exe')
print(result)  # 6217ce726fc8ccd48ec76e9f92d15feecd20422c30367c6dc8c222ab352a3ec6

# 高大上版
posted @ 2020-07-18 16:47  holting  阅读(96)  评论(0)  编辑  收藏  举报