類的定義
假如要定義一個類 Point，表示二維的座標點：
|
1 2 3 4 |
# point.py class Point: def __init__(self, x=0, y=0): self.x, self.y = x, y |
最最基本的就是 __init__ 方法，相當於 C++ / Java 的建構函式。帶雙下劃線 __ 的方法都是特殊方法，除了 __init__ 還有很多，後面會有介紹。
引數 self 相當於 C++ 的 this，表示當前例項，所有方法都有這個引數，但是呼叫時並不需要指定。
|
1 2 3 4 5 6 |
>>> from point import * >>> p = Point(10, 10) # __init__ 被呼叫 >>> type(p) <class 'point.Point'> >>> p.x, p.y (10, 10) |
幾乎所有的特殊方法（包括 __init__）都是隱式呼叫的（不直接呼叫）。
對一切皆物件的 Python 來說，類自己當然也是物件：
|
1 2 3 4 5 6 7 |
>>> type(Point) <class 'type'> >>> dir(Point) ['__class__', '__delattr__', '__dict__', ..., '__init__', ...] >>> Point.__class__ <class 'type'> |
Point 是 type 的一個例項，這和 p 是 Point 的一個例項是一回事。
現新增方法 set：
|
1 2 3 4 |
class Point: ... def set(self, x, y): self.x, self.y = x, y |
|
1 2 3 4 |
>>> p = Point(10, 10) >>> p.set(0, 0) >>> p.x, p.y (0, 0) |
p.set(...) 其實只是一個語法糖，你也可以寫成 Point.set(p, ...)，這樣就能明顯看出 p 就是 self 引數了：
|
1 2 3 |
>>> Point.set(p, 0, 0) >>> p.x, p.y (0, 0) |
值得注意的是，self 並不是關鍵字，甚至可以用其它名字替代，比如 this：
|
1 2 3 4 |
class Point: ... def set(this, x, y): this.x, this.y = x, y |
與 C++ 不同的是，“成員變數”必須要加 self. 字首，否則就變成類的屬性（相當於 C++ 靜態成員），而不是物件的屬性了。
訪問控制
Python 沒有 public / protected / private 這樣的訪問控制，如果你非要表示“私有”，習慣是加雙下劃線字首。
|
1 2 3 4 5 6 7 8 9 |
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 就相當於私有了：
|
1 2 3 4 5 6 7 |
>>> p = Point(10, 10) >>> p.__x ... AttributeError: 'Point' object has no attribute '__x' >>> p.__f() ... AttributeError: 'Point' object has no attribute '__f' |
_repr_
嘗試列印 Point 例項：
|
1 2 3 4 |
>>> p = Point(10, 10) >>> p <point.Point object at 0x000000000272AA20> |
通常，這並不是我們想要的輸出，我們想要的是：
|
1 2 |
>>> p Point(10, 10) |
新增特殊方法 __repr__ 即可實現：
|
1 2 3 |
class Point: def __repr__(self): return 'Point({}, {})'.format(self.__x, self.__y) |
不難看出，互動模式在列印 p 時其實是呼叫了 repr(p)：
|
1 2 |
>>> repr(p) 'Point(10, 10)' |
_str_
如果沒有提供 __str__，str() 預設使用 repr() 的結果。
這兩者都是物件的字串形式的表示，但還是有點差別的。簡單來說，repr() 的結果面向的是直譯器，通常都是合法的 Python 程式碼，比如 Point(10, 10)；而 str() 的結果面向使用者，更簡潔，比如 (10, 10)。
按照這個原則，我們為 Point 提供 __str__ 的定義如下：
|
1 2 3 |
class Point: def __str__(self): return '({}, {})'.format(self.__x, self.__y) |
_add_
兩個座標點相加是個很合理的需求。
|
1 2 3 4 5 6 |
>>> 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__ 即可做到：
|
1 2 3 |
class Point: def __add__(self, other): return Point(self.__x + other.__x, self.__y + other.__y) |
|
1 2 3 |
>>> p3 = p1 + p2 >>> p3 Point(20, 20) |
這就像 C++ 裡的操作符過載一樣。
Python 的內建型別，比如字串、列表，都“過載”了 + 操作符。
特殊方法還有很多，這裡就不逐一介紹了。
繼承
舉一個教科書中最常見的例子。Circle 和 Rectangle 繼承自 Shape，不同的圖形，面積（area）計算方式不同。
|
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 |
# 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 |
用法比較直接：
|
1 2 3 4 5 6 7 |
>>> from shape import * >>> circle = Circle(3.0) >>> circle.area() 28.274333882308138 >>> rectangle = Rectangle(2.0, 3.0) >>> rectangle.area() 6.0 |
如果 Circle 沒有定義自己的 area：
|
1 2 |
class Circle(Shape): pass |
那麼它將繼承父類 Shape 的 area：
|
1 2 |
>>> Shape.area is Circle.area True |
一旦 Circle 定義了自己的 area，從 Shape 繼承而來的那個 area 就被重寫（overwrite）了：
|
1 2 3 |
>>> from shape import * >>> Shape.area is Circle.area False |
通過類的字典更能明顯地看清這一點：
|
1 2 3 4 5 |
>>> Shape.__dict__['area'] <function Shape.area at 0x0000000001FDB9D8> >>> Circle.__dict__['area'] <function Circle.area at 0x0000000001FDBB70> |
所以，子類重寫父類的方法，其實只是把相同的屬性名繫結到了不同的函式物件。可見 Python 是沒有覆寫（override）的概念的。
同理，即使 Shape 沒有定義 area 也是可以的，Shape 作為“介面”，並不能得到語法的保證。
甚至可以動態的新增方法：
|
1 2 3 4 5 6 7 |
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。
|
1 2 3 4 |
class AbstractEventLoop: def run_forever(self): raise NotImplementedError ... |
縱然如此，你是無法禁止使用者例項化 AbstractEventLoop 的：
|
1 2 3 4 5 |
loop = asyncio.AbstractEventLoop() try: loop.run_forever() except NotImplementedError: pass |
C++ 可以通過純虛擬函式或設建構函式為 protected 來避免介面被例項化，Java 就更不用說了，介面就是介面，有完整的語法支援。
你也無法強制子類必須實現“介面”中定義的每一個方法，C++ 的純虛擬函式可以強制這一點（Java 更不必說）。
就運算元類「自以為」實現了“介面”中的方法，也不能保證方法的名字沒有寫錯，C++ 的 override 關鍵字可以保證這一點（Java 更不必說）。
靜態型別的缺失，讓 Python 很難實現 C++ / Java 那樣嚴格的多型檢查機制。所以面向介面的程式設計，對 Python 來說，更多的要依靠程式設計師的素養。
回到 Shape 的例子，仿照 asyncio，我們把“介面”改成這樣：
|
1 2 3 |
class AbstractShape: def area(self): raise NotImplementedError |
這樣，它才更像一個介面。
super
有時候，需要在子類中呼叫父類的方法。
比如圖形都有顏色這個屬性，所以不妨加一個引數 color 到 __init__：
|
1 2 3 |
class AbstractShape: def __init__(self, color): self.color = color |
那麼子類的 __init__() 勢必也要跟著改動：
|
1 2 3 4 |
class Circle(AbstractShape): def __init__(self, color, r=0.0): super().__init__(color) self.r = r |
通過 super 把 color 傳給父類的 __init__()。其實不用 super 也行：
|
1 2 3 4 |
class Circle(AbstractShape): def __init__(self, color, r=0.0): AbstractShape.__init__(self, color) self.r = r |
但是 super 是推薦的做法，因為它避免了硬編碼，也能處理多繼承的情況。