python 常用模块--logging，JSON/pickle，os

一：logging模块（日志管理模块）

1，日志级别（默认级别为WARNING，默认打印到终端）

CRITICAL = 50 #FATAL = CRITICAL
ERROR = 40
WARNING = 30 #WARN = WARNING
INFO = 20
DEBUG = 10
NOTSET = 0 #不设置

2，为logging模块指定全局配置

'''
可在logging.basicConfig()函数中可通过具体参数来更改logging模块默认行为，可用参数有:
filename：指定日志写入的文件
filemode：文件打开方式，默认为'a'模式
format：指定handler使用的日志显示格式。
datefmt：指定日期时间格式。
level：设置日志级别
stream：用指定的stream创建StreamHandler

format参数中可能用到的格式化串：
%(name)s            Logger的名字
%(levelno)s         数字形式的日志级别
%(levelname)s       文本形式的日志级别
%(pathname)s        调用日志输出函数的模块的完整路径名
%(filename)s        调用日志输出函数的模块的文件名
%(module)s          调用日志输出函数的模块名
%(funcName)s        调用日志输出函数的函数名
%(lineno)d          调用日志输出函数的语句所在的代码行
%(created)f         当前时间，用UNIX标准的表示时间的浮点数表示
%(asctime)s         字符串形式的当前时间；默认格式 2018-04-05 10:31:49,130 最后的数字为毫秒
%(thread)d          线程ID
%(threadName)s      线程名
%(process)d         进程ID
%(message)s         用户输出的消息
%(relativeCreated)d 输出自logger创建以来的毫秒数
'''

import logging
logging.basicConfig(filename='access.log',    #不指定filename默认打印到终端
                    format='%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s',
                    datefmt='%Y-%m-%d %H:%M:%S %p',
                    level=30)
#这种方式无法指定字符编码，Windows系统中会使用gbk格式把信息写入文件，所以读的时候也需要使用gbk格式
logging.debug('调试debug')
logging.info('消息info')
logging.warning('警告warn')
logging.error('错误error')
logging.critical('严重critical')

3，logging模块中的4个对象：Logger,Filter,Handler,Formatter

4，应用--logging配置设置

# conf settings.py    在配置文件写入配置信息
import os
BASE_DIR=os.path.dirname(os.path.dirname(__file__))     #可以取得软件所在目录

# 定义日志文件的路径
LOG_PATH=r'%s\log\access.log' %BASE_DIR
BOSS_LOG_PATH=r'%s\log\boss.log' %BASE_DIR

# 定义三种日志输出格式
standard_format = '[%(asctime)s][%(threadName)s:%(thread)d][task_id:%(name)s][%(filename)s:%(lineno)d]' \
                  '[%(levelname)s][%(message)s]'      #其中name为getlogger指定的名字
simple_format = '[task_id:%(name)s][%(levelname)s][%(asctime)s][%(filename)s:%(lineno)d]%(message)s'
id_simple_format = '[task_id:%(name)s][%(levelname)s][%(asctime)s] %(message)s'

# logger配置字典
LOGGING_DIC = {
    'version': 1,
    'disable_existing_loggers': False,
    #1、定义Formatter对象
    'formatters': {
        'standard': {
            'format': standard_format
        },
        'simple': {
            'format': simple_format
        },
        'id_simple':{
            'format':id_simple_format
        }
    },
    #2、定义Filter对象
    'filters': {},
    #3、定义Handler对象
    'handlers': {
        #打印到终端的日志
        'stream': {
            'level': 'DEBUG',
            'class': 'logging.StreamHandler',  # 打印到屏幕
            'formatter': 'simple'
        },
        #写入文件的日志,收集info及以上的日志
        'access': {
            'level': 'INFO',
            'class': 'logging.handlers.RotatingFileHandler',  # 保存到文件
            'formatter': 'standard',
            'filename': LOG_PATH,  # 日志文件
            'maxBytes': 1024*1024*5,  # 设置一份日志文件的大小 5M
            'backupCount': 5,    #最多保留5份日志文件
            'encoding': 'utf-8',  # 日志文件的编码
        },
        #写入文件的日志,收集error及以上的日志
        'boss': {
                    'level': 'ERROR',
                    'class': 'logging.handlers.RotatingFileHandler',  # 保存到文件
                    'formatter': 'id_simple',
                    'filename': BOSS_LOG_PATH,  # 日志文件
                    'maxBytes': 1024*1024*5,  # 日志大小 5M
                    'backupCount': 5,
                    'encoding': 'utf-8',  # 日志文件的编码
                },
    },
    #定义Logger对象，key设置为空是默认设置，可以匹配所有logger实例对象
    'loggers': {
        '': {
            'handlers': ['access', 'stream','boss'],  # 设置把logger对象得到的信息传递到哪些handler对象去
            'level': 'DEBUG',
            'propagate': False,  # 是否向父logger传递
        },
    },
}

###############################################################################################################
# lib  common.py    在公用模块写入logger功能
import logging.config
import logging
from conf import settings

def get_logger(logger_name):
    logging.config.dictConfig(settings.LOGGING_DIC)  # 导入settings文件中定义的logger配置字典
    logger=logging.getLogger(logger_name)
    return logger

###################################################################################################################
#  core  src.py    在主程序中调用logger功能
from conf import settings
from lib import common
logger=common.get_logger('transfer')
def transfer():
    logger.info('转账。。。。')
    pass

二：json模块/pickle模块

1，认识序列化（python中称之为 pickling）

我们把对象(变量)从内存中变成可存储或传输的过程称之为序列化。序列化之后，就可以把序列化后的内容写入磁盘，或者通过网络传输到别的机器上。反过来，把变量内容从序列化的对象重新读到内存里称之为反序列化，即unpickling。

2，json模块

如果我们要在不同的编程语言之间传递对象，就必须把对象序列化为标准格式，比如XML，但更好的方法是序列化为JSON，因为JSON表示出来就是一个字符串，可以被所有语言读取，也可以方便地存储到磁盘或者通过网络传输。JSON不仅是标准格式，并且比XML更快，而且可以直接在Web页面中读取，非常方便。

JSON表示的对象就是标准的JavaScript语言的对象，JSON和Python内置的数据类型对应如下：

JSON类型	Python类型
{}	dict
[]	list
"string"	str
1234.56	int或float
true/false	True/False
null	None

注意：并非python所有类型都可以使用JSON模块来序列化，python中的元组，集合就无法使用JSON模块序列化！

import json   #直接导入json模块
adict = {'name':'rock','age':18,'hobbies':['reading','running','smile']}
adict = json.dumps(adict)    #将python中的字典序列化为json字符串（注意：json字符串中只用双引号，不用单引号）
with open('msg.json','w',encoding='utf-8') as f1:
    f1.write(adict)

with open('msg.json','r',encoding='utf-8') as f2:
    data = f2.read()
    adict = json.loads(data)    #将json字符串反序列化为原来的python类型，这里为字典
    print(adict)      
#{'name': 'rock', 'age': 18, 'hobbies': ['reading', 'running', 'smile']}

#另一种方式使用JSON 模块 ，dump 与 load 
import json   #直接导入json模块
adict = {'name':'rock','age':18,'hobbies':['reading','running','smile']}
with open('msg.json','w',encoding='utf-8') as f1:
    json.dump(adict,f1)        #序列化为JSON字符串

with open('msg.json','r',encoding='utf-8') as f2:
    adict = json.load(f2)     #反序列化为原来的python类型

3，pickle模块

pickle模块是python特有的序列化模块，即它只能用于python。所以用pickle模块序列化后的数据无法跨平台使用。python对象经pickle模块序列化生成的是bytes类型的数据。

import pickle
aset = {1,2,3,4}
aset_pic = pickle.dumps(aset)   #将集合序列化为bytes类型
with open('a1.pkl','wb') as f1:
    f1.write(aset_pic)

with open('a1.pkl','rb') as f2:
    data = f2.read()
    res = pickle.loads(data)      #将bytes类型反序列化为原来的python类型
    print(res,type(res))

#pickle模块另一种使用方式
import pickle
aset = {1,2,3,4}
with open('a1.pkl','wb') as f1:
    pickle.dump(aset,f1)

with open('a1.pkl','rb') as f2:
    res = pickle.load(f2)
    print(res,type(res))

三：os模块

os模块是与操作系统交互的一个接口。

import os     #直接导入 os 模块

os.remove('path')     #删除一个文件
os.rename('old_name','new_name')    #重命名一个文件
os.listdir('dirname')       #以列表方式列出指定目录下的所有文件和子目录，包括隐藏文件
os.path.abspath('path')         #返回path规范化的绝对路径
os.path.split('path')         #将path分割成目录和文件名二元组返回
os.path.dirname('path')       #返回path的目录，其实就是os.path.split(path)的第一个元素
os.path.basename('path')       #返回path最后的文件名，其实就是os.path.split(path)的第二个元素
os.path.exists(r'path')        #如果path存在，返回True；如果path不存在，返回False
os.path.isabs(r'path')         #如果path是绝对路径，返回True
os.path.isfile(r'path')         #如果path是一个存在的文件，返回True。否则返回False
os.path.isdir(r'path')                      #如果path是一个存在的目录，则返回True。否则返回False
os.path.join(path1,path2,path3,...)          #将多个路径组合后返回
os.path.getsize(r'path')                    #返回path的大小，单位是字节

python 常用模块--logging，JSON/pickle，os

猜你喜欢