官網(wǎng)類的基礎(chǔ)語法閱讀

英文官方文檔: https://docs.python.org/3.8/tutorial/classes.html

中文官方文檔: https://docs.python.org/zh-cn/3.8/tutorial/classes.html

類提供了一種組合數(shù)據(jù)和功能的方法。

創(chuàng)建一個新類意味著創(chuàng)建一個新的對象類型，從而允許創(chuàng)建一個該類型的新實例。

1、類定義

最簡單的類定義看起來像這樣:

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

類定義與函數(shù)定義 (def 語句) 一樣必須被執(zhí)行才會起作用。

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

2、類對象

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

(1)屬性引用

屬性引用的標(biāo)準(zhǔn)語法: 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"。

(2)實例化

類的實例化使用函數(shù)表示法。

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

x = MyClass()

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

實例化操作（“調(diào)用”類對象）會創(chuàng)建一個空對象，也可以使用__init__() 創(chuàng)建帶有特定初始狀態(tài)的自定義實例。例如:

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

此時，類的實例化操作會自動為新創(chuàng)建的類實例調(diào)用 __init__()。 因此在這個示例中，可以通過 x = MyClass() 語句獲得一個經(jī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)

3、實例對象

實例對象唯一操作是屬性引用。 有兩種有效的屬性名稱：數(shù)據(jù)屬性和方法。

(1)數(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

(2)方法

方法是“從屬于”對象的函數(shù)。 【注：方法是針對對象來說的，函數(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ù)對象。

4、方法對象

通常，方法在綁定后立即被調(diào)用，在 MyClass 示例中，這將返回字符串 'hello world'。

x.f()

但是，立即調(diào)用一個方法并不是必須的: x.f 是一個方法對象，它可以被保存起來以后再調(diào)用。 例如:

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

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

雖然 f() 的函數(shù)定義指定了一個參數(shù)，但在上面調(diào)用 x.f() 時并沒有帶參數(shù)。 當(dāng)不帶參數(shù)地調(diào)用一個需要參數(shù)的函數(shù)時 Python 肯定會引發(fā)異常，即使參數(shù)實際未被使用。

方法的特殊之處就在于實例對象會作為函數(shù)的第一個參數(shù)被傳入。 在我們的示例中，調(diào)用 x.f() 其實就相當(dāng)于 MyClass.f(x)。 【注：也就是方法參數(shù)列表中的self】

總之，調(diào)用一個具有 n 個參數(shù)的方法就相當(dāng)于調(diào)用再多一個參數(shù)的對應(yīng)函數(shù)，這個參數(shù)值為方法所屬實例對象，位置在其他參數(shù)之前。

當(dāng)一個實例的非數(shù)據(jù)屬性【注：即方法】被引用時，將搜索實例所屬的類。

如果被引用的屬性名稱表示一個有效的類屬性中的函數(shù)對象，會通過打包（指向）查找到的實例對象和函數(shù)對象 到一個抽象對象的方式來創(chuàng)建方法對象：這個抽象對象就是方法對象。 【注：xf = x.f，x.f 是一個方法對象】

當(dāng)附帶參數(shù)列表調(diào)用方法對象時，將基于實例對象和參數(shù)列表構(gòu)建一個新的參數(shù)列表【注：self和參數(shù)列表】，并使用這個新參數(shù)列表調(diào)用相應(yīng)的函數(shù)對象。

5、類和實例變量

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

【注：下例中kind是類變量，name是實例變量】

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ù)可能在涉及可變對象的時候，例如列表和字典，導(dǎo)致令人驚訝的結(jié)果。

例如以下代碼中的 tricks 列表不應(yīng)該被用作類變量，因為所有的 Dog 實例將只共享一個單獨的列表:

【注：類變量是所有實例所共享的，以下代碼中的 tricks 列表不應(yīng)該被用作類變量，實例調(diào)用 add_trick 時，就改變了 tricks 列表】

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

6、補充說明

如果同樣的屬性名稱同時出現(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ù)常常被命名為 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)的全局作用域就是包含其定義的模塊。（類永遠(yuǎn)不會被作為全局作用域。）

雖然我們很少會有充分的理由在方法中使用全局作用域，但全局作用域存在許多合法的使用場景：舉個例子，導(dǎo)入到全局作用域的函數(shù)和模塊可以被方法所使用，在其中定義的函數(shù)和類也一樣。

通常，包含該方法的類本身是在全局作用域中定義的，而在下一節(jié)中我們將會發(fā)現(xiàn)為何方法需要引用其所屬類的很好的理由。

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

到此這篇關(guān)于Python3.8官網(wǎng)文檔之類的基礎(chǔ)語法閱讀的文章就介紹到這了,更多相關(guān)python3.8基礎(chǔ)語法內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！