搞懂Python的類和對象名稱空間

<a name="blog1544254642"></a>

代碼塊的分類

python中分幾種代碼塊類型，它們都有本身的做用域，或者說名稱空間：

• 文件或模塊總體是一個代碼塊，名稱空間爲全局範圍
• 函數代碼塊，名稱空間爲函數自身範圍，是本地做用域，在全局範圍的內層
  • 函數內部可嵌套函數，嵌套函數有更內一層的名稱空間
• 類代碼塊，名稱空間爲類自身
  • 類中可定義函數，類中的函數有本身的名稱空間，在類的內層
  • 類的實例對象有本身的名稱空間，和類的名稱空間獨立
  • 類可繼承父類，能夠連接至父類名稱空間

正是這一層層隔離又鏈接的名稱空間將變量、類、對象、函數等等都組織起來，使得它們能夠擁有某些屬性，能夠進行屬性查找。

本文詳細解釋類和對象涉及的名稱空間，屬於純理論類的內容，有助於理解python面向對象的細節。期間會涉及全局和本地變量做用域的查找規則，若有不明白之處，可先看文章：Python做用域詳述

<a name="blog1544254643"></a>

一個歸納全文的示例

如下是一個能在必定程度上歸納全文的示例代碼段：

x = 11           # 全局變量x

def f():         # 全局變量f
    print(x)     # 引用全局變量x

def g():         # 全局變量g
    x = 22       # 定義本地變量x
    print(x)     # 引用本地變量x

class supcls():      # 全局變量supcls
    x = 33           # 類變量x
    def m(self):     # 類變量m，類內函數變量self
        x = 44       # 類內函數變量x
        self.x = 55  # 對象變量x

class cls(supcls):   # 全局變量cls
    x = supcls.x     # 引用父類屬性x，並定義cls類屬性x
    def n(self):     # 類變量n
        self.x = 66  # 對象變量x

若是能理解上面的每一個x屬於哪一個做用域、哪一個名稱空間，本文內容基本上就理解了。

<a name="blog1544254644"></a>

類的名稱空間

下面有一個類，類中有類屬性x、y，有方法m和n。

class supcls():
    x = 3
    y = 4

    def m(self):
        x = 33
        self.x = 333
        self.y = 444
        self.z = 555

    def n(self):
        return self.x, self.y, self.z

當python解釋到supcls代碼塊後，知道這是一個類，類有本身的名稱空間。因此，當知道了這個類裏面有x、y、m、n後，這幾個屬性都會放進類supcls的名稱空間中。

以下圖：

在上圖中，類的名稱空間中有屬性x、y、m和n，它們都稱爲類屬性。須要說明的是，在python中，函數變量m、n和普通變量沒什麼區別，僅僅只是它保存了指向函數體的地址，函數體即上圖中用func m和func n所表示的對象。

由於有名稱空間，能夠直接使用徹底限定名稱去訪問這個名稱空間中的內容。例如：

print(supcls.x)
print(supcls.y)
print(supcls.m)
print(supcls.n)

輸出結果：

3
4
<function supcls.m at 0x02B83738>
<function supcls.n at 0x02B836F0>

由於函數m和n也是類的屬性，它們也能夠直接經過類名來訪問執行。例如，新加入一個函數，但不用self參數了，而後執行它。

class testcls():
    z = 3
    def a():
        x = 1
        print(x)
        # print(z)     # 這是錯的

testcls.a()

不只如此，方法也是屬性，它實際上就是函數(在python 3.0中確實如此，在之前版本中方法和函數是有點區別的)。因此，能夠將方法保存下來，以後再去調用它：

aa = testcls.a
aa()
print(aa)

可是須要注意，方法代碼塊中看不見類變量。雖然類和方法的做用域關係相似於全局做用域和函數本地做用域，但並不老是等價。例如，方法a()中沒法直接訪問類變量z。這就像類內部看不到全局變量同樣。

上面全都是使用類名.屬性這種徹底限定名稱去訪問類中的屬性的。若是生成類的對象，則能夠經過對象去訪問相關對象屬性，由於對象有本身的名稱空間，且部分屬性來源於類。

<a name="blog1544254645"></a>

對象名稱空間

類就像一個模板，能夠根據這個模板大量生成具備本身特性的對象。在Python中，只需像調用函數同樣直接調用類就能夠建立對象。

例如，下面建立了兩個cls類的對象o1和o2，建立類的時候能夠傳遞參數給類，這個參數能夠傳遞給類的構造函數__init__()。

o1 = cls()
o2 = cls("some args")

對象有本身的名稱空間。由於對象是根據類來建立的，類是它們的模板，因此對象名稱空間中包含全部類屬性，可是對象名稱空間中這些屬性的值不必定和類名稱空間屬性的值相同。

如今根據supcls類構造兩個對象s1和s2：

class supcls():
    x = 3
    y = 4
    def m(self):
        x = 33
        self.x = 333
        self.y = 444
        self.z = 555
    def n(self):
        return self.x, self.y, self.z

s1 = supcls()
s2 = supcls()

那麼它們的名稱空間，以及類的名稱空間的關係以下圖所示：

如今僅僅只是對象s一、s2鏈接到了類supcls，對象s1和s2有本身的名稱空間。但由於類supcls中沒有構造方法__init__()初始化對象屬性，因此它們的名稱空間中除了python內部設置的一些"其它"屬性，沒有任何屬於本身的屬性。

但由於s一、s2鏈接到了supcls類，因此能夠進行對象屬性查找，若是對象中沒有，將會向上找到supcls。例如：

print(s1.x)    # 輸出3，搜索到類名稱空間
print(s1.y)    # 輸出4，搜索到類名稱空間
# print(s1.z)  # 這是錯的

上面再也不是經過徹底限定的名稱去訪問類中的屬性，而是經過對象屬性查找的方式搜索到了類屬性。但上面訪問z屬性將報錯，由於尚未調用m方法。

當調用m方法後，將會經過self.xxx的方式設置徹底屬於對象自身的屬性，包括x、y、z。

s1.m()
s2.m()

如今，它們的名稱空間以及類的名稱空間的關係以下圖所示：

如今對象名稱空間中有x、y和z共3個屬性(不考慮其它python內部設置的屬性)，再經過對象名去訪問對象屬性，仍然會查找屬性，但對於這3個屬性的搜索不會進一步搜索到類的名稱空間。但若是訪問對象中沒有的屬性，好比m和n，它們不存在於對象的名稱空間中，因此會搜索到類名稱空間。

print(s1.x)  # 對象屬性333，搜索到對象名稱空間
print(s1.y)  # 對象屬性444，搜索到對象名稱空間
print(s1.z)  # 對象屬性555，搜索到對象名稱空間
s1.m()       # 搜索到類名稱空間
s1.n()       # 搜索到類名稱空間

對象與對象之間的名稱空間是徹底隔離的，對象與類之間的名稱空間存在鏈接關係。因此，s1和s2中的x和y和z是互不影響的，誰也看不見誰。

但如今想要訪問類變量x、y，而不是對象變量，該怎麼辦？直接經過類名的徹底限定方式便可：

print(s1.x)      # 輸出333，對象屬性，搜索到對象名稱空間
print(supcls.x)  # 輸出3，類屬性，搜索到類名稱空間

和類同樣，經過對象能夠訪問到方法，方法能夠賦值給一個變量保存下來，之後再執行：

mm = s1.m
mm()

實際上，s1.m是一個function類的實例對象。在s1.xxx搜索索性的時候，若是發現xxx不是對象或類的數據屬性，說明這是方法屬性，python會將這個方法與對象(obj.method)或類(cls.method)進行關聯。不管如何，方法都是類的屬性。

由於對象有了本身的名稱空間，就能夠直接向這個名稱空間添加屬性或設置屬性。例如，下面爲s1對象添加一個新的屬性，但並非在類內部設置，而是在類的外部設置：

s1.x = 3333       # 在外部設置已有屬性x
s1.var1 = "aaa"   # 在外部添加新屬性var1

新屬性var1將只存在於s1，不存在於s2和類supcls中。

<a name="blog1544254646"></a>

類屬性和對象屬性

屬於類的屬性稱爲類屬性，即那些存在於類名稱空間的屬性。類屬性分爲類變量和方法。方法分爲3種：

• 實例方法：普通的方法，要經過self參數傳遞實例對象
• 類方法：傳遞的是類名而非實例對象的方法
• 靜態方法：不經過self傳遞對象的方法

相似的，屬於對象名稱空間的屬性稱爲對象屬性。對象屬性脫離類屬性，和其它對象屬性相互隔離。

例如：

class cls:
    x=3
    def f():
        y=4
        print(y)
    def m(self):
        self.z=3

上面的x、f、m都是類屬性，x是類變量，f和m是方法，z是對象屬性。

• x能夠經過類名和對象名來訪問。
• f沒有參數，不能經過對象來調用(經過對象調用時默認會傳遞對象名做爲方法的第一個參數)，只能經過類名來調用，因此f屬於靜態方法。
• m能夠經過對象名來調用，也能夠經過類名來調用(在子類繼承父類，擴展父類方法的時候很經常使用)。
• z經過self設置，獨屬於每一個self參數表明的對象，因此是對象屬性。

<a name="blog1544254647"></a>

子類繼承時的名稱空間

子類和父類之間有繼承關係，它們的名稱空間也經過一種特殊的方式進行了鏈接：子類能夠繼承父類的屬性。

例以下面的例子，子類class childcls(supcls)表示childcls繼承了父類supcls。

class supcls():
    x = 3
    y = 4
    def m(self):
        x = 33
        self.x = 333
        self.y = 444
        self.z = 555
    def n(self):
        return self.x, self.y, self.z

class childcls(supcls):
    y = supcls.y + 1    # 經過類名訪問父類屬性
    def n(self):
        self.z = 5555

當python解釋完這兩段代碼塊時，初始時的名稱空間結構圖以下：

當執行完class childcls(supcls)代碼塊以後，子類childcls就有了本身的名稱空間。初始時，這個名稱空間中除了鏈接到父類supcls外，還有本身的類變量y和方法n()，子類中的方法n()重寫了父類supcls的方法n()。

由於有本身的名稱空間，因此能夠訪問類屬性。當訪問的屬性不存在於子類中時，將自動向上搜索到父類。

print(childcls.x)   # 父類屬性，搜索到父類名稱空間
print(childcls.y)   # 子類自身屬性，搜索到子類名稱空間
print(childcls.z)   # 錯誤，子類和父類都沒有該屬性

當建立子類對象的時候，子類對象的變量搜索規則：

1. 子類對象自身名稱空間
2. 子類的類名稱空間
3. 父類的類名稱空間

例如，建立子類對象c1，並調用子類的方法n()：

c1 = childcls()
c1.n()

如今，子類對象c一、子類childcls和父類supcls的關係以下圖所示：

經過前面的說明，想必已經不用過多解釋。

<a name="blog1544254648"></a>

多重繼承時的名稱空間

python支持多重繼承，只需將須要繼承的父類放進子類定義的括號中便可。

class cls1():
    ...

class cls2():
    ...

class cls3(cls1,cls2):
    ...

上面cls3繼承了cls1和cls2，它的名稱空間將鏈接到兩個父類名稱空間，也就是說只要cls1或cls2擁有的屬性，cls3構造的對象就擁有(注意，cls3類是不擁有的，只有cls3類的對象才擁有)。

但多重繼承時，若是cls1和cls2都具備同一個屬性，好比cls1.x和cls2.x，那麼cls3的對象c3.x取哪個？會取cls1中的屬性x，由於規則是按照(括號中)從左向右的方式搜索父類。

再考慮一個問題，若是cls1中沒有屬性x，但它繼承自cls0，而cls0有x屬性，那麼，c3.x取哪一個屬性。

這在python 3.x中是一個比較複雜的問題，涉及到動態調整訪問順序。但基本上能夠根據MRO(Method Resolution Order)算法總結爲：先左後右，先深度再廣度，但必須遵循共同的超類最後搜索。

此處只給一個它們的訪問順序圖示，這也是__mro__屬性的默認順序：

<a name="blog1544254649"></a>

類自身就是一個全局屬性

在python中，類並無什麼特殊的，它存在於模塊文件中，是全局名稱空間中的一個屬性。

例如，在模塊文件中定義了一個類cls，那麼這個cls就是一個全局變量，只不過這個變量中保存的地址是類代碼塊所在數據對象。

# 模塊文件頂層
class cls():
    n = 3

而模塊自己是一個對象，有本身的模塊對象名稱空間(即全局名稱空間)，因此類是這個模塊對象名稱空間中的一個屬性，僅此而已。

另外須要注意的是，類代碼塊和函數代碼塊不同，涉及到類代碼塊中的變量搜索時，只會根據對象與類的鏈接、子類與父類的繼承鏈接進行搜索。不會像全局變量和函數同樣，函數內能夠向上搜索全局變量、嵌套函數能夠搜索外層函數。

例如：

# 全局範圍
x = 3
def f():
    print(x)   # 搜索到全局變量x

class sup():
    # print(x)   # 這是錯的，不會搜索全局變量
    y = 3
    print(y)     # 這是對的，存在類屬性y
    def m(self):
        # print(y)   # 這是錯的，不會搜索到類變量
        self.z = 4

class childcls(sup):
    # print(y)      # 這是錯的，不會搜索到父類

其實很容易理解爲何面向對象要有本身的搜索規則。對象和類之間是is a的關係，子類和父類也是is a的關係，這兩個is a是面向對象時名稱空間之間的鏈接關係，在搜索屬性的時候能夠順着"這根樹"不斷向上爬，直到搜索到屬性。

<a name="blog1544254650"></a>

__dict__就是名稱空間

前面一直說名稱空間，這個抽象的東西用來描述做用域，好比全局做用域、本地做用域等等。

在其餘語言中可能很難直接查看名稱空間，可是在python中很是容易，由於只要是數據對象，只要有屬性，就有本身的__dict__屬性，它是一個字典，表示的就是名稱空間。__dict__內的全部東西，均可以直接經過點"."的方式去訪問、設置、刪除，還能夠直接向__dict__中增長屬性。

例如:

class supcls():
    x=3

class childcls(supcls):
    y=4
    def f(self):
        self.z=5

>>> c=childcls()
>>> c.__dict__.keys()
dict_keys([])

>>> c.f()
>>> c.__dict__
{'z': 5}

能夠直接去增、刪、改這個dict，所做的修改都會直接對名稱空間起做用。

>>> c.newkey = "NEWKEY"
>>> c.__dict__["hello"] = "world"
>>> c.__dict__
{'z': 5, 'newkey': 'NEWKEY', 'hello': 'world'}

注意，__dict__表示的是名稱空間，因此不會顯示類的屬性以及父類的屬性。正如上面剛建立childcls的實例時，dict中是空的，只有在c.f()以後才設置獨屬於對象的屬性。

若是要顯示類以及繼承自父類的屬性，可使用dir()。

例如：

>>> c1 = childcls()
>>> c1.__dict__
{}
>>> dir(c1)
['__class__', '__delattr__', '__dict__',
......
'f', 'x', 'y']

關於__dict__和dir()的詳細說明和區別，參見dir()和__dict__的區別。

<a name="blog1544254651"></a>

__class__和__bases__

前面屢次提到對象和類之間有鏈接關係，子類與父類也有鏈接關係。可是究竟是怎麼鏈接的？

• 對象與類之間，經過__class__進行鏈接：對象的__class__的值爲所屬類的名稱
• 子類與父類之間，經過__bases__進行鏈接：子類的__bases__的值爲父類的名稱

例如：

class supcls():
    x=3

class childcls(supcls):
    y=4
    def f(self):
        self.z=5

c = childcls()

c是childcls類的一個實例對象：

>>> c.__class__
<class '__main__.childcls'>

childcls繼承自父類supcls，父類supcls繼承自祖先類object：

>>> childcls.__bases__
(<class '__main__.supcls'>,)

>>> supcls.__bases__
(<class 'object'>,)

<a name="blog1544254652"></a>

查看類的繼承層次

下面經過__class__和__bases__屬性來查看對象所在類的繼承樹結構。

代碼以下：

def classtree(cls, indent):
    print("." * indent + cls.__name__)
    for supcls in cls.__bases__:
        classtree(supcls, indent + 3)


def objecttree(obj):
    print("Tree for %s" % obj)
    classtree(obj.__class__, 3)


class A: pass
class B(A): pass
class C(A): pass
class D(B, C): pass
class E: pass
class F(D, E): pass

objecttree(B())
print("==============")
objecttree(F())

運行結果：

Tree for <__main__.B object at 0x037D1630>
...B
......A
.........object
==============
Tree for <__main__.F object at 0x037D1630>
...F
......D
.........B
............A
...............object
.........C
............A
...............object
......E
.........object

原文出處：https://www.cnblogs.com/f-ck-need-u/p/10094021.html