Comment s'utiliser soi-même en Python

Avant d'introduire l'utilisation de self en Python, introduisons d'abord les classes et les instances en Python
Nous savons que les concepts les plus importants de l'orientation objet sont les classes et les instances. Les classes sont des modèles abstraits, tels que les étudiants abstraits. Les choses peuvent être représentées. par une classe d'étudiant. Les instances sont des « objets » spécifiques créés à partir de classes. Chaque objet hérite des mêmes méthodes de la classe, mais ses données peuvent être différentes.
1. Prenons l'exemple de la classe Student. En Python, la classe est définie comme suit :

class Student(object):
    pass

(Object) indique de quelle classe la classe hérite. La classe Object est une classe dont toutes les classes hériteront.

2. Instance : Une fois la classe définie, vous pouvez créer une instance de Student via la classe Student. La création d'une instance se fait via le nom de la classe + ():

student = Student()

3. vous pouvez Lors de la création d'une instance, nous remplissons avec force les attributs que nous pensons devoir être liés. Ici, nous utilisons la méthode __init__, une méthode intégrée à Python. Par exemple, dans la classe Student, associez-y des attributs tels que le nom et le score : __init__方法，例如在Student类时，把name、score等属性绑上去:

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

这里注意：（1）、__init__方法的第一参数永远是self，表示创建的类实例本身，因此，在__init__方法内部，就可以把各种属性绑定到self，因为self就指向创建的实例本身。（2）、有了__init__方法，在创建实例的时候，就不能传入空的参数了，必须传入与__init__方法匹配的参数，但self不需要传，Python解释器会自己把实例变量传进去：

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

另外，这里self就是指类本身，self.name就是Student类的属性变量，是Student类所有。而name是外部传来的参数，不是Student类所自带的。故，self.name = name的意思就是把外部传来的参数name的值赋值给Student类自己的属性变量self.name。

4、和普通数相比，在类中定义函数只有一点不同，就是第一参数永远是类的本身实例变量self，并且调用时，不用传递该参数。除此之外，类的方法(函数）和普通函数没啥区别，你既可以用默认参数、可变参数或者关键字参数（*args是可变参数，args接收的是一个tuple，**kw是关键字参数，kw接收的是一个dict）。

5、既然Student类实例本身就拥有这些数据，那么要访问这些数据，就没必要从外面的函数去访问，而可以直接在Student类的内部定义访问数据的函数（方法），这样，就可以把”数据”封装起来。这些封装数据的函数是和Student类本身是关联起来的，称之为类的方法：

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

这样一来，我们从外部看Student类，就只需要知道，创建实例需要给出name和score。而如何打印，都是在Student类的内部定义的，这些数据和逻辑被封装起来了，调用很容易，但却不知道内部实现的细节。

如果要让内部属性不被外部访问，可以把属性的名称前加上两个下划线，在Python中，实例的变量名如果以开头，就变成了一个私有变量（private），只有内部可以访问，外部不能访问，所以，我们把Student类改一改：

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)

改完后，对于外部代码来说，没什么变动，但是已经无法从外部访问实例变量.__name和实例变量.__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;

这样就确保了外部代码不能随意修改对象内部的状态，这样通过访问限制的保护，代码更加健壮。

但是如果外部代码要获取name和score怎么办？可以给Student类增加get_name和get_score这样的方法：

class Student(object):
    ...

    def get_name(self):
        return self.__name

    def get_score(self):
        return self.__score

如果又要允许外部代码修改score怎么办？可以给Student类增加set_score方法：

class Student(object):
    ...

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

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

有些时候，你会看到以一个下划线开头的实例变量名，比如_name，这样的实例变量外部是可以访问的，但是，按照约定俗成的规定，当你看到这样的变量时，意思就是，“虽然我可以被访问，但是，请把我视为私有变量，不要随意访问”。

封装的另一个好处是可以随时给Student类增加新的方法，比如：get_grade:

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

同样的，get_grade

>>> student.get_grade()
'A'

Notez ici : (1), __init__< Le premier paramètre de la méthode /code> est toujours <code>self, qui représente l'instance de classe créée. Par conséquent, dans le __init__</. code>, vous pouvez Diverses propriétés sont liées à self, car self pointe vers l'instance créée elle-même. (2) Avec la méthode <code>__init__, lors de la création d'une instance, vous ne pouvez pas transmettre de paramètres vides. Vous devez transmettre des paramètres qui correspondent à la méthode __init__, mais ce n'est pas nécessaire. pass, l'interpréteur Python transmettra lui-même les variables d'instance : 🎜

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

t = Test()
t.ppr()
执行结果：
<__main__.Test object at 0x000000000284E080>
<class &#39;__main__.Test&#39;>

🎜 De plus, ici self fait référence à la classe elle-même, et self.name est Student< Les variables d'attribut de la classe /code> appartiennent à la classe <code>Student. Et name est un paramètre externe, pas celui fourni avec la classe Student. Par conséquent, self.name = name signifie attribuer la valeur du paramètre externe name à la propre variable d'attribut de la classe Student self.name</code >. 🎜🎜4. Par rapport aux nombres ordinaires, la seule différence entre la définition de fonctions dans une classe est que le <strong>premier paramètre</strong> est toujours <strong>la propre variable d'instance de la classe</strong><code>self</strong>. code>, et lors de l'appel, ce paramètre n'a pas besoin d'être transmis. De plus, les méthodes de classe (fonctions) ne sont pas différentes des fonctions ordinaires. Vous pouvez utiliser des <strong>paramètres par défaut, des paramètres variables ou des paramètres de mots-clés</strong> (<strong>*args sont des paramètres variables, args reçoit un tuple</strong). >, <strong>**kw est un paramètre de mot clé, et kw reçoit un dict</strong>). 🎜🎜5. Puisque l'instance de classe <strong>Student</strong> possède elle-même ces données, alors pour accéder à ces données, il n'est pas nécessaire d'y accéder à partir de fonctions externes. Au lieu de cela, les fonctions d'accès aux données peuvent être définies directement à l'intérieur du fichier. Classe d'étudiant. (Méthode), de cette manière, les "données" peuvent être encapsulées. Ces fonctions qui encapsulent les données sont associées à la classe Student elle-même et sont appelées méthodes de classe : 🎜<div class="code" style="position:relative; padding:0px; margin:0px;"><div class="code" style="position:relative; padding:0px; margin:0px;"><pre class="brush:py;">class Test: def ppr(): print(self) t = Test() t.ppr()</pre><div class="contentsignin">Copier après la connexion</div></div><div class="contentsignin">Copier après la connexion</div></div><div class="code" style="position:relative; padding:0px; margin:0px;"><div class="code" style="position:relative; padding:0px; margin:0px;"><pre class="brush:py;">class Test: def ppr(): print(__class__) Test.ppr() 运行结果： &lt;class &amp;#39;__main__.Test&amp;#39;&gt;</pre><div class="contentsignin">Copier après la connexion</div></div><div class="contentsignin">Copier après la connexion</div></div>🎜 De cette façon, lorsque nous regardons la classe Student de l'extérieur, nous avons seulement besoin de savoir que le nom et le score doivent être donné pour créer une instance. La manière d'imprimer est entièrement définie dans la classe Student <strong>Ces données et logiques sont encapsulées, ce qui facilite leur appel, mais vous ne connaissez pas les détails de l'implémentation interne. </strong>🎜🎜Si vous souhaitez empêcher l'accès aux attributs internes en externe, vous pouvez ajouter deux traits de soulignement <strong> avant le nom de l'attribut, en Python, si le nom de variable d'une instance commence par </strong>, ça devient Une variable privée (privée) n'est accessible qu'en interne mais pas en externe On change donc la classe Student : 🎜<div class="code" style="position:relative; padding:0px; margin:0px;"><div class="code" style="position:relative; padding:0px; margin:0px;"><pre class="brush:py;">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()</pre><div class="contentsignin">Copier après la connexion</div></div><div class="contentsignin">Copier après la connexion</div></div>🎜Après la modification, il n'y a pas de changement pour le code externe, mais l'instance n'est pas accessible de l'extérieur. La variable <code>.__name et la variable d'instance .__score sont : 🎜

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

🎜 Cela garantit que le code externe ne peut pas modifier à volonté l'état interne de l'objet, de sorte que grâce à la protection des restrictions d'accès, le code est plus robuste. 🎜🎜Mais que se passe-t-il si le code externe veut obtenir le nom et le score ? Vous pouvez ajouter des méthodes comme get_name et get_score à la classe Student : 🎜

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;>

🎜Et si vous souhaitez autoriser du code externe à modifier le score ? Vous pouvez ajouter la méthode set_score à la classe Student : 🎜rrreee🎜Il est à noter qu'en Python, les noms de variables sont similaires à __xxx__, c'est-à-dire celles commençant par un double trait de soulignement et se terminant par un double les traits de soulignement sont des variables spéciales. , les variables spéciales sont accessibles directement, pas les variables privées, donc les noms de variables tels que __name__ et __score__ ne peuvent pas être utilisés. 🎜🎜Parfois, vous verrez des noms de variables d'instance commençant par un trait de soulignement, tels que _name. Cependant, selon la convention, lorsque vous voyez une telle variable, cela signifie "Bien que je sois accessible". , veuillez me traiter comme une variable privée et n'y accédez pas à volonté." 🎜🎜Un autre avantage de l'encapsulation est que vous pouvez ajouter de nouvelles méthodes à la classe Student à tout moment, telles que : get_grade:🎜rrreee🎜De même, get_grade< /code> Les méthodes peuvent être appelées directement sur des variables d'instance sans connaître les détails d'implémentation internes : 🎜<div class="code" style="position:relative; padding:0px; margin:0px;"><div class="code" style="position:relative; padding:0px; margin:0px;"><pre class="brush:py;">&gt;&gt;&gt; student.get_grade() &amp;#39;A&amp;#39;</pre><div class="contentsignin">Copier après la connexion</div></div><div class="contentsignin">Copier après la connexion</div></div><p>6、<code>self的仔细用法
(1)、self代表类的实例，而非类。

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

t = Test()
t.ppr()
执行结果：
<__main__.Test object at 0x000000000284E080>
<class &#39;__main__.Test&#39;>

从上面的例子中可以很明显的看出，self代表的是类的实例。而self.__class__则指向类。
注意：把self换成this，结果也一样，但Python中最好用约定俗成的self。
（2）、self可以不写吗？
在Python解释器的内部，当我们调用t.ppr()时，实际上Python解释成Test.ppr(t)，也就是把self替换成了类的实例。

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

t = Test()
t.ppr()

运行结果如下：

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

运行时提醒错误如下：ppr在定义时没有参数，但是我们运行时强行传了一个参数。

由于上面解释过了t.ppr()等同于Test.ppr(t)，所以程序提醒我们多传了一个参数t。

这里实际上已经部分说明了self在定义时不可以省略。

当然，如果我们的定义和调用时均不传类实例是可以的，这就是类方法。

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

Test.ppr()

运行结果：
<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()

运行结果：

<__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()方法，所以就会成功调用。

（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

运行结果如下：

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不是应该是调用它的实例t吗？怎么变成了Desc类的实例了呢？
因为这里调用的是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 &#39;__main__.Test&#39;>

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!