程式碼塊的分類

python中分幾種程式碼塊型別，它們都有自己的作用域，或者說名稱空間：

• 檔案或模組整體是一個程式碼塊，名稱空間為全域性範圍
• 函式程式碼塊，名稱空間為函式自身範圍，是本地作用域，在全域性範圍的內層
  • 函式內部可巢狀函式，巢狀函式有更內一層的名稱空間
• 類程式碼塊，名稱空間為類自身
  • 類中可定義函式，類中的函式有自己的名稱空間，在類的內層
  • 類的例項物件有自己的名稱空間，和類的名稱空間獨立
  • 類可繼承父類，可以連結至父類名稱空間

正是這一層層隔離又連線的名稱空間將變數、類、物件、函式等等都組織起來，使得它們可以擁有某些屬性，可以進行屬性查詢。

本文詳細解釋類和物件涉及的名稱空間，屬於純理論類的內容，有助於理解python面向物件的細節。期間會涉及全域性和本地變數作用域的查詢規則，如有不明白之處，可先看文章：Python作用域詳述

一個概括全文的示例

以下是一個能在一定程度上概括全文的示例程式碼段：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
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。

1
2
3
4
5
6
7
8
9
10
11
12
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所表示的物件。

因為有名稱空間，可以直接使用完全限定名稱去訪問這個名稱空間中的內容。例如：

1
2
3
4
print(supcls.x)
print(supcls.y)
print(supcls.m)
print(supcls.n)

輸出結果：

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

因為函式m和n也是類的屬性，它們也可以直接通過類名來訪問執行。例如，新加入一個函式，但不用self引數了，然後執行它。

1
2
3
4
5
6
7
8
class testcls():
    z = 3
    def a():
        x = 1
        print(x)
        # print(z)     # 這是錯的

testcls.a()

但是需要注意，類方法程式碼塊中看不見類變數。雖然類和類方法的作用域關係類似於全域性作用域和函式本地作用域，但並不總是等價。例如，方法a()中無法直接訪問類變數z。這就像類內部看不到全域性變數一樣。

上面全都是使用類名.屬性這種完全限定名稱去訪問類中的屬性的。如果生成類的物件，則可以通過物件去訪問相關物件屬性，因為物件有自己的名稱空間，且部分屬性來源於類。

物件名稱空間

類就像一個模板，可以根據這個模板大量生成具有自己特性的物件。在Python中，只需像呼叫函式一樣直接呼叫類就可以建立物件。

例如，下面建立了兩個cls類的物件o1和o2，建立類的時候可以傳遞引數給類，這個引數可以傳遞給類的建構函式__init__()。

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

物件有自己的名稱空間。因為物件是根據類來建立的，類是它們的模板，所以物件名稱空間中包含所有類屬性，但是物件名稱空間中這些屬性的值不一定和類名稱空間屬性的值相同。

現在根據supcls類構造兩個物件s1和s2：

1
2
3
4
5
6
7
8
9
10
11
12
13
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。例如：

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

上面不再是通過完全限定的名稱去訪問類中的屬性，而是通過物件屬性查詢的方式搜尋到了類屬性。但上面訪問z屬性將報錯，因為還沒有呼叫m方法。

當呼叫m方法後，將會通過self.xxx的方式設定完全屬於物件自身的屬性，包括x、y、z。

1
2
s1.m()
s2.m()

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

現在物件名稱空間中有x、y和z共3個屬性(不考慮其它python內部設定的屬性)，再通過物件名去訪問物件屬性，仍然會查詢屬性，但對於這3個屬性的搜尋不會進一步搜尋到類的名稱空間。但如果訪問物件中沒有的屬性，比如m和n，它們不存在於物件的名稱空間中，所以會搜尋到類名稱空間。

1
2
3
4
5
print(s1.x)  # 物件屬性333，搜尋到物件名稱空間
print(s1.y)  # 物件屬性444，搜尋到物件名稱空間
print(s1.z)  # 物件屬性555，搜尋到物件名稱空間
s1.m()       # 搜尋到類名稱空間
s1.n()       # 搜尋到類名稱空間

物件與物件之間的名稱空間是完全隔離的，物件與類之間的名稱空間存在連線關係。所以，s1和s2中的x和y和z是互不影響的，誰也看不見誰。

但現在想要訪問類變數x、y，而不是物件變數，該怎麼辦？直接通過類名的完全限定方式即可：

1
2
print(s1.x)      # 輸出333，物件屬性，搜尋到物件名稱空間
print(supcls.x)  # 輸出3，類屬性，搜尋到類名稱空間

因為物件有了自己的名稱空間，就可以直接向這個名稱空間新增屬性或設定屬性。例如，下面為s1物件新增一個新的屬性，但並不是在類內部設定，而是在類的外部設定：

1
2
s1.x = 3333       # 在外部設定已有屬性x
s1.var1 = "aaa"   # 在外部新增新屬性var1

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

類屬性和物件屬性

屬於類的屬性稱為類屬性，即那些存在於類名稱空間的屬性。類屬性分為類變數和類方法。有些類方法無法通過物件來呼叫，這類方法稱為稱為靜態方法。

類似的，屬於物件名稱空間的屬性稱為物件屬性。物件屬性脫離類屬性，和其它物件屬性相互隔離。

例如：

1
2
3
4
5
6
7
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。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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()。

因為有自己的名稱空間，所以可以訪問類屬性。當訪問的屬性不存在於子類中時，將自動向上搜索到父類。

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

當建立子類物件的時候，子類物件的變數搜尋規則：

1. 子類物件自身名稱空間
2. 子類的類名稱空間
3. 父類的類名稱空間

例如，建立子類物件c1，並呼叫子類的方法n()：

1
2
c1 = childcls()
c1.n()

現在，子類物件c1、子類childcls和父類supcls的關係如下圖所示：

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

多重繼承時的名稱空間

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

1
2
3
4
5
6
7
8
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中，父類屬性的搜尋規則是先左後右，先深度後廣度，搜尋到了就停止。

如下圖：

一般不建議使用多重繼承，甚至不少語言根本就不支援多重繼承，因為很容易帶來屬性混亂的問題。

類自身就是一個全域性屬性

在python中，類並沒有什麼特殊的，它存在於模組檔案中，是全域性名稱空間中的一個屬性。

例如，在模組檔案中定義了一個類cls，那麼這個cls就是一個全域性變數，只不過這個變數中儲存的地址是類程式碼塊所在資料物件。

1
2
3
# 模組檔案頂層
class cls():
    n = 3

而模組本身是一個物件，有自己的模組物件名稱空間(即全域性名稱空間)，所以類是這個模組物件名稱空間中的一個屬性，僅此而已。

另外需要注意的是，類程式碼塊和函式程式碼塊不一樣，涉及到類程式碼塊中的變數搜尋時，只會根據物件與類的連線、子類與父類的繼承連線進行搜尋。不會像全域性變數和函式一樣，函式內可以向上搜尋全域性變數、巢狀函式可以搜尋外層函式。

例如：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
# 全域性範圍
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__中增加屬性。

例如:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
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，所作的修改都會直接對名稱空間起作用。

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

注意，__dict__表示的是名稱空間，所以不會顯示類的屬性以及父類的屬性。正如上面剛建立childcls的例項時，dict中是空的，只有在c.f()之後才設定獨屬於物件的屬性。

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

例如：

1
2
3
4
5
6
7
>>> c1 = childcls()
>>> c1.__dict__
{}
>>> dir(c1)
['__class__', '__delattr__', '__dict__',
......
'f', 'x', 'y']

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

__class__和__base__

前面多次提到物件和類之間有連線關係，子類與父類也有連線關係。但是到底是怎麼連線的？

• 物件與類之間，通過__class__進行連線：物件的__class__的值為所屬類的名稱
• 子類與父類之間，通過__bases__進行連線：子類的__bases__的值為父類的名稱

例如：

1
2
3
4
5
6
7
8
9
class supcls():
    x=3

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

c = childcls()

c是childcls類的一個例項物件：

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

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

1
2
3
4
5
>>> childcls.__bases__
(<class '__main__.supcls'>,)

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

檢視類的繼承層次

下面通過__class__和__bases__屬性來檢視物件所在類的繼承樹結構。

程式碼如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
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())

執行結果：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
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

鄭州哪家男科醫院好

鄭州婦科醫院哪好

鄭州醫院哪家看男科好

鄭州哪家醫院看男科好