代碼塊的分類
python中分幾種代碼塊類型，它們都有自己的作用域，或者說名稱空間：
- 文件或模塊整體是一個代碼塊，名稱空間為全局范圍
- 函數代碼塊，名稱空間為函數自身范圍，是本地作用域，在全局范圍的內層
- 函數內部可嵌套函數，嵌套函數有更內一層的名稱空間
- 類代碼塊，名稱空間為類自身
- 類中可定義函數，類中的函數有自己的名稱空間，在類的內層
- 類的實例對象有自己的名稱空間，和類的名稱空間獨立
- 類可繼承父類，可以鏈接至父類名稱空間
正是這一層層隔離又連接的名稱空間將變量、類、對象、函數等等都組織起來，使得它們可以擁有某些屬性，可以進行屬性查找。
本文詳細解釋類和對象涉及的名稱空間，屬於純理論類的內容，有助於理解python面向對象的細節。期間會涉及全局和本地變量作用域的查找規則，如有不明白之處，可先看文章：Python作用域詳述
一個概括全文的示例
以下是一個能在一定程度上概括全文的示例代碼段：
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屬於哪個作用域、哪個名稱空間，本文內容基本上就理解了。
類的名稱空間
下面有一個類，類中有類屬性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。這就像類內部看不到全局變量一樣。
上面全都是使用類名.屬性這種完全限定名稱去訪問類中的屬性的。如果生成類的對象，則可以通過對象去訪問相關對象屬性，因為對象有自己的名稱空間，且部分屬性來源於類。
對象名稱空間
類就像一個模板，可以根據這個模板大量生成具有自己特性的對象。在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()
那么它們的名稱空間，以及類的名稱空間的關系如下圖所示：
現在僅僅只是對象s1、s2連接到了類supcls，對象s1和s2有自己的名稱空間。但因為類supcls中沒有構造方法__init__()初始化對象屬性，所以它們的名稱空間中除了python內部設置的一些"其它"屬性，沒有任何屬於自己的屬性。
但因為s1、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中。
類屬性和對象屬性
屬於類的屬性稱為類屬性，即那些存在於類名稱空間的屬性。類屬性分為類變量和方法。方法分為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參數代表的對象，所以是對象屬性。
子類繼承時的名稱空間
子類和父類之間有繼承關系，它們的名稱空間也通過一種特殊的方式進行了連接：子類可以繼承父類的屬性。
例如下面的例子，子類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) # 錯誤，子類和父類都沒有該屬性
當創建子類對象的時候，子類對象的變量搜索規則：
- 子類對象自身名稱空間
- 子類的類名稱空間
- 父類的類名稱空間
例如，創建子類對象c1，並調用子類的方法n()：
c1 = childcls()
c1.n()
現在，子類對象c1、子類childcls和父類supcls的關系如下圖所示：
通過前面的說明，想必已經不用過多解釋。
多重繼承時的名稱空間
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__屬性的默認順序：
類自身就是一個全局屬性
在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是面向對象時名稱空間之間的連接關系，在搜索屬性的時候可以順着"這根樹"不斷向上爬，直到搜索到屬性。
__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__的區別。
__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'>,)
查看類的繼承層次
下面通過__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