Python打卡十六——继承

Python打卡十六——继承

1、继承小例子

'''
    继承是面向对象程序设计的重要特征，也是实现“代码复用”的重要手段。

    Python 支持多重继承，一个子类可以继承多个父类。继承的语法格式如下：
        class 子类类名(父类 1[，父类 2，...])：
            类体

        如果在类定义中没有指定父类，则默认父类是 object 类。也就是说，object 是所有类的父
    类，里面定义了一些所有类共有的默认实现，比如：__new__()。

'''

class Person:
    def __init__(self,name,age):
        self.name = name
        self.__age = age    #私有实例属性

    def say_age(self):
        print("朕的年龄是尔等可随便知道的？！")

class Student(Person):
    def __init__(self,name,age,score):
        Person.__init__(self,name,age)
        self.score = score

s = Student("任嘉伦",31,100)
s.say_age()
print(s.name)
#print(s.__age)    #私有属性继承了但是无法这样用     AttributeError: 'Student' object has no attribute '__age'
print(dir(s))
print(s._Person__age)
print(s.score)

运行结果：

朕的年龄是尔等可随便知道的？！
任嘉伦
['_Person__age', '__class__', '__delattr__', '__dict__', '__dir__', '__doc__', '__eq__', '__format__', '__ge__', '__getattribute__', '__gt__', '__hash__', '__init__', '__init_subclass__', '__le__', '__lt__', '__module__', '__ne__', '__new__', '__reduce__', '__reduce_ex__', '__repr__', '__setattr__', '__sizeof__', '__str__', '__subclasshook__', '__weakref__', 'name', 'say_age', 'score']
31
100

2、方法的重写

'''
    1. 成员继承：子类继承了父类除构造方法之外的所有成员。
    2. 方法重写：子类可以重新定义父类中的方法，这样就会覆盖父类的方法，也称为“重写”
'''
class Person:
    def __init__(self,name,age):
        self.name = name
        self.__age = age    #私有实例属性

    def say_age(self):
        print("朕的年龄是尔等可随便知道的？！")

    def say_name(self):
        print("我的名字是",self.name)

class Student(Person):
    def __init__(self,name,age,score):
        Person.__init__(self,name,age)
        self.score = score
    
    #重写say_name()方法
    def say_name(self):
        print("My name is {0}".format(self.name))

s = Student("任嘉伦",31,100)
s.say_name()

运行结果：

My name is 任嘉伦

3、object根类
（1）通过累的方法mro()或者类属性__mro__可以输出这个类的继承层次结构。
（2）object类是所有类的父类，因此所有的类都有object类的属性和方法。
（3）内置函数dir()可以让我们方便的看到指定对象所有的属性。
dir(student)打印的say_age虽然是方法，实际上也是属性。只不过这个属性的类型是“method”而已。

4、重写__dir__（）方法

class Person:
    def __init__(self,name,age):
        self.name = name
        self.__age = age    #私有实例属性
	#重写__str__()方法
    def __str__(self):
        return "My name is {0} and my age is {1}".format(self.name,self.__age)

p = Person("Allen",31)
print(p)       
#重写前输出 <__main__.Person object at 0x0000025045757F48>
#重写后输出 My name is Allen and my age is 31

5、多重继承

在Python中允许多重继承，一个子类可以有多个“直接父类”。这样就具备了多个父类的特点，但是这样会把“类的整体层次”搞得异常复杂。

多重继承的例子：

class A:
	def a(self):
		print("aa")
class B:
	def b(self):
		print("bb")
class C(A,B):
	def c(self):
		print("cc")

c1 = C()
c1.c()
c1.b()
c1.a()

运行结果：

cc
bb
aa

6、mro——同名父类方法解析顺序

'''
        在Python中允许多重继承，一个子类可以有多个“直接父类”。这样就具备了多个父类的特点，
    但是这样会把“类的整体层次”搞得异常复杂。
        Python 支持多继承，如果父类中有相同名字的方法，在子类没有指定父类名时，解释器将
    “从左向右”按顺序搜索。
        MRO（Method Resolution Order）：方法解析顺序。 
        我们可以通过 mro()方法获得“类的层次结构”，方法解析顺序也是按照这个“类的层次结构”寻找的。
'''

class A:
    def a(self):
        print("aa")

    def say(self):
        print("say AAA")

class B:
    def b(self):
        print("bb")

    def say(self):
        print("say BBB")

class C(B,A):
    def c(self):
        print("cc")

class D(A,B):
    def d(self):
        print("dd")

c1 = C()
'''
c1.c()
c1.b()
c1.a()
'''
print(C.mro())
c1.say()
d1 = D()
print(D.mro())
d1.say()

运行结果：

[<class '__main__.C'>, <class '__main__.B'>, <class '__main__.A'>, <class 'object'>]
say BBB
[<class '__main__.D'>, <class '__main__.A'>, <class '__main__.B'>, <class 'object'>]
say AAA

7、super()获取父类方法

'''
    在子类中，如果想要获得父类的方法时，我们可以通过 super()来做。
'''
class A:
    def say(self):
        print("A:",self)
        print("say AAA")

class B(A):
    def say(self):
        #A.say(self)
        super().say()
        print("say BBB")
b = B()
b.say()

运行结果：

A: <__main__.B object at 0x0000018E669A5D08>
say AAA
say BBB

8、多态

'''

        多态（polymorphism）是指同一个方法调用由于对象不同可能会产生不同的行为。

        在现实生活中，我们有很多例子。比如：同样是吃饭的方法，中国人用筷子吃饭，
    英国人用刀叉吃饭，印度人用手吃饭。

        关于多态要注意以下 2 点：
    1. 多态是方法的多态，属性没有多态。
    2. 多态的存在有 2 个必要条件：继承、方法重写。

'''
class Man:
    def eat(self):
        print("吃饭啦！！！啦啦啦~~~")

class Chinese(Man):
    def eat(self):
        print("中国人用筷子吃饭！")

class English(Man):
    def eat(self):
        print("英国人用刀叉吃饭！")

class India(Man):
    def eat(self):
        print("印度人用手吃饭！")

def ManEat(man):
    if(isinstance(man,Man)):
        man.eat()
    else:
        print("不能吃饭！！！")

ManEat(Chinese())
ManEat(English())
ManEat(India())

运行结果：

中国人用筷子吃饭！
英国人用刀叉吃饭！
印度人用手吃饭！