python重要内置模块

目录

• • 包的概念
  • 包的具体使用
  • 编程思想的转变
  • 常用内置模块之collections模块 (收集)
  • 常用内置模块之time模块 (时间)
  • 常用内置模块之random模块 (随机)
• os模块
• sys模块
• json模块
• json模块的实战练习
• hashiib加密模块
• subprocess模块
• logging日志模块
• 日志配置文件
• pickle模块

包的概念

1.什么是包？
一个内部含有多个模块文件的文件夹(且其中一个文件为__init__.py文件)

包的具体使用

1，创建包
在python2中创建包时必须含有__init__.py文件，但是在python3中不需要。但是建议我们在任何时候创建包都加入__init__.py文件

2.如果导入包中的部分模块
  from 包名 import md1
  from 包名 import md1,md2 #跟导入模块操作一样，

3.如果直接导入包名
  import 包名
  #导入包名 其实就是导入了包下面的__init__.py文件，该文件里有什么变量名都可以通过包名加.的方式执行。

编程思想的转变

1.面条阶段  （新手阶段）
  写出的代码像面条一样全部堆积在一起，都在一个文件中 

2.函数阶段   （少年阶段）
  根据不同的功能 写出不同封装好的函数 然后调用 

3.模块阶段    （成熟阶段）
  根据不同的功能 拆分成不同模块的py文件，然后在使用的时候互相调用

'''
1.第一阶段比较杂乱无章，把所有的代码都放在一个文件中 比较难管理和维护
2.第二阶段 只是做了一个简单的小分类 在稍微大一点的项目中效率还是很低
3.第三阶段 开发效率高 易读性高 维护成本低
'''

常用内置模块之collections模块 (收集)

1，具名元组：namedtuple
   from collections import namedtuple
   可以把元组编出一个有名字的
   变量名 = namedtuple(元组名，['数据名'，'数据名'])
   print(变量名) # 变成了一个可执行的对象 可以根据数据名传参
   res = a('8','9') #用一个变量名接收 a的传参执行结果
   print(res) #元组名(数据名='8',数据名='9')

  代码展示：
    from collections import namedtuple
    a = namedtuple('纸牌',['点数','花色'])
    res = a('8','红桃')
    print(res)    # 纸牌(点数='8'花色='红桃')
    print(res.点数) # '8'
    print(res.花色) # '红桃'
    #可以给元组内的数据 有一个明确的名字

2.队列与堆栈：deque
  队列：先进先出
  堆栈：先进后出
  from collections import deque
  可以实现在快速在列表头部添加或删除元素
  a = deque(['moon','sksk','tom','sum'])
  a.append('s1')
  a.appendleft('s2')
  a.insert(0,'s3')
  a.popleft()   #直接删除最头部元素
  print(a)

常用内置模块之time模块 (时间)

import time
'''
时间的3种表现形式
 		1.时间戳 秒数（它指的是从19701月1日零时零分零秒至现在时间的总秒数）
 		2.结构化时间 （主要是给计算机看的）
 		3.格式化时间（主要是给人看的）
'''

import time
print(time.time())  # 打印时间戳 1666170636.043264
print(time.localtime())
# 结构化时间 tm_year=2022, tm_mon=10, tm_mday=19, tm_hour=17, tm_min=10, tm_sec=36, tm_wday=2, tm_yday=292, tm_isdst=0
print(time.strftime('%Y年 %m月 %d日 ')) #2022年 10月 19日
print(time.strftime('%Y %m %d %H %M %S')) #2022 10 19 17 10 36
print(time.strftime('%Y年 %m月 %d日 %H时 %M分 %S秒'))#2022年 10月 19日 17时 10分 36秒
print(time.strftime('%Y %m %d %X')) # 2022 10 19 17 11 42

from datetime import date, datetime
'''
datetime 年月日时分秒
date     年月日
time 		 时分秒
'''
print(datetime.datetime.now())  #打印 现在的时间 年月日时分秒
print(date.today())     # 打印今天的日期 2022-10-19
print(datetime.today())  # 打印今天的时间 2022-10-19 18:28:21
print(datetime.utcnow()) #打印获取的是世界标准时区的当前时间
c = datetime(2018,5,28,12,21,21)
print(c)   #2018-05-28 12:21:21 打印指定的时间

将获取的字符串转换为datetime类型

from datetime import datetime
d = datetime.strptime('2017/9/30','%Y/%m/%d')
print(d)  # 2017-09-30 00:00:00
e = datetime.strptime('2017年9月30日星期六','%Y年%m月%d日星期六')
print(e)# 2017-09-30 00:00:00
e=datetime.strptime('2017年9月30日星期六','%Y年%m月%d日星期六')
print(e)# 2017-09-30 00:00:00
h=datetime.strptime('9/30/2017 8:42:50 ','%m/%d/%Y %H:%M:%S ')
print(h)# 2017-09-30 08:42:50
使用关键词strptime 可以把接收到的字符串转换成时间

添加时间
import datetime
a = datetime.date.today() #2022-10-19
b = datetime.timedelta(days = 3)  #3 days, 0:00:00
print(a+b)    # 2022-10-22
#关键字 timedelta 时间长度的意思

c = datetime.timedelta(minutes=20) # 20分钟的意思
print(a+c) 

常用内置模块之random模块 (随机)

import random

random.random() #随机产生0-1之间的小数
random.randint(1,10) #随机产生1-10之间的整数
random.randrange(1,10,2)#随机产生1-10之间的整数 步长为2 13579 默认步长为1
random.choice(['1', '2', '3', '4']) #随机列表中的元素
random.choices(['1', '2', '3', '4']) #随机列表中的元素 并保留原格式['1']
random.sample(['1', '2', '3', '4'],2) #可以设置随机抽取出来几个
# 例如5位数验证码
random.sample(['1', '2', '3', '4'，'5','6','7','8','9'],5)
#这样可以一次获取5个随机数字

l1 = [1,2,3,4,5,6,7,8,9]
random.shuffle(l1)
print(l1) # [1, 8, 4, 6, 5, 7, 9, 3, 2]
#这样列表内数据已被随机打乱

小练习：
'''产生图片验证码: 每一位都可以是大写字母 小写字母 数字  4位'''
import random
def code1(n):
    code = ''
    for i in range(n):  #n = 循环几次
        upper_ = chr(random.randint(65,90))  #随机大写字母
        lower_ = chr(random.randint(97,122)) #随机小写字母
        num_ = str(random.randint(0,9))   #随机数字
        temp = random.choice([upper_,lower_,num_]) # 随机产生的类型
        code = code+temp    # 每循环一次产生一位
    return code

res = code1(5)
print(res)

os模块

1.什么是os模块
  os模块主要是与代码运行所在的系统打交道的，我们可以在python中使用这个模块，可以做一些文件类的操作。
2.代码展示
  import os
  1.创建目录(文件夹)
    os.mkedir(r'd1')
    # 相对路径 在执行文件所在的路径下创建目录 可以创建单级目录
    so.makedirs(r'd1/d2/d3')   so.makedirs(r'd1')
    # 可以创建多级目录 也可以创建单级目录

  2.删除目录(文件夹)
    os.rmdir(r'd1')
    # 可以删除单级目录 前提目录下文件为空
    os.removedirs(r'd1/d2')
    # 可以一次性删除多级目录  前提目录下文件为空

  3.查询文件路径
    os.listdir()
    # 可以查询当前执行文件所在环境下的所有文件
    os.listdir(r'd1/d2')
    # 可以查询d2文件里面的所有文件

  4.删除/重命名文件
    os.rename('d1/123.py',r'd1/321.py')
    # 需要填写准确的文件所在位置后 再填写新的名字
    os.remove('d1/321.py')
    # 删除对应文件 

  5.动态获取项目根目录
    os.path.abspath(__file__)
    # 获取执行文件的绝对路径
    os.path.dirname(__file__)
    # 获取执行文件所在目录路径

  6.判断路径是否存在文件(文件，目录)
    os.path.exists(r'd1/321.py')
    # 判断该文件是否存在 返回结果为布尔值
    os.path.exists(r'd1/d2/d3')
    # 判断该目录是否存在 范围结果为布尔值
    os.path.isfile(r'd1/d2')
    # 判断路径是否是文件 如果是文件夹返回 False 是文件返回True 

  7.拼接路径
    s1 = r'd1/d2'
    s2 = r'123.py'
    os.path.join(s1,s2) #r'd1/d2/123.py'
    res = os.path.join(s1,s2)
    #使用join方法进行拼接，拼接结果可以赋予变量

 8.获取文件大小(字节为单位)
   os.path.getsize(r'd1/d2/123.py') # 24
   # 返回结果为整数类型 数字

sys模块

import sys

1.sys.path
  #获取执行文件的sys.path
2.sys.version
  #获取当前文件版本
3.sys.platform
  #获取平台信息

 res = sys.argv
if len(res) != 3:
    print('执行命令缺少了用户名或密码')
else:
    username = res[1]
    password = res[2]
    if username == 'jason' and password == '123':
        print('jason您好 文件正常执行')
    else:
        print('您不是jason无权执行该文件')

json模块

import json

json模块也称之为序列号模块，序列化模块可以打破语言限制实现不同的编程语言之间的数据交互

json是格式化数据的作用

json是字符串类型，并且都是双引号

json相关操作
		针对数据
    data_1 = {'name':'moon','age':'18'}
  	json.dumps(data_1)
    #将数据转换为json格式 

    res = json.dumps(data_1)
    json.loads(res)
    #将json格式再转回数据

    json.dumps()  #数据转成json   序列化
    json.loads()   #将json 转为数据  反序列化

    json.dump(data_1,f)  #专业为文件服务
    #直接将转换的数据放入文件中

    json.load(f)
    #直接将文件里的json格式反序列化输出

json模块的实战练习

用户登录注册功能
import os
import json

1.注册功能
#获取执行文件所在目录
base_dir = os.path.dirname(__file__)
#拼接出db文件夹路径
db_dir = os.path.join(base_air,'db')
#创建db文件夹
if not os.path.isdir(db_dir)
    os.mkdir(db)

hashiib加密模块

1.何为加密
  将明文文件处理成私密的密文数据，让人无法看懂 更加有安全性
2.判断数据是否被加密
  如果是一串没有规律的字符串 里面有（数字，字母，符号等）就是加密数据了
3.密文的长短有什么作用
  一般来看密文越长表示使用的加密算法越复杂，也可以说明越安全
4.常见的加密算法有哪些
  md5 sha256 sha512  base64  hmac
5.代码实现：

  import hashiib
  md5 = hashiib.md5() # 选择一个加密算法 这里选择为md5
  md5.update(b'123456') #传入明文数据，且已二进制的形式传入
  res = md5.hexdigest() #获取加密密文
  print(res)  #5d41402abc4b2a76b9719d911017c592 这就是密文的样式

6，加密算法不变，内容如果相同 那结果肯定相同
  import hashlib
  md5 = hashlib.md5()
  md5.update(b'moon')
  md5.update(b'123')
  # md5.update(b'moon123') #8aff4877eb76417460c0fc7f84b32566
  res = md5.hexdigest()
  print(res)

  一次性传和分开传，只要内容是一样的 那获得的密文也是一样的

7. 被加密后的数据是不可以解密的
   只能从明文变成密文，无法从密文转为明文

8. 加盐处理
   在明文中增加干扰项，安全性更加提高
   例如 可以在明文前后加入
   md5.update('公司设置的干扰项',encode('utf8'))
   md5.update(b'传入的明文')
   这个干扰项可以是随机变化的，比如 明文的部分内容，比如时间

9. 加密实际运用
   1.用户密码加密
   2.文件安全性校验
   3.文件内容一致性校验
   4.超大文件如果加密 （截取部分内容加密 ）

subprocess模块

模拟操作系统终端 执行命令并获取结果
import subprocess
res = subprocess.Popen(
    'asdas',  # 操作系统要执行的命令
    shell=True,  # 固定配置
    stdin=subprocess.PIPE,  # 输入命令
    stdout=subprocess.PIPE,  # 输出结果
)
print('正确结果', res.stdout.read().decode('gbk'))  # 获取操作系统执行命令之后的正确结果
print('错误结果', res.stderr)  # 获取操作系统执行命令之后的错误结果

logging日志模块

1，日志是什么？
   日志就是可以纪录你的每一个操作的记事本
2. 日志的级别
   五种级别
   DEBUG - 调试模式，应用场景是问题诊断；
   INFO - 通常只记录程序中一般事件的信息，用于确认工作一切正常；
   WARNING - 打印警告信息，系统还在正常运行；
   ERROR - 错误导致某些功能不能正常运行时记录的信息；
   CRITICAL - 当发生严重错误，导致应用程序不能继续运行时记录的信息。

3.日志的组成
  产生日志
  过滤日志
  输出日志
  日志格式

 import logging

# 1.日志的产生(准备原材料)        logger对象
logger = logging.getLogger('购物车记录')
# 2.日志的过滤(剔除不良品)        filter对象>>>:可以忽略 不用使用
# 3.日志的产出(成品)             handler对象
hd1 = logging.FileHandler('a1.log', encoding='utf-8')  # 输出到文件中
hd2 = logging.FileHandler('a2.log', encoding='utf-8')  # 输出到文件中
hd3 = logging.StreamHandler()  # 输出到终端
# 4.日志的格式(包装)             format对象
fm1 = logging.Formatter(
        fmt='%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s',
        datefmt='%Y-%m-%d %H:%M:%S %p',
)
fm2 = logging.Formatter(
        fmt='%(asctime)s - %(name)s:  %(message)s',
        datefmt='%Y-%m-%d',
)
# 5.给logger对象绑定handler对象
logger.addHandler(hd1)
logger.addHandler(hd2)
logger.addHandler(hd3)
# 6.给handler绑定formmate对象
hd1.setFormatter(fm1)
hd2.setFormatter(fm2)
hd3.setFormatter(fm1)
# 7.设置日志等级
logger.setLevel(10)  # debug
# 8.记录日志
logger.debug('写了半天 好累啊 好热啊')

日志配置文件

import logging
import logging.config
# 定义日志输出格式 开始
standard_format = '[%(asctime)s][%(threadName)s:%(thread)d][task_id:%(name)s][%(filename)s:%(lineno)d]' \
                  '[%(levelname)s][%(message)s]'  # 其中name为getlogger指定的名字
simple_format = '[%(levelname)s][%(asctime)s][%(filename)s:%(lineno)d]%(message)s'
# 自定义文件路径
LOG_DIR = os.path.join(BASE_DIR,'log')
if not os.path.exists(LOG_DIR):
    os.mkdir(LOG_DIR)
logfile_path = os.path.join(LOG_DIR,'atm.log')
LOGGING_DIC = {
    'version': 1,
    'disable_existing_loggers': False,
    'formatters': {
        'standard': {
            'format': standard_format
        },
        'simple': {
            'format': simple_format
        },
    },
    'filters': {},  # 过滤日志
    'handlers': {
        # 打印到终端的日志
        'console': {
            'level': 'DEBUG',
            'class': 'logging.StreamHandler',  # 打印到屏幕
            'formatter': 'simple'
        },
        # 打印到文件的日志,收集info及以上的日志
        'default': {
            'level': 'DEBUG',
            'class': 'logging.handlers.RotatingFileHandler',  # 保存到文件
            'formatter': 'standard',
            'filename': logfile_path,  # 日志文件
            'maxBytes': 1024 * 1024 * 5,  # 日志大小 5M
            'backupCount': 5,
            'encoding': 'utf-8',  # 日志文件的编码，再也不用担心中文log乱码了
        },
    },
    'loggers': {
        # logging.getLogger(__name__)拿到的logger配置
        '': {
            'handlers': ['default', 'console'],  # 这里把上面定义的两个handler都加上，即log数据既写入文件又打印到屏幕
            'level': 'DEBUG',
            'propagate': True,  # 向上（更高level的logger）传递
        },  # 当键不存在的情况下 (key设为空字符串)默认都会使用该k:v配置
        # '购物车记录': {
        #     'handlers': ['default','console'],  # 这里把上面定义的两个handler都加上，即log数据既写入文件又打印到屏幕
        #     'level': 'WARNING',
        #     'propagate': True,  # 向上（更高level的logger）传递
        # },  # 当键不存在的情况下 (key设为空字符串)默认都会使用该k:v配置
    },
}

def get_logger(msg):
    logging.config.dictConfig(settings.LOGGING_DIC)  # 自动加载字典中的配置
    logger1 = logging.getLogger(msg)
    return logger1

pickle模块

优势：能够序列化python中的所有类型
缺陷：只能够在python中使用，无法跨语言传输

'''
可实现需求，产生一个对象并保存到文件中，取出来还是一个对象
'''

举例说明：

class C1:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def func(self):
        print('func')

    def func1(self):
        print('func1')

obj = C1('张无忌',22)

import pickle
with open(r'a.txt','wb')as f:
    # 存和取 都需要用二进制模式 rb wb
    pickle.dump(obj,f)
    # 这样就可以把一个对象存入了文件中

with open(r'a.txt','rb')as f:
    # 存和取 都需要用二进制模式 rb wb
    res = pickle.load(f)
    # 这样由使用一个变量把 存入的对象接收出来了

print(res.name) # 张无忌
res.func()  # func
#测试完成 是可以之前对象内的数据和方法