异常处理，约束，MD5加密，日志处理

Posted 2021-12-28 shuai-aoli

1，异常处理

一般的异常处理说的是抛异常和处理异常

• 异常处理从产生异常开始
  语法：
  

  抛异常:产生异常
  raise Exception("")

• 处理异常
  语法：
  

  处理异常
  try:
      操作
  except Exception as e:
      异常父类，可以捕获所有异常
  else:
      保护不抛出异常的代码，当try中午异常的时候执行
  finall:
      最后总要执行我

• 自定义异常类，只需要继承Exception
  语法：
  

  自定义异常
  class Gandererror(Exception):
      pass

处理异常用法：

 1 import  traceback #导入一个包，获取错误堆栈信息
 2 #一个加法的函数，只能算整数，其他数据类型抛出异常
 3 def add(a,b):
 4     if type(a) != int or type(b) != int:
 5         raise TypeError("不是整数")
 6     else:
 7         return a+b
 8 #捕获异常并处理
 9 try:
10     c = add(10,"s")
11 except TypeError as e:
12     print(e)
13     val = traceback.format_exc()
14     print(val)

 

2，约束

约束是对子类进行的约束
1   通过抛异常（简单，Python适用）
    在父类中给出一个方法，
    这个方法什么都不写，就抛异常NotImplementError()
    在子类中把上述方法进行重写

 1 class Animal(object):#父类中的方法抛异常
 2     def chi(self):
 3         raise NotImplementedError()
 4 class Cat(Animal):#子类有重构方法
 5     def chi(self):
 6         print("好看的吃")
 7 class Dog(Animal):#子类没有重构方法
 8     def chisi(self):
 9         print("吃的真香")
10 def chi(obj):
11     obj.chi()
12 c = Cat()
13 d = Dog()
14 chi(c)#这个能执行
15 chi(d)#这个不能执行

2   抽象类和抽象方法  接口：类中都是抽象的方法
    from abc import ABCMeta,abstractmethod
    抽象方法：抽象方法不用给出方法体，就写个pass就行了
    抽象类：
        类（metaclass=ABCMeta）
        概念：如果类中包含抽象方法，这个类一定是抽象类
        特点：抽象类一般不创建对象
             抽象类中可以存在正常方法
    可以约束子类必须实现抽象方法
　　 

3，MD5加密

MD5加密：
    不可逆
    引入模块 hashlib
　　为了防止撞库，可以加密的时候加点料

使用：

 1 import hashlib
 2 
 3 obj = hashlib.md5()
 4 #obj = hashlib.md5(b‘afnchannednaa‘)
 5 obj.update("shuai".encode(encoding="utf-8"))
 6 mi = obj.hexdigest()
 7 print(mi)
 8 
 9 
10 运行结果：
11 0e0e07a286355994d72085e8ce9761cd

 

4，日志处理

日志处理（重要，简单）
    引入logging模块

• 基本配置
  

   1 import logging
   2 logging.basicConfig(filename=‘app.log‘,#文件名，创建在同一目录下面
   3                     format=‘%(asctime)s - %(name)s - %(levelname)s - %(module)s: %(message)s‘,
   4                     #格式化时间，对应下面的datefmt,
   5                     #用户
   6                     #日志等级名
   7                     #模块，即文件名
   8                     #信息，调用写入
   9                     datefmt=‘%Y-%m-%d %H:%M:%S‘,
  10                     level=40)
  11                          #CRITICAL = 50
  12                         #日志级别
  13                         #FATAL = CRITICAL
  14                         #ERROR = 40
  15                         #WARNING = 30
  16                         #WARN = WARNING
  17                         #INFO = 20
  18                         #DEBUG = 10
  19                         #NOTSET = 0
  20 
  21 
  22 logging.critical("我是critical")
  23 logging.error("我是error")
  24 logging.warning("我是警告")
  25 logging.info("我是基本信息")
  26 logging.debug("我是调试")
  27 logging.log(2, "我是自定义")
  28     

   

• 简单应用

   1 import traceback,logging
   2 
   3 logging.basicConfig(filename=‘app.log‘,#文件名，创建在同一目录下面
   4                     format=‘%(asctime)s - %(name)s - %(levelname)s - %(module)s: %(message)s‘,
   5                     #格式化时间，对应下面的datefmt,
   6                     #用户
   7                     #日志等级名
   8                     #模块，即文件名
   9                     #信息，调用写入
  10                     datefmt=‘%Y-%m-%d %H:%M:%S‘,
  11                     level=40)
  12                         CRITICAL = 50
  13                         日志级别
  14                         FATAL = CRITICAL
  15                         ERROR = 40
  16                         WARNING = 30
  17                         WARN = WARNING
  18                         INFO = 20
  19                         DEBUG = 10
  20                         NOTSET = 0
  21 #抛出异常，通过处理异常，捕获异常写入日志
  22 for i in range(20):
  23     try:
  24         if i % 3 == 0:
  25             raise FileNotFoundError("我是FileNotFountException")
  26         elif i % 3 == 1:
  27             raise StopIteration()
  28         elif i % 3 == 2:
  29             raise KeyError()
  30 
  31     except FileNotFoundError as e:
  32         val = traceback.format_exc()
  33         logging.error(val)
  34     except StopIteration as e:
  35         val = traceback.format_exc()
  36         logging.error(val)
  37     except KeyError as e:
  38         val = traceback.format_exc()
  39         logging.error(val)
  40     except Exception as e:
  41         val = traceback.format_exc()
  42         logging.error(val)

   

• 多个日志文件写入，类似于nginx中的access.log和error.log

   1 import logging
   2 
   3 # 创建?个操作?志的对象logger（依赖FileHandler）
   4 file_handler = logging.FileHandler(‘l1.log‘, ‘a‘, encoding=‘utf-8‘)
   5 # 设置日志文件内容的格式
   6 file_handler.setFormatter(logging.Formatter(fmt="%(asctime)s - %(name)s - %(levelname)s -%(module)s: %(message)s"))
   7 logger1 = logging.Logger(‘A‘, level=40)
   8 logger1.addHandler(file_handler)
   9 # 记录日志
  10 logger1.error(‘我是A系统‘)
  11 
  12 # 再创建?个操作?志的对象logger（依赖FileHandler）
  13 file_handler2 = logging.FileHandler(‘l2.log‘, ‘a‘, encoding=‘utf-8‘)
  14 file_handler2.setFormatter(logging.Formatter(fmt="%(asctime)s - %(name)s -%(levelname)s -%(module)s: %(message)s"))
  15 logger2 = logging.Logger(‘B‘, level=40)
  16 logger2.addHandler(file_handler2)
  17 # 记录日志
  18 logger2.error(‘我是B系统‘)