python之面向对象性封装,多态,以及鸭子类型

默认类型

class A:

    class_name = 'python23期'

    def __init__(self, name, age):

        self.name = name

        self.age =age

a1 = A('李业', 21) # 实例化一个a1的对象

print(a1.name)

a2 = A('李东宇', 24) # 实例化一个a2的对象

print(a2.age)

封装

把很多数据封装到⼀个对象中. 把固定功能的代码封装到⼀个代码块, 函数, 对象, 打包成模块. 这都属于封装的思想. 具体的情况具体分析. 比如. 你写了⼀个很⽜B的函数. 那这个也可以被称为封装. 在⾯向对象思想中. 是把⼀些看似⽆关紧要的内容组合到⼀起统⼀进⾏存储和使⽤. 这就是封装.

多态

一个事务有多种形态比如水

什么是多态: 在python中默认支持多态,就是a可以定义多种数据类型,不用规定其所属的数据类型,可以是字符串,列表,元组等任意数据类型

python中定义变量不用规定变量的类型

a = 'alex'

a = [1, 2, 3]

a = (22, 33)

Java

int a = 12 # a必须是整型

String b = 'abc'# b必须是一个字符串类型的

鸭子类型

python中你看起来像鸭子,那么你就是鸭子

就是相互独立的两个类,本身是没有什么关系的,然后它们内部有共同的名字func,这种就是鸭子

格式

class A:

    def login(self):

        pass

    def register(self):

        pass

class B:

    def login(self):

        pass

    def register(self):

        pass

# A,B两个类,没有任何关系,独立两个,但是里面的功能相似,所以python一般会将类似于A,B两个类

# 里面的相似的功能让其命名相同.

# 1. A,B虽然无关系,但是很默契的制定了一个规范.让你使用起来更方便.

super

格式

class A:

    def f1(self):

        print('in A f1')

    def f2(self):

        print('in A f2')

class Foo(A):

    def f1(self):

        # super().f2()

        super(Foo, self).f2()

        print('in A Foo')

obj = Foo()

obj.f1()

# 执行结果

in A f2

in A Foo

class A:

    def f1(self):

        print('in A')

class Foo(A):

    def f1(self):

        super(Foo,self).f1()

        print('in Foo')  # 2

class Bar(A):

    def f1(self):

        print('in Bar')  # 1

class Info(Foo,Bar):

    def f1(self):

        super(Info,self).f1()

        print('in Info f1')  # 3

obj = Info()

print(Info.mro())  # [Info, Foo, Bar, A]

obj.f1()

# 执行结果

[<class '__main__.Info'>, <class '__main__.Foo'>, <class '__main__.Bar'>, <class '__main__.A'>, <class 'object'>]

in Bar

in Foo

in Info f1

super() 严格意义并不是执行父类的方法.

单继承: super() 肯定是执行父类的方法.

多继承: super(S,self) 严格按照self从属于的类的mro的执行顺序,执行 S类的下一位.***

类的约束

# 版本二 统一接口

class Wecht:

    def pay(self,money):

        print(f'利用微信支付了{money}')

class Alipay:

    def pay(self, money):

        print(f'利用支付宝支付了{money}')

def pay(obj, money): # 定义一个统一化的设计

obj.pay(money)

obj1 = Wecht()

obj2 = Alipay()

pay(obj1,200)

pay(obj2,300)

# 输出结果

利用微信支付了200

利用支付宝支付了300

# 版本三 野路子写法

# 版本四 按照之前的代码逻辑进行改变

发现问题:

以上代码没有约束,原因就是想怎么写就怎么写,都能实现当时的功能(个人理解)

在上面的情况下(在一些重要的逻辑,与用户数据相关等核心部分),我们要建立一种约束,避免发生此类错误

类的约束有两种解决方式

在父类建立一种约束
利用抽象类(指定的一种规范)的概念

第一种解决方式(建议使用方式)

在父类定义一个pay方法,主动抛出异常,如果子类没有定义pay方法,并且

再建立一个父类pay的方法,约定俗称定义一种规范,子类要定义pay方法,但是没有强制性,还是可以执行

	raise 主动报错提醒

class Payment:

    def pay(self,money):

        raise Exception('必须得定义这个类')

class Wechat(Payment):

    def pay(self,money):

        print(f'利用微信支付了{money}')

class Alipay(Payment):

    def pay(self, money):

        print(f'利用支付宝支付了{money}')

class QQpay(Payment):

    def fuqian(self, money):

        print(f'利用QQ支付了{money}')

def pay(obj, money):

    obj.pay(money)

obj1 = Wechat()

obj2 = Alipay()

pay(obj1,200)

pay(obj2,300)

obj3 = QQpay()

pay(obj3,599)

# 输出结果

Traceback (most recent call last):

  File "/Users/wuqiang/work/PycharmProjects/python23/day24/day24.py", line 50, in <module>

    pay(obj3,599)

  File "/Users/wuqiang/work/PycharmProjects/python23/day24/day24.py", line 41, in pay

    obj.pay(money)

  File "/Users/wuqiang/work/PycharmProjects/python23/day24/day24.py", line 22, in pay

    raise Exception('必须得定义这个类')

Exception: 必须得定义这个类

第二种解决方式

利用抽象类概念, 基类如先设置,子类如果没有定义pay方法,在实例化对象的时候就会抛出错误

from abc import ABCMeta,abstractmethod

class Payment(metaclass=ABCMeta):

    @abstractmethod

    def pay(self, money):

        pass

class Wecht(Payment):

    def pay(self,money):

        print(f'利用微信支付了{money}')

class Alipay(Payment):

    def pay(self, money):

        print(f'利用支付宝支付了{money}')

class QQpay(Payment):

    def fuqian(self, money):

        print(f'利用QQ支付了{money}')

obj3 = QQpay()

# 输出结果

    obj3 = QQpay()

TypeError: Can't instantiate abstract class QQpay with abstract methods pay