第十九天- 约束 异常处理 日志使用

# 类的约束:

# 为何要用，在哪里遇到？

# 例：贴吧登录(若不同人来写)
class Normal:  # 张三版
    def login(self):
        print("普通账号登录")

class Member:  # 李四版
    def login(self):
        print("吧务账号登录")

class Admin:  # 王二版
    def denglu(self):
        print("管理员登陆")

项目经理
def login(obj):
    obj.login()
#
n = Normal()
login(n)

m = Member()
login(m)

a = Admin()
login(a)  # 报错 'Admin' object has no attribute 'login'

# 所以有统一调用时，要避免这样的调用不了，要约束程序的结构.也就是说.
# 分配任务之前就应该把功能定义好.然后分别给底下的程序员来完成相应功能

# 方法一 抛异常 (常用)
'''
提取⽗类.然后在⽗类中定义好⽅法.在这个⽅法中什么都不⽤⼲.就抛⼀个异
常就可以了.这样所有的⼦类都必须重写这个⽅法.否则.访问的时候就会报错.
(尽量抛出的是NotImplementError. 这样比较专业, ⽽且错误比较明确)
'''

class Base: # 项目经理 先定好规范
    def login(self):  # 强制子类做xxx事情(方法)
        raise NotImplementedError("子类没有实现该方法")  # 不做就报错 抛异常

class Normal(Base):  # 张三版
    def login(self):
        print("普通账号登录")

class Member(Base):  # 李四版
    def login(self):  # 对login方法的覆盖重写
        print("吧务账号登录")

class Admin(Base):  # 王二版
    # def denglu(self):  # 这里方法不是login就没有覆盖   
    def login(self):
        print("管理员登陆")


def login(obj):  # 项目经理调用
    obj.login()

n = Normal()
login(n)  # 当Normal (子类) 去执行login时,先回找自身,自己有所以直接执行，也就不会报错了

m = Member()
login(m)

# a = Admin()
# login(a) # 当Admin (子类) 去执行login时，会先回找自身,但他这里自己没有，所以会去父类找login,也就是执行力父类的报错
# 报错 NotImplementedError: 子类没有实现该方法

a = Admin()
login(a)

 

# 方案二  写抽象类和抽象⽅法 来约束子类
'''
我们如果写⼀个⽅法.不知道⽅法的内部应该到底写什么. 那这个⽅法其实就应该是⼀个抽象的⽅法.
如果⼀个类中包含抽象⽅法. 那么这个类⼀定是⼀个抽象类.抽象类是不能有实例的.如.你看看⼀些
抽象派画作.现实中是不存在的.也就⽆法建立实例对象与之相对应.所以抽象类⽆法创建对象.创时会报错
'''

from abc import  ABCMeta,abstractmethod # 原类 抽象
# 贴吧登录
class Base(metaclass=ABCMeta): # 项目经理 抽象类
    @abstractmethod # 抽象方法
    def login(self):  # 约束子类
        pass

    def hehe(self): # 抽象类中可以有正常方法
        print("呵呵呵")

# b = Base() # 报错的. 原因是Base是一个抽象类. 含有抽象方法. 不允许创建对象的


class Normal(Base):  # 张三版
    def login(self): # 子类对抽象的内容给出具体的实现 . 重写
        print("普通账号登录")

class Member(Base):  # 李四版
    def login(self):  # 子类对抽象的内容给出具体的实现 . 重写
        print("吧务账号登录")

class Admin(Base):  # 王二版
    # def denglu(self):  # 报错 继承了前面的抽象必须覆盖
    def login(self):
        print("管理员登陆")


def login(obj):  # 项目经理调用
    obj.login()


n = Normal()
login(n)

m = Member()
login(m)

a = Admin()
login(a)

# 抽象类. 含有抽象方法. 不允许创建对象
# 一个类如果全部都是抽象方法. 这个类可以被称为接口. 用来约束子类和规范子类

# 总结

'''
当我们需要对子类进行约束:
    1.抛出异常 NotImplementedError()  没有实现   -> 约定俗成.  多观察
    2.写抽象类
        from abc import ABCMeta, abstractmethod
        class Base(metaclass = ABCMeta):
            @abstractmethod
            def 方法(self):
                pass
        如果一个类中包含了抽象方法. 那么这个类一定是一个抽象类
        一个抽象类中可以包含正常的方法

        接口: 接口中所有的方法都是抽象方法

        子类必须重写父类中的抽象方法. 否则子类也是一个抽象类
'''

# 异常处理  try...except

# 写法(语法)
try:
    '''操作'''
except '错误名称' as 别名:
    '''出现错误的时候. 要干什么...'''
except '错误名称' as 别名:
    '''出现错误的是偶. 要干什么'''
except Exception as e:
    '''异常的父类，可以捕获所有的异常'''
else:
    '''保护部抛出异常的代码，当try中无异常时执行'''
finally:
    '''最后执行这里'''

'''
解读:程序先执⾏操作,然后如果出错了会走except中的代码.如果不出错,执⾏else中
的代码.不论处不出错.最后都要执⾏finally中的语句.⼀般我们⽤try...except就够⽤了.
顶多加上finally. finally⼀般⽤来作为收尾⼯作. 
'''

try:
    print(1/0)  #  0不能做除数   ZeroDivisionError: division by zero
except ZeroDivisionError as z:
    print("错了. 除数不能为0")


import traceback
# 计算a+b
def cul(a, b):
    if (type(a) == int or type(a) == float) and (type(b) == int or type(b) == float):
        return a + b
    else:
        # 在这里有两种方案. 1. 直接返回 , 2. 抛出异常
        # raise 抛出 Exception 错误和异常,所有错误的根
        raise Exception("我要的不是这个. 你应该我传递int或者float")


try:
    print(cul(1,2))
    print(cul(1,"疙瘩汤"))

except Exception as e:
    # 获取错误信息 访问堆栈信息
    print(traceback.format_exc()) # 获取堆栈信息 一般不这么写 装日志
    print("有误")  # 打印是给客户看的

 

 

# 日志(固定套路，用时照搬)：
# 1. 导入logging模块.
# 2. 简单配置⼀下logging
# 3. 出现异常的时候(except). 向⽇志⾥写错误信息.

import logging
# filename: ⽂件名
# format: 数据的格式化输出. 最终在⽇志⽂件中的样⼦
# 时间-名称-级别-模块: 错误信息
# datefmt: 时间的格式
# level: 错误的级别权重, 当错误的级别权重⼤于等于leval的时候才会写⼊⽂件
logging.basicConfig(filename='x1.log',
     format='%(asctime)s - %(name)s - %(levelname)s -%(module)s: %(message)s',
     datefmt='%Y-%m-%d %H:%M:%S',
level=30)
# 当前配置表示 0以上的分数会被写⼊⽂件
# CRITICAL = 50
# FATAL = CRITICAL
# ERROR = 40
# WARNING = 30
# WARN = WARNING
# INFO = 20
# DEBUG = 10
# NOTSET = 0
logging.critical("我是critical") # 50分. 最贵的
logging.error("我是error") # 40分
logging.warning("我是warning") # 30分
logging.info("我是info")
logging.debug("我是debug")
logging.log(1, "我什么都不是")

# 例子，接上面
import traceback
try:
    print(1/0)
except Exception:
    logging.error(traceback.format_exc()) # 用法
    print("出错了")

 

# 把⽇志⽂件分开 FileHandler

import logging
# 创建⼀个操作⽇志的对象logger（依赖FileHandler）
file_handler = logging.FileHandler('l1.log', 'a', encoding='utf-8')
file_handler.setFormatter(logging.Formatter(fmt="%(asctime)s - %(name)s - %(levelname)s -%(module)s: %(message)s"))
logger1 = logging.Logger('A系统', level=logging.ERROR)
logger1.addHandler(file_handler)
logger1.error('我是A系统')


# 再创建⼀个操作⽇志的对象logger（依赖FileHandler）
file_handler2 = logging.FileHandler('l2.log', 'a', encoding='utf-8')
file_handler2.setFormatter(logging.Formatter(fmt="%(asctime)s - %(name)s -%(levelname)s -%(module)s: %(message)s"))
logger2 = logging.Logger('B系统', level=logging.ERROR)
logger2.addHandler(file_handler2)
logger2.error('我是B系统')