python面向对象封装_Python面向对象编程：数据封装、继承和多态

小编今天带大家学习一下 Python 中面向对象程序设计以及数据封装、继承和多态三大特性。

在 Python 中所有数据类型都可以视为对象，我们也可以自定义对象，自定义的对象数据类型就是面向对象中类(Class)的概念。Class

是一种抽象概念，比如说定义一个篮球运动员的

Class，指的是球员这个概念，而实例(Instance)则是一个个具体的球员，比如科比和麦迪是两个具体的球员。所以面向对象的程序设计思想是先抽象出

Class，然后根据 Class 创建 Instance。通常一个 Class 既包含数据也包含操作数据的方法。

类和实例

作为面向对象最重要的概念，必须牢记要先创建抽象的类(Class)然后根据类创建具体的实例对象。下面以篮球运动员类为例，在 Python

中进行定义：

class Player(object):

pass

关键字 class 后面是类名 Player，括号里面是该类所继承的对象，如果没有继承类一般都写做 object 类。定义好类之后，就可以根据

Player 类创建 Player 的实例，创建实例可以通过类名+( )来实现。

>>> Kobe = Player()

>>> Kobe<__main__.player object at 0x10a67a209>

>>> Player

从结果可以看到变量 Kobe 指向的就是一个 Player 实例，而 Player

本身则是一个类。类作为一个具有模板作用的定义，我们可以在创建实例时将一些必备的属性定义到里面去。Python 中通过定义一个特殊的 __init__

方法来实现：

class Player(object):

def __init__(self, name, points):

self.name = name

self.points = points

需要强调的一点是，__init__ 方法的第一个参数永远都是 self，可以理解为创建的实例本身，定义中各类属性都绑定到

self。定义完改方法后在传参的时候就要按照定义的参数方式进行传参了：

>>> Kobe = Player('Kobe Bryant', 30.3)

>>>

Kobe.name'Kobe Bryant'

>>> Kobe.points

30.3

类的方法与普通函数并没有太大区别，类定义中函数第一个参数都是

self，除此之外也可以传入普通函数一样的默认参数、可变参数、关键字参数和命名关键字参数等。

数据封装

数据封装是面向对象编程的第一大特征。所谓数据封装，就是指在类定义时指定访问内部数据的方式，这种方式通过在类中定义函数来实现，这样数据就被封装起来了。而封装数据的函数是和类本身关联在一起的，我们称之为类的方法。

class Player(object):

def __init__(self, name, score):

self.name = name

self.points = points

def print_points(self):

print('%s: %s' % (self.name, self.points))

访问对象数据时：

>>> Kobe.print_points()

Kobe Bryant: 30.3

数据封装还有个好处就是可以给类添加新的方法，直接在定义类的函数中进行添加即可：

class Student(object):

... def get_points(self):

if self.points >= 28: print("You are a mvp player!")

elif self.points >= 20: print("You are an all star player!")

else:

print("hurry up!")

使用该方法访问数据：

>>> Kobe.get_points()You are a mvp player!

继承

面向对象程序设计的第二大特征叫做继承。当我们定义一个 Class

的时候，可以从当前环境下某个现有的类进行继承，新定义的类就可以称之为子类，而之前存在的类可以称之为父类或者是基类。

还是按照前面的类定义的例子，对 Player 类定义一个 do 的方法：

class Player(object):

def do(self):

print('Player is shooting')

当我们需要定义一个子类 AllStar 类的时候就可以直接从 Player 类继承：

class AllStar(Player): pass

对于 Player 类来说，AllStar 类就是它的子类，而对于 AllStar

类来说，Player类就是它的父类。继承的最大好处在于子类可以获得父类的全部功能，由于父类 Player 有着 do 方法，那它的子类 AllStar

类啥也不用定义就直接获取了父类的方法：

Curry = Curry()

Curry.do()"Player is shooting"

继承的另一个好处在于可以对所继承的父类的功能进行修改，继承了老子的本领还可以对该本领推陈出新，子类厉害哟。

多态

当子类和父类同时存在某种方法时，子类的方法会覆盖父类的方法。按前例就是当Player 父类和 AllStar 子类同时存在 do

方法时，子类会对父类的方法进行覆盖。我们先来看 Curry 这个对象的数据类型：

>>> isinstance(Curry, AllStar)True

>>> isinstance(Curry, Player)True

看来 Curry 这个实例对象不仅是 AllStar 也是一个 Player。原来 AllStar 这个类作为子类是从 Player

这个父类上继承下来的!子承父业！

因此，在一段继承关系中，如果某个实例对象的数据类型是某个子类，那它的数据类型也可以被看作是父类。但反过来可不行，不能乱了辈份。对于在父类下任何新增的子类都不必对该类的方法进行修改，任何依赖于以父类名作为参数的函数都可以不加修改正常运行，其原因就在于多态。多态的好处在于：

对于一个未知变量，我们在只知道它的父类类型而对其子类类型一无所知的情况下可以放心地调用相应的方法，而调用的方法是具体作用在哪个对象上，由运行时确定的对象类型所决定。多态的厉害支持在于：调用的时候只管拿来调用并不管其中的调用细节。当我们要新增一个

Player 子类时，只要保证 do 方法编写无误，对之前代码是如何调用的并不关心。

免责声明：内容和图片源自网络，版权归原作者所有，如有侵犯您的原创版权请告知，我们将尽快删除相关内容。