day26

------------恢复内容开始------------`

   
今日内容：
   1. 约束 
   
   2. 自定义异常

   
   3. hashlib 
   
   4. logging 
   
内容详细：
   1. 约束 
      建议使用：
         class BaseMessage(object):
            def send(self):
               """
               必须继承BaseMessage，然后其中必须编写send方法。用于完成具体业务逻辑。
               """
               raise NotImplementedError(".send() 必须被重写.")
               # raise Exception(".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)
      
      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 
   
      总结：
         1. 什么是接口以及作用？
            接口时一种数据类型，主要用于约束派生类中必须实现指定的方法。
            Python中不存在，Java和C# 中是存在的。
         2. Python中使用过什么来约束呢？
            - 抽象类+抽象方法，编写上麻烦。
            - 人为主动抛出异常 
         
         3. 约束时，抛出的异常是否可以用其他的？
            不专业：raise Exception(".send() 必须被重写.")
            专业：raise NotImplementedError(".send() 必须被重写.")
            
         4. 以后看代码，揣摩心思
            
         5. 写代码：
5.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)

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

            
   
         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 
                     
                  ....
   
   
   2. 自定义异常
   
      # 知识点：如何自定义异常类？# 继承Exception 
      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)
         
   
   3. 加密 
      
      
      关键词：撞库: MD5加密不可逆,不可以反推   但是可以通过撞库来破解简单的md5加密   就是通过简单密码进行md5得到密文和已知密码比较来得到密文的明文
      
         
      加盐  加盐可以避免上述撞库的产生
   
      不加盐hashlib.md5()   hashlib.md5(字符串)即是加盐   SALT即是加的盐 

import hashlib

SALT = b'2erer3asdfwerxdf34sdfsdfs90'

def md5(pwd):
    # 实例化对象
    obj = hashlib.md5(SALT)#不加盐hashlib.md5()   hashlib.md5(字符串)即是加盐   SALT即是加的盐 

    # 写入要加密的字节
    obj.update(pwd.encode('utf-8'))
    # 获取密文
    return obj.hexdigest() # 21232f297a57a5a743894a0e4a801fc3 # 66fbdc0f98f68d69cd458b0cee975fe3 # c5395258d82599e5f1bec3be1e4dea4a


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

4. 日志 logging
   
      为什么要有日志？
         给开发人员看，用于排查错误。

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

1. logging的bebug  如果有两个logger  并不会向两个logger都写入信息  只会向第一个文件位置写入信息  第二个不起作用

2. 如果想向两个文件写入  , 需要自定义file_hander等

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

   
   总结：
      1. 约束     ***
         
      2. md5           *****
      
      3. 自定义异常   *** 
      
      4. 日志处理     ****