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

默认类型

class A: class_name = 'python23期' def __init__(self, name, age): self.name = name
self.age =agea1 = 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):
passclass 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 Fooclass A:
def f1(self):
print('in A')class Foo(A):
def f1(self):
super(Foo,self).f1()
print('in Foo') # 2class Bar(A):
def f1(self):
print('in Bar') # 1class Info(Foo,Bar): def f1(self):
super(Info,self).f1()
print('in Info f1') # 3obj = 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# 版本三 野路子写法# 版本四 按照之前的代码逻辑进行改变发现问题:
以上代码没有约束,原因就是想怎么写就怎么写,都能实现当时的功能(个人理解)
在上面的情况下(在一些重要的逻辑,与用户数据相关等核心部分),我们要建立一种约束,避免发生此类错误

类的约束有两种解决方式

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

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

在父类定义一个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):
passclass 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