Python面向对象三要素-继承（Inheritance）

　　　　　　　　　　　Python面向对象三要素-继承（Inheritance）

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　作者：尹正杰

版权声明：原创作品，谢绝转载！否则将追究法律责任。

 

 

一.继承概述

1>.基本概念

　　前面我们学习了Python的面向对象三要素之一，封装。今天我们来学习一下继承（Inheritance）

　　人类和猫类都继承自动物类。

　　个体继承自父类，继承了父类的一部分特征，但也可以有自己的个性。

　　再面向对象的世界中，从父类继承，就可以直接拥有父类的属性方法，这样可以减少代码，多复用。子类可以定义自己的属性和方法。

2>.看一个不用继承的例子

#！/usr/bin/env python
#_*_conding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie


class Animal:
    def shout(self):
        print("Animal shouts")


class Cat:
    def shout(self):
        print("Cat shouts")


a = Animal()
a.shout()

c = Cat()
c.shout()



#以上代码执行结果如下:
Animal shouts
Cat shouts

3>. 使用继承的方式改良上一个不用继承的案例

#！/usr/bin/env python
#_*_conding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie


class Animal:
    def __init__(self,name):
        self._name = name

    def shout(self):        #定义一个通用的吃方法
        print("{} shouts".format(self.__class__.__name__))

    @property
    def name(self):
        return self._name

class Cat(Animal):
    pass

class Dog(Animal):
    pass

a = Animal("monster")
a.shout()

cat = Cat("Kitty")
cat.shout()
print(cat.name)

dog = Dog("二哈")
dog.shout()
print(dog.name)


#以上代码执行结果如下:
Animal shouts
Cat shouts
Kitty
Dog shouts
二哈

#！/usr/bin/env python
#_*_conding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie

class Document:
    def __init__(self,content):
        self.content = content

    def print(self):     #基类中只定义，不实现的方法，称为“抽象方法”。在python中，如果采用这种方式定义的抽象方法，子类可以不实现，知道子类使用该方法的时候才报错。
        """
            基类提供的方法可以不具体实现，因为它未必适合子类的打印，子类中需要覆盖重写。
        """
        raise  NotImplementedError()

class Word(Document):
    pass

class Pdf(Document):
    pass

4>.总结

　　通过上例可以看出，通过继承，猫类，狗类不用写代码，直接继承了父类的属性和方法。

　　继承：
　　　　class Cat(Animal)这种形式就是从父类继承，括号中写上继承的类的列表。
　　　　继承可以让子类从父类获取特征（属性和方法）

　　父类：
　　　　calss Animal就是Cat和Dog的父类，也称为基类，超类。

　　子类：
　　　　Cat就是Animal的子类，也成为派生类。

 

二.继承定义

1>.继承使用格式

通过上面的案例，相比大家也可以总结出来继承的使用格式：
　　class 子类名（基类1[,基类2，...]）

和C++一样，Python也支持多继承，继承也可以多级。

2>.在Python3中，object类是所有对象的根基类

#！/usr/bin/env python
#_*_conding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie


class A:
    pass

#如果类定义时，没有基类列表，等同于继承自object。
class A(object):
    pass


"""
    注意，上例在Python2中，两种写法时不同的。
    Python支持多继承，继承也可以多级。
"""

3>.查看继承的特殊属性和方法

#！/usr/bin/env python
#_*_conding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie


class A:
    pass

print(A.__base__)               #类的基类。
print(A.__bases__)              #类的基类元组。
print(A.__mro__)                #显示方法查找顺序，基类的元组。
print(A.mro())                  #同上，返回列表。
print(A.__subclasses__())       #类的子类列表。



#以上代码执行结果如下:
<class 'object'>
(<class 'object'>,)
(<class '__main__.A'>, <class 'object'>)
[<class '__main__.A'>, <class 'object'>]
[]

 

三.继承中的访问控制

1>.代码案例

#！/usr/bin/env python
#_*_conding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie

"""
    从父类继承，自己没有的，就可以到父类中找。
    私有的都是不可以访问的，但是本质上依然是改了名称放在这个属性所在类的实例"__dict__"中。
    知道这个新名称就可以直接找到这个隐藏的变量，这是个黑魔法技巧，慎用。
"""

class Animal:
    __COUNT = 100
    HEIGHT = 0

    def __init__(self,age,weight,height):
        self.__COUNT += 1
        self.age = age
        self.__weight = weight
        self.HEIGHT = height

    def eat(self):
        print("{} eat".format(self.__class__.__name__))

    def __getweight(self):
        print(self.__weight)

    @classmethod
    def showcount1(cls):
        print(cls)
        print(cls.__dict__)
        print(cls.__COUNT)

    @classmethod
    def __showcount2(cls):
        print(cls.__COUNT)

    def showcount3(self):
        print(self.__COUNT)

class Cat(Animal):
    NAME = 'CAT'
    __COUNT = 200


c = Cat(3,5,15)
c.eat()
print(c.HEIGHT)
# print(c.__COUNT)          #不能访问，因为它属于私有变量，该私有变量python内部做了处理，变量名称被更改。

# print(c.__getweight())    #同上，这是私有方法，该私有方法python内部做了处理，变量名称被更改。

c.showcount1()

# c.__showcount2()            #无法直接访问父类的私有方法,如果你非要访问的话，可以使用“c._Animal__showcount2()”

c.showcount3()

print(c._Cat__COUNT)

print(c._Animal__COUNT)

print(c.NAME)

print("{}".format(Animal.__dict__))
print("{}".format(Cat.__dict__))
print(c.__dict__)
print(c.__class__.mro())



#以上代码执行结果如下:
 Cat eat
15
<class '__main__.Cat'>
{'__module__': '__main__', 'NAME': 'CAT', '_Cat__COUNT': 200, '__doc__': None}
100
101
200
101
CAT
{'__module__': '__main__', '_Animal__COUNT': 100, 'HEIGHT': 0, '__init__': <function Animal.__init__ at 0x000001F6AB694438>, 'eat': <function Animal.eat at 0x000001F6AB6944C8>, '_Animal__getweight': <function Animal.__getweight at 0x000001F6AB694558>, 'showcount1': <classmethod object at 0x000001F6AB6BA388>, '_Animal__showcount2': <classmethod object at 0x000001F6AB6BA0C8>, 'showcount3': <function Animal.showcount3 at 0x000001F6AB6949D8>, '__dict__': <attribute '__dict__' of 'Animal' objects>, '__weakref__': <attribute '__weakref__' of 'Animal' objects>, '__doc__': None}
{'__module__': '__main__', 'NAME': 'CAT', '_Cat__COUNT': 200, '__doc__': None}
{'_Animal__COUNT': 101, 'age': 3, '_Animal__weight': 5, 'HEIGHT': 15}
[<class '__main__.Cat'>, <class '__main__.Animal'>, <class 'object'>]

2>.总结

　　继承时，公有的，子类和实例都可以随意访问；私有成员被隐藏，子类和实例不可直接访问，但私有变量所在的类内的方法中可以访问这个私有变量。

　　Python通过自己一套实现，实现和其它语言一样的面向对象的继承机制。

　　实例属性查找顺序：
　　　　实例的 "__dict__" ===> "类__dict__" ===> "父类__dict"
　　　　如果搜索这些地方后没有找到就会抛出异常，先找到就立即返回了。

 

四.方法的重写，覆盖override

1>.super()可以访问到父类的类属性

#！/usr/bin/env python
#_*_conding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie

class Animal:
    def shout(self):
        print("Animal shouts")

class Cat(Animal):
    # def shout(self):            #覆盖了父类方法
    #     print("miao")

    def shout(self):              #覆盖了自身的方法，显式调用了父类的方法
        print(super())
        print(super(Cat,self))
        print(super(self.__class__,self))

        super().shout()
        super(Cat,self).shout()     #等价于super()
        self.__class__.__base__.shout(self)

a = Animal()
a.shout()

c = Cat()
c.shout()

print(a.__dict__)
print(c.__dict__)
print(Animal.__dict__)
print(Cat.__dict__)




#以上代码执行结果如下:
Animal shouts
<super: <class 'Cat'>, <Cat object>>
<super: <class 'Cat'>, <Cat object>>
<super: <class 'Cat'>, <Cat object>>
Animal shouts
Animal shouts
Animal shouts
{}
{}
{'__module__': '__main__', 'shout': <function Animal.shout at 0x000001DD6FB85678>, '__dict__': <attribute '__dict__' of 'Animal' objects>, '__weakref__': <attribute '__weakref__' of 'Animal' objects>, '__doc__': None}
{'__module__': '__main__', 'shout': <function Cat.shout at 0x000001DD6FB851F8>, '__doc__': None}

2>.类方法和静态方法覆盖

#！/usr/bin/env python
#_*_conding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie

"""
    这些方法都可以覆盖，原理都一样，属性字典的搜索顺序。
"""

class Animal:

    @classmethod
    def class_method(cls):
        print("class_method_animal")

    @staticmethod
    def static_method():
        print("static_method_animal")

class Cat(Animal):

    @classmethod
    def class_method(cls):
        print("class_method_cat")

    @staticmethod
    def static_method():
        print("static_method_cat")

c = Cat()
c.class_method()
c.static_method()

print(Cat.__dict__)
print(Animal.__dict__)

Cat.static_method()
Animal.static_method()



#以上代码执行结果如下:
class_method_cat
static_method_cat
{'__module__': '__main__', 'class_method': <classmethod object at 0x0000019B18317588>, 'static_method': <staticmethod object at 0x0000019B183175C8>, '__doc__': None}
{'__module__': '__main__', 'class_method': <classmethod object at 0x0000019B183174C8>, 'static_method': <staticmethod object at 0x0000019B18317508>, '__dict__': <attribute '__dict__' of 'Animal' objects>, '__weakref__': <attribute '__weakref__' of 'Animal' objects>, '__doc__': None}
static_method_cat
static_method_animal

 

五.继承时使用初始化

1>.手动调用父类的构造方法

#！/usr/bin/env python
#_*_conding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie


class A:
    def __init__(self,a,d = 10):
        self.a = a
        self.__d = d

class B:
    def __init__(self,b,c):
        A.__init__(self,b + c,b - c)            #我们调用了A的构造方法，那么就可以使用它的属性啦。
        self.b = b
        self.c = c

    def printv(self):
        print(self.b)
        print(self.a)


f = B(200,300)
print(f.__dict__)
print(f.__class__.__bases__)
f.printv()



#以上代码执行结果如下:
{'a': 500, '_A__d': -100, 'b': 200, 'c': 300}
(<class 'object'>,)
200
500

2>.自动调用父类的构造方法

#！/usr/bin/env python
#_*_conding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie

class Animal:
    def __init__(self,age):
        print("init in Animal")
        self.age = age

    def show(self):
        print(self.age)

class Cat(Animal):
    def __init__(self,age,weight):
        #调用父类的__init__方法的顺序有时决定着show方法的结果
        super().__init__(age)
        print("init in Cat")
        self.age = age + 1
        self.weight = weight
        # super().__init__(age)     #调用父类的方法其实也可以不用放在第一行，在Java语言中必须放在构造方法的首行。

c = Cat(10,5)
c.show()



#以上代码执行结果如下:
init in Animal
init in Cat
11

3>.属性的继承说明

　　一个原则，自己的私有属性，就该自己的方法读取和修改，不要借助其它类的方法，即使是父类或者派生类的方法。

 

六.多继承

1>.Python不同版本的类概述

　　Python2.2之前类时没有共同祖先的，之后，引入object类，它时所有类的共同祖先类object。

　　Python2.7.X中为了兼容，分为古典类（旧式类）和新式类。

　　Python3中全部都是新式类。

　　新式类都是继承自object，新式类可以使用super。

2>.Python多继承实现

 

　　在面向对象这种，父类，子类通过继承联系在一起，如果可以通过一套方法，就可以实现不同表现，就是多态。一个类继承自多个类就是多继承，它将具有多个类的特征。

   多继承毕竟会带来路径选择问题，究竟继承哪个父类的特征呢？如上图所示，左图是多继承（菱形继承），右图是单一继承。

　　Python使用MRO（method resolution order方法解析顺序）解决基类搜索顺序问题。

　　历史原因，MRO有三个搜素算法：
　　　　经典算法，按照定义从左到右，深度优先策略。2.2版本之前左图的MRO是MyClass->D->B->A->C->A
　　　　新式类算法，是经典算法的升级，深度优先，重复的只保留最后一个。2.2版本左图的MRO是MyClass->D->B->C->A->object
　　　　C3算法，在类被创建出来的时候，就计算一个MRO有序列表。2.3之后，Python3唯一支持的算法左图中的MRO是MyClass->D->B->C-A->object的列表。C3算法解决多继承的二义性。
　　
　　经典算法有很大的问题，如果C中有覆盖A的方法，也不会访问到它，因为先访问A的（深度优先）。

　　新式类算法，依然采用了深度优先，解决重复问题，但是同经典算法一样，没有解决继承的单调性。
　　
　　C3算法，解决了继承的单调性，它阻止创建之前产生二义性的代码。求得的MRO本质是为了线性化，且确定了顺序。

　　单调性：假设有A,B,C三个类，C的mro是[C，A,B],那么C的子类的mro中，A,B的顺序一致就是单调的。

3>.多继承的缺点

　　多继承很好的模拟了世界，因为事物很少是单一继承，但是舍弃简单，必然引入复杂性，带来了冲突。

　　如同一个孩子继承了来自父母双方的特征。那么到底眼睛像爸爸还是妈妈呢？孩子究竟该像谁多一点呢？

　　多继承的实现会导致编译器设计的复杂度增加，所以有些高级编程语言舍弃了类的多继承。

　　C++支持多继承；Java舍弃了多继承。

　　Java中，一个类可以实现多个接口，一个接口也可以继承多个接口。Java的接口很纯粹，只是方法的声明，继承者必须实现这些方法，就具有了这些能力。就能干什么。

　　多继承可能会带来二义性，例如，猫和狗都继承自动物类，现在如果一个多继承了猫和狗类，猫和狗都有shout方法，子类究竟继承谁的shout呢？解决方案：实现多继承的语言，要解决二义性，深度优先或者广度优先。

　　当类很多，继承复杂的情况下，继承路径太多，很难说清什么样的继承路径。

　　Python语法时允许多继承，但Python代码时解释执行，只是执行到的时候才发现错误。

　　团队协作开发，如果引入多继承，那代码很可能不可控。

　　不管编程语言是否支持多继承，都应当避免多继承。

　　Python的面向对象，我们看到的太灵活了，太开放了，所以要团队守规矩。

 

七.Mimin类

1>.单继承存在的弊端案例

#！/usr/bin/env python
#_*_conding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie

class Document:
    def __init__(self,content):
        self.content = content

    def print(self):     #基类中只定义，不实现的方法，称为“抽象方法”。在python中，如果采用这种方式定义的抽象方法，子类可以不实现，知道子类使用该方法的时候才报错。
        """
            基类提供的方法可以不具体实现，因为它未必适合子类的打印，子类中需要覆盖重写。
        """
        raise  NotImplementedError()

class Word(Document):
    pass

class Pdf(Document):
    pass


"""
    抛出问题:
        从上面的案例可以看出print算是一种能力（打印功能），不是所有的Document的子类都需要的，所以从这个角度触发，上面的基类Document设计有点问题。
        
    解决思路:
        如果在现有子类Word或Pdf上直接增加，虽然可以，却违反了OCP的原则(多用“继承”，少修改),所以可以继承后增加打印功能。
        
        在这个时候发现，为了增加一种能力，就要增加一次继承，类可能太多了，继承的方式不是很好了。
        
        功能太多，A类需要某几样功能，B类需要另几样功能，他们需要的是多个功能的自由组合，继承实现很繁琐。
        
        我们可以引入类装饰器来解决问题，装饰器的有点在于:
            简单方便，在需要的地方动态增加，直接使用装饰器
            可以为类灵活的增加功能。
        
        但是类装饰器不可继承，因此我们引入Mixin方案，Mixin就是其它类混合进来，同时带来了类的属性和方法。
        
        Mixin类本质上就是多继承实现的。Mixin体现的是一种组合的设计模式。
"""

2>.Mixin案例展示

#！/usr/bin/env python
#_*_conding:utf-8_*_
#@author :yinzhengjie
#blog:http://www.cnblogs.com/yinzhengjie

class Document:             #假设该类为第三方库，不允许修改
    def __init__(self,content):
        self.content = content


class Word(Document):       #假设该类为第三方库，不允许修改
    pass

class Pdf(Document):        #假设该类为第三方库，不允许修改
    pass



def printable(cls):                 #定义类装饰器
    def _print(self):
        print(self.content,"装饰器")
    cls.print = _print
    return cls

@printable
class PrintablePdf(Word):           #使用类装饰器和Mixin进行使用上的对比
    pass

print(PrintablePdf.__dict__)
print(PrintablePdf.mro())


class PrintableMimin:                    #Mixin就是其它类混合进来，同时带来了类的属性和方法，这里看来和装饰器效果一样，也没有什么特别的。但是Mixin是类，就可以继承。
    def print(self):
        print(self.content,"Mixin")

class PrintableWord(PrintableMimin,Word):       #Mixin类本质上就是多继承实现的。Mixin体现的是一种组合的设计模式。
    pass

print(PrintableWord.__dict__)
print(PrintableWord.mro())


pw = PrintableWord("test string")
pw.print()

class SuperPrintableMixin(PrintableMimin):
    def print(self):
        print("{0} 打印增强前 {0}".format("*" * 20))
        super().print()
        print("{0} 打印增强后 {0}".format("*" * 20))


class SuperPrintablePdf(SuperPrintableMixin,Pdf):
    pass

print(SuperPrintablePdf.__dict__)
print(SuperPrintablePdf.mro())

spp = SuperPrintablePdf("super print pdf")
spp.print()



#以上代码执行结果如下:
{'__module__': '__main__', '__doc__': None, 'print': <function printable.<locals>._print at 0x0000016E8C6459D8>}
[<class '__main__.PrintablePdf'>, <class '__main__.Word'>, <class '__main__.Document'>, <class 'object'>]
{'__module__': '__main__', '__doc__': None}
[<class '__main__.PrintableWord'>, <class '__main__.PrintableMimin'>, <class '__main__.Word'>, <class '__main__.Document'>, <class 'object'>]
test string Mixin
{'__module__': '__main__', '__doc__': None}
[<class '__main__.SuperPrintablePdf'>, <class '__main__.SuperPrintableMixin'>, <class '__main__.PrintableMimin'>, <class '__main__.Pdf'>, <class '__main__.Document'>, <class 'object'>]
******************** 打印增强前 ********************
super print pdf Mixin
******************** 打印增强后 ********************

3>.Mixin类的使用原则

　　在面向对象的设计中，一个复杂的类，往往需要很多功能，而这些功能有来自抓不同的类提供，这就需要很多的类组合在一起。

　　从设计模式的角度来说，应该多组合，少继承。

　　Mixin类的使用原则：
　　　　Mixin类中不应该显式的出现__init__初始化方法。
　　　　Mixin类通常不能独立工作，因为它式准备混入别的类中的部分功能实现。
　　　　Mixin类的祖先类也应该式Mixin类。

　　使用时，Mixin类通常在继承列表的第一个位置，例如上来中的"class PrintableWord(PrintableMixin,Word):pass"

　　Mixin类和装饰器：
　　　　这两种方式都可以使用，看个人喜好。
　　　　如果还需要继承就得使用Mixin类的方式。