一:继承
定义:一个类除了拥有自身的属性方法之外,还拥有另外一个类的属性和方法
继承: 1.单继承 2.多继承
子类: 一个类继承了另外一个类,那么这个类是子类(衍生类)
父类:一个类继承了另外一个类,被继承的那个类是父类(超类,基类)
object 是所有的类的父类
1.单继承
#例:
class Human():
def eat(self):
print("远古人类打猎,吃猎物")
def sleep(self):
print("远古人类吃饱了就睡觉")
def __beat_doudou(self):
print("远古人类起来先打豆豆,再打猎")
#把要继承的类放到class 定义类的这个括号里面写
#(1) 子类可以调用父类的公有成员(方法,属性)
#例:
class Man(Human):
pass
#实例化对象
obj = Man()
obj.eat()
#(2) 子类不可以调用父类私有成员(方法,属性)
#例:
class Woman(Human):
def myskill(self):
#调用父类公有方法
self.eat()
#不能够在子类里面调用父类私有方法
#self>__beat_doudou()
obj = Woman()
#obj.__beat_doudou() 私有的没法再类外调用
obj.myskill()
#(3)子类可以改造父类的公有方法
子父继承之后,如果调用的成员
子类里面有,优先调用子类的
子类里面没有,就调用父类
#例:
class Children():
#对eat方法进行改写
def eat(self):
print("小孩生下来只会喝奶")
obj = Children()
obj.eat()
2.多继承
#(1) 基本语法
#例:
class Father():
f_property = "风流倜傥,英俊潇洒"
def f_hobby(self):
print("喜欢跑步")
class Mother():
m_property = "沉鱼落雁,闭月羞花"
def m_hobby(self):
print("喜欢做菜")
#多继承:在括号里面用逗号,把多个父类隔开
class Daughter(Father,Mother):
pass
obj = Daughter()
print(obj.f_property)
obj.m_hobby()
#(2)调用父类
class Father():
f_property = "风流倜傥,英俊潇洒"
def f_hobby():
print("喜欢跑步")
class Mother():
m_property = "沉鱼落雁,闭月羞花"
def m_hobby(self):
print("喜欢做菜")
class Son(Father,Mother):
#f_property = "子类的属性f_property"
#(1)通过类的方式调用父类的相关成员
def skill1(self):
#调用Father的f_hobby
Father.f_hobby()
#调用Mother中的m_property
print(Mother.m_property)
#(2)通过对象的方式调用父类的相关成员
def skill2(self):
#调用Father中的f_property
print(self.f_property)
#调用Mother中的m_hobby
self.m_hobby()
#(3)使用super调用父类的相关成员
def skill3(self):
# 调用Father中的f_property
#super() 一定调用的是父类的,区别于self
#print(super().f_property)
#super().f_hobby() error super() 调用的是绑定方法,默认传递self参数
super().m_hobby()
print("============")
obj = Son()
obj.skill1()
#obj.skill2()
obj.skill3()
#关于super的概念
(1)super 本事是一个类,super()是一个对象,用于调用父类的绑定方法
(2)super() 只应用在绑定方法中,默认自动传递self对象(前提:super所在作用域存在self)
(3)super用途:解决复杂的多继承调用顺序
3.菱形继承
#菱形继承就是广度优先算法的方式继承父类函数
#例:下面是关于例1中的继承关系
Human
Man Woman
Children
#例:
class Human():
pty = 111
def feelT(self):
print("远古人类天热了1")
print(self.pty)
print("远古人天冷了2")
class Man(Human):
pty = 222
def feelT(self):
print("现代男性天气热了3")
super().feelT()
print("现代男性天冷了4")
class Woman(Human):
pty = 333
def feelT(self):
print("现代女性天热了5")
super().feelT()
print("现代女性天冷了6")
class Children(Man,Woman):
pty = 444
def feelT(self):
print("小孩天热了7")
super().feelT()
print("小孩天冷了8")
obj = Children()
obj.feelT()
#c.f => 7
#M.f =>3
"""
#mro 列表:通过c3算法,把所有的继承关系按照列表的顺序呈现
#语法:
#类.mro() => 继承顺序列表
[<class '__main__.Children'>,
<class '__main__.Man'>,
<class '__main__.Woman'>,
<class '__main__.Human'>,
<class 'object'>]
super 就是默认按照mro列表的顺序,依次调用
用于解决多继承调用顺序混乱的问题
"""
lst = Children.mro()
print(lst)
#判断是否是子父关系 [有血缘关系即可] issubclass
res = issubclass(Children,Man)
res = issubclass(Children,Human)
#满足一个条件,即返回真
res = issubclass(Children,(Man,Woman))
print(res)
#判断对象的类型, [有血缘关系即可] isinstance
res = isinstance(obj,Children)
res = isinstance(obj,Man)
res = isinstance(obj,(Human,Woman))
print(res)
二:多态(不同的对象)
不同的子类对象,调用相同的父类方法,产生不同的执行结果
特征:继承 重写
好处:在不改变代码的前提下,实现代码的复用,和不同的效果
#例:
class Soldier():
#攻击
def attack(self):
pass
#撤退
def back(self):
pass
#陆军
class Army(Soldier):
def attack(self):
print("[陆军]使用坦克进攻轰炸")
def back(self):
print("[陆军]使用军车进行撤退")
#海军
class Navy(Soldier):
def attack(self):
print("[海军]使用鱼雷攻击")
def back(self):
print("[陆军]开启防御鱼雷模式")
#空军
class Airforce(Soldier):
def attack(self):
print("[空军]炮弹袭击")
def back(self):
print("[空军]降落防空基地")
#实例化各个兵种,各就位准备
obj_army = Army()
obj_navy = Navy()
obj_airforce = Airforce()
lst = [obj_army,obj_navy,obj_airforce]
#等待将军下发命令
strvar = """
您好将军,下面是您的操作按钮:
1.全体出击
2.全体撤退
3.陆军出击,其他人撤退
4.退出程序
"""
sign = True
while sign:
print(strvar)
num = input("将军请下令:")
for i in lst:
if num == "1":
i.attack()
elif num == "2":
i.back()
elif num == "3":
if isinstance(i,Army):
i.attack()
else:
i.back()
elif num == "4" or num.upper() == "Q":
sign = False
break
else:
print("风太大,我听不到")
break