Python中的類

類的定義

示例：

class Person:
    country = "China"
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def speak(self, word):
        print(word)

其中 country 是類屬性，即 Person類的靜态屬性，speak() 為 Person類的函數屬性，即類的動态屬性~

類的執行個體化

對上述示例的類進行執行個體化：

>>> p = Person('Kitty', 18)       # 執行個體化 Person類，得到對象 p
>>> p.name                              # 調用對象 p 的name屬性
'Kitty' 
>>> p.speak('hello')                 # 調用對象 p 的綁定方法
hello

類中的 __init__ 方法用于初始化對象，而在類的是執行個體化過程中，對應類中第一個被調用的并不是 __init__ 方法，第一個被調用的是 __new__方法。在對象的初始化之前首先要建立對象，__new__方法正是用來建立這個對象~

類的執行個體化過程也可以通過如下語句來實作：

>>> p = object.__new__(Person)        # __new__方法繼承自 object類
>>> Person.__init__(p, 'Kitty', 18)
>>> p.name
'Kitty'

在Person類中重寫 __new__方法：

class Person:
    country = "China"
    def __new__(cls, name, age):
        print('__new__ called')
        return super(Person, cls).__new__(cls)

    def __init__(self, name, age):
        self.name = name
        self.age = age

    def speak(self, word):
        print(word)

p = Person('Kitty', 18)          # 執行個體化對象
print('name : %s' % p.name)

# 輸出結果：
__new__ called
name : Kitty

很明顯 __new__方法是先于 __init__ 方法被調用的~

類的執行個體化過程大緻步驟如下：

1、p = Person('Kitty', 18) ，會調用 Person類的__new__方法，并傳遞 name 和 age 參數

2、__new__方法會建立一個 Person類的對象并傳回

3、最後利用這個對象調用類的 __init__ 方法完成初始化，__init__ 方法的第一個參數是self，對象在調用 __init__ 方法時會将自己當做參數傳遞給這個self。

注意：__init__方法沒有傳回值~，__init__ 方法僅完成對象的初始化工作~

self是什麼？

在類的内部，self 就是一個對象。使用對象調用方法時（對象的綁定方法），目前對象會被自動傳遞給 self，即 self 表示調用該方法的對象~

類屬性的調用

操作類的變量屬性：

>>> Person.country                  # 調用類屬性
'China'
>>> Person.country = 'USA'     # 修改類屬性
>>> Person.country
'USA'
>>> del Person.country           # 删除類屬性
>>> Person.country                 # 删除後無法再調用
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: type object 'Person' has no attribute 'country'

調用類的函數屬性：

這裡僅介紹綁定方法的調用（即第一個參數是self的方法），類中的其他方法暫先不做介紹~

speak() 是類的函數屬性，對象調用不需要傳遞 self參數（對象調用會自動完成self參數傳值，下面會介紹），若是類來調用，則需要手動傳遞這個 self參數，即需要傳遞一個Person類的對象~

class Person:
    country = "China"

    def __init__(self, name, age):
        self.name = name
        self.age = age

    def speak(self, word):
        print(word)

p = Person('Kitty', 18) 
p.speak('hello')                  # 對象調用，會自動将 對象p 作為第一個參數傳遞給 self
Person.speak(p, '你好')     # 類調用需要手動傳遞 self 的值

# 輸出結果：
hello
你好

類的名稱空間

類名.__dict__ 用來檢視一個類（或對象）的名稱空間，可以這樣了解。其實__dict__是類的一個内置屬性，存儲所有執行個體共享的變量和函數(類屬性，方法等)，類的__dict__并不包含其父類的屬性。對象中的 __dict__ 屬性下面會介紹~

這裡注意和 dir() 方法的差別，dir(類名或對象名) 會傳回一個類（或對象）的所有屬性，包括從父類中繼承的屬性。

Person類的__dict__屬性
{'__module__': '__main__',        # 所處子產品
'__init__': <function Person.__init__ at 0x11023b378>,   # __init__方法
'speak': <function Person.speak at 0x11023b400>,       # speak 方法
'__dict__': <attribute '__dict__' of 'Person' objects>,      # 應該就是指  類的__dict__屬性，具體參閱：https://blog.csdn.net/lis_12/article/details/53519060
'__weakref__': <attribute '__weakref__' of 'Person' objects>, 
'__doc__': None}             # # class說明文檔

調用類的屬性，首先會去類的名稱空間中（Person.__dict__）尋找對應名稱的key，相當于Person.__dict__['country']，也可以直接這樣調用：

>>> Person.__dict__['country']
'China'
>>> Person.__dict__['country'] = 'USA'
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
TypeError: 'mappingproxy' object does not support item assignment

注意：

__dict__ 對于類中的屬性隻能檢視，不能修改~

Python内置屬性

除了 __dict__，Python中的類還有很多别的内置屬性：

__doc__ :類的說明

__name__: 類名

__module__: 類定義所在的子產品

__bases__ : 包含了類的所有父類的元組

示例如下：

class Person:
    '''human being'''
    country = "China"

    def __init__(self, name, age):
        self.name = name
        self.age = age

    def speak(self, word):
        print(word)

print(Person.__doc__)
print(Person.__name__)
print(Person.__module__)
print(Person.__bases__)

#結果輸出：
human being
Person
__main__
(<class 'object'>,)

Python中的對象

對象的名稱空間

class Person:
    country = "China"

    def __init__(self, name, age):
        self.name = name
        self.age = age

    def speak(self, word):
        print(word)

執行個體化一個Person類的對象的過程中，init方法會将參數指派給 name 與 age 屬性，可以通過執行個體的__dict__ 檢視，注意：執行個體的__dict__ 僅存儲與該執行個體相關的執行個體屬性，沒有函數屬性，也沒有共有屬性~

>>> p = Person('Kitty', 18)
>>> print(p.__dict__)
{'name': 'Kitty', 'age': 18}

注意執行個體.__dict__ 與類.__dict__ 的差別~

通過類.__dict__ 可以檢視類中的屬性，但是不能修改，但是通過執行個體.__dict__ 除了檢視，還可以進行修改~

>>> p.__dict__['name']
'Kitty'
>>> p.__dict__['age']
18
>>> p.__dict__['name'] = 'abc'
>>> p.__dict__['age'] = 20
>>> p.name
'abc'
>>> p.age 
20

對象的變量屬性調用

通過對象可以直接調用該對象的變量屬性，例如 p對象的 name屬性和 age屬性~

>>> p = Person('Kitty', 18)
>>> p.name
'Kitty'
>>> p.age
18

也可以通過 p對象調用對應類（這裡是Person類）的變量屬性，若是類的變量屬性發生變化，則所有對象擷取到的類變量屬性都會改變~

>>> p.country
'China'

>>> Person.country = 'UK'       # 修改 類的變量屬性
>>> p2 = Person('baby', 22)
>>> p.country
'UK'
>>> p2.country
'UK'

Tip：

可以将所有類共有的屬性設定成類屬性；
對象尋找屬性會先在自己的名稱空間中尋找，若是沒有再去類的名稱空間中尋找~

注意1

在修改類的變量屬性時，若變量是不可變類型，則僅能通過類名.變量屬性來修改，如下示例：

>>> Person.country = 'USA'     # 修改類屬性
>>> p.country   
'USA'
>>> p.country = 'UK'
>>> p.country
'UK'
>>> Person.country
'USA'
>>> p2.country
'USA'

p.country 并沒有修改類屬性，而是給自己添加了一個新的屬性，這個新添加的屬性存放在對象自己的名稱空間中，類的變量屬性 country 并沒有發生改變~

>>> p.__dict__
{'country': 'UK', 'age': 20, 'name': 'abc'}

在類中 self 表示目前調用的對象，當 self 引用的變量和類變量同名的時候，需要注意區分：這兩個變量之間沒有關聯，self 引用的變量屬于對象，放在對象的名稱空間中，類變量則放在類名稱空間中

class Person:
    country = "China"
    def __init__(self, name, age):
        self.name = name
        self.age = age
        self.country = 'AUS'     # 添加對象屬性
    def speak(self):
        print(self.country)
############
>>> p = Person('Kitty', 18)
>>> p.country
'AUS'
>>> p.speak()
AUS
>>> Person.country
'China'

注意2

當類變量為可變類型時，需要區分對象的 2種操作：

class Person:
    country = "China"
    lst = []
    def __init__(self, name, age):
        self.name = name
        self.age = age
        self.lst.append(name)
    def speak(self):
        print(self.name)
############
>>> p = Person('Kitty', 18)
>>> p.__dict__
{'age': 18, 'name': 'Kitty'}
>>> Person.lst
['Kitty']

上述示例中，self 針對 lst 變量并不是一個指派操作，而是調用了 lst的append方法，是以這個過程會先在對象的名稱空間中尋找 lst 屬性，對象的名稱空間中沒有，然後再去類的名稱空間中尋找，Person類中存在該屬性，于是調用其 append 方法。

這個過程通過對象修改了類的可變類型的變量~

若 self 針對 lst 變量是一個指派操作，這樣就為目前對象新增了一個 lst 屬性

class Person:
    country = "China"
    lst = []
    def __init__(self, name, age):
        self.name = name
        self.age = age
        self.lst = name
    def speak(self):
        print(self.name)
############
>>> p = Person('Kitty', 18)
>>> p.__dict__
{'age': 18, 'name': 'Kitty', 'lst': 'Kitty'}
>>> Person.__dict__
{'__module__': '__main__', 'country': 'China', 'lst': [], '__doc__': None, '__init__': <function __init__ at 0x105f5fc08>, 'speak': <function speak at 0x105f5c0c8>}

對象的方法（綁定方法）

class Person:
    country = "China"
    def __init__(self, name, age):
        self.name = name
        self.age = age
    def speak(self):
        print(self.name + ', ' + str(self.age))
############
>>> p1 = Person('Kitty', 18)
>>> p2 = Person('baby', 22)
>>> p1.__dict__
{'age': 18, 'name': 'Kitty'}
>>> p2.__dict__
{'age': 22, 'name': 'baby'}

可以看到對象的名稱空間中沒有函數屬性，函數屬性在類的名稱空間當中

>>> Person.speak
<unbound method Person.speak>
>>> p1.speak
<bound method Person.speak of <__main__.Person instance at 0x105f727a0>>
>>> p2.speak
<bound method Person.speak of <__main__.Person instance at 0x105f728c0>>

>>> p1.speak()
Kitty, 18
>>> p2.speak()
baby, 22
>>> Person.speak(p1)     # 通過類調用
Kitty, 18

簡述Python中的類與對象Python中的類Python中的對象

Python中的類

類的定義

類的執行個體化

類屬性的調用

類的名稱空間

Python内置屬性

Python中的對象

對象的名稱空間

對象的變量屬性調用

對象的方法（綁定方法）

繼續閱讀

python 繪制ROC圖像

python類屬性繼承和定制

python類重載運算符init和str

python對象_查找Python對象具有的方法

python類繼承構造函數的執行問題解析

二十四、python中類的建立，類的初始化，類的屬性，類的方法詳解

python模拟登陸爬取webserver 輸出結果

python對象持久化shelve子產品

python3面向對象--python3中類的繼承

python類庫configparser

err: command ‘gcc‘ failed with exit status 1 解決方法

python對象_python對象引用，可變性和垃圾回收

用python腳本将DNA序列的.fa檔案格式轉換為.npy

Python中的抽象

Python基礎 Zero to Hero面向對象程式設計(二)