Verstehen Sie sich selbst in Python in einem Artikel

Magisches Selbst:

In Python-Klassen ist der erste Parameter der Funktion das Instanzobjekt selbst und Schreiben Sie den Namen per Konvention als self. Seine Funktion entspricht dieser in Java, die das Objekt der aktuellen Klasse darstellt und Eigenschaften und Methoden in der aktuellen Klasse aufrufen kann.

Klasse ist eine objektorientierte Designidee, und Instanzen (d. h. Objekte, Objekte) werden basierend auf der Klasse erstellt.

Eine Klasse (Klasse) sollte Daten und Methoden zum Betreiben von Daten enthalten. Im Allgemeinen handelt es sich um Attribute und Funktionen (dh Aufrufmethoden).

Warum self im Unterricht verwenden?

Im Klassencode (Funktion) müssen Sie auf die Variablen und Funktionen in der aktuellen Instanz zugreifen, d. h. auf die entsprechende Variable (Eigenschaft) in der Instanz zugreifen:

: Instanz. PropertyNam, um den vorherigen Wert zu lesen und den neuen Wert zu schreiben.

Rufen Sie die entsprechende Funktion auf: Instance.function(), dh führen Sie die entsprechende Aktion aus.

-> Wenn Sie auf die Variablen der Instanz zugreifen und die Funktionen der Instanz aufrufen müssen, benötigen Sie natürlich das entsprechende Instanzobjekt selbst.

-> In Python ist festgelegt, dass der erste Parameter der Funktion das Instanzobjekt selbst sein muss, und es wird empfohlen, seinen Namen laut Konvention als self zu schreiben.

-> Deshalb brauchen wir das Selbst (das Bedürfnis, das Selbst zu nutzen).

Zuerst die Definition einer Klasse in Python:

In Python wird eine Klasse durch das Schlüsselwort class definiert:

class gefolgt von The Der Klassenname, nämlich Person, beginnt normalerweise mit einem Großbuchstaben, gefolgt von (Objekt), das angibt, von welcher Klasse die Klasse geerbt wird. Wenn es keine geeignete geerbte Klasse gibt, wird normalerweise die Objektklasse verwendet alle Klassen. Alle Klassen werden vererbt.

class Person（object）:
    pass

Instanziieren Sie die Person-Klasse. Die Instanziierung wird durch Klassenname + () erstellt.

class Person(object):
    pass
student = Person()    # 创建类的实例化
print(student)
print(Person)

Wie Sie sehen können, zeigt die Variable student auf ein Personenobjekt, und das folgende 0x0000026EE434D8D0 ist die Speicheradresse jedes Objekts und die Person selbst ist eine Klasse.

Sie können Attribute auch an Instanzvariablen binden, zum Beispiel: Namens- und Bewertungsattribute an Schüler binden

class Person(object):
    pass
student = Person()
# print(student)
# print(Person)
student.name = "Gavin"     # 为实例变量 student 绑定 name 属性   类似于 赋值 操作
student.score = 100        # 为 其绑定  score 属性
print(student.name)
print(student.score)

Obwohl die obige Methode eine Instanz von sein kann Die Bindung von Klassenattributen ist nicht praktisch und elegant genug, da Klassen beim Erstellen einer Instanz zwangsweise ausgefüllt werden müssen. In Python wird dies normalerweise in einer Methode verwendet. Die Methode def __init__(self) bindet Attribute wie Name und Bewertung an die Instanzvariable, wenn diese erstellt wird.

class Person(object):
    def __init__(self,name,score):
        self.name = name
        self.score = score
        
student = Person('Gavin',100)    #  传入 __init__ 方法中需要的参数
print(student.name)
print(student.score)

Wenn leere Parameter übergeben werden, wird ein Fehler gemeldet:

class Person(object):
    def __init__(self,name,score):
        self.name = name
        self.score = score
        
student = Person()      # 此处应该有参数传入，却没有传
print(student.name)
print(student.score)

Hinweis:

1. Der erste Parameter der __init__-Methode ist immer self, der die erstellte Instanz selbst darstellt. Daher können Sie innerhalb der __init__-Methode verschiedene Attribute an self binden, da self auf die erstellte Instanz selbst verweist.

2. Wenn Sie die __init__-Methode verwenden, können Sie beim Erstellen einer Instanz keine leeren Parameter übergeben. Sie müssen Parameter übergeben, die mit der __init__-Methode übereinstimmen, aber self muss nicht übergeben werden es selbst. Übergeben Sie Instanzvariablen.

Verwandte Empfehlungen: „Python-Video-Tutorial“

Definieren Sie mehrere Funktionen in einer Klasse, um sich gegenseitig aufzurufen

class Person(object):
    def __init__(self,x,y):
        self.x = x
        self.y = y
        
    def add(self):
        sum = self.x + self.y
        return sum
    
    def square(self):
        squr = pow(self.x,2)+pow(self.y,2)
        return squr
    def add_square(self):
        c = self.add()+self.square()
        return c
        
student = Person(3,4)
print(student.add())
print(student.square())
print('--------- 我是可爱的分割线-----------')
print(student.add_square())

Wie aus den obigen Beispielen ersichtlich ist, weisen in Klassen definierte Funktionen im Vergleich zu gewöhnlichen Funktionen nur zwei Unterschiede auf:

1 Der erste Parameter ist immer self und dieser Parameter muss nicht übergeben werden Aufruf.

2. Wenn sich Funktionen in einer Klasse gegenseitig aufrufen, muss self hinzugefügt werden, wie im obigen Beispiel: c = self.add()+self.square(), wenn self nicht hinzugefügt wird, Es wird ein Fehler gemeldet: Die Funktion ist undefiniert, siehe Bild unten:

除此之外，类的方法和普通函数没甚区别，当然也可以使用 默认参数、可变参数和关键字参数，例子如下：

class Person(object):
    def __init__(self,x,y):
        self.x = x
        self.y = y
        
        
    def add(self,z=16):         # 设置 默认变量 z =16,这只是个普通的局部变量，非实例变量，实例变量需要 
    self.z = z,这样定义
        sum = self.x + self.y + z
        return sum
    
    def square(self):
        squr = pow(self.x,2)+pow(self.y,2)
        return squr
    def add_square(self,z):        #  调用时传入变量，这也是个普通的局部变量，非实例变量 
        c = self.add()+self.square() + z
        return c
        
student = Person(3,4)
print(student.add())
print(student.square())
print('--------- 我是可爱的分割线-----------')
print(student.add_square(16))

看了上述的例子可能还是不明白 self 到底是个什么鬼，为啥要使用 self 这鬼东西？没关系，往下看：

其实 self 这家伙简单的说就是把 class 中 定义的 变量和函数 变成 实例变量和实例函数，作为类 class 的成员，使得成员间能互相调用，而不需要从外部调用 数据（变量）和 方法（函数），以实现数据的封装，以上面的 Person 类为例：

创建实例的时候需要给出实例变量 x,y, 调用函数时给出 z ，调用很容易，却不知道内部实现的细节。

总之，类是创建实例的模板，而实例则是一个一个具体的对象，各个实例拥有的数据都相互独立、互不影响；方法是与实例绑定的函数，和普通的函数不同，方法可以直接访问实例的数据。

其实 self 中存储的是实例变量和实例函数的属性，可以理解为一个字典（ dict ），如：{'name':'zhang','age':'18'}就是这些。

注意只有数据属性，并没有创建新的类的方法。  类----->通过实例化生成----对象---->（对象只是一串类似于字典的数据，没有把类的里的方法复制给你，python没有new这个方法！）

class Person(object):
    def __init__(self,x,y):
        self.x = x
        self.y = y
        
        
    def add(self,z=16):     # 设置 z 为实例变量，即 self.z = z, z 是 class 的一个成员了，而非普通局部变量
        self.z = z
        sum = self.x + self.y + z  # z虽然已被实例化，但是依然可以当作 普通变量来用
        return sum
    
    def square(self):
        squr = pow(self.x,2)+pow(self.y,2)
        return squr
    def add_square(self):        
        c = self.add()+self.square() + self.z  # 调用实例变量 z 
        return c
        
student = Person(3,4)
print(student.add())
print(student.square())
print('--------- 我是可爱的分割线-----------')
print(student.add_square())
print(student.z)          # 函数add 中的 z 被实例化以后，就可以利用实例化的方法访问它

通过这个例子可以看出， z 本来是 add() 函数的默认形参，通过将其实例化，就可以在其他函数体内调用实例变量z 

被实例化以后，就可以利用实例化的方法访问它。

那么 self 到底是什么？

class Box(object):
    def __init__(self, boxname, size, color):
        self.boxname = boxname
        self.size = size
        self.color = color  # self就是用于存储对象属性的集合，就算没有属性self也是必备的
 
    def open(self, myself):
        print('-->用自己的myself，打开那个%s,%s的%s' % (myself.color, myself.size, myself.boxname))
        print('-->用类自己的self，打开那个%s,%s的%s' % (self.color, self.size, self.boxname))
 
    def close(self):
        print('-->关闭%s，谢谢' % self.boxname)
 
 
b = Box('魔盒', '14m', '红色')
b.close()
b.open(b)  # 本来就会自动传一个self，现在传入b，就会让open多得到一个实例对象本身，print看看是什么。
print(b.__dict__)  # 这里返回的就是self本身，self存储属性，没有动作。

self代表类的实例，而非类；self 就是 对象/实例 属性集合

Box 是个类-----》self 实例化------》 b对象/ 实例

class 抽象体------》实例化------》对象/实例，含有属性：{'boxname':'魔盒', ‘size’：‘14m’, 'color':'red'}，即 self

self 看似是整个对象，实际上清楚地描述了类就是产生对象的过程，描述了 self 就是得到了 对象，所以 self 内的键值可以直接使用

正如自然界中一个有效的对象，必须包括：

1、描述对象的属性；2、对象的方法

所以 self是必须的，也是对象中重要的特性。

看下面的代码，感觉就更神奇了：

class Box(object):
    def myInit(mySelf, boxname, size, color):
        mySelf.boxname = boxname
        mySelf.size = size
        mySelf.color = color  # 自己写一个初始化函数，一样奏效,甚至不用self命名。其它函数当中用标准self
        return mySelf  # 返回给实例化过程一个对象！神奇！并且含有对象属性/字典
 
    # def __init__(self, boxname, size, color):
    #     self.boxname = boxname
    #     self.size = size
    #     self.color = color  #注释掉原来标准的初始化
 
    def open(self, myself):
        print(self)
        print('-->用自己的myself，打开那个%s,%s的%s' % (myself.color, myself.size, myself.boxname))
        print('-->用类自己的self，打开那个%s,%s的%s' % (myself.color, myself.size, myself.boxname))
 
    def close(self):
        print('-->关闭%s，谢谢' % self.boxname)
 
 
# 经过改造，运行结果和标准初始化没区别
 
b = Box().myInit('魔盒', '14m', '红色')
# b = Box('魔盒', '14m', '红色')#注释掉原来标准的初始化方法
b.close()
b.open(b)  # 本来就会自动传一个self，现在传入b，就会让open多得到一个实例对象本身，print看看是什么。
print(b.__dict__)  # 这里返回的就是self本身，self存储属性，没有动作。

换个角度来讲，对类的操作有：

1、定义属性 ； 2、调用方法

对类的反馈有：

1、得到属性 ； 2、执行方法

在 class 类的函数中，为什么 self是必要的，因为 self 是对象的载体，可以理解成一个字典，看下面代码：

class Box(object):
    def myInit(mySelf, boxname, size, color):
        print(mySelf.__dict__)#显示为{}空字典
        mySelf.boxname = boxname
        mySelf.__dict__['aa'] = 'w'#甚至可以像字典一样操作
        mySelf.size = size
        mySelf.color = color  # 自己写一个初始化函数，一样奏效,甚至不用self命名。其它函数当中用标准self
        return mySelf  # 返回给实例化过程一个对象！神奇！并且含有对象属性/字典
 
    # def __init__(self, boxname, size, color):
    #     self.boxname = boxname
    #     self.size = size
    #     self.color = color  #注释掉原来标准的初始化
 
    def open(self, myself):
        print(self)
        print('-->用自己的myself，打开那个%s,%s的%s' % (myself.color, myself.size, myself.boxname))
        print('-->用类自己的self，打开那个%s,%s的%s' % (myself.color, myself.size, myself.boxname))
 
    def close(self):
        print('-->关闭%s，谢谢' % self.boxname)
 
 
# 经过改造，运行结果和标准初始化没区别
 
b = Box().myInit('魔盒', '14m', '红色')
# b = Box('魔盒', '14m', '红色')#注释掉原来标准的初始化方法
b.close()
b.open(b)  # 本来就会自动传一个self，现在传入b，就会让open多得到一个实例对象本身，print看看是什么。
print(b.__dict__)  # 这里返回的就是self本身，self存储属性，没有动作。

注意此处的： mySelf.__dict__['aa'] = 'w'  #甚至可以像字典一样操作； 在 b.__dict__ 的结果中显示为：'aa':'w'

故可以把 self 理解成存储 实例化对象属性的字典(dict), self 存储属性，而没有动作执行。

self总是指调用时的类的实例。

python 中一些特殊的实例变量：

1、私有变量(private),只有内部可以访问，外部不能访问，私有变量是在名称前以两个下划线开头，如：__name，其实私有变量也不是完全不能被外部访问，不能直接访问是因为python解释器对外把 __name 变量改成了 _类名__name,所仍然可以通过 _类名__name 来访问 __name。

2、在Python中，变量名类似__xxx__的，也就是以双下划线开头，并且以双下划线结尾的，是特殊变量，特殊变量是可以直接访问的，不是private变量，所以，不能用__name__、__score__这样的变量名。

3. Instanzvariablennamen, die mit einem Unterstrich beginnen, wie z. B. _name, sind von außen zugänglich. Wenn Sie jedoch eine solche Variable sehen, bedeutet dies: „Obwohl ich darauf zugreifen kann, aber bitte behandeln Sie mich.“ als private Variable und greifen Sie nicht nach Belieben darauf zu.

Das obige ist der detaillierte Inhalt vonVerstehen Sie sich selbst in Python in einem Artikel. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!