re
正则表达式
匹配字符串
场景 例如:爬虫,密码规则验证,邮箱地址验证,手机号码

学习re主要学习的就是 那一堆特殊符号

hashlib
hash是一种算法 lib表示库
该模块包含了一堆的hash算法
hash接受任意长度的输入,计算后,输出一段固定长度的字符串
根据算法的不同结果的长度也不同
在算法固定的情况下,输入的数据相同,输出的结果也必然相同
hash的两个作用:
    1.加密 无法被反解
    2.文件校验 比对两个文件是否完全相同

常用模块

1.logging *****

翻译为日志记录
    该模块用于记录日志的
    
    1.日志是什么?
    日志其实就是日记,用于记录某个时间点发生了什么事
    
    2.为什么要记录日志?
    是为了日后来复查,提取有用的信息
    
    3.如何来记录日志?
    可以直接打开文件,往里写东西
    
    直接写入文件的两个问题:
    1.你写的数据格式,别人看不懂
    2.解析数据麻烦
    
    因此logging就诞生了
    logging 专门用于记录日志
    
    日志的级别
    1.debug (最底层)          调试信息(用于记录程序在开发过程中的调试记录,例如,不清楚这个变量的值,所以打印一下)
    2.info  记录普通信息(没特别的意义,就是简单的记录)
    3.warning    警告信息(当某些操作可能发生错误,就记录为警告信息,涉及一些安全操作时,例如删库)
    4,error    错误信息(当程序遇到错误时,列入要求用户输入一个整数,他偏要输入小数,导致数据类型转换失败)
    5.critical    严重错误(当程序遇到问题,无法继续执行时,例如,需要一个核心组件,然而这个组件被用户删了)
    为什么分级:随着时间的推移,你的日志会越来越多,成千上万条,这时候要提取有用的信息就很慢,所有使用logging,这样一来,在查看日志的时候,可以快速的定位到想要的日志
    
    为什么要设置最低等级,因为一些级别的日志对我是无用的
    
    如果我们需要更详细的去定制logging的各项功能,就需要我们系统的学习一下logging这个模块
    四种核心角色
        1.Logger 日志生成器:负责产生一条完整的日志
        2.Filter 过滤器:负责对日志进行过滤
        3.Handle 处理器:负责将日志输出到指定位置
        4.Formater 格式化:负责处理日志显示的格式
    一条日志的生命周期
    1.由Logger产生日志
    2.交给过滤器进行过滤
    3.交给Hanlder按照Formater的格式进行输出
    这三步都可以 对日志进行筛选,什么样的需要显示,什么样的不需要显示
     
    使用方法
    
    import logging
    
    # 简单的使用
    logging.debug('这是一条日志信息') # 没有输出任何内容
    因为logging模块为日志划分了级别,由于你输出的级别没有达到最低级别,所有没有输出
    logging.info()
    logging.debug()
    logging.warnning()
    logging.error()
    logging.critical()
    最低等级是warnning
    logging用数字来表示级别  从低到高 0 10 20 30 40 50
    #默认情况下,级别为warnning,输出的位置是控制台,默认的日志格式为 级别:日志生成器的名称:调试的信息
    
    如何修改默认的行为
    logging.basicConfig(filename="mylog.txt", # 指定的日志文件名
                filemode="a", #指定的是文件打开的模式  通常为a
                level=logging.DEBUG, # 指定级别
                format="%(filename)s %(levelname)s %(asctime)s %(message)s",# 指定显示格式
                )
    
    
    需求:有一个登录注册 功能 需要记录用户操作日志,程序员需要看到最详细的信息,而boss只需要看到简单信息
    
    #自定义四种核心觉得,完成日志的输出
    #参数指定的生成器的名称(因为可以同时存在多个生成器,需要名字来加以区分)
    mylog = logging.getLogger('mylog')
    #设置生成器的级别,低于该级别的不会生成
    mylog.setLevel(10)
    # 过滤器 这里不讲 需要使用面向对象的基础知识点(不常用)
    # 给程序员看的日志处理器
    handler1 = logging.FileHandler("youlog.txt",encoding="utf8",)
    #将处理器 绑定给生成器, add函数表明了  一个生成器可以添加多个处理器
    mylog.addHandler(handler1)


    # 给老板看的日志处理器
    handler2 = logging.FileHandler("boss.txt",encoding="utf8",)
    #将处理器 绑定给生成器, add函数表明了  一个生成器可以添加多个处理器
    mylog.addHandler(handler2)
    

    # 格式化处理器
    
    # 程序员的格式化处理器
    formater1= logging.Formatter(fmt="%(threadName)s %(funcName)s %(module)s %(filename)s %(levelname)s %(asctime)s %(message)s")
    # 将格式化处理器 绑定给  handler
    handler1.setFormatter(formater1)


    # 老板的格式化处理器
    formater2= logging.Formatter(fmt="%(levelname)s %(asctime)s %(message)s")
    # 将格式化处理器 绑定给  handler
    handler2.setFormatter(formater2)


    
    现在需求已经实现了,但是每次使用日志都要写这么一堆代码,最好把配置写死,直接复制已有的配置信息
    # logging.config 专门用于配置logging模块
    import logging.config
    #导入包含配置字典的模块
    import loggin_config
    #通过一个字典来配置logging模块
    logging.config.dictConfig(loggin_config.LOGGING_DIC)
    
    通过名称来获取一个生成器
    aaloger = logging.getLogger('aa')
    aaloger.info('测试信息')
    
    当要获取的名称不存在时,会返回一个默认的生成器
    aaloger = logging.getLogger('asadafasd')
    
    print(aaloger.name)
   
    
    
    字典配置(重点)
    字典的 内容重点,但是不需要背,
    需要记住的是 如何来加载配置

                  '[%(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 = "dictconfig.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',  # 日志文件的编码
        },
        "ATM":{
            'level': 'DEBUG',
            'class': 'logging.handlers.RotatingFileHandler',  # 保存到文件
            'formatter': 'standard',
            'filename': "ATMlog.txt",  # 日志文件
            'maxBytes': 1024*1024*5,  # 日志大小 5M
            'backupCount': 5, #日志文件最大个数
            'encoding': 'utf-8',  # 日志文件的编码
        }
    },
    'loggers': {
        #logging.getLogger(__name__)拿到的logger配置
        #aa是生成器的名称 可以随便写
        # 如果将key(生成器名称)设置为空 则意味着将它作为默认的是你生成器
        '': {
            'handlers': ['default', 'console'],  # 这里把上面定义的两个handler都加上，即log数据既写入文件又打印到屏幕
            'level': 'DEBUG',
            'propagate': True,  # 向上（更高level的logger）传递 日志的继承
        },
        "atm":{
            'handlers': ['ATM'],  # 这里把上面定义的两个handler都加上，即log数据既写入文件又打印到屏幕
            'level': 'DEBUG',
            'propagate': True,  # 向上（更高level的logger）传递 日志的继承
        }
    },
}```

        
    # 了解知识点

    # 自己来定义四种核心角色

    import logging
    mylog = logging.getLogger("father")
    mylog.setLevel(10)

    handler = logging.FileHandler("father.log")
    mylog.addHandler(handler)
    handler.setLevel(10)

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

    # 在获取一个生成器  同时指定该生成器的父生成器是father这个生成器
    sonlog = logging.getLogger("father.son")

    # 需求:子生成器 的输出位置与父生成器不同  格式相同
    sonhandler = logging.FileHandler("son.txt",encoding="utf8")
    sonlog.addHandler(sonhandler)


    sonfmt = logging.Formatter(fmt="%(threadName)s %(funcName)s %(module)s %(filename)s %(levelname)s %(asctime)s %(message)s")
    sonhandler.setFormatter(sonfmt)


    # 继承后子生成器 可以直接使用父生成器的配置

    # mylog.info("这是一条日志信息!")
    # sonlog.info("这是  son 输出的日志信息!")


    #子生成器 在生成一个日志时  会自动给父生成器也发一个

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

    sonlog.info("这是  son 输出的日志信息!")
     
        
        学习logging模块,是为了更方便的记录日志,不用再自己解决日志记录的问题
        
        
#### 2.sys模块 ***
        是system的缩写,表示系统,指的是python的解释器
        import sys
        # 用于操作系统调用解释器时传入的参数
        print(sys.argv) 当前文件路径,是解释器的第一个参数
        给多个参数,用空格隔开
        
        #当你要开发一款基于cmd的程序时,就需要使用这个属性了,因为一些操作系统没有界面,只能通过cmd来使用
        
        #需求 开发一个基于cmd的复制文件的工具
        第一个参数表示被执行的py文件,第二个作为源文件路径,第三个作为目标文件的路径
        source_path = sys.argv[1]
        target_path = sys.argv[2]
        
        
        sys.exit(0) 表示正常退出
        
        总结 sys]处理与python解释器相关的一些操作
        添加环境变量 sys.path
        获取调用解释器的参数  sys.argv
        
#### 3.shevlem模块***
        用于序列化的模块:json,pickle
        
        import shelve
        shelve.open('test.she')
        s.['name'] = 'egon'
        s['dic'] = {'age':20}
        
        s = shelve.open('test.she')
        print(s['name'])
        
        #shelve 模块只有一个函数,就是open用于打开一个文件,
        打开以后,操作方式与字典完全一致,你可以把它当成字典,并且是自带buff的字典,可以字典给完成序列化
        同样支持 python所有的基础数据类型
        该模块序列化得到的数据,只能被该模块使用,其他语言没有这个模块,所以无法使用,即无法跨平台,当你写的程序是一个单机程序时,可以考虑
        后期,只要涉及到数据交换,就应该使用json

posted on 2018-12-09 11:20 shanau2 阅读(133) 评论(0) 编辑收藏举报

会员力量，点亮园子希望

刷新页面返回顶部

导航

昨日回顾

常用模块

1.logging *****