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

一、约束

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

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

 1 class BaseMessage(object):
 2     def send(self):
 3         """
 4         必须继承BaseMessage，然后其中必须编写send方法。用于完成具体业务逻辑。
 5         """
 6         raise Exception()
 7 
 8 class Email(BaseMessage):
 9     def send(self):
10         pass # 发送邮件
11         
12     def f1(self):
13         pass 
14     
15     def f2(self):
16         pass 
17 class Wechat(BaseMessage):
18     def send(self):
19         pass # 发送微信
20     
21     def f1(self):
22         pass 
23     
24     def f2(self):
25         pass 
26 class Msg(BaseMessage):
27     def send(self):
28         pass # 发送短信
29         
30     def f1(self):
31         pass 
32     
33     def f2(self):
34         pass 
35         
36         
37 def func(arg):
38     """
39     报警通知的功能
40     """
41     arg.send()
42     
43 
44 obj = Msg()
45 func(obj)

约束实例一

 1 class BaseMessage(object):
 2     def send(self,x1):
 3         """
 4         必须继承BaseMessage，然后其中必须编写send方法。用于完成具体业务逻辑。
 5         """
 6         raise NotImplementedError(".send() 必须被重写.")
 7 
 8 class Email(BaseMessage):
 9     def send(self,x1):
10         """
11         必须继承BaseMessage，然后其中必须编写send方法。用于完成具体业务逻辑。
12         """
13         pass
14 
15 obj = Email()
16 obj.send(1)   #中有几个参数，子类中的send方法中必须有相同的参数

约束实例二

 1 Python：
 2 类 
 3     类：
 4         class Foo:
 5             pass 
 6     抽象类和抽象方法：
 7         
 8 Java、C#:
 9 类 
10     类 
11         class Foo:
12             def f1(self):
13                 pass 
14                 
15             def f2(self):
16                 pass # 可人为抛出异常。 
17                 
18         class Bar(Foo):
19             def f1(self):
20                 pass 
21     
22     抽象类，约束，约束继承它的派生类必须实现它其中的抽象方法。
23         abstact class Foo:
24             def f1(self):
25                 print(1,3,4) 
26                 
27             abstact def f2(self):pass
28         
29         class Bar(Foo):
30             def f2(self):
31                 print('111')
32                 
33         
34         
35 接口，接口中不允许在方法内部写代码，只能约束继承它的类必须实现接口中定义的所有方法。
36     interface IFoo:
37         
38         def f1(self,x1):pass 
39         
40         def f2(self,x1):pass 
41         
42     interface IBar:
43         
44         def f3(self,x1):pass 
45         
46         def f4(self,x1):pass 
47     
48     class Foo(IFoo,IBar):# 实现了2个接口
49         
50         def f1(self,x1):pass 
51         
52         def f2(self,x1):pass 
53         
54         def f3(self,x1):pass 
55         
56         def f4(self,x1):pass

java中的接口和python对比

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

python中的抽象类和抽象方法了解

总结：
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 
        
    ....

实例

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

猜你喜欢