码迷,mamicode.com
首页 > 编程语言 > 详细

Python常用模块

时间:2019-11-28 21:11:05      阅读:70      评论:0      收藏:0      [点我收藏+]

标签:解释   handlers   hex   chdir   加密算   开始   接受   模式   跨平台   

一、time模块

import time

1 、时间戳

??时间戳(timestamp):时间戳表示的是从1970年1月1日00:00:00开始按秒计算的偏移量。

time_stamp = time.time()
print(time_stamp, type(time_stamp))  # 1574923359.1739607 <class ‘float‘>

2、 格式化时间

??格式化的时间字符串(format string):格式化时间表示的是普通的字符串格式的时间。

format_time = time.strftime("%Y-%m-%d %X")
print(format_time, type(format_time)) #2019-03-07 16:22:11 <class ‘str‘>

3 、结构化时间

??结构化的时间(struct time):struct_time元组共有9个元素共九个元素,分别为(年,月,日,时,分,秒,一年中第几周,一年中第几天,夏令时)

# 本地时区的struct_time: 
print( time.localtime() )  # time.struct_time(tm_year=2019, tm_mon=11, tm_mday=28, tm_hour=14, tm_min=45, tm_sec=34, tm_wday=3, tm_yday=332, tm_isdst=0)

# UTC时区的struct_time:
print(time.gmtime() )  # time.struct_time(tm_year=2019, tm_mon=11, tm_mday=28, tm_hour=6, tm_min=45, tm_sec=34, tm_wday=3, tm_yday=332, tm_isdst=0)

# 结构化时间的基准时间
print(time.localtime(0) )  # time.struct_time(tm_year=1970, tm_mon=1, tm_mday=1, tm_hour=8, tm_min=0, tm_sec=0, tm_wday=3, tm_yday=1, tm_isdst=0)

# 结构化时间的基准时间上增加一年时间
print(time.localtime(3600 * 24 * 365) )  # time.struct_time(tm_year=1971, tm_mon=1, tm_mday=1, tm_hour=8, tm_min=0, tm_sec=0, tm_wday=4, tm_yday=1, tm_isdst=0)

4、 不同格式时间的转换

技术图片

??如上图所示,我们总能通过某些方法在结构化时间-格式化时间-时间戳三者之间进行转换,下面我们将用代码展示如何通过这些方法转换时间格式。

# 结构化时间
now_time = time.localtime()
print(now_time)  # time.struct_time(tm_year=2019, tm_mon=11, tm_mday=28, tm_hour=14, tm_min=51, tm_sec=55, tm_wday=3, tm_yday=332, tm_isdst=0)

# 把结构化时间转换为时间戳格式
print(time.mktime(now_time))  # 1574923915.0

# 把结构化时间转换为格式化时间
# %Y年-%m月-%d天 %X时分秒=%H时:%M分:%S秒
print(time.strftime("%Y-%m-%d %X", now_time) )  # 2019-11-28 14:51:55

# 把格式化时间化为结构化时间,它和strftime()是逆操作
print(time.strptime(2013-05-20 13:14:52, %Y-%m-%d %X) )  # time.struct_time(tm_year=2013, tm_mon=5, tm_mday=20, tm_hour=13, tm_min=14, tm_sec=52, tm_wday=0, tm_yday=140, tm_isdst=-1)

# 把结构化时间表示为这种形式:‘Sun Jun 20 23:21:05 1993‘。
print(time.asctime() )  # Thu Nov 28 14:51:55 2019
# 如果没有参数,将会将time.localtime()作为参数传入。
print(time.asctime(time.localtime()) )  # Thu Nov 28 14:51:55 2019

# 把一个时间戳转化为time.asctime()的形式。
print(time.ctime() )  # Thu Nov 28 14:51:55 2019
# 如果参数未给或者为None的时候,将会默认time.time()为参数。它的作用相当于time.asctime(time.localtime(secs))。
print(time.ctime(time.time()))  # Thu Nov 28 14:51:55 2019

5、 其他用法

# 推迟指定的时间运行,单位为秒
start = time.time()
time.sleep(3)
end = time.time()

print(end-start) #3.0005428791046143

二、datetime模块

datetime模块可以看成是时间加减的模块

import datetime

用法:

import datetime
import time

# 返回当前时间
print(datetime.datetime.now() )  # 2019-11-28 15:02:23.138960
print(datetime.date.fromtimestamp(time.time()))  # 2019-11-28

# 当前时间+3天
print(datetime.datetime.now() + datetime.timedelta(3) )  # 2019-12-01 15:02:23.138960
# 当前时间-3天
print(datetime.datetime.now() + datetime.timedelta(-3))  # 2019-11-25 15:02:23.138960
# 当前时间-3小时
print(datetime.datetime.now() + datetime.timedelta(hours=3)  )  # 2019-11-28 18:02:23.138960
# 当前时间+30分钟
print(datetime.datetime.now() + datetime.timedelta(minutes=30) )  # 2019-11-28 15:32:23.138960

# 时间替换
c_time = datetime.datetime.now()
print(c_time.replace(minute=20, hour=5, second=13))  # 2019-11-28 05:20:13.138960

三、random模块

import random

# 大于0且小于1之间的小数
print(random.random())  # 0.42866657593385415

# 大于等于1且小于等于3之间的整数
print(random.randint(1, 3))  # 3

# 大于等于1且小于3之间的整数
print(random.randrange(1, 3))  # 2

# 大于1小于3的小数,如1.927109612082716
print(random.uniform(1, 3))  # 2.1789596280319605

# 列表内的任意一个元素,即1或者‘23’或者[4,5]
print(random.choice([1, 23, [4, 5]]))  # [4, 5]

# random.sample([], n),列表元素任意n个元素的组合,示例n=2
print(random.sample([1, 23, [4, 5]], 2))  # [‘23‘, 1]

lis = [1, 3, 5, 7, 9]
# 打乱l的顺序,相当于"洗牌"
random.shuffle(lis)
print(lis)  # [9, 1, 5, 7, 3]

四、os模块

os模块负责程序与操作系统的交互,提供了访问操作系统底层的接口,多用于文件处理。

用法:

  • os.getcwd():获取当前工作目录,即当前python脚本工作的目录路径
  • os.chdir("dirname"):改变当前脚本工作目录;相当于shell下cd
  • os.curdir:返回当前目录: (‘.‘)
  • os.pardir:获取当前目录的父目录字符串名:(‘..‘)
  • os.makedirs(‘dirname1/dirname2‘):可生成多层递归目录
  • os.removedirs(‘dirname1‘):若目录为空,则删除,并递归到上一级目录,如若也为空,则删除,依此类推
  • os.mkdir(‘dirname‘):生成单级目录;相当于shell中mkdir dirname
  • os.rmdir(‘dirname‘):删除单级空目录,若目录不为空则无法删除,报错;相当于shell中rmdir dirname
  • os.listdir(‘dirname‘):列出指定目录下的所有文件和子目录,包括隐藏文件,并以列表方式打印
  • os.remove():删除一个文件
  • os.rename("oldname","newname")重命名文件/目录
  • os.stat(‘path/filename‘):获取文件/目录信息
  • os.sep:输出操作系统特定的路径分隔符,win下为"\",Linux下为"/"
  • os.linesep:输出当前平台使用的行终止符,win下为"\t\n",Linux下为"\n"
  • os.pathsep:输出用于分割文件路径的字符串 win下为;,Linux下为:
  • os.name:输出字符串指示当前使用平台。win->‘nt‘; Linux->‘posix‘
  • os.system("bash command"):运行shell命令,直接显示
  • os.environ:获取系统环境变量
  • os.path.abspath(path):返回path规范化的绝对路径
  • os.path.split(path):将path分割成目录和文件名二元组返回
  • os.path.dirname(path):返回path的目录。其实就是os.path.split(path)的第一个元素
  • os.path.basename(path):返回path最后的文件名。如何path以/或\结尾,那么就会返回空值。即os.path.split(path)的第二个元素
  • os.path.exists(path):如果path存在,返回True;如果path不存在,返回False
  • os.path.isabs(path):如果path是绝对路径,返回True
  • os.path.isfile(path):如果path是一个存在的文件,返回True。否则返回False
  • os.path.isdir(path):如果path是一个存在的目录,则返回True。否则返回False
  • os.path.join(path1[, path2[, ...]]):将多个路径组合后返回,第一个绝对路径之前的参数将被忽略
  • os.path.getatime(path):返回path所指向的文件或者目录的最后存取时间
  • os.path.getmtime(path):返回path所指向的文件或者目录的最后修改时间
  • os.path.getsize(path): 返回path的大小

五、sys模块

sys模块负责程序与python解释器的交互,提供了一系列的函数和变量,用于操控python的运行时环境。

用法:

  • sys.argv:命令行参数List,第一个元素是程序本身路径
  • sys.modules.keys():返回所有已经导入的模块列表
  • sys.exc_info():获取当前正在处理的异常类,exc_type、exc_value、exc_traceback当前处理的异常详细信息
  • sys.exit(n):退出程序,正常退出时exit(0)
  • sys.hexversion:获取Python解释程序的版本值,16进制格式如:0x020403F0
  • sys.version:获取Python解释程序的版本信息
  • sys.maxint:最大的Int值
  • sys.maxunicode:最大的Unicode值
  • sys.modules:返回系统导入的模块字段,key是模块名,value是模块
  • sys.path:返回模块的搜索路径,初始化时使用PYTHONPATH环境变量的值
  • sys.platform:返回操作系统平台名称
  • sys.stdout:标准输出
  • sys.stdin:标准输入
  • sys.stderr:错误输出
  • sys.exc_clear():用来清除当前线程所出现的当前的或最近的错误信息
  • sys.exec_prefix:返回平台独立的python文件安装的位置
  • sys.byteorder:本地字节规则的指示器,big-endian平台的值是‘big‘,little-endian平台的值是‘little‘
  • sys.copyright:记录python版权相关的东西
  • sys.api_version:解释器的C的API版本

    六、JSON、Pickle模块

    1、序列化把对象(变量)从内存中变成可存储或传输的过程称之为序列化,在Python中叫pickling,在其他语言中也被称之为serialization,marshalling,flattening。

    1、Json序列化

    使用json序列化能够达到跨平台传输数据的目的。

    json数据类型和python数据类型对应关系表:

    Json类型——Python类型

    • {}——dict
    • []——list
    • "string"——str
    • 520.13——int或float
    • true/false——True/False
    • null——None

    json模块序列化和反序列化的一个过程如下图所示

    技术图片

    import json
    
    struct_data = {name: json, age: 23, sex: male}
    print(struct_data, type(struct_data))  # {‘name‘: ‘json‘, ‘age‘: 23, ‘sex‘: ‘male‘} <class ‘dict‘>
    
    data = json.dumps(struct_data)
    print(data, type(data))  # {"name": "json", "age": 23, "sex": "male"} <class ‘str‘>
    
    # 注意:无论数据是怎样创建的,只要满足json格式(如果是字典,则字典内元素都是双引号),就可以json.loads出来,不一定非要dumps的数据才能loads
    data = json.loads(data)
    print(data, type(data))  # {‘name‘: ‘json‘, ‘age‘: 23, ‘sex‘: ‘male‘} <class ‘dict‘>
    
    # 序列化,写入磁盘
    with open(Json序列化对象.json, w) as fw:
        json.dump(struct_data, fw)
    
    # 反序列化
    with open(Json序列化对象.json) as fr:
        data = json.load(fr)
    print(data)  # {‘name‘: ‘json‘, ‘age‘: 23, ‘sex‘: ‘male‘}

    2、Pickle序列化

    Pickle序列化和所有其他编程语言特有的序列化问题一样,它只能用于Python,并且可能不同版本的Python彼此都不兼容,因此,只能用Pickle保存那些不重要的数据,即不能成功地反序列化也没关系。但是pickle的好处是可以存储Python中的所有的数据类型,包括对象,而json模块不可以。

    pickle模块序列化和反序列化的过程如下图所示:

    技术图片

    import pickle
    
    struct_data = {name: json, age: 23, sex: male}
    print(struct_data, type(struct_data))  # {‘name‘: ‘json‘, ‘age‘: 23, ‘sex‘: ‘male‘} <class ‘dict‘>
    
    data = pickle.dumps(struct_data)
    print(data, type( data))  # b‘\x80\x03}q\x00(X\x04\x00\x00\x00nameq\x01X\x04\x00\x00\x00jsonq\x02X\x03\x00\x00\x00ageq\x03K\x17X\x03\x00\x00\x00sexq\x04X\x04\x00\x00\x00maleq\x05u.‘ <class ‘bytes‘>
    
    data = pickle.loads(data)
    print(data, type(data))  # {‘name‘: ‘json‘, ‘age‘: 23, ‘sex‘: ‘male‘} <class ‘dict‘>
    
    # 序列化(注意:pickle模块需要使用二进制存储,即‘wb‘模式存储)
    with open(Pickle序列化对象.pkl, wb) as fw:
        pickle.dump(struct_data, fw)
    
    # 反序列化
    with open(Pickle序列化对象.pkl, rb) as fr:
        pickle = pickle.load(fr)
    print(data)  # {‘name‘: ‘json‘, ‘age‘: 23, ‘sex‘: ‘male‘}

    七 、hashlib模块

    hash是一种算法(Python3.版本里使用hashlib模块代替了md5模块和sha模块,主要提供 SHA1、SHA224、SHA256、SHA384、SHA512、MD5 算法),该算法接受传入的内容,经过运算得到一串hash值。

    hash值的特点:

    1. 只要传入的内容一样,得到的hash值一样,可用于非明文密码传输时密码校验
    2. 不能由hash值返解成内容,即可以保证非明文密码的安全性
    3. 只要使用的hash算法不变,无论校验的内容有多大,得到的hash值长度是固定的,可以用于对文本的哈希处理
    import hashlib
    
    m = hashlib.md5()
    
    m.update(hello.encode(utf8))
    print(m.hexdigest())  # 5d41402abc4b2a76b9719d911017c592
    
    m.update(hash.encode(utf8))
    print(m.hexdigest())  # 97fa850988687b8ceb12d773347f7712
    
    m2 = hashlib.md5()
    m2.update(hellohash.encode(utf8))
    print(m2.hexdigest())  # 97fa850988687b8ceb12d773347f7712
    
    m3 = hashlib.md5()
    m3.update(hello.encode(utf8))
    print(m3.hexdigest())  # 5d41402abc4b2a76b9719d911017c592

    撞库破解hash算法加密

    hash加密算法虽然看起来很厉害,但是他是存在一定缺陷的,即可以通过撞库可以反解,如下代码所示。

    import hashlib
    
    # 假定我们知道hash的微信会设置如下几个密码
    pwd_list = [
        hash3714,
        hash1313,
        hash94139413,
        hash123456,
        123456hash,
        h123ash,
    ]
    
    
    def make_pwd_dic(pwd_list):
        dic = {}
        for pwd in pwd_list:
            m = hashlib.md5()
            m.update(pwd.encode(utf-8))
            dic[pwd] = m.hexdigest()
        return dic
    
    
    def break_code(hash_pwd, pwd_dic):
        for k, v in pwd_dic.items():
            if v == hash_pwd:
                print(hash的微信的密码是===>%s % k)
    
    
    hash_pwd = 0562b36c3c5a3925dbe3c4d32a4f2ba2
    break_code(hash_pwd, make_pwd_dic(pwd_list))
    # hash的微信的密码是===>hash123456

    为了防止密码被撞库,我们可以使用python中的另一个hmac 模块,它内部对我们创建key和内容做过某种处理后再加密。

    如果要保证hmac模块最终结果一致,必须保证:

    1. hmac.new括号内指定的初始key一样
    2. 无论update多少次,校验的内容累加到一起是一样的内容
    import hashlib
    import hmac
    
    # 注意hmac模块只接受二进制数据的加密
    h1 = hmac.new(bhash, msg=None, digestmod=hashlib.md5)
    h1.update(bhello)
    h1.update(bworld)
    print(h1.hexdigest())  # 905f549c5722b5850d602862c34a763e
    
    h2 = hmac.new(bhash, msg=None, digestmod=hashlib.md5)
    h2.update(bhelloworld)
    print(h2.hexdigest())  # 905f549c5722b5850d602862c34a763e
    
    h3 = hmac.new(bhashhelloworld, msg=None, digestmod=hashlib.md5)
    print(h3.hexdigest())  # a7e524ade8ac5f7f33f3a39a8f63fd25

    八、logging模块

    1、低配logging

    日志总共分为以下五个级别,这个五个级别自下而上进行匹配 debug-->info-->warning-->error-->critical,默认最低级别为warning级别。

    v1

    v1版本无法指定日志的级别;无法指定日志的格式;只能往屏幕打印,无法写入文件。

    import logging
    
    logging.debug(调试信息)
    logging.info(正常信息)
    logging.warning(警告信息)  # WARNING:root:警告信息
    logging.error(报错信息)  # ERROR:root:报错信息
    logging.critical(严重错误信息)  # CRITICAL:root:严重错误信息

    v2

    v2版本不能指定字符编码;只能往文件中打印。

    可在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参数会被忽略。
    import logging
    # 日志的基本配置
    
    logging.basicConfig(filename=access.log,
                        format=%(asctime)s - %(name)s - %(levelname)s -%(module)s: %(message)s,
                        datefmt=%Y-%m-%d %H:%M:%S %p,
                        level=10)
    
    logging.debug(调试信息)  #  2019-11-28 18:25:26 PM - root - DEBUG -run: 调试信息
    logging.info(正常信息)  #  2019-11-28 18:25:26 PM - root - INFO -run: 正常信息
    logging.warning(警告信息)  #  2019-11-28 18:25:26 PM - root - WARNING -run: 警告信息
    logging.error(报错信息)  #  2019-11-28 18:25:26 PM - root - ERROR -run: 报错信息
    logging.critical(严重错误信息)  #  2019-11-28 18:25:26 PM - root - CRITICAL -run: 严重错误信息

    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用户输出的消息

    v3

    logging模块包含四种角色:logger、Filter、Formatter对象、Handler

    1. logger:产生日志的对象
    2. Filter:过滤日志的对象
    3. Formatter对象:可以定制不同的日志格式对象,然后绑定给不同的Handler对象使用,以此来控制不同的Handler的日志格式
    4. Handler:接收日志然后控制打印到不同的地方,FileHandler用来打印到文件中,StreamHandler用来打印到终端
    """
    critical=50
    error =40
    warning =30
    info = 20
    debug =10
    """
    
    import logging
    
    # 1、logger对象:负责产生日志,然后交给Filter过滤,然后交给不同的Handler输出
    logger = logging.getLogger(__file__)
    
    # 2、Filter对象:不常用,略
    
    # 3、Handler对象:接收logger传来的日志,然后控制输出
    h1 = logging.FileHandler(t1.log)  # 打印到文件
    h2 = logging.FileHandler(t2.log)  # 打印到文件
    sm = logging.StreamHandler()  # 打印到终端
    
    # 4、Formatter对象:日志格式
    formmater1 = logging.Formatter(%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s,
                                   datefmt=%Y-%m-%d %H:%M:%S %p, )
    
    formmater2 = logging.Formatter(%(asctime)s :  %(message)s,
                                   datefmt=%Y-%m-%d %H:%M:%S %p, )
    
    formmater3 = logging.Formatter(%(name)s %(message)s, )
    
    # 5、为Handler对象绑定格式
    h1.setFormatter(formmater1)
    h2.setFormatter(formmater2)
    sm.setFormatter(formmater3)
    
    # 6、将Handler添加给logger并设置日志级别
    logger.addHandler(h1)
    logger.addHandler(h2)
    logger.addHandler(sm)
    
    # 设置日志级别,可以在两个关卡进行设置logger与handler
    # logger是第一级过滤,然后才能到handler
    logger.setLevel(30)
    h1.setLevel(10)
    h2.setLevel(10)
    sm.setLevel(10)
    
    # 7、测试
    logger.debug(debug)
    logger.info(info)
    logger.warning(warning)
    logger.error(error)
    logger.critical(critical)

    2、高配logging

    1、 配置日志文件

    以上三个版本的日志只是为了引出我们下面的日志配置文件

    import os
    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()指定的名字;lineno为调用日志输出函数的语句所在的代码行
    simple_format = [%(levelname)s][%(asctime)s][%(filename)s:%(lineno)d]%(message)s
    id_simple_format = [%(levelname)s][%(asctime)s] %(message)s
    # 定义日志输出格式 结束
    
    logfile_dir = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))  # log文件的目录,需要自定义文件路径 # atm
    logfile_dir = os.path.join(logfile_dir, log)  # C:\Users\oldboy\Desktop\atm\log
    
    logfile_name = log.log  # log文件名,需要自定义路径名
    
    # 如果不存在定义的日志目录就创建一个
    if not os.path.isdir(logfile_dir):  # C:\Users\oldboy\Desktop\atm\log
        os.mkdir(logfile_dir)
    
    # log文件的全路径
    logfile_path = os.path.join(logfile_dir, logfile_name)  # C:\Users\oldboy\Desktop\atm\log\log.log
    # 定义日志路径 结束
    
    # log配置字典
    LOGGING_DIC = {
        version: 1,
        disable_existing_loggers: False,
        formatters: {
            standard: {
                format: standard_format
            },
            simple: {
                format: simple_format
            },
        },
        filters: {},  # filter可以不定义
        handlers: {
            # 打印到终端的日志
            console: {
                level: DEBUG,
                class: logging.StreamHandler,  # 打印到屏幕
                formatter: simple
            },
            # 打印到文件的日志,收集info及以上的日志
            default: {
                level: INFO,
                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配置。如果‘‘设置为固定值logger1,则下次导入必须设置成logging.getLogger(‘logger1‘)
            ‘‘: {
                # 这里把上面定义的两个handler都加上,即log数据既写入文件又打印到屏幕
                handlers: [default, console],
                level: DEBUG,
                propagate: False,  # 向上(更高level的logger)传递
            },
        },
    }
    
    
    
    def load_my_logging_cfg():
        logging.config.dictConfig(LOGGING_DIC)  # 导入上面定义的logging配置
        logger = logging.getLogger(__name__)  # 生成一个log实例
        logger.info(It works!)  # 记录该文件的运行状态
        
        return logger
    
    
    if __name__ == __main__:
        load_my_logging_cfg()

    2、 使用日志

    import time
    import logging
    import my_logging  # 导入自定义的logging配置
    
    logger = logging.getLogger(__name__)  # 生成logger实例
    
    
    def demo():
        logger.debug("start range... time:{}".format(time.time()))
        logger.info("中文测试开始。。。")
        for i in range(10):
            logger.debug("i:{}".format(i))
            time.sleep(0.2)
        else:
            logger.debug("over range... time:{}".format(time.time()))
        logger.info("中文测试结束。。。")
    
    
    if __name__ == "__main__":
        my_logging.load_my_logging_cfg()  # 在你程序文件的入口加载自定义logging配置
        demo()

    3、Django日志配置文件

    # logging_config.py
    
    LOGGING = {
        version: 1,
        disable_existing_loggers: False,
        formatters: {
            standard: {
                format: [%(asctime)s][%(threadName)s:%(thread)d][task_id:%(name)s][%(filename)s:%(lineno)d]
                          [%(levelname)s][%(message)s]
            },
            simple: {
                format: [%(levelname)s][%(asctime)s][%(filename)s:%(lineno)d]%(message)s
            },
            collect: {
                format: %(message)s
            }
        },
        filters: {
            require_debug_true: {
                (): django.utils.log.RequireDebugTrue,
            },
        },
        handlers: {
            # 打印到终端的日志
            console: {
                level: DEBUG,
                filters: [require_debug_true],
                class: logging.StreamHandler,
                formatter: simple
            },
            # 打印到文件的日志,收集info及以上的日志
            default: {
                level: INFO,
                class: logging.handlers.RotatingFileHandler,  # 保存到文件,自动切
                filename: os.path.join(BASE_LOG_DIR, "xxx_info.log"),  # 日志文件
                maxBytes: 1024 * 1024 * 5,  # 日志大小 5M
                backupCount: 3,
                formatter: standard,
                encoding: utf-8,
            },
            # 打印到文件的日志:收集错误及以上的日志
            error: {
                level: ERROR,
                class: logging.handlers.RotatingFileHandler,  # 保存到文件,自动切
                filename: os.path.join(BASE_LOG_DIR, "xxx_err.log"),  # 日志文件
                maxBytes: 1024 * 1024 * 5,  # 日志大小 5M
                backupCount: 5,
                formatter: standard,
                encoding: utf-8,
            },
            # 打印到文件的日志
            collect: {
                level: INFO,
                class: logging.handlers.RotatingFileHandler,  # 保存到文件,自动切
                filename: os.path.join(BASE_LOG_DIR, "xxx_collect.log"),
                maxBytes: 1024 * 1024 * 5,  # 日志大小 5M
                backupCount: 5,
    
                formatter: collect,
                encoding: "utf-8"
            }
        },
        loggers: {
            # logging.getLogger(__name__)拿到的logger配置
            ‘‘: {
                handlers: [default, console, error],
                level: DEBUG,
                propagate: True,
            },
            # logging.getLogger(‘collect‘)拿到的logger配置
            collect: {
                handlers: [console, collect],
                level: INFO,
            }
        },
    }
    
    
    # -----------
    # 用法:拿到俩个logger
    
    logger = logging.getLogger(__name__)  # 线上正常的日志
    collect_logger = logging.getLogger("collect")  # 领导说,需要为领导们单独定制领导们看的日志

    Python常用模块

    标签:解释   handlers   hex   chdir   加密算   开始   接受   模式   跨平台   

    原文地址:https://www.cnblogs.com/springsnow/p/11953440.html

    (0)
    (0)
       
    举报
    评论 一句话评论(0
    登录后才能评论!
    © 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
    迷上了代码!