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，如需转载请自行联系原作者
