全面理解python中self的用法


self代表類的實例,而非類。

 

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

 

執行結果如下

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

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

self不必非寫成self

把上面的代碼改寫一下。

class Test:
  def prt(this):
    print(this)
    print(this.__class__)
  
t = Test()
t.prt()

改成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 "h.py", line 6, in <module>
  t.prt()
TypeError: prt() takes 0 positional arguments but 1 was given

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

class Test:
  def prt():
    print(__class__)
Test.prt()

運行結果如下

<class '__main__.Test'>

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

先看代碼

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

運行結果如下

<__main__.Child object at 0x0000000002A47080>
<__main__.Child object at 0x0000000002A47080>
<__main__.Parent object at 0x0000000002A47240>

解釋:

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

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

所以沿着繼承樹往上找,發現在父類Parent中定義了pprt()方法,所以就會成功調用。

在描述符類中,self指的是描述符類的實例

不太容易理解,先看實例:

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 in Test: <__main__.Test object at 0x0000000002A570B8>
self in Desc: <__main__.Desc object at 0x000000000283E208>
<__main__.Desc object at 0x000000000283E208> <__main__.Test object at 0x0000000002A570B8> <class '__main__.Test'>

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

如果直接通過類來調用屬性x也可以得到相同的結果。

下面是把t.x改為Test.x運行的結果。

self in Test: <__main__.Test object at 0x00000000022570B8>
self in Desc: <__main__.Desc object at 0x000000000223E208>
<__main__.Desc object at 0x000000000223E208> None <class '__main__.Test'>

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

從OO的本質理解python中的self
假設要對用戶的數據進行操作,用戶的數據包含name和age。如果用面向過程的話,實現出來是下面這樣子的。

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) 

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

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.GetName() 
print u.GetAge() 

總結

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

 


注意!

本站转载的文章为个人学习借鉴使用,本站对版权不负任何法律责任。如果侵犯了您的隐私权益,请联系我们删除。



 
粤ICP备14056181号  © 2014-2021 ITdaan.com