Quel est le but du mot «moi»?

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

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

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.

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.

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

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.

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:

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: []

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]

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 .

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"

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

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 :).

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.

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

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.

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.

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.

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

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

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)où 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.

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

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).}

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

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