day 26 约束、自定义异常、加密hashlib、logging

一、约束

建议使用：
class BaseMessage(object):
    def send(self):
        """
        必须继承BaseMessage，然后其中必须编写send方法。用于完成具体业务逻辑。
        """
        raise NotImplementedError(".send() 必须被重写.")  主动抛异常，意味着子类中必须有send方法

#BaseMessage类用于约束，约束其派生类：保证派生类中必须编写send方法，不然执行可能就会报错。

class BaseMessage(object):
    def send(self):
        """
        必须继承BaseMessage，然后其中必须编写send方法。用于完成具体业务逻辑。
        """
        raise Exception()

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)

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

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

obj = Email()
obj.send(1)   #中有几个参数，子类中的send方法中必须有相同的参数

Python：
类 
    类：
        class Foo:
            pass 
    抽象类和抽象方法：
        
Java、C#:
类 
    类 
        class Foo:
            def f1(self):
                pass 
                
            def f2(self):
                pass # 可人为抛出异常。 
                
        class Bar(Foo):
            def f1(self):
                pass 
    
    抽象类，约束，约束继承它的派生类必须实现它其中的抽象方法。
        abstact class Foo:
            def f1(self):
                print(1,3,4) 
                
            abstact def f2(self):pass
        
        class Bar(Foo):
            def f2(self):
                print('111')
                
        
        
接口，接口中不允许在方法内部写代码，只能约束继承它的类必须实现接口中定义的所有方法。
    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):# 实现了2个接口
        
        def f1(self,x1):pass 
        
        def f2(self,x1):pass 
        
        def f3(self,x1):pass 
        
        def f4(self,x1):pass 

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()

总结：
1. 什么是接口以及作用？
　　接口时一种数据类型，主要用于约束派生类中必须实现指定的方法。
　　Python中不存在，Java和C# 中是存在的。
2. Python中使用过什么来约束呢？
　　- 抽象类+抽象方法（伪造出接口类型），编写上麻烦。
　　- 人为主动抛出异常 

3. 约束时，抛出的异常是否可以用其他的？
　　不专业：raise Exception(".send() 必须被重写.")
　　专业：raise NotImplementedError(".send() 必须被重写.")

4. 以后看代码，揣摩心思

5. 写代码：
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)


6. 应用场景：
多个类，内部都必须有某些方法时，需要使用基类+异常进行约束。
学员管理程序：

class IBase:
    def login():
        raise NotImplementedError(".send() 必须被重写.")

class Student:
    def login(self):
        pass 
        
    def score(self):
        pass 
        
class Teacher:
    def login(self):
        pass 
        
    def exam(self):
        pass 
        
class Manager(self):
    def login(self):
        pass 
        
    ....

二、 异常处理：

实例

　　一、自定义异常异常

# 知识点：如何自定义异常类？
class MyException(Exception):
    def __init__(self,code,msg):
        self.code = code
        self.msg = msg
try:
    # 知识点：主动抛出异常 
    raise MyException(1000,'操作异常')

except KeyError as obj:
    print(obj,1111)
except MyException as obj: # 知识点：捕获异常   结果#(1000, '操作异常') 2222
    print(obj,2222)
except Exception as obj:
    print(obj,3333)

class MyException(Exception):
    def __init__(self,code,msg):
        self.code = code
        self.msg = msg
try:
    raise MyException(1000,'操作异常')

except KeyError as obj:
    print(obj,1111)
except MyException as obj:
    print(obj,2222)
except Exception as obj:
    print(obj,3333)

 　

　　二、加密

import hashlib   引入模块
SALT = b'2erer3asdfwerxdf34sdfsdfs90'
def md5(pwd):
    # 实例化对象
    obj = hashlib.md5(SALT)     #SALT为加盐操作，加入特殊的值，防止别人盗用
    # 写入要加密的字节
    obj.update(pwd.encode('utf-8'))   #要加密的必须是字节，字符串用encode来转化为字节
    # 获取密文
    return obj.hexdigest() #  c5395258d82599e5f1bec3be1e4dea4a

user = input("请输入用户名:")
pwd = input("请输入密码:")
if user == 'oldboy' and md5(pwd) == 'c5395258d82599e5f1bec3be1e4dea4a':
    print('登录成功')
else:
    print('登录失败')

　　三、日志

　　　　日志的目的是为了给开发着看的，当有错误时，把错误记录下来。防止发生错误的时候开发者方便排查错误

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')


import traceback

def func():
    try:
        a = a +1
    except Exception as e:
        # 获取当前错误的堆栈信息
        msg = traceback.format_exc()     获取当前错误信息的具体位置， 带错误行，错误类型
        logging.error(msg)
func()

实例坑：

引入模块只能导入一个日志，有两个及以上是，内存中只会存在第一个文件

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)

logging.error('x4')
logging.error('x5')

自定义日志可以解决上述问题

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('s1', level=logging.ERROR)
logger1.addHandler(file_handler)


logger1.error('123123123')



# 在创建一个操作日志的对象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('s2', level=logging.ERROR)
logger2.addHandler(file_handler2)

logger2.error('666')