python学习第十九天

1.约束(抛出异常；写抽象类)(难点)

    约束是对类的约束
        1.提取父类.然后在父类中定义好方法.这个方法只需要抛出一个异常，子类必须重写这个方法，否则访问就会报错。
        2. 使用元类来描述父类，在元类中给出一个抽象方法. 这样子类就不得不给出抽象方法的具体实现，也可以起到约束的效果.

    1.抛出异常  NotImplementedError
        格式：
            class Base:  # 父类
                def 方法名(self):  # 强制子类做 longin,()
                    raise NotImplementedError('xxxxxxx')
            class Fun(Base):
                def 方法名(self):
                    内容

        例：
            class Base:
                def login(self):  # 强制子类做 longin,()
                    raise NotImplementedError('子类没事有实现该方法')  # 报错，抛出异常

            # 用户登陆 1号成员
            class User(Base):
                def login(self):
                    print('用户登陆')
            # 用户登陆 2号成员
            class Member(Base):
                def login(self):
                    print('成员登陆')
            # 用户登陆 3号成员
            class Admin(Base):
                def denglu(self):
                    print('管理员登陆')

            # 项目经理
            def denglu(obj):
                obj.login()
            u = User()
            denglu(u)
            m = Member()
            denglu(m)
            a = Admin()
            denglu(a)

    2.写抽象类
        格式：
            from abc import ABCMeta, abstractmethod

            class Base(metaclass = ABCMeta):    抽象类

                @abstractmethod
                def 方法(self):pass

            class Foo(Base):  子类必须重写父类中的抽象方法
                def 方法(self):
                    pass

            一个类包含类抽象方法. 这个类一定是抽象类
            抽象类中可以有正常的方法
            抽象类中如果有抽象方法. 这个类将不能创建对象
            接口: 类中都是抽象方法
            子类必须重写父类中的抽象方法. 否则子类也是一个抽象类

        例：
            from abc import ABCMeta, abstractmethod

            class Animal(metaclass=ABCMeta):
                @abstractmethod
                def chi(self):
                    pass

            class Dog(Animal):
                def chi(self):
                    print('吃狗粮')

            d = Dog()
            d.chi()



2.异常处理

    由python解释器来调用代码. 出现了错误. 系统会自动的产生一个叫异常的对象.
    系统会尝试着把错误返回给调用方. 过程被称为:抛异常
    我们通过try...except 可以吧系统产生的这个错误获取到. 过程叫捕获异常

    1.异常
        格式：
            try:

            except Error as e:

            except....

            else:

            finally:
                收尾
        例：
            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('垃圾，输入数字')

            print(cul(1.3, 3))
            print(cul(1.3, 'euan'))

    2.自定义异常
        例：
            class GenderException(Exception):
                pass

            class Person:
                def __init__(self, name, gander):
                    self.name =name
                    self.gander = gander


                def man(self):
                    if self.gander != '男':
                        raise GenderException('性别不对')
                    else:
                        print('欢迎观临')

            try:
                p1 = Person('EUAN','男')
                p1.man()

                p2 = Person('Qian', '女')
                p2.man()
            except GenderException as e:
                print('Not For You')
            except Exception as e:
                print('其他错误')

    3.获取异常：
        格式：
            import traceback
            try:
                # 尝试执行的代码
            except Exception as e:
                # 获取到错误信息. 我们需要访问堆栈信息
                traceback.format_exc() # 获取堆栈信息(错误信息) 记录到日志中



3.关于日志的处理
    1. 导入logging模块.
    2. 简单配置一下logging
    3. 出现异常的时候(except). 向日志里写错误信息.


    例：
        import logging
                
            filename: 文件名
            format : 数据的格式化输出. 最终在⽇志⽂件中的样⼦
            时间-名称-级别-模块: 错误信息
            datefmt: 时间的格式
            level: 错误的级别权重, 当错误的级别权重大于等于leval的时候才会写入文件
                
        logging.basicConfig(filename='x1.log', #  一般日志文件为 .log
             format='%(asctime)s - %(name)s - %(levelname)s -%(module)s: %(message)s',
             datefmt='%Y-%m-%d %H:%M:%S',
        level=0)    # 当前配置表示 0以上的分数会被写入文件
                    # 测试时一般设置为10
                    # 发布给用户后一般设置为30
                
        日志的分数计算
            CRITICAL = 50  重大错误，一般架构师用
            FATAL = CRITICAL
            ERROR = 40  程序员使用的比较多的
            WARNING = 30  
            WARN = WARNING  
            INFO = 20  
            DEBUG = 10  
            NOTSET = 0  
                       
        logging.critical("我是critical")
        logging.error("我是error")
        logging.warning("我是warning")
        logging.info("我是info")
        logging.debug("我是debug")
        logging.log(1, "我什么都不是")
        
        import traceback
        try:
            print(1/0)
        except Exception:
            logging.error(traceback.format_exc()) # 用法
            print("出错了")


    1.记录日志的第一种写法：   配合异常记录日志
    
        import traceback
        import logging
        
        logging.basicConfig(filename='x.log', #  一般日志文件为 .log
             format='%(asctime)s - %(name)s - %(levelname)s -%(module)s: %(message)s',
             datefmt='%Y-%m-%d %H:%M:%S',
        level=30)
        
        try:
            print(1/0)
        except Exception:
            logging.error(traceback.format_exc())
            print('出错了')


    2.记录日志的第二种写法：
    
        import logging
        
        # 1.创建⼀个操作⽇志的对象logger（依赖FileHandler）
        file_handler = logging.FileHandler('日志1.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=20)
        logger1.addHandler(file_handler) # 把文件助手和日志对象绑定
        
        logger1.error('我是A系统出错了') #   使用  记录日志
        
        
        # 2.再创建⼀个操作⽇志的对象logger（依赖FileHandler）
        file_handler2 = logging.FileHandler('日志2.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=20)
        logger2.addHandler(file_handler2)
        
        logger2.error('我是系统出错了') #   使用  记录日志