python多态_再谈继承，Python里有什么不同以及多态

一、继承:

继承(Inheritance)我叫小王，我爸是大王。继承的本质是个性对共性的属性与方法的接收，并加入个性特有的属性与方法。

一个类继承另一个类，则称继承的类为子类、派生类、衍生类，被继承的类为父类、基类。通过继承实现代码的复用，达到延续和扩展父类信息。继承后子类自动拥有了父类的属性和方法，子类根据需要新增和重写自己特有的属性和方法，实现功能的扩展。

1、理解

继承的本质在于抽象。类是对对象的抽象，继承是对某一批类的抽象，从而实现对现实世界更好的建模。同时使用继承可以提高代码的复用性。(事实上，利用组合可以更好的实现代码复用！)

 1class Parent:
 2    money = 1000
 3    job = '房地产'
 4
 5    def __init__(self):
 6        print("初始化父类。。。")       
 7
 8
 9class Child(Parent):
10    job = ''
11
12    def __init__(self,job):
13        self.job = job
14        print("初始化子类。。。")   
15
16    def __str__(self):
17        return '属性："%s", %s' % (self.job, self.money)
18
19c = Child('电竞')
20print(c)

运行结果：

1初始化子类。。。
2属性："电竞", 1000

2、判断子类    
使用issubclass(cls, A_tuple)判断是否为某一个类的子类，其中cls 就是要判断的是否为A_tuple中类的衍生类或者同类，A_tuple可以是一个元组，也可以是一个元素，为父类的元组，A_tuple中有一个类是cls的父类则返回True。

 1class A:
 2    pass
 3class B(A):
 4    pass
 5class C(B):
 6    pass
 7class D(B):
 8    pass
 9
10print(issubclass(B, A), issubclass(C, A))

3、私有信息访问限制

如果子类方法想要访问父类的私有属性和方法时，是不能直接访问的，只能通过调用父类方法访问

 1class Parent:
 2    def __init__(self, name):
 3        self.__name = name # 私有属性
 4    def __drinking(self): # 私有方法
 5        print("%s爱抽烟。。" % self.__name)
 6    def get_name(self):
 7        return self.__name
 8class Children(Parent):
 9    pass
10c = Children("小明")
11#print(c.__name) # 会报 no attribute错误
12# c.__drinking() # 会报 no attribute错误
13print(c.get_name())

4、方法重写

方法重写就是当父类的方法不能满足业务时，就可以通过子类重写父类的方法达到效果，而不需要修改父类方法。在Python中重写就是覆盖父类方法，那么我们在调用时都会遵循就近原则。

 1class Father:
 2    name = ''
 3    age = 0
 4    def eat(self):
 5        print("爸爸吃一碗！")
 6class Son(Father):
 7    def eat(self):
 8        print("儿子吃一盆！")
 9def main():
10    s = Son()
11    s.eat()
12if __name__ == '__main__':
13    main()

Son类重写了Father的eat方法，当main方法调用eat方法时，会优先考虑自己本类的方法，如果没有才会去寻找父类方法。如：

 1class Father:
 2    name = ''
 3    age = 0
 4    def __init__(self, name, age):
 5        self.name = name
 6        self.age = age
 7    def study(self):
 8        print("%s在看python指南！" % self.name)
 9        self.sing()
10    def sing(self):
11        print("爸爸在唱精忠报国")
12class Son(Father):
13    def sing(self):
14        print("%s在唱夏洛特烦恼" % self.name)
15def main():
16    s = Son("大锤", 18)
17    s.study()
18if __name__ == '__main__':
19    main()

二、多态

多态(polymorphism)是很多面向对象编程语言的重要特性，尽管我们的python语言中没有多态这一特性，但是不影响我们对这一特性的了解。不要叹息，我们的python语言特价灵活，有更加灵活的鸭子模型。要是我对你说今天会有好事发生。我并没有说好事是什么，这个好事就是模糊的，究竟是什么好事呢？就是今天我们就会将继承、封装、鸭子模型三大特性斩获囊中。
电脑上的USB接口，就是一个多态，凡是实现了这个接口的电子产品如u盘、打印机、手机都可以与电脑对接，在python中，多态更加灵活，只需要一个对象“看起来像鸭子，走起路来像鸭子，那它被认定是只鸭子”即经典的鸭子模型。

1、理解

在同一个方法中，参数不同导致结果不同的现象叫多态。比如定义一个鸟类，在定义百灵鸟类和鹦鹉类，然后在重写fly方法。定义一个方法，如果传入的是百灵鸟类就会打印百灵鸟的fly方法，如果传入鹦鹉打印鹦鹉的fly方法。

 1class Bird:
 2    def fly(self):
 3        print("鸟会飞。。。")
 4class Lark(Bird):
 5    def fly(self):
 6        print("百灵鸟在飞。。。")
 7class Parrot(Bird):
 8    def fly(self):
 9        print("八哥在飞。。。")
10def fly(bird):
11    bird.fly()
12lark= Lark()
13parrot = Parrot()
14fly(lark)
15fly(parrot)

2、实例

王大锤有一个车库，里面有两种车，奔驰和奥迪，那他具体开哪辆呢，就是要到时开车方法里面传入的是什么车，那就开什么车

 1import random
 2class Car:
 3    def __init__(self, color, name):
 4        self.color = color
 5        self.name = name
 6    def run(self):
 7        print(self.name + "启动了")
 8class Bmw(Car):
 9    def __init__(self, color):
10        self.color = color
11        self.name = "宝马"    
12class Benz(Car):
13    def __init__(self, color):
14        self.color = color
15        self.name = "奔驰"    
16class Carport:
17    def __init__(self):
18        self.cars = []
19    def fill(self, car):
20        self.cars.append(car)
21    def get_car(self):
22        return self.cars[random.randint(0, len(self.cars)-1)]
23class Person:
24    def drive(self, car):
25        print("我在开%s的%s" % (car.color, car.name))
26if __name__ == '__main__':    
27    port = Carport()
28    port.fill(Bmw("红色"))
29    port.fill(Benz("黄色"))
30    car = port.get_car()    
31    p = Person()
32    p.drive(car)

3、鸭子模型

因为Python是弱类型语言，所以它的多态和其他面向对象语言比如Java不一样，在Java中实现多态必须使用继承，不然编译就会出现类型不符合，而Python本身不会出现这样的情况，因此在实现多态时，并不一定要使用继承，比如刚刚品酒的例子进行修改：

 1class MaoTai:
 2    @staticmethod
 3    def show_advertisement():
 4        print("相逢，人生的机缘；相识，人生的财富；相知，人生的感动。 5茅台迎宾酒，迎宾迎天下")
 6class WuLiangYe:
 7    @staticmethod
 8    def show_advertisement():
 9        print("中国的五粮液，世界的五粮液!")
10class JianNanChun:
11    @staticmethod
12    def show_advertisement():
13        print("唐时宫廷酒，盛世剑南春")
14class Person:
15    def drink(self, wine):
16        wine.show_advertisement()
17        print("----")
18if __name__ == '__main__':
19    p = Person()
20    p.drink(MaoTai)
21    p.drink(WuLiangYe)
22    p.drink(JianNanChun)

鸭子模型是动态语言的一个特点，意思就是一个对象“看起来像鸭子，走起路来像鸭子，那它被认定是只鸭子”， 就像刚刚品酒，我定义的MaoTai、WuLiangYe、JianNanChun并不需要集成Wine类，只需要在它们三个类中有一个show_ad的方法，那么在Person类中的drink()方法就可以传入这三个不同的类也能达到打印不同的广告词的效果。这个在静态语言中是没法完成的，因为静态语言对参数的类型有严格的限制。也就是讲动态类型语言的变量或者参数不需要声明的原因，都只需要在运行时校验。

4、super()

上面讲到了重写，子类会覆盖父类的方法，但如果你一定要调用父类方法时，怎么办呢？就使用super()调用

 1class Father:
 2    name = ''
 3    age = 0
 4    def __init__(self, name, age):
 5        self.name = name
 6        self.age = age
 7    def kungfu(self):
 8        print("祖传的咏春拳。。")
 9class Son(Father):
10    # 重写父类的方法，但是祖传的咏春还是会的，因此要用super()调用父类
11    def kungfu(self):
12        #super(Son,self).kungfu()
13        super().kungfu()
14        print("会八卦掌、形意拳。。")
15def main():
16    s = Son("小明", 18)
17    s.kungfu()
18if __name__ == '__main__':
19    main()

继承字典类：

1class ObjectDict(dict):
2    def __init__(self, *args, **kwargs):
3        super().__init__(*args, **kwargs)       
4    def __getattr__(self, name):        
5        return self[name]
6if __name__ == '__main__':
7    object_dict = ObjectDict(price=100.1)  
8print(object_dict.price)

来个复杂点的例子:

 1class ObjectDict(dict):
 2    def __init__(self, *args, **kwargs):
 3        super(ObjectDict, self).__init__(*args, **kwargs)       
 4    def __getattr__(self, name):
 5        if isinstance(self[name], dict):
 6            return ObjectDict(self[name])
 7        return self[name]
 8if __name__ == '__main__':
 9    object_dict = ObjectDict(b={'name': '高性能MySQL'}, price=100.1)
10    print(object_dict.b, object_dict.b.name)
11    print(object_dict.price)

最后，奉上视频

继承的理解

多态的理解