9. 類?

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 的屬性。嚴(yán)格來說，對模塊中名稱的引用是屬性引用：表達式 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)在外層作用域中重新綁定。

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

9.3. 初探類?

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

class ClassName:
    <statement-1>
    .
    .
    .
    <statement-N>

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

x = MyClass()

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

x = MyClass()

>>> 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)

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

x.f()

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

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'

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']

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)細(xì)節(jié)，并在必要時控制對象的訪問；此特性可以通過用 C 編寫 Python 擴展來使用。）

客戶端應(yīng)當(dāng)謹(jǐn)慎地使用數(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):
    <statement-1>
    .
    .
    .
    <statement-N>

名稱 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 的子類。

class DerivedClassName(Base1, Base2, Base3):
    <statement-1>
    .
    .
    .
    <statement-N>

9.6. 私有變量?

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

由于存在對于類私有成員的有效使用場景（例如避免名稱與子類所定義的名稱相沖突），因此存在對此種機制的有限支持，稱為 名稱改寫。 任何形式為 __spam 的標(biāo)識符（至少帶有兩個前綴下劃線，至多一個后綴下劃線）的文本將被替換為 _classname__spam，其中 classname 為去除了前綴下劃線的當(dāng)前類名稱。 這種改寫不考慮標(biāo)識符的句法位置，只要它出現(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 標(biāo)識符的情況下也不會出錯，因為它會在 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
<str_iterator object at 0x10c90e650>
>>> next(it)
'a'
>>> next(it)
'b'
>>> next(it)
'c'
>>> next(it)
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
    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)建迭代器的簡單而強大的工具。 它們的寫法類似于標(biāo)準(zhǔn)的函數(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']

備注

1

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