¿Cuál es el propósito de la palabra 'yo'?

1130

¿Cuál es el propósito de la selfpalabra en Python? Entiendo que se refiere al objeto específico creado a partir de esa clase, pero no puedo ver por qué debe agregarse explícitamente a cada función como parámetro. Para ilustrar, en Ruby puedo hacer esto:

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

Lo cual entiendo, con bastante facilidad. Sin embargo, en Python necesito incluir self:

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

¿Alguien puede hablarme sobre esto? No es algo con lo que me haya encontrado en mi experiencia (ciertamente limitada).

richzilla
fuente
111
Puede encontrar interesante este ensayo "Por qué el yo explícito tiene que quedarse" por Guido van Rossum: neopythonic.blogspot.com/2008/10/…
unutbu
14
Consulte también "¿Por qué debe usarse 'self' explícitamente en las definiciones y llamadas de métodos
unutbu
37
"Lo que entiendo, con bastante facilidad" --- Bastante subjetivo, ¿no crees? ¿Qué hace que sea @namemás intuitivo que self.name? El último, IMO, es más intuitivo.
Santa
14
Esa es la diferencia clave entre una función y un método de clase. Una función está flotando libre, sin gravámenes. Un método de clase (instancia) debe ser consciente de que es primario (y de las propiedades principales), por lo que debe pasar al método una referencia a la clase principal (como propio ). Es solo una regla menos implícita que debe internalizar antes de comprender la POO. Otros idiomas eligen el azúcar sintáctico sobre la simplicidad semántica, Python no es otros idiomas.
Evan Plaice
99
No creo que "explícito sea mejor que implícito" realmente explique bien esta elección de diseño. @fooy self.fooson igualmente explícitos ya que no es necesario que se produzca una resolución implícita (por ejemplo, en C ++, se puede acceder "implícitamente" a los miembros de la instancia sin "explícitamente" usar espacios de nombres). La única diferencia es que Ruby introduce una nueva semántica (@), mientras que Python no. Si una nueva semántica valió o no la cantidad de verbosidad evitada es puramente subjetiva. Sin embargo, debe tenerse en cuenta que la mayoría de los lenguajes modernos eligen introducir un concepto aquí (por ejemplo, php's $ this, JS's this).
Jing

Respuestas:

710

La razón que necesita usar self.es porque Python no usa la @sintaxis para referirse a los atributos de instancia. Python decidió hacer métodos de una manera que haga que la instancia a la que pertenece el método se pase automáticamente, pero no se reciba automáticamente: el primer parámetro de los métodos es la instancia en la que se llama al método. Eso hace que los métodos sean completamente iguales a las funciones, y deja que el nombre real lo use usted (aunque selfes la convención, y la gente generalmente fruncirá el ceño cuando usa otra cosa) selfno es especial para el código, es solo otro objeto .

Python podría haber hecho algo más para distinguir los nombres normales de los atributos, una sintaxis especial como la que Ruby tiene, o requerir declaraciones como C ++ y Java, o tal vez algo aún más diferente, pero no fue así. Python es todo para hacer las cosas explícitas, haciendo obvio qué es qué, y aunque no lo hace completamente en todas partes, sí lo hace, por ejemplo, los atributos. Es por eso que asignar a un atributo de instancia necesita saber a qué instancia asignar, y es por eso que necesita self..

Thomas Wouters
fuente
23
@Georg: se clsrefiere al objeto de clase, no al objeto de instancia
SilentGhost
17
@SilentGhost: en realidad, el nombre del primer parámetro es lo que quieras que sea. En los métodos de clase, la convención es usar clsy selfse usa convencionalmente, por ejemplo, métodos. Si quisiera, podría usarlo selfpara métodos de clase y, clspor ejemplo, métodos. También podría usar boby fnordsi quisiera.
SingleNegationElimination
67
Me parece interesante que la comunidad no eligió en thislugar de self. ¿ selfTiene algún historial del que no tenga conocimiento en lenguajes de programación antiguos?
Jules GM
24
@Julius El selfvino de las convenciones de Modula-3, vea esta respuesta para obtener más detalles sobre esta elección. (Descargo de responsabilidad: es mío).
Bakuriu
99
@Julius La selfpalabra clave (Smalltalk, 1980) es anterior a la thispalabra clave (de C ++). Ver: stackoverflow.com/questions/1079983/…
Wes Turner
425

Tomemos una clase de vector simple:

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

Queremos tener un método que calcule la longitud. ¿Cómo sería si quisiéramos definirlo dentro de la clase?

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

¿Cómo debería ser cuando lo definiéramos como un método / función global?

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

Entonces toda la estructura permanece igual. ¿Cómo puedo hacer uso de esto? Si suponemos por un momento que no habíamos escrito un lengthmétodo para nuestra Vectorclase, podríamos hacer esto:

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

Esto funciona porque el primer parámetro de length_global, se puede reutilizar como selfparámetro en length_new. Esto no sería posible sin un explícito self.


Otra forma de entender la necesidad de lo explícito selfes ver dónde Python agrega algo de azúcar sintáctico. Cuando recuerdas, básicamente, una llamada como

v_instance.length()

se transforma internamente en

Vector.length(v_instance)

es fácil ver dónde selfencaja. En realidad, no escribe métodos de instancia en Python; lo que escribes son métodos de clase que deben tomar una instancia como primer parámetro. Y por lo tanto, tendrá que colocar el parámetro de instancia en algún lugar explícitamente.

Debilski
fuente
44
Vector.length_new = length_global ... De hecho, comencé a usar una sintaxis como esta en mis declaraciones de clase. Cada vez que solo quiero heredar algunos de los métodos de otra clase, solo copie explícitamente la referencia a los métodos.
Jeeyoung Kim
2
¿sería justo decir que el "método de instancia" de Python es simplemente un azúcar sintáctico de métodos globales estáticos (como en Java o C ++) con un objeto de instancia pasado para empaquetar múltiples atributos? --- bueno, esto es algo medio cierto ya que en el polimorfismo, el propósito más importante de "esto" (como en Java) o "self" es darle la implementación correcta de los métodos. Python tiene esto. entonces llamar a myobj.someMethod () es igual a TheClassOfMyObj.someMethod (myobj) en python. tenga en cuenta que el "TheClassOfMyObj" es automáticamente descubierto por python desde "self", de lo contrario tendría que averiguarlo.
teddy teddy
3
De hecho, no solo los métodos de instancia son solo métodos de clase, sino que los métodos son solo funciones que son miembros de una clase, como se Vector.length_new = length_globalmuestra.
RussW
1
"Esto funciona, porque el primer parámetro de length_global, puede reutilizarse como el parámetro self en length_new. Esto no sería posible sin un self explícito". - Funcionaría igual. se reutilizaría para el yo implícito ... el segundo ejemplo es un razonamiento circular: hay que colocarlo explícitamente allí, porque python necesita el yo explícito.
Karoly Horvath
1
@KarolyHorvath: Claro, también sería posible tener un lenguaje con un modelo donde los métodos definidos internamente no necesiten un yo explícito, pero los métodos definidos externamente sí. Pero diría que hay cierta coherencia en requerir el yo explícito en ambos casos, lo que lo convierte en una razón legítima para hacerlo de esta manera. Otros idiomas pueden elegir diferentes enfoques.
Debilski
423

Digamos que tiene una clase ClassAque contiene un método methodAdefinido como:

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

y ObjectAes una instancia de esta clase.

Ahora cuando ObjectA.methodA(arg1, arg2)se llama, python lo convierte internamente para usted como:

ClassA.methodA(ObjectA, arg1, arg2)

La selfvariable se refiere al objeto mismo.

Arjun Sreedharan
fuente
94
Leí todas las otras respuestas y entendí un poco, leí esta y luego todo tuvo sentido.
Seth
3
¡Esto lo clavó para mí!
Bernard 'Beta Berlin' Parah
2
¿Pero por qué no mantener esas tripas adentro, como lo hace Ruby?
Cees Timmerman
Pero en el método __init __ (self), acepta self, entonces, incluso sin crear el objeto, ¿cómo se refiere a sí mismo?
saurav
En serio, esto es mucho mejor que el ejemplo de Debilski porque no es demasiado complejo y las personas pueden no estar familiarizadas con los vectores.
NoName
215

Cuando se crean instancias de objetos, el objeto mismo se pasa al parámetro self.

ingrese la descripción de la imagen aquí

Debido a esto, los datos del objeto están vinculados al objeto. A continuación se muestra un ejemplo de cómo le gustaría visualizar el aspecto de los datos de cada objeto. Observe cómo 'self' se reemplaza con el nombre de los objetos. No digo que este diagrama de ejemplo a continuación sea del todo exacto, pero espero que sirva para visualizar el uso de uno mismo.

ingrese la descripción de la imagen aquí

El objeto se pasa al parámetro self para que el objeto pueda mantener sus propios datos.

Aunque esto puede no ser del todo exacto, piense en el proceso de crear instancias de un objeto como este: cuando se crea un objeto, utiliza la clase como plantilla para sus propios datos y métodos. Sin pasar su propio nombre al parámetro self, los atributos y métodos de la clase permanecerían como una plantilla general y no se referenciaría (pertenecería) al objeto. Entonces, al pasar el nombre del objeto al parámetro auto, significa que si se instancian 100 objetos de una clase, todos pueden realizar un seguimiento de sus propios datos y métodos.

Vea la siguiente ilustración:

ingrese la descripción de la imagen aquí

sw123456
fuente
Hola, cuando accedes a los atributos de Bob, por ejemplo, "bob.name ()", en realidad estás accediendo a bob (). Self.name, por así decirlo desde el ' init ' ¿verdad?
udarH3
3
Cuando escribe bob.name () en el comentario anterior, está dando a entender que bob tiene un método llamado name () debido al hecho de que agregó corchetes después de name. En este ejemplo, sin embargo, no existe tal método. 'bob.name' (que no tiene paréntesis) está accediendo directamente al atributo llamado nombre desde el método init (constructor). Cuando se llama al método de hablar de bob, es el método que accede al atributo de nombre y lo devuelve en una declaración de impresión. Espero que esto ayude.
sw123456
3
No, obtienes el valor de self.name, que para el objeto bob es en realidad bob.name, porque el nombre del objeto se pasa al parámetro self cuando se crea (instancia). De nuevo, espero que esto ayude. Siéntete libre de votar la publicación principal si es así.
sw123456
2
El nombre se asigna a self.name en la instanciación. Después de crear un objeto, todas las variables que pertenecen al objeto son las que tienen el prefijo 'self'. Recuerde que self se reemplaza con el nombre del objeto cuando se crea desde la clase.
sw123456
55
¡Así es como explicas las cosas! buen trabajo :)
penta
80

Me gusta este ejemplo:

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
fuente
18
así que los vars sin yo son simplemente vars estáticos de la clase, como en java
teddy teddy
55
teddy teddy, no estás del todo correcto. El comportamiento (estático o no estático) depende no solo selfdel tipo de variable sino también de él. Intente hacer el primer ejemplo con un entero simple en lugar de una lista. El resultado sería bastante diferente.
Konstantin
2
En realidad, mi pregunta con esto es ¿por qué se le permite decir a.fooen el primer ejemplo, en lugar de hacerlo A.foo? Claramente foopertenece a la clase ...
Radon Rosborough
Puede llamar a miembros estáticos desde instancias del objeto en la mayoría de los idiomas. ¿Por qué es eso sorprendente?
Paarth
2
@RadonRosborough Porque en el primer ejemplo, ay bson ambas etiquetas (o punteros) para A()(la clase). a.foohace referencia al A().foométodo de clase. Sin embargo, aen el segundo ejemplo, se convierte en una referencia a una instancia de A(), como lo hace b. Ahora que son instancias en lugar del objeto de clase en sí, self permite que el foométodo opere en las instancias.
LegendaryDude
40

Lo demostraré con código que no usa clases :

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'

Las clases son solo una forma de evitar pasar todo el tiempo en este "estado" (y otras cosas buenas como la inicialización, la composición de la clase, las metaclases raramente necesarias y el apoyo a métodos personalizados para anular operadores).

Ahora demostremos el código anterior utilizando la maquinaria de clase python incorporada, para mostrar cómo es básicamente lo mismo.

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é mi respuesta de una pregunta cerrada duplicada]

ninjagecko
fuente
1
Deseo que Python endulce los manipuladores tan bien como Ruby.
Cees Timmerman
20

Los siguientes extractos son de la documentación de Python sobre self :

Al igual que en Modula-3, no hay shorthands [en Python] para hacer referencia a los miembros del objeto desde sus métodos: la función del método se declara con un primer argumento explícito que representa el objeto, que la llamada proporciona implícitamente.

A menudo, el primer argumento de un método se llama self. Esto no es más que una convención: el nombre self no tiene absolutamente ningún significado especial para Python. Sin embargo, tenga en cuenta que al no seguir la convención, su código puede ser menos legible para otros programadores de Python, y también es concebible que se pueda escribir un programa de navegador de clase que se base en dicha convención.

Para obtener más información, consulte el tutorial de documentación de Python sobre clases .

Matthew Rankin
fuente
20

Además de todas las otras razones ya mencionadas, permite un acceso más fácil a los métodos anulados; se le puede llamar Class.some_method(inst).

Un ejemplo de dónde es útil:

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
fuente
17

Su uso es similar al uso de thispalabras clave en Java, es decir, para dar una referencia al objeto actual.

Gaurav Nishant
fuente
2
clase myClass: def myFunc (this, name): this.name = name
LEMUEL ADANE
16

Python no es un lenguaje creado para la programación orientada a objetos a diferencia de Java o C ++.

Al llamar a un método estático en Python, uno simplemente escribe un método con argumentos regulares dentro de él.

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

Sin embargo, un método de objeto, que requiere que hagas una variable, que es un animal, en este caso, necesita el argumento propio

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

El método self también se usa para referirse a un campo variable dentro de la clase.

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


    def getAnimalName(self):
        return self.animalName

En este caso, self se refiere a la variable animalName de toda la clase. RECUERDE: Si tiene una variable dentro de un método, self no funcionará. Esa variable simplemente existe mientras el método se está ejecutando. Para definir campos (las variables de toda la clase), debe definirlos FUERA de los métodos de clase.

Si no entiende una sola palabra de lo que estoy diciendo, entonces Google "Programación Orientada a Objetos". Una vez que comprenda esto, ni siquiera tendrá que hacer esa pregunta :).

Ytpillai
fuente
+1 debido a la distinción entre staticMethod()y objectMethod(self). Me gustaría agregar eso para invocar el primero, diría Animal.staticMethod(), mientras objectMethod()necesita una instancia:a = Animal(); a.objectMethod()
Laryx Decidua
Lo que estás diciendo no es 100% cierto. Eso es solo una convención. Todavía puede llamar al método estático desde un objeto creado. Simplemente no podrás usar ningún miembro de la clase porque no te declaraste a ti mismo. Incluso puedo llamar a Animal.objectMethod (animalObj) para llamar a la no estática. Básicamente, esto significa que un método estático es solo un método que no utiliza variables miembro. No debería haber ninguna necesidad de declararse. Es un requisito de lenguaje tonto, creo. Lenguajes como Lua y C ++ le dan variables obj detrás de escena.
user441521
Hiciste una declaración de cadena animalName inútil y el método de estrellar animalName.
Cees Timmerman
3
@ytpillai Irrelevante. El código confuso e incorrecto no debe presentarse como una respuesta.
Cees Timmerman
1
def getAnimalNamepara no golpear la cadena que está intentando devolver, y se selfrefiere a la instancia de la clase, no a ningún campo dentro de ella.
Cees Timmerman
10

Está ahí para seguir el zen de Python "explícito es mejor que implícito". De hecho, es una referencia a su objeto de clase. En Java y PHP, por ejemplo, se llamathis .

Si user_type_namehay un campo en su modelo, puede acceder a él self.user_type_name.

dan-klasson
fuente
10

En primer lugar, self es un nombre convencional, podría poner cualquier otra cosa (ser coherente) en su lugar.

Se refiere al objeto en sí mismo, por lo que cuando lo está utilizando, declara que .name y .age son propiedades de los objetos Student (nota, no de la clase Student) que va a crear.

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

El código está aquí

Akash Kandpal
fuente
1
Tu respuesta me parece la más clara. +1
Pawel
9

selfes una referencia de objeto al objeto en sí mismo, por lo tanto, son iguales. Los métodos de Python no se invocan en el contexto del objeto en sí. selfen Python se puede usar para tratar con modelos de objetos personalizados o algo así.

Ming-Tang
fuente
8

El uso del argumento, convencionalmente llamado, selfno es tan difícil de entender, como ¿por qué es necesario? ¿O por qué mencionarlo explícitamente? Esa, supongo, es una pregunta más grande para la mayoría de los usuarios que buscan esta pregunta, o si no es así, sin duda tendrán la misma pregunta a medida que avanzan aprendiendo Python. Les recomiendo que lean estos dos blogs:

1: Uso de auto explicado

Tenga en cuenta que no es una palabra clave.

El primer argumento de cada método de clase, incluido init, siempre es una referencia a la instancia actual de la clase. Por convención, este argumento siempre se llama self. En el método init, self se refiere al objeto recién creado; en otros métodos de clase, se refiere a la instancia cuyo método fue llamado. Por ejemplo, el siguiente código es el mismo que el código anterior.

2: ¿Por qué lo tenemos de esta manera y por qué no podemos eliminarlo como un argumento, como Java, y tener una palabra clave en su lugar?

Otra cosa que me gustaría agregar es que un selfargumento opcional me permite declarar métodos estáticos dentro de una clase, al no escribirself .

Ejemplos de código:

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"

PD : esto solo funciona en Python 3.x.

En versiones anteriores, debe agregar explícitamente @staticmethoddecorador, de lo contrario, el selfargumento es obligatorio.

Bugs Buggy
fuente
7

Me sorprende que nadie haya criado a Lua. Lua también usa la variable 'self', sin embargo, puede omitirse pero aún usarse. C ++ hace lo mismo con 'esto'. No veo ninguna razón para tener que declarar 'self' en cada función, pero aún así debería poder usarlo como puede hacerlo con lua y C ++. Para un lenguaje que se enorgullece de ser breve, es extraño que requiera que declares la auto variable.

usuario441521
fuente
6

Eche un vistazo al siguiente ejemplo, que explica claramente el propósito 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 se usa / necesita para distinguir entre instancias.

Fuente: auto variable en Python explicada - Pythontips

kmario23
fuente
Sí, creo que sabemos por qué se usa self, pero la pregunta es por qué el lenguaje te hace declararlo explícitamente. Muchos otros lenguajes no requieren esto y un lenguaje que se enorgullece de ser breve, pensaría que solo le darían la variable detrás de escena para usar como Lua o C ++ (esto).
user441521
3
@ kmario23 Su respuesta fue de aquí: pythontips.com/2013/08/07/the-self-variable-in-python-explained Por favor, siempre reconozca a los autores originales cuando publique respuestas como propias.
geekidharsh
@geekidharsh gracias, agregué una nota!
kmario23
5

Es porque, por cierto, Python está diseñado, las alternativas difícilmente funcionarían. Python está diseñado para permitir que los métodos o funciones se definan en un contexto donde tanto implícito this(a-la Java / C ++) como explícito @(a-la ruby) no funcionarían. Veamos un ejemplo con el enfoque explícito con las convenciones de python:

def fubar(x):
    self.x = x

class C:
    frob = fubar

Ahora la fubarfunción no funcionaría, ya que supondría que selfes una variable global (y frobtambién en). La alternativa sería ejecutar métodos con un alcance global reemplazado (donde selfestá el objeto).

El enfoque implícito sería

def fubar(x)
    myX = x

class C:
    frob = fubar

Esto significaría que myXse interpretaría como una variable local en fubar(y frobtambién en). La alternativa aquí sería ejecutar métodos con un alcance local reemplazado que se retiene entre llamadas, pero eso eliminaría la posibilidad de variables locales del método.

Sin embargo, la situación actual funciona bien:

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

 class C:
     frob = fubar

aquí, cuando se llama como método frob, recibirá el objeto en el que se llama a través del selfparámetro, y fubaraún se puede llamar con un objeto como parámetro y funciona igual ( es lo mismo C.frobque creo).

Rey del cielo
fuente
3

En el __init__método, self se refiere al objeto recién creado; en otros métodos de clase, se refiere a la instancia cuyo método fue llamado.

self, como nombre, es solo una convención , ¡llámalo como quieras! pero al usarlo, por ejemplo, para eliminar el objeto, debe usar el mismo nombre:, __del__(var)donde varse usó en el__init__(var,[...])

También deberías echar un vistazo clspara tener una imagen más grande . Esta publicación podría ser útil.

Oussama L.
fuente
3

self está actuando como el nombre del objeto actual o la instancia de clase.

# 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
fuente
1

self es inevitable.

Solo había una pregunta que debía selfser implícita o explícita. Guido van Rossumresolvió esta pregunta diciendo que selftiene que quedarse .

Entonces, ¿dónde selfviven?

Si nos limitáramos a la programación funcional, no la necesitaríamos self. Una vez que ingresamos a Python OOP encontramosself allí.

Aquí está el caso de uso típico class Ccon el métodom1

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

Este programa generará:

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

Entonces selfcontiene la dirección de memoria de la instancia de clase. El propósito de selfsería mantener la referencia para métodos de instancia y para que tengamos acceso explícito a esa referencia.


Tenga en cuenta que hay tres tipos diferentes de métodos de clase:

  • métodos estáticos (léase: funciones),
  • métodos de clase,
  • métodos de instancia (mencionados).
prosti
fuente
0

de los documentos ,

Lo especial de los métodos es que el objeto de instancia se pasa como el primer argumento de la función. En nuestro ejemplo, la llamada x.f()es exactamente equivalente a MyClass.f(x). En general, llamar a un método con una lista de n argumentos es equivalente a llamar a la función correspondiente con una lista de argumentos que se crea insertando el objeto de instancia del método antes del primer argumento.

precediendo a esto el fragmento relacionado,

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

    def f(self):
        return 'hello world'

x = MyClass()

nmxl
fuente
-2

Es una referencia explícita al objeto de instancia de clase.

SilentGhost
fuente
21
No creo que esto ayude a richzilla a entender la razón detrás de esto.
Georg Schölly
1
@SilentGhost: lo has clavado. Estoy impresionado. si lo entiendo correctamente: ¿creo un objeto como una instancia de la clase definida y el parámetro self hace referencia a ese objeto? Entiendo que self se refiere de manera implícita a la clase en sí, pero sería genial si explicas tu respuesta un poco más.
dkrynicki