Sebelum memperkenalkan penggunaan diri dalam Python, mari kita perkenalkan dahulu kelas dan kejadian dalam Python
Kami tahu bahawa konsep berorientasikan objek yang paling penting ialah kelas dan contoh adalah templat abstrak perkara seperti pelajar boleh diwakili oleh kelas Pelajar. Instance ialah "objek" khusus yang dibuat berdasarkan kelas Setiap objek mewarisi kaedah yang sama daripada kelas, tetapi datanya mungkin berbeza.
1. Ambil kelas Pelajar sebagai contoh Dalam Python, kelas ditakrifkan seperti berikut:

class Student(object):
    pass

(Objek) menunjukkan kelas mana yang diwarisi oleh kelas Objek akan mewarisi.

2 Contoh: Selepas kelas ditakrifkan, anda boleh mencipta tika Pelajar melalui kelas Pelajar Mencipta tika dicapai melalui nama kelas + ():

student = Student()

3. Oleh kerana kelas memainkan peranan templat adalah untuk mengisi secara paksa atribut yang kami fikir mesti terikat semasa membuat contoh. Di sini kita menggunakan kaedah __init__, kaedah terbina dalam Python Contohnya, dalam kelas Pelajar, ikat atribut seperti nama dan skor kepadanya:

class Student(object):
    def __init__(self, name, score):
        self.name = name
        self.score = score

Nota di sini: (1), yang. bahagian pertama kaedah __init__ Parameter pertama sentiasa self, yang mewakili kelas yang dicipta sendiri Oleh itu, di dalam kaedah __init__, anda boleh mengikat pelbagai atribut kepada diri sendiri, kerana diri menunjuk kepada contoh yang dibuat itu sendiri. (2) Dengan kaedah __init__, apabila membuat contoh, anda tidak boleh menghantar parameter kosong Anda mesti memasukkan parameter yang sepadan dengan kaedah __init__, tetapi diri tidak perlu dihantar Jurubahasa Python akan pembolehubah Instance diluluskan dalam:

>>>student = Student("Hugh", 99)
>>>student.name
"Hugh"
>>>student.score
99

Selain itu, di sini self merujuk kepada kelas itu sendiri dan self.name ialah pembolehubah atribut kelas Student, yang dimiliki oleh kelas Student. Dan name ialah parameter luaran, bukan parameter yang disertakan dengan kelas Student. Oleh itu, self.name = name bermaksud untuk memberikan nilai parameter luaran name kepada pembolehubah atribut kelas Pelajar sendiri self.name.

4 Berbanding dengan nombor biasa, hanya terdapat satu perbezaan apabila mentakrifkan fungsi dalam kelas, iaitu parameter pertama sentiasa pembolehubah contoh kelas itu sendiri. self Dan apabila membuat panggilan, tidak perlu melepasi parameter ini. Selain itu, kaedah kelas (fungsi) tidak berbeza daripada fungsi biasa Anda boleh menggunakan parameter lalai, parameter pembolehubah atau parameter kata kunci (*args ialah parameter berubah, args Apa yang diterima ialah tuple<. ??>, **kw ialah parameter kata kunci dan kw menerima dict).

5 Memandangkan contoh kelas

Pelajar sendiri memiliki data ini, maka untuk mengakses data ini, tidak perlu mengaksesnya daripada fungsi luaran, tetapi boleh ditakrifkan secara langsung dalam kelas Pelajar. . Fungsi (kaedah) data, supaya "data" boleh dikapsulkan. Fungsi yang merangkum data ini dikaitkan dengan kelas Pelajar itu sendiri, dan dipanggil kaedah kelas:

class Student(obiect):
    def __init__(self, name, score):
        self.name = name
        self.score = score
    def print_score(self):
        print "%s: %s" % (self.name, self.score)

>>>student = Student("Hugh", 99)
>>>student.print_score
Hugh: 99

Dengan cara ini, apabila kita melihat kelas Pelajar dari luar, kita hanya perlu tahu apa yang diperlukan untuk buat nama dan skor. Cara mencetak ditakrifkan dalam kelas Pelajar

Data dan logik ini dirangkumkan, menjadikannya mudah untuk dipanggil, tetapi anda tidak mengetahui butiran pelaksanaan dalaman.

Jika anda ingin menghalang atribut dalaman daripada diakses secara luaran, anda boleh menambah dua garis bawah

sebelum nama atribut Dalam Python, jika nama pembolehubah bagi suatu contoh bermula dengan , kemudian Ia menjadi pembolehubah persendirian (peribadi), yang hanya boleh diakses secara dalaman dan bukan secara luaran Oleh itu, kami menukar kelas Pelajar:

class Student(object):

    def __init__(self, name, score):
        self.__name = name
        self.__score = score
    def print_score(self):
        print "%s: %s" %(self.__name,self.__score)

Selepas pengubahsuaian, tiada perubahan untuk kod luaran. tetapi Pembolehubah Instance

dan pembolehubah instance .__name tidak lagi boleh diakses dari luar: .__score

>>> student = Student('Hugh', 99)
>>> student.__name
Traceback (most recent call last):
  File "<stdin>", line 1, in <module>
AttributeError: &#39;Student&#39; object has no attribute &#39;__name&#39;

Ini memastikan kod luaran tidak boleh mengubah suai keadaan dalaman objek sesuka hati, supaya melalui perlindungan sekatan akses, kod itu lebih mantap.

Tetapi bagaimana jika kod luaran ingin mendapatkan nama dan markah? Anda boleh menambah kaedah seperti get_name dan get_score pada kelas Pelajar:

class Student(object):
    ...

    def get_name(self):
        return self.__name

    def get_score(self):
        return self.__score

Bagaimana jika anda mahu membenarkan kod luaran mengubah suai skor? Anda boleh menambah kaedah set_score pada kelas Pelajar:

class Student(object):
    ...

    def set_score(self, score):
        self.__score = score

Perlu diingat bahawa dalam Python, nama pembolehubah adalah serupa dengan

, iaitu nama yang bermula dengan garis bawah berganda dan berakhir dengan dua kali ganda. garis bawah ialah pembolehubah khas. __xxx____name__Kadangkala, anda akan melihat nama pembolehubah contoh bermula dengan garis bawah, seperti _name Pembolehubah contoh sedemikian boleh diakses secara luaran, bagaimanapun, mengikut konvensyen, apabila anda melihat pembolehubah tersebut Apabila, ia bermakna, ". Walaupun saya boleh diakses, sila anggap saya sebagai pembolehubah peribadi dan jangan mengaksesnya sesuka hati." Satu lagi faedah pengkapsulan __score__

ialah anda boleh menambah kaedah baharu

ke kelas Pelajar pada bila-bila masa, seperti:

:

class Student(object):
    ...
    def get_grade(self):
        if self.score >= 90:
            return 'A'
        elif self.score >= 60:
            return 'B'
        else:
            return 'C'

Begitu juga, get_grade kaedah boleh terus Dipanggil pada pembolehubah contoh, tidak perlu mengetahui butiran pelaksanaan dalaman:

>>> student.get_grade()
'A'

6、self的仔細用法
(1)、self代表類的實例，而非類。

class Test:
    def ppr(self):
        print(self)
        print(self.__class__)

t = Test()
t.ppr()
執(zhí)行結(jié)果：
<__main__.Test object at 0x000000000284E080>
<class &#39;__main__.Test&#39;>

從上面的例子中可以很明顯的看出，self代表的是類的實例。而self.__class__則指向類。
注意：把self換成this，結(jié)果也一樣，但Python中最好用約定俗成的self。
（2）、self可以不寫嗎？
在Python解釋器的內(nèi)部，當我們調(diào)用t.ppr()時，實際上Python解釋成Test.ppr(t)，也就是把self替換成了類的實例。

class Test:
    def ppr():
        print(self)

t = Test()
t.ppr()

運行結(jié)果如下：

Traceback (most recent call last):
File "cl.py", line 6, in
t.ppr()
TypeError: ppr() takes 0 positional arguments but 1 was given

運行時提醒錯誤如下：ppr在定義時沒有參數(shù)，但是我們運行時強行傳了一個參數(shù)。

由于上面解釋過了t.ppr()等同于Test.ppr(t)，所以程序提醒我們多傳了一個參數(shù)t。

這里實際上已經(jīng)部分說明了self在定義時不可以省略。

當然，如果我們的定義和調(diào)用時均不傳類實例是可以的，這就是類方法。

class Test:
    def ppr():
        print(__class__)

Test.ppr()

運行結(jié)果：
<class &#39;__main__.Test&#39;>

（3）、在繼承時，傳入的是哪個實例，就是那個傳入的實例，而不是指定義了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()

運行結(jié)果：

<__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()方法，所以沿著繼承樹往上找，發(fā)現(xiàn)在父類Parent中定義了pprt()方法，所以就會成功調(diào)用。

（4）、在描述符類中，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

運行結(jié)果如下：

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>

這里主要的疑問應該在：Desc類中定義的self不是應該是調(diào)用它的實例t嗎？怎么變成了Desc類的實例了呢？
因為這里調(diào)用的是t.x，也就是說是Test類的實例t的屬性x，由于實例t中并沒有定義屬性x，所以找到了類屬性x，而該屬性是描述符屬性，為Desc類的實例而已，所以此處并沒有頂用Test的任何方法。

那么我們?nèi)绻苯油ㄟ^類來調(diào)用屬性x也可以得到相同的結(jié)果。

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

self in Test: <__main__.Test object at 0x00000000022570B8>
self in Desc: <__main__.Desc object at 0x000000000223E208>
<__main__.Desc object at 0x000000000223E208> None <class &#39;__main__.Test&#39;>

Atas ialah kandungan terperinci Bagaimana untuk menggunakan diri dalam Python. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!