Python面向对象之类的封装、继承与多态
Python面向对象中类的三大特性,即封装、继承与多态,同时也是所有语言在面向对象编程中的重要特性,下面用实际的代码部分针对每一种特性做出说明。
一、封装
顾名思义,封装即把我们想要的内容封装到某个地方,因此在这里记录两个问题,一是如何封装、二是如何调用封装的内容。
1、封装数据
1
2
3
4
5
6
7
8
9
|
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间接调用
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
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、单继承
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
|
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、多继承
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
|
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、类的继承顺序
与其说类的继承顺序,不如说是对象执行方法时,该方法在类中的查找顺序,之所以用到继承,那么一定是需要用到父类当中的某个方法,那么这个方法在类中就要遵循一定的查找顺序,简而言之可以概括为:先下后上、从左到右,下面通过代码来进行说明。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
|
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方法时,该方法在类中是按照什么顺序查找的。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
|
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”,这是两个版本中的一点区别。
最后来看一种更为复杂的继承关系
代码如下:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
|
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与其他语言的区别吧。
本文转自阿布ve 51CTO博客,原文链接:http://blog.51cto.com/abuve/1796166,如需转载请自行联系原作者