面向对象三大特性之继承

继承是一种创建新类的方式，极大程度上规避了类与类之间代码重复的问题。
Ps：在Python中，是支持多继承的，即一个子类可以继承多个父类。这是其他大多数语言中所不支持的。父类也可以叫基类，超类子类也可以叫派生类实例名.__class__ 查看当前实例所属的类类名.__bases__ 查看所继承的父类（元组形式，该元组中每个索引上封装了一个类对象）。Python2.x无法使用类名.__base__ 查看所继承的父类（返回类对象）。Python2.x无法使用
class Man(object):

    def __init__(self,name,age,gender):
        self.name = name
        self.age = age
        self.gender = gender

class Woman(object):

    def __init__(self, name, age, gender):
        self.name = name
        self.age = age
        self.gender = gender

m1 = Man("小明",18,"male")
w1 = Woman("小红",17,"female")

# 使用 实例名.__class__ 可以看到实例对象属于的类

print(m1.__class__) # <class ‘__main__.Man‘>
print(w1.__class__) # <class ‘__main__.Woman‘>
class Man(object):

    def __init__(self,name,age,gender):
        self.name = name
        self.age = age
        self.gender = gender

class Woman(Man): # 继承 Man， 拿到 Man 的所有方法与属性
    pass

m1 = Man("小明",18,"male")
w1 = Woman("小红",17,"female")

# 使用 实例名.__class__ 可以看到实例对象属于的类

print(m1.__class__) # <class ‘__main__.Man‘>
print(w1.__class__) # <class ‘__main__.Woman‘>

# 使用 类名.__bases__ 可查看继承的父类 Ps: __base__ 返回类对象， __bases__ 返回元组，该元组每个索引上封装了一个类对象

print(Woman.__base__) # <class ‘__main__.Man‘>
print(Woman.__bases__) # (<class ‘__main__.Man‘>,)

在Python2.x中具有经典类和新式类之分。
经典类：没有继承object的类及其子类统称为经典类。
新式类：继承object的类及其子类统称为新式类

而在Python3.x中取消了经典类，所有类默认统一继承object类。

优点：新式类对比经典类来说，对于一些操作有了更好的支持。Ps：个人推荐，即使使用Python3.x，也应当在继承中明确写上继承object类，这样显得更加规范。
# ==== Python2.x中的经典类 ====

class B1:
    pass

class B2(B1):
    pass

# ==== Python2.x中的新式类 ====

class F1(object):
    pass

class F2(F1):
    pass

# Ps：Python3.x中即使没有继承任何类，也都默认继承了object类。因此Python3中的所有类都是新式类。

当父类中的某一方法与子类中的方法同名时。子类实例对象的查找顺序是：

实例对象自身的__dict__  ---> 实例对象.__class__.__dict__ ---> 实例对象.__class__.__base__.__dict__ 依次序向上查找（注意：这里是指没有描述符的情况下）因此，只要父类中的某一方法与子类中的方法同名，那么当前子类的实例对象要想调用该方法时首先拿到的是子类中的方法。注意！！！不是覆盖！！！父类中的同名方法依旧存在！！！这不是覆盖！！！我称之为覆写
class F1(object):

    def show(self):
        print("F1.show")


class F2(F1):

    def show(self):
        print("F2.show")


f = F2()
f.show() # F2.show

单继承的查找顺序

在单继承下，不管是经典类还是新式类查找方式都一样。一条路摸到黑...
class A(object):
    
    def show(self):
        print("---A---")

class B(A):
    pass

b1 = B()

b1.show() # ---A---


单继承查找注意事项

单继承下每一次找都先从实例对象开始找。注意事项：普通的未设定为隐藏/私有的方法与设定了隐藏/私有的方法查找顺序本质是一样的。但是！他们的查找结果却完全不同
# 普通方法查找class A(object):
    def show(self):
        print("---A.show---")
        self.test()

    def test(self):
        print("---A.test---")

class B(A):

    def test(self):
        print("---B.test---")

b1 = B()
b1.show()

# ==== 执行结果 ===

"""
---A.show---
---B.test---
"""

# ==== 步骤分析 ===

"""
1. 查找 b.__dict__ 试图找到show 失败
2. 查找 B.__dict__ 试图找到show 失败
3. 查找 A.__dict__ 试图找到show 成功！！找到实例绑定方法show() 将 实例化对象 b1 自动传入
# === 开始重新接着找 ===
4. 查找 b.__dict__ 试图找到test 失败
5. 查找 B.__dict__ 试图找到test 成功！！找到实例绑定方法test() 将 实例化对象 b1 自动传入

"""
# 私有方法，隐藏方法查找class A(object):
    def show(self):
        print("---A.show---")
        self.__test()

    def __test(self):
        print("---A.test---")

class B(A):

    def __test(self):
        print("---B.test---")

b1 = B()
b1.show()

# ==== 执行结果 ===

"""
---A.show---
---A.test---
"""

# ==== 步骤分析 ===

"""
1. 查找 b.__dict__ 试图找到show 失败
2. 查找 B.__dict__ 试图找到show 失败
3. 查找 A.__dict__ 试图找到show 成功！！找到实例绑定方法show() 将 实例化对象 b1 自动传入
# === 开始重新接着找 ===
4. 查找 b.__dict__ 试图找到_A__test 失败
5. 查找 B.__dict__ 试图找到_A__test 失败
6. 查找 A.__dict__ 试图找到_A__test 成功！！找到实例绑定方法_A__test() 将 实例化对象 b1 自动传入
"""

普通多继承与钻石多继承

多继承，有两种情况。一种是普通多继承，一种是钻石多继承。

1.普通多继承：
    深度优先：从左至右一条一条的分支开始查找，每条分支找到头。最后找object类。

2.钻石多继承：
    在钻石多继承下经典类与新式类的查找顺序并不一样。
    经典类：深度优先。从左至右一条一条的分支开始查找，每条分支找到头。钻石的顶部类会在第一次就拿到。
    新式类：广度优先。从左至右一条一条的分支开始查找，如果都没有找到才去找钻石的顶部类。最后找object类。



普通多继承的查找顺序


class A(object):
    def show(self):
        print("---A---")

class B(object):
    def show(self):
        print("---B---")

class C(object):
    def show(self):
        print("---C---")

class D(A):
    def show(self):
        print("---D---")

class E(B):
    def show(self):
        print("---E---")

class F(C):
    def show(self):
        print("---F---")

class G(D,E,F):
    def show(self):
        print("---G---")

print(G.mro())  # 继承查找链，Python2.x中无法使用。

# [<class ‘__main__.G‘>, <class ‘__main__.D‘>, <class ‘__main__.A‘>, <class ‘__main__.E‘>, <class ‘__main__.B‘>, <class ‘__main__.F‘>, <class ‘__main__.C‘>, <class ‘object‘>]

钻石多继承下的经典类查找顺序（深度优先）

# -*- coding:utf-8 -*-

#  由于Python2中super方法并不支持经典类。也不支持mro方法，所以我就这样来进行验证了。class A:
    def show(self):
        print("---A---")

class B(A):
    pass

class C(A):
    def show(self):
        print("---C---")

class D(A):
    def show(self):
        print("---D---")

class E(B):
    pass

class F(C):
    def show(self):
        print("---F---")

class G(D):
    def show(self):
        print("---G---")

class H(E,F,G):
    pass

h1 = H()
h1.show() # ---A---

钻石多继承下的新式类查找顺序（广度优先）

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(A):
    def show(self):
        print("---D---")

class E(B):
    def show(self):
        print("---E---")

class F(C):
    def show(self):
        print("---F---")

class G(D):
    def show(self):
        print("---G---")


class H(E,F,G):
    def show(self):
        print("---G---")

print(H.mro())  # 继承查找链，Python2.x中无法使用

# [<class ‘__main__.H‘>, <class ‘__main__.E‘>, <class ‘__main__.B‘>, <class ‘__main__.F‘>, <class ‘__main__.C‘>, <class ‘__main__.G‘>, <class ‘__main__.D‘>, <class ‘__main__.A‘>, <class ‘object‘>]

类的继承关系是在定义类的时候产生的，底层会根据一个叫c3算法（数学层面的算法）的东西生成一套继承关系。而使用 类名.mro()会调出一个列表，该列表下存放的就是当前类的属性查找顺序关系。

Ps：在Python2.x版本中不支持该方法。 

super的基本使用案例

注意：super方法只能在新式类中使用！不能在经典类中使用！！！

Python2中新式类使用super方法格式如下：
    super(当前的类名,self).需要调用的父类方法(需要传给父类的参数不传self)

Python3中的类使用super方法格式如下：
    super().需要调用的父类方法(需要传给父类的参数不传self)super方法调用的类中的方法必须是存在于mro关系列表中，也就是说彼此之间必须有继承关系！
class Person(object):
    """人类"""
    def __init__(self,name,age,gender):
        self.name = name
        self.age = age
        self.gender = gender

class Student(Person):
    """学生"""
    def __init__(self,name,age,gender,height,weight):

        self.height = height
        self.weight = weight

        super(Student, self).__init__(name, age, gender)  # 调用父类的方法。根据当前实例对象的类的mro列表的顺序进行查找
# super().__init__(height,weight) 尽管可以这样传参，但是我仍然推荐上面的传参方式。

    def get_msg(self):
        print("姓名是:[{0}],年龄是:[{1}],性别是:[{2}],身高是:[{3}],体重是[{4}]".format(self.name,self.age,self.gender,self.height,self.weight))

s1 = Student("小明",18,"male",178,128)
s1.get_msg()  # 姓名是:[小明],年龄是:[18],性别是:[male],身高是:[178],体重是[128]
print(s1.__dict__)  # {‘height‘: 178, ‘weight‘: 128, ‘name‘: ‘小明‘, ‘age‘: 18, ‘gender‘: ‘male‘}

super方法在多继承下使用的注意事项

super严格依赖实例化对象所属类生成的mro列表进行查找。因此使用super要尽量的在继承关系清晰明了的情况下使用。注意事项：即使看起来两个毫无关系的类，在mro列表中也是具有了关系。如下：
class A(object):
    def show(self):
        super(A, self).show()  # 1.根据mro列表来找，此时是A，向后。找到B
        print("---A---")  # 3.打印 ---A---

class B(object):
    def show(self):
        print("---B---") # 2.打印 ---B--- 返回

class C(A,B):
    pass

print(C.mro()) # [<class ‘__main__.C‘>, <class ‘__main__.A‘>, <class ‘__main__.B‘>, <class ‘object‘>]

c1 = C()
c1.show()

# ==== 执行结果 ====

"""
[<class ‘__main__.C‘>, <class ‘__main__.A‘>, <class ‘__main__.B‘>, <class ‘object‘>]
---B---
---A---
"""

Python2经典类使用super

由于经典类本身并不能使用super，所以我们在Python2.x经典类中要想使用super方法，需要添加一句代码：

__metaclass__ = type

添加完后这个代码，多继承下的经典类将按照新式类的查找方式进行查找！

这条代码的本质是为你定义的类添加一个元类。
# ==== 不添加 __metaclass__ = type ，经典类使用super()会抛出异常 ====

"""
Traceback (most recent call last):
  File "C:/Users/Administrator/PycharmProjects/learn/logging?????.py", line 44, in <module>
    c1.show()
  File "C:/Users/Administrator/PycharmProjects/learn/logging?????.py", line 31, in show
    super(A, self).show()  # 1.根据mro列表来找，此时是A，向后。找到B
TypeError: super() argument 1 must be type, not classobj
"""
__metaclass__ = type # Python2.x中的经典类查找顺序变为新式类的查找顺序。 如不添加则无法使用super方法

class A:
    def show(self):
        super(A, self).show()  # 1.根据mro列表来找，此时是A，向后。找到B
        print("---A---")  # 3.打印 ---A---

class B(object):
    def show(self):
        print("---B---") # 2.打印 ---B--- 返回

class C(A,B):
    pass

print(C.mro()) # [<class ‘__main__.C‘>, <class ‘__main__.A‘>, <class ‘__main__.B‘>, <class ‘object‘>]

c1 = C()
c1.show()

# ==== 执行结果 ====

"""
[<class ‘__main__.C‘>, <class ‘__main__.A‘>, <class ‘__main__.B‘>, <class ‘object‘>]
---B---
---A---
"""

直接调用的基本使用案例

# ==== 可以看到 A 和 B 之间并没有任何关系，我们依旧可以调用其中的方法 ====

class A(object):
    def show(self):
        B.show(self) # 由于是类来调用方法，所以我们需要手动为其传入self参数。即手动传入当前实例化对象a1
        print("---A---")

class B(object):
    def show(self):
        print("---B---")

print(A.mro()) # [<class ‘__main__.A‘>, <class ‘object‘>]

a1 = A()
a1.show()

# ==== 执行结果 ====

"""
[<class ‘__main__.A‘>, <class ‘object‘>]
---B---
---A---
"""