Python面向对象之类的封装继承与多态

Posted 2020-08-03

　　Python面向对象中类的三大特性，即封装、继承与多态，同时也是所有语言在面向对象编程中的重要特性，下面用实际的代码部分针对每一种特性做出说明。

一、封装

　　顾名思义，封装即把我们想要的内容封装到某个地方，因此在这里记录两个问题，一是如何封装、二是如何调用封装的内容。

1、封装数据

class Company:
    def __init__(self, dept, leader):
        self.dept = dept
        self.leader = leader
        
if __name__ == "__main__":    
    # 将公司名和Leader分别封装到对象obj1、obj2中self的dept和leader属性中
    obj1 = Company("A","Kevin")    
    obj2 = Company("B","Jone")

2、调用数据

　　调用数据又可以分为两种方式：通过对象直接调用、通过self间接调用

class Company:
    def __init__(self, dept, leader):
        self.dept = dept
        self.leader = leader    
        
    def show(self):
        print self.dept        
        print self.leader
        
if __name__ == "__main__":
    obj1 = Company("A","Kevin")    
    obj2 = Company("B","Jone")
    
    # 通过对象直接调用封装的数据 
    print obj1.dept    
    print obj1.leader    
    
    # 通过self来间接调用，self即为对象本身
    obj1.show()
    obj2.show()

　　总结封装特性：即通过类的构造方法将我们想要的内容封装到对象中，调用时通过对象直接调用、或通过self指向的类对象来间接调用。

二、继承

　　顾名思义继承即为拥有了某些不属于自己的东西，Python当中类的继承同样如此，通过继承可以为我们的类扩展更多的功能，同时在代码模块化开发、升级的过程中，继承也是一种规模化、高效化的生产方式。

　　不同于其他语言，Python中的类还具有多继承的特性，即可以有多个父类，下面通过代码来展示类的单继承、多继承以及继承过程中类成员方法的寻找顺序。

1、单继承

class Scale:
    def check(self):
        if self.count_person > 500:            
            print "%s is big company." %self.name        
        else:            
            print "%s is small company." %self.name
            
class Company(Scale):
    def __init__(self, name, count):
        self.name = name
        self.count_person = count
        
if __name__ == "__main__":
    my_company = Company("ABC", 800)    
    # Company类中并没有check方法，代码会向上自动检测父类中是否存在check方法，结果在Scale类中找到了
    my_company.check()

2、多继承

class Scale:
    def check(self):
        if self.count_person > 500:            
            return "%s is big company." %self.name        
        else:            
            return "%s is small company." %self.name
            
class Detail:
    def show(self, scale):
        print "%s, This company has %s persons." %(scale, self.count_person)
        
class Company(Scale, Detail):
    def __init__(self, name, count):
        self.name = name
        self.count_person = count
        
if __name__ == "__main__":
    my_company = Company("ABC", 800)
    company_scale = my_company.check()
    my_company.show(company_scale)

　　上述代码中Company分别继承了父类Scale、Detail，在实例化对象my_company后，我们分别用到了父类中的check和show方法。

3、类的继承顺序

　　与其说类的继承顺序，不如说是对象执行方法时，该方法在类中的查找顺序，之所以用到继承，那么一定是需要用到父类当中的某个方法，那么这个方法在类中就要遵循一定的查找顺序，简而言之可以概括为：先下后上、从左到右，下面通过代码来进行说明。

class Scale:
    def check(self):
        if self.count_person > 500:            
            print "%s is big company." %self.name        
        else:            
            print "%s is small company." %self.name
            
class Detail:
    def show(self, scale):
        print "%s, This company has %s persons." %(scale, self.count_person)
        
class Company(Scale, Detail):
    def __init__(self, name, count):
        self.name = name
        self.count_person = count    
        
    def show(self):
        print "This is display from class Company, our company has %s persons." %self.count_person
        
if __name__ == "__main__":
    my_company = Company("ABC", 800)
    my_company.check()
    my_company.show()

1) 创建实例化对象 my_company，并封装了公司名称、人数等基本内容到对象中。
2) 调用类中的check方法，此时程序发现本类中没有check方法，于是开始向上寻找，最终在Detail类中找到。
3) 调用类中的show方法，此时程序发现本类中存在show方法，直接调用。

下面来看稍微复杂些的情况，父类又继承父类，同时一个父类被多个子类同时继承，关系如下图所示。

C_5类继承了C_3和C_4类，同时C_3类、C_4类又分别继承C_1类和C_2类，C_1、C_2类又共同继承了C_0类，我们来看通过对象来调用C_5类中的special方法时，该方法在类中是按照什么顺序查找的。

class C_0:
    def special(self):
        print "I am special from C_0"
        
class C_1(C_0):
    def f1(self):
        pass
        
class C_2(C_0):
    def special(self):
        print ‘I am special from C_2‘
        
class C_3(C_1):
    def f3(self):
        pass
        
class C_4(C_2):
    def f4(self):
        pass
        
class C_5(C_3, C_4):
    def f5(self):
        pass
        
if __name__ == "__main__":
    obj = C_5()
    obj.special()

　　代码最终打印了“I am special from C_0”，由此可见代码是从左边开始查找，一直找到了最顶层的C_0的special方法，但在Python3版本中，同样的情况，代码走到C_1时就会停止向上查找，而是回到C_5中继续向右查找，最终执行了C_2类中的special方法，打印了“I am special from C_2”，这是两个版本中的一点区别。

最后来看一种更为复杂的继承关系

代码如下：

class C_1:
    def show(self):
        self.detail() 
        
class C_2(C_1):
    def __init__(self):
        self.title = "This is C_2"
 
    def show(self):
        self.detail() 
        
    def detail(self):
        print ‘I am detail from C_2‘
        
class C_3(C_2):
    def __init__(self):
        self.title = "This is C_3"
        
class C_4():
    def detail(self):
        print ‘I am detail from C_4‘
        
class C_5(C_4, C_3):
    pass
    
my_data = C_5()
my_data.show()print my_data.title

这里我们讨论两个内容：
1、对象my_data中的show方法最终打印了什么内容。
2、对象my_data中的title属性中的内容是什么。

我们来分析一下整个对象实例化及其方法的调用过程
1、创建对象my_data，注意此处的C_5后面是加括号的，即创建实例化对象，此时代码按照从下到上、从左到右的顺序查找构造方法。
2、最终在C_3类中找到了__init__构造方法，并执行其中的对象属性赋值。
3、调用对象my_data中的show方法，此时代码依然按照下至上，左至右的顺序查找整个类中的show方法。
4、最终在最顶层的C_1类中找到了show方法，并执行其中的start方法。
5、代码继续从self所指的my_data对象中重新开始查找start方法。
6、从C_5中查找start方法，未找到--->C_4中，未找到--->C_3中，未找到--->C_2中，找到start方法，并执行其中的detail方法。
7、代码继续从self所指的my_data对象中重新开始查找detail方法。
8、从C_5中查找detail方法，未找到--->C_4中，找到了detail方法，并打印“I am detail from C_4”
9、由于实例化类的时候，代码自动执行了C_3中的构造方法，说以title的值为“This is C_3”

最终结果为：
I am detail from C_4
This is C_3

　　总结：在类的继承中我们一直讨论从下至上，从左到右的顺序来查找对应的方法，但实际情况中，父类往往又调用了其他子类当中的方法，此时就要注意self本身的含义，self即指该类实例化对象本身，类中如果调用了self对应的方法，也就是要从对象最底层重新开始寻找对应的方法，例如上述代码中，不能误以为最终C_2中的show方法调用本类里的detail方法，要注意detail方法是要被重新查找的。理解这一点至关重要，否则我们在阅读Python项目的源码时会遇到很多困难。

三、多态

　　Python当中的多态我认为是非常好理解的，顾名思义多态就是多种形态，在python中我们在对函数、或是类进行传参的时候，我们往往不会特别关心传递的参数到底是什么类型，例如它可以是字符串、可以是整型、列表、字典、甚至是任何对象，但是在其他编程语言中，参数往往需要被明确定义是什么类型，这也是Python与其他语言的区别吧。

本文出自 “记录IT运维的那些事” 博客，请务必保留此出处http://abuve.blog.51cto.com/2237587/1796166