项目开发规范、time模块、日志

一. 昨日内容回顾
    自定义模块
    import tbjx

    1.创建一个以 tbjx 命名的名称空间
    2.执行此模块的代码，并将所有内容加载到内存
    3.调用此模块的代码要通过 tbjx. 的方式

    改名：
        import time as t
            1.使代码更简洁
            2.优化代码

    import a
    import b
    import c

    from tbjx import name,read1
    1.创建一个以 tbjx 命名的名称空间
    2.执行此模块的代码，并将所有内容加载到内存
    3.直接将 name read1 加载到当前文件的全局中
        好处：使用方便
        缺点：容易与本文件同名的变量，函数冲突

    from tbjx import functools as func

    from tbjx import *
    1.创建一个以 tbjx 命名的名称空间
    2.执行此模块的代码，并将所有内容加载到内存
    3.直接将 tbjx 模块中所有的内容全部复制一份到当前文件中

    __all__ = ["name", "read1"]

    文件的使用：
        1.当脚本或者代码块，运行本文件的所有代码
        2.当作一个模块，被其他模块调用
            __name__
            本文件使用，相当于 __main__
            其他文件，__name__ == "被调用的模块名"

    __name__ == "__main__":
        1.可以在本模块下，测试自己的代码
        2.项目的执行文件使用

    解释器是按照一定的顺序和位置去寻找模块
    搜索路径：内存--->内置模块--->sys.path[此列表的第一个元素是当前文件的路径]

    想在不同的文件夹下调用模块？
    将模块的路径添加到sys.path中

import sys
print(sys.modules)
程序一运行，解释器会把所有这些 modules 先加载到内存中


二.项目开发规范
    代码不可能只写在一个文件中，否则调整和修改都很不方便，所以要将代码规范化：
        目录规范化，代码规范化(PEP8)

    目录规范化的好处？
        1.项目结构清晰，便于查找
        2.对项目修改时，易于调试

# 三.time模块，datetime模块

import time
print(time.time())
print(time.sleep(1))

# time模块提供的时间有三种模式
# 第一种形式
# time.time() 时间戳——从1970.1.1 0：00距今的时间，供计算机使用
import time
print(time.time())

# 第二种形式(格式化时间)
# 2019/1/8 10:39 strftime()
import time
ft = time.strftime("%Y-%m-%d")
ft = time.strftime("%Y/%m/%d")
ft = time.strftime("%Y/%m/%d %I%M%S")
ft = time.strftime("%Y{}%m{}%d %I:%M:%S").format("年", "月", "日")
print(ft)  # 2019年01月08 10:55:19

# 第三种形式：结构化时间以元组的形式存在
# 作为格式化时间与时间戳进行转化的中转
import time
struct_time = time.localtime()
print(struct_time)
# time.struct_time(tm_year=2019, tm_mon=1, tm_mday=8, tm_hour=10,
# tm_min=56, tm_sec=56, tm_wday=1, tm_yday=8, tm_isdst=0)
print(struct_time[0])  # 2019
print(struct_time.tm_year)  # 2019

# 三种格式之间的转化
# 时间戳 ---> 格式化时间
import time
timestamp = time.time()
# 先将时间戳转化成结构化时间
st = time.localtime(timestamp)
ft = time.strftime("%Y{}%m{}%d %I:%M:%S", st).format("年", "月", "日")
print(ft)  # 2019年01月08 11:00:59

# 格式化时间 ---> 时间戳
import time
ft = time.strftime("%Y/%m/%d %I:%M:%S")
# 先将格式化时间转化成结构化时间
st = time.strptime(ft, "%Y/%m/%d %I:%M:%S")
print(st)
# time.struct_time(tm_year=2019, tm_mon=1, tm_mday=8, tm_hour=11,
tm_min=3, tm_sec=58, tm_wday=1, tm_yday=8, tm_isdst=-1)

# 另一种转化方式
# 结构化时间 ---> 格式化时间  格式固定
import time
strut_time = time.localtime()
st = time.asctime(strut_time)
print(st)  # Tue Jan  8 11:10:57 2019

# 时间戳 ---> 格式化时间  格式固定
import time
print(time.ctime(15000000000))  # Mon May  1 10:40:00 2445

# 时间差的计算
# 2019 1 8 11
# 2016 9 16 12
# 第一步，将这两个格式化时间转化成时间戳

import time
now_time = time.strftime("%Y/%m/%d %H:%M:%S")
now_timestamp = time.mktime(time.strptime(now_time, "%Y/%m/%d %H:%M:%S"))

old_time = time.strftime("2016/9/16 12:00:00")
old_timestamp = time.mktime(time.strptime(old_time, "%Y/%m/%d %H:%M:%S"))

dif_time = now_timestamp - old_timestamp
# print(time.strftime("%Y/%m/%d %H:%M:%S", time.localtime(dif_time)))
struct_time = time.gmtime(dif_time)

msg = "过去了%d年%d月%d天%d小时%d分钟%d秒" % (struct_time.tm_year-1970,struct_time.tm_mon-1,
                                          struct_time.tm_mday-1,struct_time.tm_hour,
                                          struct_time.tm_min,struct_time.tm_sec)
print(msg)  
# 过去了2年3月22天23小时29分钟55秒

# datetime

import datetime
now_time = datetime.datetime.now()
print(now_time)  # 2019-01-08 11:30:56.074414
print(now_time + datetime.timedelta(weeks=3))  # 三周前
print(now_time + datetime.timedelta(weeks=3))  # 三周后
# print(now_time + datetime.timedelta(years=3))    # 年没有
print(datetime.datetime.now() + datetime.timedelta(days=-3))      # 三天前
print(datetime.datetime.now() + datetime.timedelta(days=3))       # 三天后
print(datetime.datetime.now() + datetime.timedelta(hours=5))      # 5小时后
print(datetime.datetime.now() + datetime.timedelta(hours=-5))     # 5小时前
print(datetime.datetime.now() + datetime.timedelta(minutes=-15))  # 15分钟前
print(datetime.datetime.now() + datetime.timedelta(minutes=15))   # 15分钟后
print(datetime.datetime.now() + datetime.timedelta(seconds=-70))  # 70秒前
print(datetime.datetime.now() + datetime.timedelta(seconds=70))   # 70秒后

# 可以直接调整
print(now_time.replace(year=2010))  # 2010-01-08 11:34:20.476402
print(now_time.replace(month=10))   # 2019-10-08 11:35:10.009449
print(now_time.replace(year=2010, month=10, day=23))  # 2010-10-23 11:36:25.877321

# 将时间戳转化成时间
print(datetime.date.fromtimestamp(1232132131))  # 2009-01-17

四.日志
个性化推荐 —— 淘宝，京东，知乎，网易云音乐
只要做了记录，就可以当作广义的日志

开发中的日志
1.帮助调试代码  一个py文件中，使用print()太多，耗费性能大
2.代码警告，危险提示作用
3.对服务器的操作命令
4.重要的节点，需要日志提示，比如转账

# 日志分三种配置：

# 低配——不能同时显示和写入
import logging
logging.debug('debug message')          # 调试模式
logging.info('info message')            # 正常运转模式
logging.warning('warning message')      # 警告模式
logging.error('error message')          # 错误模式
logging.critical('critical message')    # 致命模式
# WARNING:root:warning message
# ERROR:root:error message
# CRITICAL:root:critical message


import logging
while 1:
    try:
        num = input(">>>")
        int(num)
    except ValueError:
        logging.warning("输入了非数字元素，警告！")

# 指定显示信息格式
import logging
logging.basicConfig(
    level=logging.DEBUG,
    # 可以设置级别 把上面的注释掉，然后写下面的
    # level=20,
    format='%(asctime)s %(filename)s[line:%(lineno)d]                     %(levelname)s %(message)s',
    datefmt='%a, %d %b %Y %H:%M:%S',)
    # filename='/tmp/test.log',
    # filemode='w')

logging.debug('debug message')
logging.info('info message')
logging.warning('warning message')
logging.error('error message')
logging.critical('critical message')
# Tue, 08 Jan 2019 12:14:58 abc.py[line:214]                     DEBUG debug message
# Tue, 08 Jan 2019 12:14:58 abc.py[line:215]                     INFO info message
# Tue, 08 Jan 2019 12:14:58 abc.py[line:216]                     WARNING warning message
# Tue, 08 Jan 2019 12:14:58 abc.py[line:217]                     ERROR error message
# Tue, 08 Jan 2019 12:14:58 abc.py[line:218]                     CRITICAL critical message

默认情况下Python的logging模块将日志打印到了标准输出中
且只显示了大于等于WARNING级别的日志
这说明默认的日志级别设置为WARNING
日志级别等级CRITICAL > ERROR > WARNING > INFO > DEBUG
默认的日志格式为  日志级别: Logger名称: 用户输出消息

import logging

logging.basicConfig(level=logging.DEBUG,
                    format="%(asctime)s %(filename)s [line:%(lineno)d]"
                           " %(levelname)s %(message)s",
                    datefmt="%a, %d, %b %Y %H:%M:%S",
                    filename="test.log",
                    filemode="w")

logging.debug("debug message")
logging.info("info message")
logging.warning("warning message")
logging.error("error message")
logging.critical("critical message")

灵活配置日志级别，日志格式，输出位置

这个日志是对本文件的记录



以下所谓加上，是指在logging.basicConfig()中，显示是在Logger所属 filename 中

logging.basicConfig()函数中可通过具体参数来更改logging模块默认行为

1. level: 设置rootlogger的日志级别

2. format: 指定handler使用的日志显示格式
    format参数中可能用到的格式化信息有以下内容：
        %(name)s——Logger的名字
                  这里如果加上的话，显示是root
        %(levelno)s——数字形式的日志级别
                     这里加上的话逐行显示10,20,30,40,50
        %(levelname)s——文本形式的日志级别
        %(pathname)s——调用日志输出函数的模块的完整路径名，可能没有
                      显示本文件的绝对路径
                      这里加上的话，会有乱码，因为路径中有中文字符
        %(filename)s——调用日志输出函数的模块的文件名
                      这里是本文件名，123asda.py
        %(module)s——调用日志输出函数的模块名
                    这里加上的话，是 123asda
        %(funcName)s——调用日志输出函数的函数名
                      这里加上的话，因为从上面到这里都还没函数
                      所以显示是 <module>
        %(lineno)d——调用日志输出函数的语句所在的代码行
                    即比如下面的 logging.debug("debug message")
                    显示是在本文件的第几行，这五个都会显示
        %(created)f——当前时间，用Unix标准的表示时间的浮点数表示
                     这里加上的话，显示 1547727721.904610
        %(relativeCreated)d——输出日志信息时间，自Logger创建以来的毫秒数
        %(asctime)s——字符串形式的当前时间
                     比如这里加上显示：Thu, 17, Jan 2019 20:27:49
        %(thread)d——线程ID，可能没有
                    这里加上显示：7536
        %(threadName)s——线程名，可能没有
                        这里加上显示：MainThread
        %(process)d——进程ID，可能没有
                     这里加上显示：7692
        %(messages)s——用户输出的消息

3. datefmt: 指定 format 中 asctime 的显示格式

4. filename: 用指定的文件名创建FileHandler,这样日志会被存储在指定的文件中

5. filemode: 文件打开方式，在指定了 filename 时使用这个参数，默认为"a"

6. stream: 用指定的stream创建StreamHandler, 可以指定输出到sys.stderr,
             sys.stdout或者文件(f=open("test.log","w")), 默认为sys.stderr.
             如果同时列出了filename和stream两个参数，stream会被忽略

import logging

# 创建一个logger对象
logger = logging.getLogger()

# 创建一个handler，用于写入日志文件
fh = logging.FileHandler("test.log", encoding="utf-8")
# 设置级别
fh.setLevel(logging.DEBUG)
# 这里 DEBUG 改为 INFO 在 test.log中也只显示 WARNING 以上级别的信息

# 再创建一个handler, 用于输出到控制台
ch = logging.StreamHandler()

# 设置显示格式，并将此格式传到两个handler中
formatter = logging.Formatter("%(asctime)s - %(name)s - %(levelname)s - %(message)s")
fh.setFormatter(formatter)
ch.setFormatter(formatter)

# 给logger对象添加两个handler
logger.addHandler(fh)
logger.addHandler(ch)

logger.debug("logger debug message")
logger.info("logger info message")
logger.warning("logger warning message")
logger.error("logger error message")
logger.critical("logger critical message")

# 与本文件同一个目录下，还会创建一个 test.log文件，输出信息和下面的一样
# 2019-01-17 21:01:52,674 - root - WARNING - logger warning message
# 2019-01-17 21:01:52,674 - root - ERROR - logger error message
# 2019-01-17 21:01:52,674 - root - CRITICAL - logger critical message

# 标配

import logging

# 1.产生 logger 对象
logger = logging.getLogger()

# 2.产生其他对象(屏幕对象，文件对象)
sh = logging.StreamHandler()
fh1 = logging.FileHandler("staff.log", encoding="utf-8")
fh2 = logging.FileHandler("boss.log", encoding="utf-8")

# 3.设置显示格式
formater = logging.Formatter('%(asctime)s-%(name)s-%(levelname)s-%(message)s')
formater1 = logging.Formatter('%(asctime)s-%(name)s-%(levelname)s-%(message)s')
formater2 = logging.Formatter('%(asctime)s-%(message)s')

# 4.给对象绑定格式
sh.setFormatter(formater)
fh1.setFormatter(formater1)
fh2.setFormatter(formater2)

# 5.给 logger 对象绑定其他对象
logger.addHandler(sh)
logger.addHandler(fh1)
logger.addHandler(fh2)

# 6.设置显示级别
# 其他对象的级别要高于 logger 的级别
logger.setLevel(40)
sh.setLevel(20)
fh1.setLevel(30)
fh2.setLevel(50)

logging.debug('debug message')
logging.info('info message')
logging.warning('warning message')
logging.error('error message')
logging.critical('critical message')

# 2019-01-08 12:40:42,240-root-ERROR-error message
# 2019-01-08 12:40:42,240-root-CRITICAL-critical message

logging库提供了多个组件：Logger, Handler, Filter, Formatter
Logger对象提供应用程序可直接使用的接口
Handler发送日志到适当的目的地
Filter提供了过滤日志信息的方法


logger的配置文件
上面方式是通过logger对象配置完成日志功能，需要创建各种对象
下面是以字典方式创建logger配置文件，也是实际工作中的做法，相当于一个模板

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]"

simple_format = "[%(levelname)s][%(asctime)s][%(filename)s:%(lineno)d][%(message)s]"

id_simple_format = "[%(levelname)s][%(asctime)s][%(message)s]"

# 设置 log 文件路径
logfile_dir = os.path.dirname(os.path.abspath(__file__))

# 设置 log 文件名
logfile_name = "test.log"

# 如果不存在定义的日志目录就创建一个
if not os.path.isdir(logfile_dir):
    os.mkdir(logfile_dir)

# log配置字典
LOGGING_DIC = {
    "version": 1,
    "disable_existing_loggers": False,
    "formatters": {
        "standard": {
            "format": standard_format
        },
        "simple": {
            "format": simple_format
        }
    },
    "filters": {},
    # 打印到屏幕的日志
    "screen": {
        "level": "DEBUG",
        "class": "logging.StreamHandler",
        "formatter": "simple"
    },
    # 打印到文件的日志,收集 INFO 及以上的日志
    "file":{
        "level": "DEBUG",
        "class": "logging.handlers.RotatingFileHandler",  # 保存到文件
        "formatter": "standard",
        "filename": logfile_path,  # 日志文件
        "maxBytes": 1024*1024*5,  # 日志大小 5M
        "backupCount": 5,
        "encoding": "utf-8",  # 日志文件的编码，不用担心中文乱码的问题
    },
    "loggers": {
        # logging.getLogger(__name__)拿到的logger配置
        "": {
            # 把上面定义的两个handler都加上，即log数据即写入文件又打印到屏幕
            "handlers": ["screen", "file"],
            # 总级别，一定要设置最低的，即 DEBUG
            "level": "DEBUG",
            # 向上（更高level的logger）传递
            "propagate": True,
        },
    },
}

def load_my_logging_cfg():
    # 导入上面定义的logging配置
    logging.config.dictConfig(LOGGING_DIC)
    logger = logging.getLogger("转账业务")
    logger.info("It works!")  # 记录该文件的运行状态

if __name__ == "__main__":
    load_my_logging_cfg()