新聞中心

這里有您想知道的互聯(lián)網(wǎng)營銷解決方案

創(chuàng)新互聯(lián)Python教程：9.類

9. 類

類把數(shù)據(jù)與功能綁定在一起。創(chuàng)建新類就是創(chuàng)建新的對象類型，從而創(chuàng)建該類型的新實例。類實例支持維持自身狀態(tài)的屬性，還支持（由類定義的）修改自身狀態(tài)的方法。

成都創(chuàng)新互聯(lián)堅持“要么做到，要么別承諾”的工作理念，服務(wù)領(lǐng)域包括：成都網(wǎng)站設(shè)計、做網(wǎng)站、企業(yè)官網(wǎng)、英文網(wǎng)站、手機端網(wǎng)站、網(wǎng)站推廣等服務(wù)，滿足客戶于互聯(lián)網(wǎng)時代的銅山網(wǎng)站設(shè)計、移動媒體設(shè)計的需求，幫助企業(yè)找到有效的互聯(lián)網(wǎng)解決方案。努力成為您成熟可靠的網(wǎng)絡(luò)建設(shè)合作伙伴！

和其他編程語言相比，python 的類只使用了很少的新語法和語義。Python 的類有點類似于 C++ 和 Modula-3 中類的結(jié)合體，而且支持面向?qū)ο缶幊蹋∣OP）的所有標準特性：類的繼承機制支持多個基類、派生的類能覆蓋基類的方法、類的方法能調(diào)用基類中的同名方法。對象可包含任意數(shù)量和類型的數(shù)據(jù)。和模塊一樣，類也支持 Python 動態(tài)特性：在運行時創(chuàng)建，創(chuàng)建后還可以修改。

如果用 C++ 術(shù)語來描述的話，類成員（包括數(shù)據(jù)成員）通常為 public （例外的情況見下文私有變量），所有成員函數(shù)都是 virtual。與在 Modula-3 中一樣，沒有用于從對象的方法中引用對象成員的簡寫形式：方法函數(shù)在聲明時，有一個顯式的參數(shù)代表本對象，該參數(shù)由調(diào)用隱式提供。與在 Smalltalk 中一樣，Python 的類也是對象，這為導(dǎo)入和重命名提供了語義支持。與 C++ 和 Modula-3 不同，Python 的內(nèi)置類型可以用作基類，供用戶擴展。此外，與 C++ 一樣，算術(shù)運算符、下標等具有特殊語法的內(nèi)置運算符都可以為類實例而重新定義。

由于缺乏關(guān)于類的公認術(shù)語，本章中偶爾會使用 Smalltalk 和 C++ 的術(shù)語。本章還會使用 Modula-3 的術(shù)語，Modula-3 的面向?qū)ο笳Z義比 C++ 更接近 Python，但估計聽說過這門語言的讀者很少。

9.1. 名稱和對象

對象之間相互獨立，多個名稱（在多個作用域內(nèi)）可以綁定到同一個對象。其他語言稱之為別名。Python 初學(xué)者通常不容易理解這個概念，處理數(shù)字、字符串、元組等不可變基本類型時，可以不必理會。但是，對涉及可變對象，如列表、字典等大多數(shù)其他類型的 Python 代碼的語義，別名可能會產(chǎn)生意料之外的效果。這樣做，通常是為了讓程序受益，因為別名在某些方面就像指針。例如，傳遞對象的代價很小，因為實現(xiàn)只傳遞一個指針；如果函數(shù)修改了作為參數(shù)傳遞的對象，調(diào)用者就可以看到更改 —- 無需 Pascal 用兩個不同參數(shù)的傳遞機制。

9.2. Python 作用域和命名空間

在介紹類前，首先要介紹 Python 的作用域規(guī)則。類定義對命名空間有一些巧妙的技巧，了解作用域和命名空間的工作機制有利于加強對類的理解。并且，即便對于高級 Python 程序員，這方面的知識也很有用。

接下來，我們先了解一些定義。

namespace （命名空間）是映射到對象的名稱?，F(xiàn)在，大多數(shù)命名空間都使用 Python 字典實現(xiàn)，但除非涉及到優(yōu)化性能，我們一般不會關(guān)注這方面的事情，而且將來也可能會改變這種方式。命名空間的幾個常見示例： abs() 函數(shù)、內(nèi)置異常等的內(nèi)置函數(shù)集合；模塊中的全局名稱；函數(shù)調(diào)用中的局部名稱。對象的屬性集合也算是一種命名空間。關(guān)于命名空間的一個重要知識點是，不同命名空間中的名稱之間絕對沒有關(guān)系；例如，兩個不同的模塊都可以定義 maximize 函數(shù)，且不會造成混淆。用戶使用函數(shù)時必須要在函數(shù)名前面附加上模塊名。

點號之后的名稱是屬性。例如，表達式 z.real 中，real 是對象 z 的屬性。嚴格來說，對模塊中名稱的引用是屬性引用：表達式 modname.funcname 中，modname 是模塊對象，funcname 是模塊的屬性。模塊屬性和模塊中定義的全局名稱之間存在直接的映射：它們共享相同的命名空間！ 1

屬性可以是只讀或者可寫的。如果可寫，則可對屬性賦值。模塊屬性是可寫時，可以使用 modname.the_answer = 42 。del 語句可以刪除可寫屬性。例如， del modname.the_answer 會刪除 modname 對象中的 the_answer 屬性。

命名空間是在不同時刻創(chuàng)建的，且擁有不同的生命周期。內(nèi)置名稱的命名空間是在 Python 解釋器啟動時創(chuàng)建的，永遠不會被刪除。模塊的全局命名空間在讀取模塊定義時創(chuàng)建；通常，模塊的命名空間也會持續(xù)到解釋器退出。從腳本文件讀取或交互式讀取的，由解釋器頂層調(diào)用執(zhí)行的語句是 __main__ 模塊調(diào)用的一部分，也擁有自己的全局命名空間。內(nèi)置名稱實際上也在模塊里，即 builtins 。

函數(shù)的本地命名空間在調(diào)用該函數(shù)時創(chuàng)建，并在函數(shù)返回或拋出不在函數(shù)內(nèi)部處理的錯誤時被刪除。（實際上，用“遺忘”來描述實際發(fā)生的情況會更好一些。）當(dāng)然，每次遞歸調(diào)用都會有自己的本地命名空間。

作用域 是命名空間可直接訪問的 Python 程序的文本區(qū)域。 “可直接訪問” 的意思是，對名稱的非限定引用會在命名空間中查找名稱。

作用域雖然是靜態(tài)確定的，但會被動態(tài)使用。執(zhí)行期間的任何時刻，都會有 3 或 4 個命名空間可被直接訪問的嵌套作用域：

最內(nèi)層作用域，包含局部名稱，并首先在其中進行搜索
封閉函數(shù)的作用域，包含非局部名稱和非全局名稱，從最近的封閉作用域開始搜索
倒數(shù)第二個作用域，包含當(dāng)前模塊的全局名稱
最外層的作用域，包含內(nèi)置名稱的命名空間，最后搜索

如果把名稱聲明為全局變量，則所有引用和賦值將直接指向包含該模塊的全局名稱的中間作用域。重新綁定在最內(nèi)層作用域以外找到的變量，使用 nonlocal 語句把該變量聲明為非局部變量。未聲明為非局部變量的變量是只讀的，（寫入只讀變量會在最內(nèi)層作用域中創(chuàng)建一個新的局部變量，而同名的外部變量保持不變。）

通常，當(dāng)前局部作用域?qū)ⅲò醋置嫖谋荆┮卯?dāng)前函數(shù)的局部名稱。在函數(shù)之外，局部作用域引用與全局作用域一致的命名空間：模塊的命名空間。類定義在局部命名空間內(nèi)再放置另一個命名空間。

劃重點，作用域是按字面文本確定的：模塊內(nèi)定義的函數(shù)的全局作用域就是該模塊的命名空間，無論該函數(shù)從什么地方或以什么別名被調(diào)用。另一方面，實際的名稱搜索是在運行時動態(tài)完成的。但是，Python 正在朝著“編譯時靜態(tài)名稱解析”的方向發(fā)展，因此不要過于依賴動態(tài)名稱解析?。ň植孔兞恳呀?jīng)是被靜態(tài)確定了。）

Python 有一個特殊規(guī)定。如果不存在生效的 global 或 nonlocal 語句，則對名稱的賦值總是會進入最內(nèi)層作用域。賦值不會復(fù)制數(shù)據(jù)，只是將名稱綁定到對象。刪除也是如此：語句 del x 從局部作用域引用的命名空間中移除對 x 的綁定。所有引入新名稱的操作都是使用局部作用域：尤其是 import 語句和函數(shù)定義會在局部作用域中綁定模塊或函數(shù)名稱。

global 語句用于表明特定變量在全局作用域里，并應(yīng)在全局作用域中重新綁定；nonlocal 語句表明特定變量在外層作用域中，并應(yīng)在外層作用域中重新綁定。

9.2.1. 作用域和命名空間示例

下例演示了如何引用不同作用域和名稱空間，以及 global 和 nonlocal 對變量綁定的影響：

 
 
 
 
  
  
  
  def scope_test():
  
  
  
   def do_local():
  
  
  
   spam = "local spam"
  
  
  
  
  
  
  
   def do_nonlocal():
  
  
  
   nonlocal spam
  
  
  
   spam = "nonlocal spam"
  
  
  
  
  
  
  
   def do_global():
  
  
  
   global spam
  
  
  
   spam = "global spam"
  
  
  
  
  
  
  
   spam = "test spam"
  
  
  
   do_local()
  
  
  
   print("After local assignment:", spam)
  
  
  
   do_nonlocal()
  
  
  
   print("After nonlocal assignment:", spam)
  
  
  
   do_global()
  
  
  
   print("After global assignment:", spam)
  
  
  
  
  
  
  
  scope_test()
  
  
  
  print("In global scope:", spam)

示例代碼的輸出是：

 
 
 
 
  
  
  
  After local assignment: test spam
  
  
  
  After nonlocal assignment: nonlocal spam
  
  
  
  After global assignment: nonlocal spam
  
  
  
  In global scope: global spam

注意，局部賦值（這是默認狀態(tài)）不會改變 scope_test 對 spam 的綁定。 nonlocal 賦值會改變 scope_test 對 spam 的綁定，而 global 賦值會改變模塊層級的綁定。

而且，global 賦值前沒有 spam 的綁定。

9.3. 初探類

類引入了一點新語法，三種新的對象類型和一些新語義。

9.3.1. 類定義語法

最簡單的類定義形式如下：

 
 
 
 
  
  
  
  class ClassName:
  
  
  
   
  
  
  
   .
  
  
  
   .
  
  
  
   .

與函數(shù)定義 (def 語句) 一樣，類定義必須先執(zhí)行才能生效。把類定義放在 if 語句的分支里或函數(shù)內(nèi)部試試。

在實踐中，類定義內(nèi)的語句通常都是函數(shù)定義，但也可以是其他語句。這部分內(nèi)容稍后再討論。類里的函數(shù)定義一般是特殊的參數(shù)列表，這是由方法調(diào)用的約定規(guī)范所指明的 —- 同樣，稍后再解釋。

當(dāng)進入類定義時，將創(chuàng)建一個新的命名空間，并將其用作局部作用域 —- 因此，所有對局部變量的賦值都是在這個新命名空間之內(nèi)。特別的，函數(shù)定義會綁定到這里的新函數(shù)名稱。

當(dāng)（從結(jié)尾處）正常離開類定義時，將創(chuàng)建一個 類對象。這基本上是一個包圍在類定義所創(chuàng)建命名空間內(nèi)容周圍的包裝器；我們將在下一節(jié)了解有關(guān)類對象的更多信息。原始的（在進入類定義之前起作用的）局部作用域?qū)⒅匦律?，類對象將在這里被綁定到類定義頭所給出的類名稱 (在這個示例中為 ClassName)。

9.3.2. Class 對象

類對象支持兩種操作：屬性引用和實例化。

屬性引用 使用 Python 中所有屬性引用所使用的標準語法: obj.name。有效的屬性名稱是類對象被創(chuàng)建時存在于類命名空間中的所有名稱。因此，如果類定義是這樣的:

 
 
 
 
  
  
  
  class MyClass:
  
  
  
   """A simple example class"""
  
  
  
   i = 12345
  
  
  
  
  
  
  
   def f(self):
  
  
  
   return 'hello world'

那么 MyClass.i 和 MyClass.f 就是有效的屬性引用，將分別返回一個整數(shù)和一個函數(shù)對象。類屬性也可以被賦值，因此可以通過賦值來更改 MyClass.i 的值。 __doc__ 也是一個有效的屬性，將返回所屬類的文檔字符串: "A simple example class"。

類的 實例化 使用函數(shù)表示法。可以把類對象視為是返回該類的一個新實例的不帶參數(shù)的函數(shù)。舉例來說（假設(shè)使用上述的類）:

 
 
 
 
  
  
  
  x = MyClass()

創(chuàng)建類的新實例并將此對象分配給局部變量 x。

實例化操作（“調(diào)用”類對象）會創(chuàng)建一個空對象。許多類喜歡創(chuàng)建帶有特定初始狀態(tài)的自定義實例。為此類定義可能包含一個名為 __init__() 的特殊方法，就像這樣:

 
 
 
 
  
  
  
  def __init__(self):
  
  
  
   self.data = []

When a class defines an __init__() method, class instantiation automatically invokes __init__() for the newly created class instance. So in this example, a new, initialized instance can be obtained by:

 
 
 
 
  
  
  
  x = MyClass()

當(dāng)然，__init__() 方法還可以有額外參數(shù)以實現(xiàn)更高靈活性。在這種情況下，提供給類實例化運算符的參數(shù)將被傳遞給 __init__()。例如，:

 
 
 
 
  
  
  
  >>> class Complex:
  
  
  
  ... def __init__(self, realpart, imagpart):
  
  
  
  ... self.r = realpart
  
  
  
  ... self.i = imagpart
  
  
  
  ...
  
  
  
  >>> x = Complex(3.0, -4.5)
  
  
  
  >>> x.r, x.i
  
  
  
  (3.0, -4.5)

9.3.3. 實例對象

現(xiàn)在我們能用實例對象做什么？實例對象所能理解的唯一操作是屬性引用。有兩種有效的屬性名稱：數(shù)據(jù)屬性和方法。

數(shù)據(jù)屬性 對應(yīng)于 Smalltalk 中的“實例變量”，以及 C++ 中的“數(shù)據(jù)成員”。數(shù)據(jù)屬性不需要聲明；像局部變量一樣，它們將在第一次被賦值時產(chǎn)生。例如，如果 x 是上面創(chuàng)建的 MyClass 的實例，則以下代碼段將打印數(shù)值 16，且不保留任何追蹤信息:

 
 
 
 
  
  
  
  x.counter = 1
  
  
  
  while x.counter < 10:
  
  
  
   x.counter = x.counter * 2
  
  
  
  print(x.counter)
  
  
  
  del x.counter

另一類實例屬性引用稱為方法。方法是“從屬于”對象的函數(shù)。（在 Python 中，方法這個術(shù)語并不是類實例所特有的：其他對象也可以有方法。例如，列表對象具有 append, insert, remove, sort 等方法。然而，在以下討論中，我們使用方法一詞將專指類實例對象的方法，除非另外顯式地說明。）

實例對象的有效方法名稱依賴于其所屬的類。根據(jù)定義，一個類中所有是函數(shù)對象的屬性都是定義了其實例的相應(yīng)方法。因此在我們的示例中，x.f 是有效的方法引用，因為 MyClass.f 是一個函數(shù)，而 x.i 不是方法，因為 MyClass.i 不是函數(shù)。但是 x.f 與 MyClass.f 并不是一回事 —- 它是一個 方法對象，不是函數(shù)對象。

9.3.4. 方法對象

通常，方法在綁定后立即被調(diào)用:

 
 
 
 
  
  
  
  x.f()

在 MyClass 示例中，這將返回字符串 'hello world'。但是，立即調(diào)用一個方法并不是必須的: x.f 是一個方法對象，它可以被保存起來以后再調(diào)用。例如:

 
 
 
 
  
  
  
  xf = x.f
  
  
  
  while True:
  
  
  
   print(xf())

將持續(xù)打印 hello world，直到結(jié)束。

當(dāng)一個方法被調(diào)用時到底發(fā)生了什么？你可能已經(jīng)注意到上面調(diào)用 x.f() 時并沒有帶參數(shù)，雖然 f() 的函數(shù)定義指定了一個參數(shù)。這個參數(shù)發(fā)生了什么事？當(dāng)不帶參數(shù)地調(diào)用一個需要參數(shù)的函數(shù)時 Python 肯定會引發(fā)異常 —- 即使參數(shù)實際未被使用…

實際上，你可能已經(jīng)猜到了答案：方法的特殊之處就在于實例對象會作為函數(shù)的第一個參數(shù)被傳入。在我們的示例中，調(diào)用 x.f() 其實就相當(dāng)于 MyClass.f(x)。總之，調(diào)用一個具有 n 個參數(shù)的方法就相當(dāng)于調(diào)用再多一個參數(shù)的對應(yīng)函數(shù)，這個參數(shù)值為方法所屬實例對象，位置在其他參數(shù)之前。

如果你仍然無法理解方法的運作原理，那么查看實現(xiàn)細節(jié)可能會弄清楚問題。當(dāng)一個實例的非數(shù)據(jù)屬性被引用時，將搜索實例所屬的類。如果被引用的屬性名稱表示一個有效的類屬性中的函數(shù)對象，會通過打包（指向）查找到的實例對象和函數(shù)對象到一個抽象對象的方式來創(chuàng)建方法對象：這個抽象對象就是方法對象。當(dāng)附帶參數(shù)列表調(diào)用方法對象時，將基于實例對象和參數(shù)列表構(gòu)建一個新的參數(shù)列表，并使用這個新參數(shù)列表調(diào)用相應(yīng)的函數(shù)對象。

9.3.5. 類和實例變量

一般來說，實例變量用于每個實例的唯一數(shù)據(jù)，而類變量用于類的所有實例共享的屬性和方法:

 
 
 
 
  
  
  
  class Dog:
  
  
  
  
  
  
  
   kind = 'canine' # class variable shared by all instances
  
  
  
  
  
  
  
   def __init__(self, name):
  
  
  
   self.name = name # instance variable unique to each instance
  
  
  
  
  
  
  
  >>> d = Dog('Fido')
  
  
  
  >>> e = Dog('Buddy')
  
  
  
  >>> d.kind # shared by all dogs
  
  
  
  'canine'
  
  
  
  >>> e.kind # shared by all dogs
  
  
  
  'canine'
  
  
  
  >>> d.name # unique to d
  
  
  
  'Fido'
  
  
  
  >>> e.name # unique to e
  
  
  
  'Buddy'

正如名稱和對象中已討論過的，共享數(shù)據(jù)可能在涉及 mutable 對象例如列表和字典的時候?qū)е铝钊梭@訝的結(jié)果。例如以下代碼中的 tricks 列表不應(yīng)該被用作類變量，因為所有的 Dog 實例將只共享一個單獨的列表:

 
 
 
 
  
  
  
  class Dog:
  
  
  
  
  
  
  
   tricks = [] # mistaken use of a class variable
  
  
  
  
  
  
  
   def __init__(self, name):
  
  
  
   self.name = name
  
  
  
  
  
  
  
   def add_trick(self, trick):
  
  
  
   self.tricks.append(trick)
  
  
  
  
  
  
  
  >>> d = Dog('Fido')
  
  
  
  >>> e = Dog('Buddy')
  
  
  
  >>> d.add_trick('roll over')
  
  
  
  >>> e.add_trick('play dead')
  
  
  
  >>> d.tricks # unexpectedly shared by all dogs
  
  
  
  ['roll over', 'play dead']

正確的類設(shè)計應(yīng)該使用實例變量:

 
 
 
 
  
  
  
  class Dog:
  
  
  
  
  
  
  
   def __init__(self, name):
  
  
  
   self.name = name
  
  
  
   self.tricks = [] # creates a new empty list for each dog
  
  
  
  
  
  
  
   def add_trick(self, trick):
  
  
  
   self.tricks.append(trick)
  
  
  
  
  
  
  
  >>> d = Dog('Fido')
  
  
  
  >>> e = Dog('Buddy')
  
  
  
  >>> d.add_trick('roll over')
  
  
  
  >>> e.add_trick('play dead')
  
  
  
  >>> d.tricks
  
  
  
  ['roll over']
  
  
  
  >>> e.tricks
  
  
  
  ['play dead']

9.4. 補充說明

如果同樣的屬性名稱同時出現(xiàn)在實例和類中，則屬性查找會優(yōu)先選擇實例:

 
 
 
 
  
  
  
  >>> class Warehouse:
  
  
  
  ... purpose = 'storage'
  
  
  
  ... region = 'west'
  
  
  
  ...
  
  
  
  >>> w1 = Warehouse()
  
  
  
  >>> print(w1.purpose, w1.region)
  
  
  
  storage west
  
  
  
  >>> w2 = Warehouse()
  
  
  
  >>> w2.region = 'east'
  
  
  
  >>> print(w2.purpose, w2.region)
  
  
  
  storage east

數(shù)據(jù)屬性可以被方法以及一個對象的普通用戶（“客戶端”）所引用。換句話說，類不能用于實現(xiàn)純抽象數(shù)據(jù)類型。實際上，在 Python 中沒有任何東西能強制隱藏數(shù)據(jù) —- 它是完全基于約定的。（而在另一方面，用 C 語言編寫的 Python 實現(xiàn)則可以完全隱藏實現(xiàn)細節(jié)，并在必要時控制對象的訪問；此特性可以通過用 C 編寫 Python 擴展來使用。）

客戶端應(yīng)當(dāng)謹慎地使用數(shù)據(jù)屬性 —- 客戶端可能通過直接操作數(shù)據(jù)屬性的方式破壞由方法所維護的固定變量。請注意客戶端可以向一個實例對象添加他們自己的數(shù)據(jù)屬性而不會影響方法的可用性，只要保證避免名稱沖突 —- 再次提醒，在此使用命名約定可以省去許多令人頭痛的麻煩。

在方法內(nèi)部引用數(shù)據(jù)屬性（或其他方法?。┎]有簡便方式。我發(fā)現(xiàn)這實際上提升了方法的可讀性：當(dāng)瀏覽一個方法代碼時，不會存在混淆局部變量和實例變量的機會。

方法的第一個參數(shù)常常被命名為 self。這也不過就是一個約定: self 這一名稱在 Python 中絕對沒有特殊含義。但是要注意，不遵循此約定會使得你的代碼對其他 Python 程序員來說缺乏可讀性，而且也可以想像一個 類瀏覽器 程序的編寫可能會依賴于這樣的約定。

任何一個作為類屬性的函數(shù)都為該類的實例定義了一個相應(yīng)方法。函數(shù)定義的文本并非必須包含于類定義之內(nèi)：將一個函數(shù)對象賦值給一個局部變量也是可以的。例如:

 
 
 
 
  
  
  
  # Function defined outside the class
  
  
  
  def f1(self, x, y):
  
  
  
   return min(x, x+y)
  
  
  
  
  
  
  
  class C:
  
  
  
   f = f1
  
  
  
  
  
  
  
   def g(self):
  
  
  
   return 'hello world'
  
  
  
  
  
  
  
   h = g

現(xiàn)在 f, g 和 h 都是 C 類的引用函數(shù)對象的屬性，因而它們就都是 C 的實例的方法 —- 其中 h 完全等同于 g。但請注意，本示例的做法通常只會令程序的閱讀者感到迷惑。

方法可以通過使用 self 參數(shù)的方法屬性調(diào)用其他方法:

 
 
 
 
  
  
  
  class Bag:
  
  
  
   def __init__(self):
  
  
  
   self.data = []
  
  
  
  
  
  
  
   def add(self, x):
  
  
  
   self.data.append(x)
  
  
  
  
  
  
  
   def addtwice(self, x):
  
  
  
   self.add(x)
  
  
  
   self.add(x)

方法可以通過與普通函數(shù)相同的方式引用全局名稱。與方法相關(guān)聯(lián)的全局作用域就是包含其定義的模塊。（類永遠不會被作為全局作用域。）雖然我們很少會有充分的理由在方法中使用全局作用域，但全局作用域存在許多合理的使用場景：舉個例子，導(dǎo)入到全局作用域的函數(shù)和模塊可以被方法所使用，在其中定義的函數(shù)和類也一樣。通常，包含該方法的類本身是在全局作用域中定義的，而在下一節(jié)中我們將會發(fā)現(xiàn)為何方法需要引用其所屬類的很好的理由。

每個值都是一個對象，因此具有類（也稱為類型），并存儲為 object.__class__ 。

9.5. 繼承

當(dāng)然，如果不支持繼承，語言特性就不值得稱為“類”。派生類定義的語法如下所示:

 
 
 
 
  
  
  
  class DerivedClassName(BaseClassName):
  
  
  
   
  
  
  
   .
  
  
  
   .
  
  
  
   .

名稱 BaseClassName 必須定義于包含派生類定義的作用域中。也允許用其他任意表達式代替基類名稱所在的位置。這有時也可能會用得上，例如，當(dāng)基類定義在另一個模塊中的時候:

 
 
 
 
  
  
  
  class DerivedClassName(modname.BaseClassName):

派生類定義的執(zhí)行過程與基類相同。當(dāng)構(gòu)造類對象時，基類會被記住。此信息將被用來解析屬性引用：如果請求的屬性在類中找不到，搜索將轉(zhuǎn)往基類中進行查找。如果基類本身也派生自其他某個類，則此規(guī)則將被遞歸地應(yīng)用。

派生類的實例化沒有任何特殊之處: DerivedClassName() 會創(chuàng)建該類的一個新實例。方法引用將按以下方式解析：搜索相應(yīng)的類屬性，如有必要將按基類繼承鏈逐步向下查找，如果產(chǎn)生了一個函數(shù)對象則方法引用就生效。

派生類可能會重寫其基類的方法。因為方法在調(diào)用同一對象的其他方法時沒有特殊權(quán)限，所以調(diào)用同一基類中定義的另一方法的基類方法最終可能會調(diào)用覆蓋它的派生類的方法。（對 C++ 程序員的提示：Python 中所有的方法實際上都是 virtual 方法。）

在派生類中的重載方法實際上可能想要擴展而非簡單地替換同名的基類方法。有一種方式可以簡單地直接調(diào)用基類方法：即調(diào)用 BaseClassName.methodname(self, arguments)。有時這對客戶端來說也是有用的。（請注意僅當(dāng)此基類可在全局作用域中以 BaseClassName 的名稱被訪問時方可使用此方式。）

Python有兩個內(nèi)置函數(shù)可被用于繼承機制：

使用 isinstance() 來檢查一個實例的類型: isinstance(obj, int) 僅會在 obj.__class__ 為 int 或某個派生自 int 的類時為 True。
使用 issubclass() 來檢查類的繼承關(guān)系: issubclass(bool, int) 為 True，因為 bool 是 int 的子類。但是，issubclass(float, int) 為 False，因為 float 不是 int 的子類。

9.5.1. 多重繼承

Python 也支持一種多重繼承。帶有多個基類的類定義語句如下所示:

 
 
 
 
  
  
  
  class DerivedClassName(Base1, Base2, Base3):
  
  
  
   
  
  
  
   .
  
  
  
   .
  
  
  
   .

對于多數(shù)應(yīng)用來說，在最簡單的情況下，你可以認為搜索從父類所繼承屬性的操作是深度優(yōu)先、從左至右的，當(dāng)層次結(jié)構(gòu)中存在重疊時不會在同一個類中搜索兩次。因此，如果某一屬性在 DerivedClassName 中未找到，則會到 Base1 中搜索它，然后（遞歸地）到 Base1 的基類中搜索，如果在那里未找到，再到 Base2 中搜索，依此類推。

真實情況比這個更復(fù)雜一些；方法解析順序會動態(tài)改變以支持對 super() 的協(xié)同調(diào)用。這種方式在某些其他多重繼承型語言中被稱為后續(xù)方法調(diào)用，它比單繼承型語言中的 super 調(diào)用更強大。

動態(tài)改變順序是有必要的，因為所有多重繼承的情況都會顯示出一個或更多的菱形關(guān)聯(lián)（即至少有一個父類可通過多條路徑被最底層類所訪問）。例如，所有類都是繼承自 object，因此任何多重繼承的情況都提供了一條以上的路徑可以通向 object。為了確?；惒粫辉L問一次以上，動態(tài)算法會用一種特殊方式將搜索順序線性化，保留每個類所指定的從左至右的順序，只調(diào)用每個父類一次，并且保持單調(diào)（即一個類可以被子類化而不影響其父類的優(yōu)先順序）。總而言之，這些特性使得設(shè)計具有多重繼承的可靠且可擴展的類成為可能。要了解更多細節(jié)，請參閱 https://www.python.org/download/releases/2.3/mro/。

9.6. 私有變量

那種僅限從一個對象內(nèi)部訪問的“私有”實例變量在 Python 中并不存在。但是，大多數(shù) Python 代碼都遵循這樣一個約定：帶有一個下劃線的名稱 (例如 _spam) 應(yīng)該被當(dāng)作是 API 的非公有部分 (無論它是函數(shù)、方法或是數(shù)據(jù)成員)。這應(yīng)當(dāng)被視為一個實現(xiàn)細節(jié)，可能不經(jīng)通知即加以改變。

由于存在對于類私有成員的有效使用場景（例如避免名稱與子類所定義的名稱相沖突），因此存在對此種機制的有限支持，稱為 名稱改寫。任何形式為 __spam 的標識符（至少帶有兩個前綴下劃線，至多一個后綴下劃線）的文本將被替換為 _classname__spam，其中 classname 為去除了前綴下劃線的當(dāng)前類名稱。這種改寫不考慮標識符的句法位置，只要它出現(xiàn)在類定義內(nèi)部就會進行。

名稱改寫有助于讓子類重載方法而不破壞類內(nèi)方法調(diào)用。例如:

 
 
 
 
  
  
  
  class Mapping:
  
  
  
   def __init__(self, iterable):
  
  
  
   self.items_list = []
  
  
  
   self.__update(iterable)
  
  
  
  
  
  
  
   def update(self, iterable):
  
  
  
   for item in iterable:
  
  
  
   self.items_list.append(item)
  
  
  
  
  
  
  
   __update = update # private copy of original update() method
  
  
  
  
  
  
  
  class MappingSubclass(Mapping):
  
  
  
  
  
  
  
   def update(self, keys, values):
  
  
  
   # provides new signature for update()
  
  
  
   # but does not break __init__()
  
  
  
   for item in zip(keys, values):
  
  
  
   self.items_list.append(item)

上面的示例即使在 MappingSubclass 引入了一個 __update 標識符的情況下也不會出錯，因為它會在 Mapping 類中被替換為 _Mapping__update 而在 MappingSubclass 類中被替換為 _MappingSubclass__update。

請注意，改寫規(guī)則的設(shè)計主要是為了避免意外沖突；訪問或修改被視為私有的變量仍然是可能的。這在特殊情況下甚至?xí)苡杏?，例如在調(diào)試器中。

請注意傳遞給 exec() 或 eval() 的代碼不會將發(fā)起調(diào)用類的類名視作當(dāng)前類；這類似于 global 語句的效果，因此這種效果僅限于同時經(jīng)過字節(jié)碼編譯的代碼。同樣的限制也適用于 getattr(), setattr() 和 delattr()，以及對于 __dict__ 的直接引用。

9.7. 雜項說明

有時會需要使用類似于 Pascal 的“record”或 C 的“struct”這樣的數(shù)據(jù)類型，將一些命名數(shù)據(jù)項捆綁在一起。這種情況適合定義一個空類:

 
 
 
 
  
  
  
  class Employee:
  
  
  
   pass
  
  
  
  
  
  
  
  john = Employee() # Create an empty employee record
  
  
  
  
  
  
  
  # Fill the fields of the record
  
  
  
  john.name = 'John Doe'
  
  
  
  john.dept = 'computer lab'
  
  
  
  john.salary = 1000

一段需要特定抽象數(shù)據(jù)類型的 Python 代碼往往可以被傳入一個模擬了該數(shù)據(jù)類型的方法的類作為替代。例如，如果你有一個基于文件對象來格式化某些數(shù)據(jù)的函數(shù)，你可以定義一個帶有 read() 和 readline() 方法從字符串緩存獲取數(shù)據(jù)的類，并將其作為參數(shù)傳入。

實例方法對象也具有屬性: m.__self__ 就是帶有 m() 方法的實例對象，而 m.__func__ 則是該方法所對應(yīng)的函數(shù)對象。

9.8. 迭代器

到目前為止，您可能已經(jīng)注意到大多數(shù)容器對象都可以使用 for 語句:

 
 
 
 
  
  
  
  for element in [1, 2, 3]:
  
  
  
   print(element)
  
  
  
  for element in (1, 2, 3):
  
  
  
   print(element)
  
  
  
  for key in {'one':1, 'two':2}:
  
  
  
   print(key)
  
  
  
  for char in "123":
  
  
  
   print(char)
  
  
  
  for line in open("myfile.txt"):
  
  
  
   print(line, end='')

這種訪問風(fēng)格清晰、簡潔又方便。迭代器的使用非常普遍并使得 Python 成為一個統(tǒng)一的整體。在幕后，for 語句會在容器對象上調(diào)用 iter()。該函數(shù)返回一個定義了 __next__() 方法的迭代器對象，此方法將逐一訪問容器中的元素。當(dāng)元素用盡時，__next__() 將引發(fā) StopIteration 異常來通知終止 for 循環(huán)。你可以使用 next() 內(nèi)置函數(shù)來調(diào)用 __next__() 方法；這個例子顯示了它的運作方式:

 
 
 
 
  
  
  
  >>> s = 'abc'
  
  
  
  >>> it = iter(s)
  
  
  
  >>> it
  
  
  
  
  
  
  
  >>> next(it)
  
  
  
  'a'
  
  
  
  >>> next(it)
  
  
  
  'b'
  
  
  
  >>> next(it)
  
  
  
  'c'
  
  
  
  >>> next(it)
  
  
  
  Traceback (most recent call last):
  
  
  
   File "", line 1, in 
  
  
  
   next(it)
  
  
  
  StopIteration

看過迭代器協(xié)議的幕后機制，給你的類添加迭代器行為就很容易了。定義一個 __iter__() 方法來返回一個帶有 __next__() 方法的對象。如果類已定義了 __next__()，則 __iter__() 可以簡單地返回 self:

 
 
 
 
  
  
  
  class Reverse:
  
  
  
   """Iterator for looping over a sequence backwards."""
  
  
  
   def __init__(self, data):
  
  
  
   self.data = data
  
  
  
   self.index = len(data)
  
  
  
  
  
  
  
   def __iter__(self):
  
  
  
   return self
  
  
  
  
  
  
  
   def __next__(self):
  
  
  
   if self.index == 0:
  
  
  
   raise StopIteration
  
  
  
   self.index = self.index - 1
  
  
  
   return self.data[self.index]

 
 
 
 
  
  
  
  >>> rev = Reverse('spam')
  
  
  
  >>> iter(rev)
  
  
  
  <__main__.Reverse object at 0x00A1DB50>
  
  
  
  >>> for char in rev:
  
  
  
  ... print(char)
  
  
  
  ...
  
  
  
  m
  
  
  
  a
  
  
  
  p
  
  
  
  s

9.9. 生成器

生成器是一個用于創(chuàng)建迭代器的簡單而強大的工具。它們的寫法類似于標準的函數(shù)，但當(dāng)它們要返回數(shù)據(jù)時會使用 yield 語句。每次在生成器上調(diào)用 next() 時，它會從上次離開的位置恢復(fù)執(zhí)行（它會記住上次執(zhí)行語句時的所有數(shù)據(jù)值）。一個顯示如何非常容易地創(chuàng)建生成器的示例如下:

 
 
 
 
  
  
  
  def reverse(data):
  
  
  
   for index in range(len(data)-1, -1, -1):
  
  
  
   yield data[index]

 
 
 
 
  
  
  
  >>> for char in reverse('golf'):
  
  
  
  ... print(char)
  
  
  
  ...
  
  
  
  f
  
  
  
  l
  
  
  
  o
  
  
  
  g

可以用生成器來完成的操作同樣可以用前一節(jié)所描述的基于類的迭代器來完成。但生成器的寫法更為緊湊，因為它會自動創(chuàng)建 __iter__() 和 __next__() 方法。

另一個關(guān)鍵特性在于局部變量和執(zhí)行狀態(tài)會在每次調(diào)用之間自動保存。這使得該函數(shù)相比使用 self.index 和 self.data 這種實例變量的方式更易編寫且更為清晰。

除了會自動創(chuàng)建方法和保存程序狀態(tài)，當(dāng)生成器終結(jié)時，它們還會自動引發(fā) StopIteration。這些特性結(jié)合在一起，使得創(chuàng)建迭代器能與編寫常規(guī)函數(shù)一樣容易。

9.10. 生成器表達式

某些簡單的生成器可以寫成簡潔的表達式代碼，所用語法類似列表推導(dǎo)式，但外層為圓括號而非方括號。這種表達式被設(shè)計用于生成器將立即被外層函數(shù)所使用的情況。生成器表達式相比完整的生成器更緊湊但較不靈活，相比等效的列表推導(dǎo)式則更為節(jié)省內(nèi)存。

示例:

 
 
 
 
  
  
  
  >>> sum(i*i for i in range(10)) # sum of squares
  
  
  
  285
  
  
  
  
  
  
  
  >>> xvec = [10, 20, 30]
  
  
  
  >>> yvec = [7, 5, 3]
  
  
  
  >>> sum(x*y for x,y in zip(xvec, yvec)) # dot product
  
  
  
  260
  
  
  
  
  
  
  
  >>> unique_words = set(word for line in page for word in line.split())
  
  
  
  
  
  
  
  >>> valedictorian = max((student.gpa, student.name) for student in graduates)
  
  
  
  
  
  
  
  >>> data = 'golf'
  
  
  
  >>> list(data[i] for i in range(len(data)-1, -1, -1))
  
  
  
  ['f', 'l', 'o', 'g']

備注

存在一個例外。模塊對象有一個秘密的只讀屬性 __dict__，它返回用于實現(xiàn)模塊命名空間的字典；__dict__ 是屬性但不是全局名稱。顯然，使用這個將違反命名空間實現(xiàn)的抽象，應(yīng)當(dāng)僅被用于事后調(diào)試器之類的場合。

文章題目：創(chuàng)新互聯(lián)Python教程：9.類
當(dāng)前地址：http://fisionsoft.com.cn/article/cccigcd.html