Quel est le but du mot «moi»?

1131

Quel est le but du selfmot en Python? Je comprends qu'il fait référence à l'objet spécifique créé à partir de cette classe, mais je ne vois pas pourquoi il doit explicitement être ajouté à chaque fonction en tant que paramètre. Pour illustrer, dans Ruby je peux faire ceci:

class myClass
    def myFunc(name)
        @name = name
    end
end

Ce que je comprends assez facilement. Cependant en Python, je dois inclure self:

class myClass:
    def myFunc(self, name):
        self.name = name

Quelqu'un peut-il me parler de cela? Ce n'est pas quelque chose que j'ai rencontré dans mon expérience (certes limitée).

richzilla
la source
111
Vous pouvez trouver intéressant cet essai "Pourquoi l'auto explicite doit rester" de Guido van Rossum: neopythonic.blogspot.com/2008/10/…
unutbu
14
Voir aussi "Pourquoi faut-il utiliser" self "explicitement dans les définitions de méthode et les appels": docs.python.org/faq/…
unutbu
37
"Ce que je comprends, assez facilement" --- Assez subjectif, vous ne pensez pas? Qu'est-ce qui rend @nameplus intuitif que self.name? Ce dernier, l'OMI, est plus intuitif.
Santa
14
C'est la principale différence entre une fonction et une méthode de classe. Une fonction flotte librement, sans encombre. Une méthode de classe (instance) doit être consciente de son parent (et des propriétés parent), vous devez donc transmettre à la méthode une référence à la classe parent (en tant que self ). C'est juste une règle implicite de moins que vous devez internaliser avant de comprendre la POO. D'autres langues choisissent le sucre syntaxique plutôt que la simplicité sémantique, le python n'est pas d'autres langues.
Evan Plaice
9
Je ne pense pas que "explicite vaut mieux qu'implicite" explique vraiment bien ce choix de conception. @fooet self.foosont également explicites car aucune résolution implicite ne doit se produire (par exemple en C ++, les membres d'instance peuvent être "implicitement" accédés sans "explicitement" utiliser des espaces de noms). La seule différence est que Ruby introduit une nouvelle sémantique (@), contrairement à Python. Le fait qu'une nouvelle sémantique valait ou non la quantité de verbosité évitée est purement subjectif. Cependant, il convient de noter que la plupart des langages modernes choisissent d'introduire un concept ici (par exemple php's $ this, JS's this).
Jing

Réponses:

710

La raison que vous devez utiliser self.est que Python n'utilise pas la @syntaxe pour faire référence aux attributs d'instance. Python a décidé de faire les méthodes de manière à ce que l'instance à laquelle la méthode appartient soit passée automatiquement, mais pas reçue automatiquement: le premier paramètre des méthodes est l'instance sur laquelle la méthode est appelée. Cela rend les méthodes entièrement identiques aux fonctions, et laisse le nom réel à votre discrétion (bien que ce selfsoit la convention, et les gens vont généralement vous froncer les sourcils lorsque vous utilisez autre chose.) selfN'est pas spécial pour le code, c'est juste un autre objet .

Python aurait pu faire autre chose pour distinguer les noms normaux des attributs - une syntaxe spéciale comme Ruby l'a fait, ou nécessitant des déclarations comme C ++ et Java, ou peut-être quelque chose d'encore plus différent - mais ce n'est pas le cas. Python est tout pour rendre les choses explicites, pour rendre évident ce qui est quoi, et bien qu'il ne le fasse pas entièrement partout, il le fait par exemple pour les attributs. C'est pourquoi l'attribution à un attribut d'instance doit savoir à quelle instance attribuer, et c'est pourquoi il a besoin self..

Thomas Wouters
la source
23
@Georg: clsfait référence à l'objet de classe, pas à l'objet d'instance
SilentGhost
17
@SilentGhost: En fait, le nom du premier paramètre est celui que vous voulez qu'il soit. Sur les méthodes de classe, la convention est d'utiliser clset selfest utilisée conventionnellement pour les méthodes d'instance. Si je le voulais, je pourrais utiliser selfdes méthodes de classe et clspar exemple des méthodes. Je pourrais aussi utiliser bobet fnordsi j'aimais.
SingleNegationElimination
67
Je trouve intéressant que la communauté n'ait pas choisi à la thisplace de self. A selfune histoire que je ne connais pas dans les anciens langages de programmation?
Jules GM
24
@Julius The selfprovient des conventions de Modula-3, voir cette réponse pour plus de détails sur ce choix. (Avertissement: sa mine).
Bakuriu
9
@Julius Le selfmot-clé (Smalltalk, 1980) est antérieur au thismot - clé (de C ++). Voir: stackoverflow.com/questions/1079983/…
Wes Turner
425

Prenons une classe vectorielle simple:

class Vector:
    def __init__(self, x, y):
        self.x = x
        self.y = y

Nous voulons avoir une méthode qui calcule la longueur. À quoi cela ressemblerait-il si nous voulions le définir à l'intérieur de la classe?

    def length(self):
        return math.sqrt(self.x ** 2 + self.y ** 2)

À quoi devrait-elle ressembler lorsque nous devions la définir comme une méthode / fonction globale?

def length_global(vector):
    return math.sqrt(vector.x ** 2 + vector.y ** 2)

Donc, la structure entière reste la même. Comment puis-je m'en servir? Si nous supposons un instant que nous n'avions pas écrit de lengthméthode pour notre Vectorclasse, nous pourrions le faire:

Vector.length_new = length_global
v = Vector(3, 4)
print(v.length_new()) # 5.0

Cela fonctionne car le premier paramètre de length_global, peut être réutilisé comme selfparamètre dans length_new. Cela ne serait pas possible sans explicite self.


Une autre façon de comprendre le besoin d'explicite selfest de voir où Python ajoute du sucre syntaxique. Lorsque vous gardez à l'esprit que, fondamentalement, un appel comme

v_instance.length()

est transformé en interne en

Vector.length(v_instance)

il est facile de voir où cela selfs'intègre. Vous n'écrivez pas réellement de méthodes d'instance en Python; ce que vous écrivez, ce sont des méthodes de classe qui doivent prendre une instance comme premier paramètre. Et par conséquent, vous devrez placer le paramètre d'instance quelque part explicitement.

Debilski
la source
4
Vector.length_new = length_global ... J'ai en fait commencé à utiliser une syntaxe comme celle-ci dans mes déclarations de classe. Chaque fois que je veux seulement hériter de certaines méthodes d'une autre classe, je copie simplement explicitement la référence aux méthodes.
Jeeyoung Kim
2
serait-il juste de dire que la "méthode d'instance" de python est simplement un sucre syntaxique de méthodes globales statiques (comme en Java ou C ++) avec un objet d'instance passé pour empaqueter plusieurs attributs? --- c'est un peu à moitié vrai car dans le polymorphisme, le but le plus important de "this" (comme en java) ou "self" est de vous donner la bonne implémentation des méthodes. Python a cela. donc appeler myobj.someMethod () est égal à TheClassOfMyObj.someMethod (myobj) en python. notez que le "TheClassOfMyObj" est automatiquement compris par python à partir de "self", sinon vous devrez le découvrir.
teddy teddy
3
En fait, non seulement les méthodes d'instance ne sont que des méthodes de classe, mais les méthodes ne sont que des fonctions qui sont membres d'une classe, comme le Vector.length_new = length_globalmontre l' illustration.
RussW
1
"Cela fonctionne, car le premier paramètre de length_global peut être réutilisé en tant que paramètre self dans length_new. Cela ne serait pas possible sans un self explicite." - cela fonctionnerait tout de même. il serait réutilisé pour le soi implicite ... le deuxième exemple est un raisonnement circulaire - vous devez explicitement placer le soi là-bas, car python a besoin du soi explicite.
Karoly Horvath
1
@KarolyHorvath: Bien sûr, il serait également possible d'avoir un langage avec un modèle où les méthodes définies en interne n'ont pas besoin d'un soi explicite mais les méthodes définies en externe le font. Mais je dirais qu'il y a une certaine cohérence à exiger le moi explicite dans les deux cas, ce qui en fait une raison légitime de le faire de cette façon. D'autres langues peuvent choisir des approches différentes.
Debilski
423

Disons que vous avez une classe ClassAqui contient une méthode methodAdéfinie comme:

def methodA(self, arg1, arg2):
    # do something

et ObjectAest une instance de cette classe.

Maintenant, quand ObjectA.methodA(arg1, arg2)est appelé, python le convertit en interne pour vous en tant que:

ClassA.methodA(ObjectA, arg1, arg2)

La selfvariable fait référence à l'objet lui-même.

Arjun Sreedharan
la source
94
J'ai lu toutes les autres réponses et en quelque sorte compris, j'ai lu celle-ci et puis tout a eu un sens.
Seth
3
Cela m'a cloué!
Bernard 'Beta Berlin' Parah
2
Pourquoi ne pas garder ces tripes à l'intérieur, comme Ruby le fait?
Cees Timmerman
Mais dans la méthode __init __ (self), il accepte soi, puis même sans créer l'objet, comment se réfère-t-il à lui-même?
saurav
Sérieusement, c'est beaucoup mieux que l'exemple de Debilski car il n'est pas trop complexe et les gens peuvent ne pas être familiers avec les vecteurs.
NoName
215

Lorsque les objets sont instanciés, l'objet lui-même est passé dans le paramètre self.

entrez la description de l'image ici

Pour cette raison, les données de l'objet sont liées à l'objet. Vous trouverez ci-dessous un exemple de la façon dont vous aimeriez visualiser les données de chaque objet. Remarquez comment «self» est remplacé par le nom des objets. Je ne dis pas que cet exemple de diagramme ci-dessous est tout à fait exact, mais il devrait, espérons-le, servir à visualiser l'utilisation de soi.

entrez la description de l'image ici

L'objet est passé dans le paramètre self afin que l'objet puisse conserver ses propres données.

Bien que cela ne soit pas tout à fait exact, pensez au processus d'instanciation d'un objet comme celui-ci: lorsqu'un objet est créé, il utilise la classe comme modèle pour ses propres données et méthodes. Sans passer son propre nom dans le paramètre self, les attributs et méthodes de la classe resteraient comme un modèle général et ne seraient pas référencés (appartiendraient) à l'objet. Ainsi, en passant le nom de l'objet dans le paramètre self, cela signifie que si 100 objets sont instanciés à partir d'une seule classe, ils peuvent tous garder une trace de leurs propres données et méthodes.

Voir l'illustration ci-dessous:

entrez la description de l'image ici

sw123456
la source
Hé là, quand on accède aux attributs de Bob par exemple par "bob.name ()", on accède en fait à bob (). Self.name pour ainsi dire depuis le ' init ' non?
udarH3
3
Lorsque vous écrivez bob.name () dans le commentaire ci-dessus, vous indiquez que bob a une méthode appelée name () en raison du fait que vous avez ajouté des crochets après le nom. Dans cet exemple, cependant, il n'y a pas une telle méthode. 'bob.name' (qui n'a pas de parenthèses) accède directement à l'attribut nommé name depuis la méthode init (constructeur). Lorsque la méthode speak de bob est appelée, c'est la méthode qui accède à l'attribut name et le renvoie dans une instruction print. J'espère que cela t'aides.
sw123456
3
Non, vous obtenez la valeur de self.name, qui pour l'objet bob est en fait bob.name, car le nom de l'objet est passé dans le paramètre self lors de sa création (instancié). Encore une fois, j'espère que cela vous aidera. N'hésitez pas à voter sur le poste principal, si c'est le cas.
sw123456
2
Le nom est attribué à self.name lors de l'instanciation. Après la création d'un objet, toutes les variables qui appartiennent à l'objet sont celles préfixées par «self». N'oubliez pas que self est remplacé par le nom de l'objet lorsqu'il est créé à partir de la classe.
sw123456
5
Voilà comment vous expliquez les choses! beau travail :)
penta
80

J'aime cet exemple:

class A: 
    foo = []
a, b = A(), A()
a.foo.append(5)
b.foo
ans: [5]

class A: 
    def __init__(self): 
        self.foo = []
a, b = A(), A()
a.foo.append(5)
b.foo
ans: []
kame
la source
18
donc les vars sans soi sont simplement des vars statiques de la classe, comme en java
teddy teddy
5
teddy teddy, vous n'êtes pas tout à fait correct. Le comportement (statique ou non statique) dépend non seulement selfdu type de variable, mais aussi de celui-ci. Essayez de faire le premier exemple avec un entier simple au lieu d'une liste. Le résultat serait bien différent.
Konstantin
2
En fait, ma question est la suivante: pourquoi avez-vous le droit de dire a.foodans le premier exemple plutôt que A.foo? fooAppartient clairement à la classe ...
Radon Rosborough
Vous pouvez appeler des membres statiques à partir d'instances de l'objet dans la plupart des langues. Pourquoi est-ce surprenant?
Paarth
2
@RadonRosborough Parce que dans le premier exemple, aet bsont tous les deux des étiquettes (ou pointeurs) pour A()(la classe). a.foofait référence à la A().foométhode de classe. Dans le deuxième exemple, cependant, adevient une référence à une instance de A(), comme le fait b. Maintenant qu'ils sont des instances au lieu de l'objet de classe lui-même, self permet à la foométhode d'opérer sur les instances.
LegendaryDude
40

Je vais démontrer avec du code qui n'utilise pas de classes :

def state_init(state):
    state['field'] = 'init'

def state_add(state, x):
    state['field'] += x

def state_mult(state, x):
    state['field'] *= x

def state_getField(state):
    return state['field']

myself = {}
state_init(myself)
state_add(myself, 'added')
state_mult(myself, 2)

print( state_getField(myself) )
#--> 'initaddedinitadded'

Les classes sont juste un moyen d'éviter de passer tout le temps dans cette "situation" (et d'autres choses intéressantes comme l'initialisation, la composition des classes, les métaclasses rarement nécessaires et la prise en charge de méthodes personnalisées pour remplacer les opérateurs).

Maintenant, montrons le code ci-dessus en utilisant la machinerie de classe python intégrée, pour montrer comment c'est fondamentalement la même chose.

class State(object):
    def __init__(self):
        self.field = 'init'
    def add(self, x):
        self.field += x
    def mult(self, x):
        self.field *= x

s = State()
s.add('added')    # self is implicitly passed in
s.mult(2)         # self is implicitly passed in
print( s.field )

[migré ma réponse à partir d'une question fermée en double]

ninjagecko
la source
1
Je souhaite Python enrobé de sucre aux gestionnaires ainsi que Ruby.
Cees Timmerman,
20

Les extraits suivants sont tirés de la documentation Python sur soi :

Comme dans Modula-3, il n'y a pas de raccourci [en Python] pour référencer les membres de l'objet à partir de ses méthodes: la fonction de méthode est déclarée avec un premier argument explicite représentant l'objet, qui est fourni implicitement par l'appel.

Souvent, le premier argument d'une méthode est appelé self. Ce n'est rien de plus qu'une convention: le nom self n'a absolument aucune signification particulière pour Python. Notez, cependant, qu'en ne suivant pas la convention, votre code peut être moins lisible par d'autres programmeurs Python, et il est également concevable qu'un programme de navigateur de classe puisse être écrit qui s'appuie sur une telle convention.

Pour plus d'informations, consultez le tutoriel de documentation Python sur les classes .

Matthew Rankin
la source
20

En plus de toutes les autres raisons déjà mentionnées, il permet un accès plus facile aux méthodes remplacées; vous pouvez appeler Class.some_method(inst).

Un exemple où c'est utile:

class C1(object):
    def __init__(self):
         print "C1 init"

class C2(C1):
    def __init__(self): #overrides C1.__init__
        print "C2 init"
        C1.__init__(self) #but we still want C1 to init the class too
>>> C2()
"C2 init"
"C1 init"
Ponkadoodle
la source
17

Son utilisation est similaire à l'utilisation du thismot - clé en Java, c'est-à-dire pour donner une référence à l'objet courant.

Gaurav Nishant
la source
2
class myClass: def myFunc (this, name): this.name = name
LEMUEL ADANE
16

Python n'est pas un langage construit pour la programmation orientée objet contrairement à Java ou C ++.

Lors de l'appel d'une méthode statique en Python, on écrit simplement une méthode avec des arguments réguliers à l'intérieur.

class Animal():
    def staticMethod():
        print "This is a static method"

Cependant, une méthode objet, qui vous oblige à créer une variable, qui est un animal, dans ce cas, a besoin de l'argument self

class Animal():
    def objectMethod(self):
        print "This is an object method which needs an instance of a class"

La méthode self est également utilisée pour faire référence à un champ variable dans la classe.

class Animal():
    #animalName made in constructor
    def Animal(self):
        self.animalName = "";


    def getAnimalName(self):
        return self.animalName

Dans ce cas, self fait référence à la variable animalName de toute la classe. N'OUBLIEZ PAS: Si vous avez une variable dans une méthode, self ne fonctionnera pas. Cette variable n'existe simplement que pendant l'exécution de cette méthode. Pour définir des champs (les variables de la classe entière), vous devez les définir EN DEHORS des méthodes de classe.

Si vous ne comprenez pas un seul mot de ce que je dis, alors Google "Programmation orientée objet". Une fois que vous aurez compris cela, vous n'aurez même plus besoin de poser cette question :).

ytpillai
la source
+1 en raison de la distinction entre staticMethod()et objectMethod(self). Je voudrais ajouter que pour invoquer la première, diriez-vous Animal.staticMethod(), tout en ayant objectMethod()besoin d'une instance:a = Animal(); a.objectMethod()
Laryx Decidua
Ce que vous dites n'est pas vrai à 100%. Ce n'est qu'une convention. Vous pouvez toujours appeler la méthode statique à partir d'un objet créé. Vous ne pourrez tout simplement pas utiliser les membres de la classe parce que vous ne vous êtes pas déclaré. Je peux même appeler Animal.objectMethod (animalObj) pour appeler le non statique. Fondamentalement, cela signifie qu'une méthode statique n'est qu'une méthode qui n'utilise pas de variables membres. Il ne devrait pas être nécessaire de se déclarer soi-même. C'est une exigence linguistique idiote, je pense. Des langages comme Lua et C ++ vous donnent des variables obj en arrière-plan.
user441521
Vous avez fait une déclaration de chaîne animalName inutile et une méthode crashName animalName.
Cees Timmerman,
3
@ytpillai Irrelevant. Un code déroutant et incorrect ne doit pas être présenté comme une réponse.
Cees Timmerman,
1
def getAnimalNamepour ne pas encombrer la chaîne que vous essayez de renvoyer et selffait référence à l'instance de la classe, pas à aucun champ à l'intérieur de celle-ci.
Cees Timmerman,
10

Il est là pour suivre le zen Python «explicite vaut mieux qu'implicite». C'est en effet une référence à votre objet de classe. En Java et PHP, par exemple, cela s'appelle this.

Si user_type_nameest un champ sur votre modèle, vous y accédez par self.user_type_name.

dan-klasson
la source
10

Tout d'abord, self est un nom conventionnel, vous pouvez mettre n'importe quoi d'autre (étant cohérent) à sa place.

Il fait référence à l'objet lui-même, donc lorsque vous l'utilisez, vous déclarez que .name et .age sont des propriétés des objets Student (notez, pas de la classe Student) que vous allez créer.

class Student:
    #called each time you create a new Student instance
    def __init__(self,name,age): #special method to initialize
        self.name=name
        self.age=age

    def __str__(self): #special method called for example when you use print
        return "Student %s is %s years old" %(self.name,self.age)

    def call(self, msg): #silly example for custom method
        return ("Hey, %s! "+msg) %self.name

#initializing two instances of the student class
bob=Student("Bob",20)
alice=Student("Alice",19)

#using them
print bob.name
print bob.age
print alice #this one only works if you define the __str__ method
print alice.call("Come here!") #notice you don't put a value for self

#you can modify attributes, like when alice ages
alice.age=20
print alice

Le code est ici

Akash Kandpal
la source
1
Votre réponse me semble la plus claire. +1
Pawel
9

selfest une référence d'objet à l'objet lui-même, par conséquent, ils sont identiques. Les méthodes Python ne sont pas appelées dans le contexte de l'objet lui-même. selfen Python peut être utilisé pour traiter des modèles d'objets personnalisés ou quelque chose.

Ming-Tang
la source
8

L'utilisation de l'argument, appelé conventionnellement, selfn'est pas aussi difficile à comprendre que pourquoi est-elle nécessaire? Ou pourquoi le mentionner explicitement? C'est, je suppose, une question plus importante pour la plupart des utilisateurs qui recherchent cette question, ou si ce n'est pas le cas, ils auront certainement la même question à mesure qu'ils avancent dans l'apprentissage de python. Je leur recommande de lire ces quelques blogs:

1: Utilisation de soi expliquée

Notez qu'il ne s'agit pas d'un mot clé.

Le premier argument de chaque méthode de classe, y compris init, est toujours une référence à l'instance actuelle de la classe. Par convention, cet argument est toujours nommé self. Dans la méthode init, self fait référence à l'objet nouvellement créé; dans d'autres méthodes de classe, il fait référence à l'instance dont la méthode a été appelée. Par exemple, le code ci-dessous est le même que le code ci-dessus.

2: Pourquoi l'avons-nous ainsi et pourquoi ne pouvons-nous pas l'éliminer comme argument, comme Java, et avoir un mot-clé à la place

Une autre chose que je voudrais ajouter est qu'un selfargument optionnel me permet de déclarer des méthodes statiques à l'intérieur d'une classe, sans écrire self.

Exemples de code:

class MyClass():
    def staticMethod():
        print "This is a static method"

    def objectMethod(self):
        print "This is an object method which needs an instance of a class, and that is what self refers to"

PS : cela ne fonctionne que dans Python 3.x.

Dans les versions précédentes, vous devez explicitement ajouter un @staticmethoddécorateur, sinon l' selfargument est obligatoire.

Bugs Buggy
la source
7

Je suis surpris que personne n'ait élevé Lua. Lua utilise également la variable «self» mais elle peut être omise mais toujours utilisée. C ++ fait de même avec «this». Je ne vois aucune raison d'avoir à déclarer «self» dans chaque fonction, mais vous devriez toujours pouvoir l'utiliser comme vous le pouvez avec lua et C ++. Pour un langage qui se targue d'être bref, il est étrange qu'il vous oblige à déclarer l'auto-variable.

user441521
la source
6

Jetez un oeil à l'exemple suivant, qui explique clairement le but de self

class Restaurant(object):  
    bankrupt = False

    def open_branch(self):
        if not self.bankrupt:
           print("branch opened")

#create instance1
>>> x = Restaurant()
>>> x.bankrupt
False

#create instance2
>>> y = Restaurant()
>>> y.bankrupt = True   
>>> y.bankrupt
True

>>> x.bankrupt
False  

self est utilisé / nécessaire pour distinguer les instances.

Source: explication de l'auto-variable en python - Pythontips

kmario23
la source
Oui, je pense que nous savons pourquoi self est utilisé, mais la question est de savoir pourquoi le langage vous oblige à le déclarer explicitement. De nombreux autres langages n'exigent pas cela et un langage qui se targue d'être bref, vous penseriez qu'ils vous donneraient simplement la variable en arrière-plan à utiliser comme Lua ou C ++ (cela).
user441521
3
@ kmario23 Votre réponse vient d'ici: pythontips.com/2013/08/07/the-self-variable-in-python-explained Veuillez toujours reconnaître les auteurs originaux lorsque vous publiez des réponses comme étant les vôtres.
geekidharsh
@geekidharsh merci, j'ai ajouté une note!
kmario23
5

C'est parce que par la façon dont python est conçu, les alternatives ne fonctionneraient guère. Python est conçu pour permettre de définir des méthodes ou des fonctions dans un contexte où à la fois implicite this(à la Java / C ++) ou explicite @(à la ruby) ne fonctionnerait pas. Prenons un exemple avec l'approche explicite avec les conventions python:

def fubar(x):
    self.x = x

class C:
    frob = fubar

Maintenant, la fubarfonction ne fonctionnerait pas car elle supposerait qu'il selfs'agit d'une variable globale (et frobaussi). L'alternative serait d'exécuter des méthodes avec une portée globale remplacée (où selfest l'objet).

L'approche implicite serait

def fubar(x)
    myX = x

class C:
    frob = fubar

Cela signifierait que myXcela serait interprété comme une variable locale dans fubar(et dans frobaussi). L'alternative ici serait d'exécuter des méthodes avec une portée locale remplacée qui est conservée entre les appels, mais cela supprimerait la possibilité de variables locales de méthode.

Cependant, la situation actuelle fonctionne bien:

 def fubar(self, x)
     self.x = x

 class C:
     frob = fubar

ici lorsqu'il est appelé en tant que méthode frobrecevra l'objet sur lequel elle est appelée via le selfparamètre, et fubarpeut encore être appelé avec un objet en tant que paramètre et fonctionne de la même (il est le même que C.frobje pense).

skyking
la source
3

Dans la __init__méthode, self fait référence à l'objet nouvellement créé; dans d'autres méthodes de classe, il fait référence à l'instance dont la méthode a été appelée.

soi, comme nom, n'est qu'une convention , appelez-la comme vous voulez! mais lorsque vous l'utilisez, par exemple pour supprimer l'objet, vous devez utiliser le même nom:, __del__(var)varétait utilisé dans le__init__(var,[...])

Vous devriez aussi y jeter un œil clspour avoir une vue d'ensemble . Ce message pourrait être utile.

Oussama L.
la source
3

self agit comme le nom d'objet actuel ou l'instance de classe.

# Self explanation.


 class classname(object):

    def __init__(self,name):

        self.name=name
        # Self is acting as a replacement of object name.
        #self.name=object1.name

   def display(self):
      print("Name of the person is :",self.name)
      print("object name:",object1.name)


 object1=classname("Bucky")
 object2=classname("ford")

 object1.display()
 object2.display()

###### Output 
Name of the person is : Bucky
object name: Bucky
Name of the person is : ford
object name: Bucky
sameer_nubia
la source
1

self est inévitable.

Il y avait juste une question qui devait selfêtre implicite ou explicite. Guido van Rossumrésolu cette question en disant selfdoit rester .

Alors où selfvivent-ils?

Si nous nous en tenions à la programmation fonctionnelle, nous n'en aurions pas besoin self. Une fois que nous entrons dans la POO Python, nous selfy trouvons .

Voici le cas d'utilisation typique class Cavec la méthodem1

class C:
    def m1(self, arg):
        print(self, ' inside')
        pass

ci =C()
print(ci, ' outside')
ci.m1(None)
print(hex(id(ci))) # hex memory address

Ce programme produira:

<__main__.C object at 0x000002B9D79C6CC0>  outside
<__main__.C object at 0x000002B9D79C6CC0>  inside
0x2b9d79c6cc0

Contient donc selfl'adresse mémoire de l'instance de classe. Le but de selfserait de conserver la référence pour les méthodes d'instance et pour nous d'avoir un accès explicite à cette référence.


Notez qu'il existe trois types différents de méthodes de classe:

  • méthodes statiques (lire: fonctions),
  • méthodes de classe,
  • méthodes d'instance (mentionnées).
prosti
la source
0

des documents ,

la particularité des méthodes est que l'objet instance est passé comme premier argument de la fonction. Dans notre exemple, l'appel x.f()est exactement équivalent à MyClass.f(x). En général, appeler une méthode avec une liste de n arguments équivaut à appeler la fonction correspondante avec une liste d'arguments créée en insérant l'objet instance de la méthode avant le premier argument.

précédant cet extrait,

class MyClass:
    """A simple example class"""
    i = 12345

    def f(self):
        return 'hello world'

x = MyClass()

nmxl
la source
-2

c'est une référence explicite à l'objet instance de classe.

SilentGhost
la source
21
Je ne pense pas que cela aide Richzilla à comprendre la raison derrière cela.
Georg Schölly
1
@SilentGhost: vous l'avez cloué. Je suis impressionné. si je le comprends bien: je crée un objet en tant qu'instance de la classe définie et le paramètre self fait référence à cet objet? Je comprends que self se réfère implicitement à la classe elle-même, mais ce serait bien si vous expliquiez un peu plus votre réponse.
dkrynicki