shelve模块,sys模块,logging模块

1.shelve模块

用于序列化的模块，shelve模块比pickle模块简单，只有open函数,返回类似字典的对象,可读可写;key必须为字符串,而值可以是python所支持的数据类型.
import shelve
s=shelve.open('a.txt')
s['name']='henry'
s['dic']={'age':18}
print(s['dic'])
shelve模块只有一个函数,就是open用于打开一个文件.
打开以后,操作方法与字典完全一致,你可以把他当成字典,而且自带buff的字典,可以字典给完成序列化.
该模式序列化得到的数据,只能被该模块使用,其他语言没有这个模块,所以无法使用,即无法跨平台.
当你写的程序是一个单机程序时可以考虑.
后期只要涉及到数据交换就应该用json.

2.sys模块

sys模块是system的缩写,表示系统
注意:
os operation system 指的是操作系统
而sys指的是python解释器

import sys
用于接受操作系统调用解释器时传入参数
sys.path 返回模块的搜索路径，初始化时使用PYTHONPATH环境变量的值

sys.argv 用于接受操作系统调用解释器时传入的参数
当你要开发一款基于CMD的程序时,就需要使用这个属性了,因为一些操作系统没有界面,只能通过CMD来使用.
# 需求 开发一个基于CMD的复制文件的工具
# 第一个参数表示被执行的py文件 第二个作为源文件路径 第三个作为目标文件的路径
#
# source_path = sys.argv[1]
# target_path = sys.argv[2]
#
# print(source_path)
# print(target_path)
#
#
# with open(source_path,"rb") as f:
　　# with open(target_path,"wb") as f1:
　　　　# while True:
　　　　　　# data = f.read(1024)
　　　　　　# if not data:
　　　　　　　　# break
　　　　　　# f1.write(data)

sys.exit(n) 退出程序，正常退出时exit(0)
sys.version 获取Python解释程序的版本信息
sys.platform 返回操作系统平台名称

总结:sys 处理与python解释器相关的一些操作
常用有两个:sys.path 添加环境变量
sys.argv 获取调用解释器参数

3.logging模块

翻译为日志记录
该模块就是用于记录日志的

日志是什么?
日志就是日记,用于记录在某个时间点,发生了什么事

为什么要记录日志?
是为了日后来复查,提取有用的信息

如何来记录日志?
可以直接打开文件往里面写东西
直接写入文件的两个问题
1.你写的数据格式别人看不懂
2.解析数据麻烦
因此logging就诞生了

简单的使用
import logging
logging.debug('这是一条日志信息')#没有输出任何内容
因为logging模块为日志划分了级别,由于你输出的级别没有的达到最低级别所以没有输出
为什么要设置最低等级 因为某些级别的日志,对我是无用的

日志级别.从低到高分别是:
1.debug 调试信息(用于记录程序员在开发过程中的调试记录)
2.info 记录普通信息(没有特别的意义,就是简单的记录)
3.warning 警告信息(当某些操作 可能发生错时,就记录为警告信息,涉及一些敏感操作时)
4.error 错误信息(当程序遇到错误时)
5.critical 严重错误 (当程序遇到问题,无法继续执行时)
logging用数字来表示级别从低到高 0 10 20 30 40 50
为什么分级别,随着时间的推移,你的日志会越来越多,成千上万条,这个时候提取有用信息就很慢,所以分等级,这样一来在查看日志的时候,可以快速定位到想要的日志.

logging.debug('debug')
logging.info('info')
logging.warning('warning')
logging.error('error')
logging.critical('critical')
#默认情况下,级别为warning,输出的位置为控制台,默认的格式为 级别:日志生成器名称:调试的详细信息

#如何修改默认的行为
可在logging.basicConfig()函数中通过具体参数来更改logging模块默认行为，可用参数有
filename：用指定的文件名创建FiledHandler（后边会具体讲解handler的概念），这样日志会被存储在指定的文件中。
filemode：文件打开方式，在指定了filename时使用这个参数，默认值为“a”还可指定为“w”。
format：指定handler使用的日志显示格式。
datefmt：指定日期时间格式。
level：设置rootlogger（后边会讲解具体概念）的日志级别
stream：用指定的stream创建StreamHandler。可以指定输出到sys.stderr,sys.stdout或者文件，默认为sys.stderr。若同时列出了filename和stream两个参数，则stream参数会被忽略。
#format格式
%(name)s：Logger的名字，并非用户名，详细查看
%(levelno)s：数字形式的日志级别
%(levelname)s：文本形式的日志级别
%(pathname)s：调用日志输出函数的模块的完整路径名，可能没有
%(filename)s：调用日志输出函数的模块的文件名
%(module)s：调用日志输出函数的模块名
%(funcName)s：调用日志输出函数的函数名
%(lineno)d：调用日志输出函数的语句所在的代码行
%(created)f：当前时间，用UNIX标准的表示时间的浮 点数表示
%(relativeCreated)d：输出日志信息时的，自Logger创建以 来的毫秒数
%(asctime)s：字符串形式的当前时间。默认格式是 “2003-07-08 16:49:45,896”。逗号后面的是毫秒
%(thread)d：线程ID。可能没有
%(threadName)s：线程名。可能没有
%(process)d：进程ID。可能没有
%(message)s：用户输出的消息

import logging
logging.basicConfig(filename='mylog.txt', #指定的日志文件名
　　　　　　　　　filemode='a', #指定文件打开的模式.通常为a
　　　　　　　　　level=logging.DEBUG, #指定级别
　　　　　　　　　format='%(filename)s %(levelname)s \
　　　　　　　　　%(asctime)s %(message)s') #指定现实格式
logging.debug('debug')
logging.info('info')
logging.warning('warning')
logging.error('error')
logging.critical('critical')

如果我们需要更详细的去定制logging的各项功能,就需要系统的了解logging的模块
四种核心角色
　　1.Logger 日志的生成器 负责产生一条完整的日志
　　2.Filter 过滤器 负责对日志进行过滤
　　3.Handler 处理器 负责将日志输出到指定的位置
　　4.Formater 格式化 负责处理日志显示格式
一条日志的生命周期:
1.由Logger产生日志
2.交给过滤器进行过滤
3.交给Handler按照Formater的格式进行输出
这三个都可以可以对日志进行删选,什么样的需要显示,什么样的不需要显示

#需求:有一个登录注册程序,功能 需要记录用户的操作日志,程序员需要看到最详细的信息,而boss只要看到简单的操作信息.

#基础版本:
#自定四种核心角色完成日志的输出
import logging
#生成器
mylog=logging.getLogger('mylog') #参数指定生成器的名字(因为可以同时存在多个生成器,需要用名字区分
mylog.setLevel(10) #设置生成器的级别 低于该级别的不会产生

#过滤器这里不讲!需要使用面向对象的基础知识点!(不常用)

#处理器
handler=logging.FileHandler('youlog.txt',mode='a',encoding='utf-8',delay=False)

#格式化处理器
formater=logging.Formatter(fmt='%(filename)s %(levelname)s %(asctime)s %(message)s')

#将处理器绑定给生成器,add函数表明了一个生成器可以添加多个处理器
mylog.addHandler(handler)

#将格式化处理器绑定给 handler,set函数表明一个处理器只能绑定一个格式化处理器
handler.setFormatter(formater)

mylog.debug('debug')
mylog.info('info')
mylog.warning('warning')
mylog.error('error')
mylog.critical('critical')

#升级版本 按照不同格式输出到不同文件中
import logging
#生成器
mylog=logging.getLogger('mylog') #参数指定生成器的名字(因为可以同时存在多个生成器,需要用名字区分
mylog.setLevel(10) #设置生成器的级别 低于该级别的不会产生

#过滤器这里不讲!需要使用面向对象的基础知识点!(不常用)

#处理器
#给程序员看的处理器
handler1=logging.FileHandler('youlog.txt',mode='a',encoding='utf-8',delay=False)
#给老板看的处理器
handler2=logging.FileHandler('bosslog.txt',mode='a',encoding='utf-8',delay=False)

#格式化处理器
#程序员
formater1=logging.Formatter(fmt='%(funcName)s %(module)s %(filename)s\
%(threadName)s %(levelname)s %(asctime)s %(message)s')
#老板
formater2=logging.Formatter(fmt='%(levelname)s %(asctime)s %(message)s')

#将处理器绑定给生成器,add函数表明了一个生成器可以添加多个处理器
mylog.addHandler(handler1)
mylog.addHandler(handler2)

#将格式化处理器绑定给 handler,set函数表明一个处理器只能绑定一个格式化处理器
handler1.setFormatter(formater1)
handler2.setFormatter(formater2)

mylog.debug('debug')
mylog.info('info')
mylog.warning('warning')
mylog.error('error')
mylog.critical('critical')

#现在需求已经实现,但是每次日志都要写一堆代码,最好能把配置写死,直接复制信息
#字典配置logging(重点)
字典的内容重点,但是不需要背
记住的是如何来加载
#logging.config 专门用来配置logging模块
import logging.config

#导入包含配置字典的模块
import loggin_config

loggin_config在另一个py文件中:
import logging
# 定义三种日志输出格式 开始
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'
id_simple_format = '[%(levelname)s][%(asctime)s] %(message)s'
# 定义日志输出格式 结束
logfile_path='配置文件路径'
# log配置字典
LOGGING_DIC = {
　　'version': 1,
　　#是否禁用已存在的生成器,这个值保持为False
　　'disable_existing_loggers': False,
　　#四个key不能随便写 是固定的
　　'formatters': {
　　　　#standard 表示格式化的处理器的名字,相当于变量的名字 可以随便写
　　　　'standard': {
　　　　　　#format是固定的不能随便写
　　　　　　'format': standard_format
　　　　},
　　　　'simple': {
　　　　　　'format': simple_format
　　　　},
　　},
　　'filters': {},
　　'handlers': {
　　　　#打印到终端的日志
　　　　#console是处理器的名称可以随便写
　　　　'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配置
　　　　#aa是生成器的名称可以随便写
　　　　'aa': {
　　　　　　'handlers': ['default', 'console'], # 这里把上面定义的两个handler都加上，即log数据既写入文件又打印到屏幕
　　　　　　'level': 'DEBUG',
　　　　　　'propagate': True, # 向上（更高level的logger）传递,日志的继承
　　　　},
　　},
}

#通过一个字典来配置logging模块
logging.config.dictConfig(loggin_config.LOGGING_DIC)

#通过名称来获取一个生成器
aaloger=logging.getLogger('aa')

#输出日志
aaloger.info('测试信息!')

#当要获取的名称不存在时,会返回一个默认的生成器
aaloger=logging.getLogger('aaa')
#输出日志
aaloger.warning('测试信息!')

#了解知识点
日志的继承
自己来定义四种核心角色
import logging
mylog=logging.getLogger('father')
mylog.setLevel(10)

handler=logging.FileHandler('father.log',mode='a',encoding='utf-8')
mylog.addHandler(handler)

fmter=logging.Formatter(fmt='%(funcName)s %(module)s %(filename)s\
%(threadName)s %(levelname)s %(asctime)s %(message)s')
handler.setFormatter(fmter)

mylog.info('这是一条日志信息!')

#再获取一个生成器,同时指定该生成器的父亲是father这个生成器
sonlog=logging.getLogger('father.son')
sonlog.info('这是son输出的日志信息!')
#继承后子生成器可以直接使用父生成器的配置

#需求:子生成器的输出位置与父生成器不同,格式相同
sonlog=logging.getLogger('father.son')
sonhandler=logging.FileHandler('son.txt',mode='a',encoding='utf-8')
sonlog.addHandler(sonhandler)
sonhandler.setFormatter(fmter)
sonlog.info('这是son输出的日志信息!')
#子生成器在生成一个日志时会自动给父生成器也发一个

#取消传递效果
sonlog.propagate=False