全面理解Python中self的用法

　　參考：https://www.cnblogs.com/wangjian941118/p/9360471.html

　　全面理解pythong中self的用法

　　self代表類的實例，而非類

　　d:/learn-python3/學習腳本/全面了解python中self的用法/test.py

# self代表類的實例，而非類 start
class Test:
    def prt(self):
        # 打印實例
        print(self)
        # 打印實例的屬性__class__即打印實例對應的類
        print(self.__class__)

t = Test()
t.prt()
# <__main__.Test object at 0x000001F5DD79C6C8>
# <class '__main__.Test'>
# self代表類的實例，而非類 end

　　執行結果如下

<__main__.Test object at 0x000001F5DD79C6C8>
<class '__main__.Test'>

　　從上面的例子可以很明顯看出，self代表的是Test類的實例。而self.class則指向類Test

　　self不必非寫成self

　　把上面的代碼改一下，把self改成其他的比如this

# self不必非寫成self start
class Test:
    def prt(this):
        # 打印實例
        print(this)
        # 打印實例的屬性__class__即打印實例對應的類
        print(this.__class__)

t = Test()
t.prt()
# self不必非寫成self end

　　改成this后，運行結果是一樣的

　　當然，最好還是按照約定成俗的習慣，使用self

　　self可以不寫嗎？

　　在Python解釋器內部，當我們調用t.prt()時，實際上Python解釋成Test.prt(t),也就是說把self替換成類的實例作為參數調用類的函數方法。

　　把上面的t.prt()一行改寫一下，運行后的實際結果完全相同。

　　實際上已經部分說明了self在定義時不可以省略

class Test:
    def prt():
        print(self)
t = Test()
t.prt()

　　運行時提醒錯誤如下：prt在定義時沒有參數，但是運行時強行傳了一個參數。

　　由於上面解釋過了t.prt()等同於Test.prt(t)，所以程序提醒多傳了一個參數t。

Traceback (most recent call last):
  File "d:/learn-python3/學習腳本/全面了解python中self的用法/test.py", line 36, in <module>  
    t.prt()
TypeError: prt() takes 0 positional arguments but 1 was given

　　如果定義和調用時均不傳類實例是可以的，就是類方法

# 定義和調用時均不傳類實例是可以的，就是類方法 start
class Test:
    def prt():
        print(__class__)

# 類方法,不是實例方法，實例方法的調用代碼應該是Test().prt()
# Test是類,Test()是實例
Test.prt()
# <class '__main__.Test'>

# 定義和調用時均不傳類實例是可以的，就是類方法 end

　　運行結果如下

<class '__main__.Test'>

　　直接使用類Test調用類函數prt()不報錯是因為使用類方法不會默認傳遞實例作為參數

　　注意：Test是類，Test()是實例，如果上面代碼改成Test().prt()則是使用實例調用同樣因為在prt()內沒有傳遞參數self會報錯

　　在繼承時，傳入的是哪個實例，就是那個傳入的實例，而不是指定義了self的類的實例。

　　先看代碼

# 在繼承時，傳入的是哪個實例，就是那個傳入的實例，而不是指定義了self的類的實例 start
class Parent:
    def pprt(self):
        print(self)

class Child(Parent):
    def cprt(self):
        print(self)
c = Child()
c.cprt()
c.pprt()
p = Parent()
p.pprt()
# 在繼承時，傳入的是哪個實例，就是那個傳入的實例，而不是指定義了self的類的實例 end

　　運行結果如下

<__main__.Child object at 0x0000026AC8D21708>
<__main__.Child object at 0x0000026AC8D21708>
<__main__.Parent object at 0x0000026AC8D21688>

　　解釋：

　　運行c.part()時應該沒有理解問題，指的是Child類的實例

　　但是在運行c.pprt()時，等同於Chile.pprt(c),所以self值的依然是Child類的實例，而不是Parent的實例，由於Child中沒有定義pprt()方法，

　　所以沿着繼承樹繼續往上找，發現父類Parent中定義了pprt()方法，所以就會調用成功。打印的self為Child類的一個實例

　　p.pprt()打印的是Parent的一個實例，沒有問題

 

 

 　　在描述符類中，self值的描述符類的實例

　　不太容易理解，先看實例

# 在描述符類中，self指的是描述符類的實例 start
class Desc:
    def __get__(self,ins,cls):
        print('self in Desc:%s' % self)
        print(self,ins,cls)

class Test:
    x = Desc()
    def prt(self):
        print('self in Test: %s' % self)

t = Test()
t.prt()
t.x

# 在描述符類中，self指的是描述符類的實例 end

　　運行結果如下

self in Test: <__main__.Test object at 0x000002255C8E1848>
self in Desc:<__main__.Desc object at 0x000002255C8E1788>
<__main__.Desc object at 0x000002255C8E1788> <__main__.Test object at 0x000002255C8E1848> <class '__main__.Test'>

　　注意：這里dialysis的是t.x,也就是說是Test類的實例t的屬性x，由於實例t中並沒有屬性x，所以找到了類屬性x，而該屬性是描述符屬性，為Desc類的實例而已，所以此處並沒有調用Test的任何方法。

　　解釋：

　　描述符屬性:在Desc中定義了__get__方法，在Test中定義了一個類屬性x，是Desc的一個實例，我們訪問t.x的時候就是訪問了Desc的__get__方法，我們在__get__方法中的3個參數self，ins，cls分別對應描述符的實例，調用該描述符類的實例，調用類

　　使用輸出順序為，描述符類的實例（Desc的實例），調用該描述符類的實例（Test的實例），調用該描述符的類(Test類)

　　下面把t.x修改為Test.x即把實例的屬性修改為類的屬性

t = Test()
t.prt()
Test.x

　　運行輸出如下

self in Test: <__main__.Test object at 0x000002007FEE1888>
self in Desc:<__main__.Desc object at 0x000002007FEE17C8>
<__main__.Desc object at 0x000002007FEE17C8> None <class '__main__.Test'>

　　對比可以看到使用類調用屬性和使用實例調用屬性的輸出第二項不同，如果使用實例調用屬性則輸出為調用它的實例，使用類屬性調用，因為沒有實例所以返回None

　　題外話：由於在很多時候描述符類中仍然需要知道調用該描述符的實例是誰，所以在描述符類中存在第二個參數ins，用來表示調用它的類實例，所以t.x時可以看到第三行中的運行結果中第二項為<main.Test object at 0x0000000002A570B8>。而采用Test.x進行調用時，由於沒有實例，所以返回None。

　　關於描述符類參考：https://www.cnblogs.com/minseo/p/8515398.html

　　從本質理解Python中的self

　　下面從面相過程和面相對象的兩種代碼方式來理解self

　　假設要對用戶的數據進行操作，用戶的數據包含name和age。如果用面向過程的話，實現出來是下面這樣子的。

# 面向過程的例子 start
def user_init(user,name,age):
    user['name'] = name
    user['age'] = age

def set_user_name(user,x):
    user['name'] = x

def set_user_age(user,x):
    user['age'] = x

def get_user_name(user):
    return user['name']

def get_user_age(user):
    return user['age']

myself = {}
user_init(myself,'kzc',17)
print(get_user_age(myself))
set_user_age(myself,20)
print(get_user_age(myself))
# 面向過程的例子 end

　　

　　可以看到，對用戶的各種操作，都要傳user參數進去。
　　如果用面向對象的話，就不用每次把user參數傳來傳去，把相關的數據和操作綁定在一個地方，在這個類的各個地方，可以方便的獲取數據。
　　之所以可以在類中的各個地方訪問數據，本質就是綁定了self這個東西，它方法的第一個參數，可以不叫self，叫其它名字，self只不過是個約定。
　　下面是面向對象的實現，可以看到，結構化多了，清晰可讀。

# 面向對象的例子 start
class User(object):
    def __init__(self,name,age):
        self.name = name
        self.age = age
    
    def SetName(self,name):
        self.name = name
    
    def SetAge(self,age):
        self.age = age

    def GetName(self):
        return self.name

    def GetAge(self):
        return self.age

u = User('kzc',17)
print(u.GetAge())
u.SetAge(20)
print(u.GetAge())
# 面向對象的例子 end

　　實現的效果是一樣的

　　總結：

• 　　self在定義時需要定義，但是在調用時會自動傳入
• 　　self的名字並不是規定死的，但是最后還是按照約定使用self
• 　　self總是值調用時類的實例