默认类型
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
