本文透過實例給大家詳細解釋了Python 的類別、繼承和多型的定義和用法，非常實用，有需要的小夥伴可以參考下
##類別的定義
假如要定義一個類別Point，表示二維的座標點：
# point.py
class Point:
def __init__(self, x=0, y=0):
self.x, self.y = x, y登入後複製
最最基本的就是__init__ 方法，相當於C / Java 的建構子。雙底線 __ 的方法都是特殊方法，除了 __init__ 還有很多，後面會有介紹。
參數 self 相當於 C 的 this，表示目前實例，所有方法都有這個參數，但呼叫時並不需要指定。
>>> from point import *
>>> p = Point(10, 10) # __init__ 被调用
>>> type(p)
<class 'point.Point'>
>>> p.x, p.y
(10, 10)
登入後複製
幾乎所有的特殊方法（包括 __init__）都是隱含呼叫的（不直接呼叫）。
對一切皆物件的Python 來說，類別自己當然也是物件：
>>> type(Point)
<class 'type'>
>>> dir(Point)
['__class__', '__delattr__', '__dict__', ..., '__init__', ...]
>>> Point.__class__
<class 'type'>
登入後複製
Point 是type 的一個實例，這和p是Point 的一個實例是一回事。
現新增方法設定：
class Point:
...
def set(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：
class Point:
...
def set(this, x, y):
this.x, this.y = x, y登入後複製
與C 不同的是，「成員變數」必須要加self. 前綴，否則就變成類別的屬性（相當於C 靜態成員），而不是物件的屬性了。
存取控制
Python 沒有 public / protected / private 這樣的存取控制，如果你非要表示“私有”，習慣是加雙底線前綴。
class Point:
def __init__(self, x=0, y=0):
self.__x, self.__y = x, y
def set(self, x, y):
self.__x, self.__y = x, y
def __f(self):
pass登入後複製
__x、__y 和__f 就相當於私有了：
>>> p = Point(10, 10)
>>> p.__x
...
AttributeError: 'Point' object has no attribute '__x'
>>> p.__f()
...
AttributeError: 'Point' object has no attribute '__f'
登入後複製
_repr_
嘗試列印Point 實例：
#
>>> p = Point(10, 10)
>>> p
<point.Point object at 0x000000000272AA20>
登入後複製
通常，這不是我們想要的輸出，我們想要的是：
新增特殊方法__repr__ 即可實作：
class Point:
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__ 的定義如下：
class Point:
def __str__(self):
return '({}, {})'.format(self.__x, self.__y)登入後複製
##_add_
##兩個座標點相加是個很合理的需求。
>>> p1 = Point(10, 10)
>>> p2 = Point(10, 10)
>>> p3 = p1 + p2
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: unsupported operand type(s) for +: 'Point' and 'Point'
登入後複製
新增特殊方法__add__ 即可做到：
##
class Point:
def __add__(self, other):
return Point(self.__x + other.__x, self.__y + other.__y)登入後複製
>>> p3 = p1 + p2
>>> p3
Point(20, 20)
登入後複製
這就像C 裡的運算元重載一樣。
Python 的內建類型，例如字串、列表，都「重載」了 操作符。
特殊方法還有很多，這裡就不逐一介紹了。
繼承
舉出一個教科書中最常見的例子。 Circle 和 Rectangle 繼承自 Shape，不同的圖形，面積（area）計算方式不同。
# shape.py
class Shape:
def area(self):
return 0.0
class Circle(Shape):
def __init__(self, r=0.0):
self.r = r
def area(self):
return math.pi * self.r * self.r
class Rectangle(Shape):
def __init__(self, a, b):
self.a, self.b = a, b
def area(self):
return self.a * self.b登入後複製
用法比較直接：
>>> from shape import *
>>> circle = Circle(3.0)
>>> circle.area()
28.274333882308138
>>> rectangle = Rectangle(2.0, 3.0)
>>> rectangle.area()
6.0
登入後複製
如果Circle 沒有定義自己的area：
class Circle(Shape):
pass
登入後複製
那麼它將繼承父類別Shape 的area：
>>> Shape.area is Circle.area
True
登入後複製
一旦Circle定義了自己的area，從Shape 繼承而來的那個area 就被重寫（overwrite）了：
>>> from shape import *
>>> Shape.area is Circle.area
False
登入後複製
透過類別的字典更能明顯地看清楚這一點：
>>> Shape.__dict__['area']
<function Shape.area at 0x0000000001FDB9D8>
>>> Circle.__dict__['area']
<function Circle.area at 0x0000000001FDBB70>
登入後複製
所以，子類別重寫父類別的方法，其實只是把相同的屬性名稱綁定到了不同的函數物件。可見 Python 是沒有覆寫（override）的概念的。
同理，即使 Shape 沒有定義 area 也是可以的，Shape 作為“介面”，並不能得到語法的保證。 甚至可以動態的新增方法：
class Circle(Shape):
...
# def area(self):
# return math.pi * self.r * self.r
# 为 Circle 添加 area 方法。
Circle.area = lambda self: math.pi * self.r * self.r登入後複製
#########動態語言通常都這麼靈活，Python 也不例外。 ######Python 官方教學「9. Classes」第一句就是：######Compared with other programming languages, Python's class mechanism adds classes with a minimum of new syntax and semantics.##### #Python 以最少的新的語法和語意實現了類別機制，這確實讓人驚嘆，但是也讓C / Java 程式設計師感到相當不適。 #########多態#########如前所述，Python 沒有覆寫（override）的概念。嚴格來講，Python 並不支援「多型」。 ###
为了解决继承结构中接口和实现的问题，或者说为了更好的用 Python 面向接口编程（设计模式所提倡的），我们需要人为的设一些规范。
请考虑 Shape.area() 除了简单的返回 0.0，有没有更好的实现？
以内建模块 asyncio 为例，AbstractEventLoop 原则上是一个接口，类似于 Java 中的接口或 C++ 中的纯虚类，但是 Python 并没有语法去保证这一点，为了尽量体现 AbstractEventLoop 是一个接口，首先在名字上标志它是抽象的（Abstract），然后让每个方法都抛出异常 NotImplementedError。
class AbstractEventLoop:
def run_forever(self):
raise NotImplementedError
...登入後複製
纵然如此，你是无法禁止用户实例化 AbstractEventLoop 的：
loop = asyncio.AbstractEventLoop()
try:
loop.run_forever()
except NotImplementedError:
pass
登入後複製
C++ 可以通过纯虚函数或设构造函数为 protected 来避免接口被实例化，Java 就更不用说了，接口就是接口，有完整的语法支持。
你也无法强制子类必须实现“接口”中定义的每一个方法，C++ 的纯虚函数可以强制这一点（Java 更不必说）。
就算子类「自以为」实现了“接口”中的方法，也不能保证方法的名字没有写错，C++ 的 override 关键字可以保证这一点（Java 更不必说）。
静态类型的缺失，让 Python 很难实现 C++ / Java 那样严格的多态检查机制。所以面向接口的编程，对 Python 来说，更多的要依靠程序员的素养。
回到 Shape 的例子，仿照 asyncio，我们把“接口”改成这样：
class AbstractShape:
def area(self):
raise NotImplementedError登入後複製
这样，它才更像一个接口。
super
有时候，需要在子类中调用父类的方法。
比如图形都有颜色这个属性，所以不妨加一个参数 color 到 __init__：
class AbstractShape:
def __init__(self, color):
self.color = color登入後複製
那么子类的 __init__() 势必也要跟着改动：
class Circle(AbstractShape):
def __init__(self, color, r=0.0):
super().__init__(color)
self.r = r登入後複製
通过 super 把 color 传给父类的 __init__()。其实不用 super 也行：
class Circle(AbstractShape):
def __init__(self, color, r=0.0):
AbstractShape.__init__(self, color)
self.r = r登入後複製
但是 super 是推荐的做法，因为它避免了硬编码，也能处理多继承的情况。
相关推荐：
Python的环境配置解析
以上是Python 的類別、繼承與多態詳解的詳細內容。更多資訊請關注PHP中文網其他相關文章！
