Python 的类、继承和多态详解

2024-01-28 14:50:03 154

类的定义

假如要定义一个类Point，表示二维的坐标点：

#point.py
classPoint:
def__init__(self,x=0,y=0):
self.x,self.y=x,y

最最基本的就是__init__方法，相当于C++/Java的构造函数。带双下划线__的方法都是特殊方法，除了__init__还有很多，后面会有介绍。

参数self相当于C++的this，表示当前实例，所有方法都有这个参数，但是调用时并不需要指定。

>>>frompointimport*
>>>p=Point(10,10)#__init__被调用
>>>type(p)

>>>p.x,p.y
(10,10)

几乎所有的特殊方法（包括__init__）都是隐式调用的（不直接调用）。

对一切皆对象的Python来说，类自己当然也是对象：

>>>type(Point)

>>>dir(Point)
['__class__','__delattr__','__dict__',...,'__init__',...]
>>>Point.__class__

Point是type的一个实例，这和p是Point的一个实例是一回事。

现添加方法set：

classPoint:
...
defset(self,x,y):
self.x,self.y=x,y

>>>p=Point(10,10)
>>>p.set(0,0)
>>>p.x,p.y
(0,0)

p.set(...)其实只是一个语法糖，你也可以写成Point.set(p,...)，这样就能明显看出p就是self参数了：

>>>Point.set(p,0,0)
>>>p.x,p.y
(0,0)

值得注意的是，self并不是关键字，甚至可以用其它名字替代，比如this：

classPoint:
...
defset(this,x,y):
this.x,this.y=x,y

与C++不同的是，“成员变量”必须要加self.前缀，否则就变成类的属性（相当于C++静态成员），而不是对象的属性了。

访问控制

Python没有public/protected/private这样的访问控制，如果你非要表示“私有”，习惯是加双下划线前缀。

classPoint:
def__init__(self,x=0,y=0):
self.__x,self.__y=x,y

defset(self,x,y):
self.__x,self.__y=x,y

def__f(self):
pass

__x、__y和__f就相当于私有了：

>>>p=Point(10,10)
>>>p.__x
...
AttributeError:'Point'objecthasnoattribute'__x'
>>>p.__f()
...
AttributeError:'Point'objecthasnoattribute'__f'

_repr_

尝试打印Point实例：

>>>p=Point(10,10)
>>>p

通常，这并不是我们想要的输出，我们想要的是：

>>>p
Point(10,10)

添加特殊方法__repr__即可实现：

classPoint:
def__repr__(self):
return'Point({},{})'.format(self.__x,self.__y)

不难看出，交互模式在打印p时其实是调用了repr(p)：

>>>repr(p)
'Point(10,10)'

_str_

如果没有提供__str__，str()缺省使用repr()的结果。
这两者都是对象的字符串形式的表示，但还是有点差别的。简单来说，repr()的结果面向的是解释器，通常都是合法的Python代码，比如Point(10,10)；而str()的结果面向用户，更简洁，比如(10,10)。

按照这个原则，我们为Point提供__str__的定义如下：

classPoint:
def__str__(self):
return'({},{})'.format(self.__x,self.__y)

_add_

两个坐标点相加是个很合理的需求。

>>>p1=Point(10,10)
>>>p2=Point(10,10)
>>>p3=p1+p2
Traceback(mostrecentcalllast):
File"",line1,in
TypeError:unsupportedoperandtype(s)for+:'Point'and'Point'

添加特殊方法__add__即可做到：

classPoint:
def__add__(self,other):
returnPoint(self.__x+other.__x,self.__y+other.__y)

>>>p3=p1+p2
>>>p3
Point(20,20)

这就像C++里的操作符重载一样。
Python的内建类型，比如字符串、列表，都“重载”了+操作符。

特殊方法还有很多，这里就不逐一介绍了。

继承

举一个教科书中最常见的例子。Circle和Rectangle继承自Shape，不同的图形，面积（area）计算方式不同。

#shape.py

classShape:
defarea(self):
return0.0

classCircle(Shape):
def__init__(self,r=0.0):
self.r=r

defarea(self):
returnmath.pi*self.r*self.r

classRectangle(Shape):
def__init__(self,a,b):
self.a,self.b=a,b

defarea(self):
returnself.a*self.b

用法比较直接：

>>>fromshapeimport*
>>>circle=Circle(3.0)
>>>circle.area()
28.274333882308138
>>>rectangle=Rectangle(2.0,3.0)
>>>rectangle.area()
6.0

如果Circle没有定义自己的area：

classCircle(Shape):
pass

那么它将继承父类Shape的area：

>>>Shape.areaisCircle.area
True

一旦Circle定义了自己的area，从Shape继承而来的那个area就被重写（overwrite）了：

>>>fromshapeimport*
>>>Shape.areaisCircle.area
False

通过类的字典更能明显地看清这一点：

>>>Shape.__dict__['area']

>>>Circle.__dict__['area']

所以，子类重写父类的方法，其实只是把相同的属性名绑定到了不同的函数对象。可见Python是没有覆写（override）的概念的。

同理，即使Shape没有定义area也是可以的，Shape作为“接口”，并不能得到语法的保证。

甚至可以动态的添加方法：

classCircle(Shape):
...
#defarea(self):
#returnmath.pi*self.r*self.r

#为Circle添加area方法。
Circle.area=lambdaself:math.pi*self.r*self.r

动态语言一般都是这么灵活，Python也不例外。

Python官方教程「9.Classes」第一句就是：

Comparedwithotherprogramminglanguages,Python'sclassmechanismaddsclasseswithaminimumofnewsyntaxandsemantics.

Python以最少的新的语法和语义实现了类机制，这一点确实让人惊叹，但是也让C++/Java程序员感到颇为不适。

多态

如前所述，Python没有覆写（override）的概念。严格来讲，Python并不支持「多态」。

为了解决继承结构中接口和实现的问题，或者说为了更好的用Python面向接口编程（设计模式所提倡的），我们需要人为的设一些规范。

请考虑Shape.area()除了简单的返回0.0，有没有更好的实现？

以内建模块asyncio为例，AbstractEventLoop原则上是一个接口，类似于Java中的接口或C++中的纯虚类，但是Python并没有语法去保证这一点，为了尽量体现AbstractEventLoop是一个接口，首先在名字上标志它是抽象的（Abstract），然后让每个方法都抛出异常NotImplementedError。

classAbstractEventLoop:
defrun_forever(self):
raiseNotImplementedError
...

纵然如此，你是无法禁止用户实例化AbstractEventLoop的：

loop=asyncio.AbstractEventLoop()
try:
loop.run_forever()
exceptNotImplementedError:
pass

C++可以通过纯虚函数或设构造函数为protected来避免接口被实例化，Java就更不用说了，接口就是接口，有完整的语法支持。

你也无法强制子类必须实现“接口”中定义的每一个方法，C++的纯虚函数可以强制这一点（Java更不必说）。

就算子类「自以为」实现了“接口”中的方法，也不能保证方法的名字没有写错，C++的override关键字可以保证这一点（Java更不必说）。

静态类型的缺失，让Python很难实现C++/Java那样严格的多态检查机制。所以面向接口的编程，对Python来说，更多的要依靠程序员的素养。

回到Shape的例子，仿照asyncio，我们把“接口”改成这样：

classAbstractShape:
defarea(self):
raiseNotImplementedError

这样，它才更像一个接口。

super

有时候，需要在子类中调用父类的方法。

比如图形都有颜色这个属性，所以不妨加一个参数color到__init__：

classAbstractShape:
def__init__(self,color):
self.color=color

那么子类的__init__()势必也要跟着改动：

classCircle(AbstractShape):
def__init__(self,color,r=0.0):
super().__init__(color)
self.r=r

通过super把color传给父类的__init__()。其实不用super也行：

classCircle(AbstractShape):
def__init__(self,color,r=0.0):
AbstractShape.__init__(self,color)
self.r=r

但是super是推荐的做法，因为它避免了硬编码，也能处理多继承的情况。

Python 的类、继承和多态详解

热门推荐

随机推荐