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

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

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

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.

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.

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

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.

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:

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

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]

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 .

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"

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

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

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.

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í

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

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.

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.

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

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

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.

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

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

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

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