python面向对象之二（类的继承、类的多态）
作者：互联网
一、类的继承
（一）、父类与子类
父类：被继承的类，子类继承父类后，会继承父类里面所有的属性（数据属性&实例属性）以及方法
子类：继承其他的类，子类继承父类后，能够继承父类里面所有的方法以及属性，当然也可以调用
实例
class Persion(object):
city='xian'
def __init__(self,name,age):
self.name=name
self.age=age
def show(self):
print('my name is {name},and my age is {age}'.format(
name=self.name,age=self.age))
class Student(Persion):
def __init__(self,name,age,score):
#子类继承父类的实例属性
Persion.__init__(self,name,age)
self.score=score
def info(self):
print('my name is {name},and my age is {age},and my score is {score},'
'and my city is {city}'.format(
name=self.name,age=self.age,score=self.score,city=self.city))
print('子类调用父类的方法输出结果：\n')
self.show()
stu=Student('wuya',18,90)
stu.info()
print(stu.city)
（二）、原则
继承的N个原则：
1、子类可以继承N个父类，但是建议不要超过两个，最多两个
2、山下原则》》》如果子类没有重写父类的方法，那么使用的是上下原则
A、如果子类没重写父类的方法，调用父类的方法，输出的结果是父类里面方法的输出结果
B、如果子类重写了父类里面的方法，那么调用该重写的方法，输出的结果是子类里面方法的输出结果
3、从左到右原则：一个子类继承多个父类，那么调用方法后，从左到右按线性的方式（找到满足的不找了）寻找
方法重写：子类重写了父类里面的方法。重写的目的是父类的方法没有办法满足子类的需求，那么就会重写
上下原则：
①、方法重写的
class Persion(object):
city='xian'
def __init__(self,name,age):
self.name=name
self.age=age
def show(self):
print('my name is {name},and my age is {age}'.format(
name=self.name,age=self.age))
class Student(Persion):
def __init__(self,name,age,score):
Persion.__init__(self,name,age)
self.score=score
def info(self):
print('my name is {name},and my age is {age},and my score is {score},'
'and my city is {city}'.format(
name=self.name,age=self.age,score=self.score,city=self.city))
def show(self):
print('我是子类的show method')
stu=Student('wuya',18,90)
stu.info()
stu.show()
②、方法未重写的
class Persion(object):
city='xian'
def __init__(self,name,age):
self.name=name
self.age=age
def show(self):
print('my name is {name},and my age is {age}'.format(
name=self.name,age=self.age))
class Student(Persion):
def __init__(self,name,age,score):
Persion.__init__(self,name,age)
self.score=score
def info(self):
print('my name is {name},and my age is {age},and my score is {score},'
'and my city is {city}'.format(
name=self.name,age=self.age,score=self.score,city=self.city))
stu=Student('wuya',18,90)
stu.info()
stu.show()
从左到右原则：
class A(object):
def show(self):
print('this is A')
class B(object):
def show(self):
print('this is B')
class C(A,B):
pass
c=C()
c.show()
（三）、继承中常见的错误日志
class A(object):
def show(self):
print('this is A')
class B(A):
def show(self):
print('this is B')
class C(A,B):
pass
c=C()
c.show()
（四）、继承的原理
所以在Python中，基于MRO的解析顺序规则，就会从左到右开始查找基类，如果找到第⼀个匹配的属性类，就会停⽌查找，如果没有，那就继续查找，直到查找到符合要求的为⽌。MRO其实就是通过⼀个C3线性化算法来实现
的，它的核⼼思想为：
1、⼦类会优先于⽗类检查
2、多个⽗类会根据它们在列表中的顺序被依次检查
3、如果对下⼀个类存在两个合法的选择，只能选择第⼀个
class A(object):
def show(self):
print('this is A')
class B(object):
def show(self):
print('this is B')
class C(A,B):
pass
c=C()
print(C.mro())
c.show()
（五）、java与python继承的区别
Java是单继承的，而python是多继承的，当然不建议超过两个
（六）、python2余python3的查找区别
把Python2的类叫经典类，Python3的类叫新式类，其实在Python2中，多个类的继承算法叫深度优先，⽽Python3叫⼴度优先
演示python3的继承查找流程
class A(object):
def show(self):
print('A')
class B(A):
def show(self):
print('B')
class C(A):
def show(self):
print('C')
class D(B,C):
pass
obj=D()
print(D.mro())
结果：python2中的结果是D,B,A,C,object python3是D,B,C,A,object
二、类的多态
（一）、优势
1、增加了持续的灵活性
2、增加了持续的额外扩展的功能
（二）、一切皆对象
name='wuya'
def func():
print('hello word')
class Person(object):
def show(self):
print('This Is A Class')
obj1=name
print(obj1)
obj2=func
obj2()
obj3=Person
obj3().show()
（三）、鸭子类型
在Python⾥⾯，所谓鸭⼦类型就是指“如果看起来像，叫声像⽽且⾛路起来像鸭⼦，那么它就是鸭⼦”。
class Animal(object):
def talk(self):
print('动物会叫')
class Cat(Animal):
def talk(self):
print('猫也是会叫的')
class Dog(Animal):
def talk(self):
print('狗也是会叫的')
def func(animal):
animal.talk()
cat=Cat()
func(animal=cat)
dog=Dog()
func(animal=dog)
标签：name,python,self,多态,class,面向对象,print,age,def 来源： https://www.cnblogs.com/L2119/p/16685919.html