day26

1. 约束

# 约束: 控制派生类中必须包含指定的方法

python:
    类
        (1)用类来进行人为约束:
            class BaseMessage(object):
                def send(self, x1):
                    """
                    必须继承BaseMessage，然后其中必须编写send方法。用于完成具体业务逻辑。
                    """
                    raise NotImplementedError(".send() 必须被重写.")

            class Email(BaseMessage):
                def send(self, x1):
                    """
                    必须继承BaseMessage，然后其中必须编写send方法。用于完成具体业务逻辑。
                    """
                    print('发送邮件')

            obj = Email()
            obj.send(1)
            
            示例:
                class BaseMessage(object):
                    def send(self):
                        """
                        必须继承BaseMessage，然后其中必须编写send方法。用于完成具体业务逻辑。
                        """
                        raise NotImplementedError(".send() 必须被重写.")
            
                class Email(BaseMessage):
                    def send(self):
                        pass  # 发送邮件
                    def f1(self):
                        pass
                    def f2(self):
                        pass
            
                class Wechat(BaseMessage):
                    def send(self):
                        pass  # 发送微信
                    def f1(self):
                        pass
                    def f2(self):
                        pass
            
                class Msg(BaseMessage):
                    def send(self):
                        pass  # 发送短信
                    def f1(self):
                        pass
                    def f2(self):
                        pass
            
                def func(arg):
                    """
                    报警通知的功能
                    """
                    arg.send()
            
                obj = Msg()
                func(obj)

        (2)抽象类和抽象方法:
            from abc import ABCMeta,abstractmethod

            class Base(metaclass=ABCMeta):  # 抽象类
                def f1(self):
                    print(123)

                @abstractmethod
                def f2(self):   # 抽象方法
                    pass

            class Foo(Base):
                def f2(self):
                    print(666)

            obj = Foo()
            obj.f1()

java、c#):
    1.类
        (1)用类来进行人为约束:
            class Foo:
                def f1(self):
                    pass

                def f2(self):
                    pass  # 可人为抛出异常。

            class Bar(Foo):
                def f1(self):
                    pass

        (2)抽象类, 约束, 约束继承它的派生类必须实现它其中的抽象方法.
            abstact class Foo:
                def f1(self):
                    pass

                abstact def f2(self):
                    pass

            class Bar(Foo):
                def f2(self):
                    print('111')


    2.接口, 接口中不允许在方法内部写代码, 只能约束继承它的类必须实现接口中定义的所有方法
        interface IFoo:
            def f1(self, x1): pass
            
            def f2(self, x1): pass

        interface   IBar:
            def f3(self, x1): pass
            
            def f4(self, x1): pass

        class Foo(IFoo, IBar):  # 实现了两个接口
            def f1(self, x1): pass
            
            def f2(self, x1): pass
            
            def f3(self, x1): pass
            
            def f4(self, x1): pass

2. 自定义异常

2.1 异常处理
    (1)第一种方法: 在try里面判断,用字典装异常代码,和对应的错误信息,返回字典.
        def func(path, prev):
            """
            去path路径的文件中, 找前缀为prev的一行数据, 获取数据并返回给调用者
            :return:
            """
            response = {}
            try:
                if not os.path.exists(path):
                    response['code'] = 1001
                    response['data'] = '文件不存在'
                    return response
                if not prev:
                    response['code'] = 1002
                    response['data'] = '关键字为空'
                    return response
                pass
            except Exception as e:
                response['code'] = 1003
                response['data'] = '未知错误'
            return response
        
        def show():
            return 8
        
        def run():
            v1 = func()
            v2 = show()

    (2) 自定义异常, 在try中判断后,直接抛出符合条件的自定义异常,下面捕获异常,进行处理.
        import os
    
        class ExistsError(Exception):
            pass
    
        class KeyInvalidError(Exception):
            pass
    
        def new_func(path, prev):
            """
            去path路径的文件中, 找前缀为prev的一行数据, 获取数据并返回给调用者
            :return:
            """
            response = {}
            try:
                if not os.path.exists(path):
                    raise ExistsError()
    
                if not prev:
                    raise KeyInvalidError()
                pass
            except ExistsError as e:
                response['code'] = 1001
                response['data'] = '文件不存在'
            except KeyInvalidError as e:
                response['code'] = 1002
                response['data'] = '关键字为空'
            except Exception as e:
                response['code'] = 1003
                response['data'] = '未知错误'
            return response

2.2 自定义异常
    class MyException(Exception):  # 自定义的异常类必须继承Exception类(任何类型的异常都必须继承它,它包含了所有异常)
        def __init__(self, code, msg):
            self.code = code
            self.msg = msg
    
    try:
        if   条件:
            raise MyException(1000, '操作异常')  # 抛出自定义异常
    
    except KeyError as obj:
        print(obj, 1111)
    except MyException as obj:  # 捕获自定义异常
        print(obj, 2222)
    except Exception as obj:
        print(obj, 3333)
　堆栈(备注:traceback:回溯;追溯;追踪;错误消息与追溯)#拿堆栈信息
　　　import traceback
　　　traceback.format_exc()

 3. hashlib(md5)-加密

# ----------基本用法--------
    import hashlib
    # 实例化对象
    obj = hashlib.md5()
    # 写入要加密的字节(注意:update()方法现在只接受bytes类型的数据，不接收str类型)
    obj.update('admin'.encode('utf-8'))
    # 取密文
    v = obj.hexdigest()
    print(v)  # 打印取出来的密文
    
# ----------创建函数使用--------
    import hashlib
    def md5(pwd):
        # 实例化对象
        obj = hashlib.md5()
        # 写入要加密的字节
        obj.update(pwd.encode('utf-8'))
        # 取密文
        v = obj.hexdigest()
        return v
    
    ret = md5('maigc')
    print(ret)
    
# -----------加盐------------
    # 加密算法虽然依然非常厉害，但时候存在缺陷，即：通过撞库可以反解。
    # 所以，有必要(加盐)对加密算法中添加自定义key再来做加密。
    import hashlib
    
    SALT = b'2erer3s98'
    
    def md5(pwd):
        # 实例化对象
        obj = hashlib.md5(SALT)  # 在这里加盐,加的盐也必须是字节
        # 写入要加密的字节
        obj.update(pwd.encode('utf-8'))
        # 取密文
        v = obj.hexdigest()  # 加盐后admin的密文:6df50917d0bfb8a02c55a64b10321a9c
        return v
    
    
    user = input("请输入用户名:")
    pwd = input("请输入用户名:")
    if user == 'magic' and md5(pwd) == '6df50917d0bfb8a02c55a64b10321a9c':
        print("登录成功")
    else:
        print('登陆失败')

4. 日志

# ---------单文件日志---------
    import logging
    
    logger = logging.basicConfig(filename='xxxxxxx.txt',
                                 format='%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s',
                                 datefmt='%Y-%m-%d %H:%M:%S',
                                 level=30)  # 阈值,超过这个才被写入日志
    
    logging.debug('x1')  # 10
    logging.info('x2')  # 20
    logging.warning('x3')  # 30
    logging.error('x4')    # 40
    logging.critical('x5')  # 50
    logging.log(10, 'x6')  # 自己设置数值
    
    # 日志等级
    """
    CRITICAL = 50
    FATAL = CRITICAL
    ERROR = 40
    WARNING = 30
    WARN = WARNING
    INFO = 20
    DEBUG = 10
    NOTSET = 0
    """

# ---------日志文件个数的坑---------
    import logging
    
    logger1 = logging.basicConfig(filename='x1.txt',
                                 format='%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s',
                                 datefmt='%Y-%m-%d %H:%M:%S',
                                 level=30)
    
    # 第二次定义的不生效,只往第一次里写
    logger2 = logging.basicConfig(filename='x2.txt',
                                 format='%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s',
                                 datefmt='%Y-%m-%d %H:%M:%S',
                                 level=30)
    
    # 第一次定义的生效,只往第一次定义的文件写
    logging.error('x4')
    logging.error('x5')

# ---------自定义日志(多文件日志)---------
    # 定义流程:
    #     先定义文件: 创建/打开文件(模式,编码格式), 写入格式(用setFormatter设置格式化,用Formatter以fmt的形式格式化).
    #     再定义日志: 用logger设置日志的 %(name)s和阈值.
    #     最后用addHandler,为日志添加操作对象(文件).
    
    import logging
    
    # 定义文件:创建一个操作日志的对象logger1(依赖FileHandler)
    file_handler1 = logging.FileHandler('l1.log', 'a', encoding='utf-8')
    file_handler1.setFormatter(logging.Formatter(fmt="%(asctime)s - %(name)s - %(levelname)s -%(module)s:  %(message)s"))
    
    # 定义日志
    logger1 = logging.Logger('s1', level=logging.ERROR)  # 设置日志的%(name)s 和阈值
    logger1.addHandler(file_handler1)  # 添加操作对象
    
    logger1.error('123123123')
    
    # 定义文件:再创建一个操作日志的对象logger2(依赖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('s1', level=logging.ERROR)
    logger2.addHandler(file_handler2)
    
    logger2.error('666')