method - Python: ¿por qué usar "self" en una clase?

super en python 3

Question

¿Cómo difieren estas 2 clases?

class A():
x=3
class B():
def __init__(self):
self.x=3

¿Hay alguna diferencia significativa?

Answer 1

Acabo de empezar a aprender Python y esto también me confundió durante un tiempo. Tratando de descubrir cómo funciona todo en general, se me ocurrió esta pieza de código muy simple:

# Create a class with a variable inside and an instance of that class
class One:
color = ''green''
obj2 = One()
# Here we create a global variable(outside a class suite).
color = ''blue''
# Create a second class and a local variable inside this class.
class Two:
color = "red"
# Define 3 methods. The only difference between them is the "color" part.
def out(self):
print(self.color + ''!'')
def out2(self):
print(color + ''!'')
def out3(self):
print(obj2.color + ''!'')
# Create an object of the class One
obj = Two()

Cuando llamamos out() obtenemos:

>>> obj.out()
red!

Cuando llamamos a out2() :

>>> obj.out2()
blue!

Cuando llamamos out3() :

>>> obj.out3()
green!

Por lo tanto, en el primer método, self especifica que Python debe usar la variable (atributo), que "pertenece" al objeto de clase que creamos, no uno global (fuera de la clase). Entonces usa color = "red" . En el método Python sustituye implícitamente self por el nombre de un objeto que creamos ( obj ). self.color significa "Estoy obteniendo color="red" del obj "

En el segundo método, no hay ningún self que especifique el objeto del que se debe tomar el color, por lo que obtiene el color = ''blue'' global color = ''blue'' .

En el tercer método, en lugar de self , usamos obj2 , un nombre de otro objeto para obtener el color . Se pone color = ''green'' .

Answer 2

Ax es una variable de clase, y se compartirá en todas las instancias de A, a menos que se anule específicamente dentro de una instancia. Bx es una variable de instancia, y cada instancia de B tiene su propia versión de la misma.

Espero que el siguiente ejemplo de Python pueda aclarar:

>>> class Foo():
... i = 3
... def bar(self):
... print ''Foo.i is'', Foo.i
... print ''self.i is'', self.i
...
>>> f = Foo() # Create an instance of the Foo class
>>> f.bar()
Foo.i is 3
self.i is 3
>>> Foo.i = 5 # Change the global value of Foo.i over all instances
>>> f.bar()
Foo.i is 5
self.i is 5
>>> f.i = 3 # Override this instance''s definition of i
>>> f.bar()
Foo.i is 5
self.i is 3

Answer 3

Como una nota al margen: self es en realidad solo una palabra elegida al azar, que todos usan, pero también puedes usar this , foo o myself o cualquier cosa que quieras, es solo el primer parámetro de cada método no estático para una clase. Esto significa que la palabra " self no es una construcción de lenguaje sino solo un nombre:

>>> class A:
... def __init__(s):
... s.bla = 2
...
>>>
>>> a = A()
>>> a.bla
2

Answer 4

Solía ​​explicarlo con este ejemplo

# By TMOTTM
class Machine:
# Class Variable counts how many machines have been created.
# The value is the same for all objects of this class.
counter = 0
def __init__(self):
# Notice: no ''self''.
Machine.counter += 1
# Instance variable.
# Different for every object of the class.
self.id = Machine.counter
if __name__ == ''__main__'':
machine1 = Machine()
machine2 = Machine()
machine3 = Machine()
#The value is different for all objects.
print ''machine1.id'', machine1.id
print ''machine2.id'', machine2.id
print ''machine3.id'', machine3.id
#The value is the same for all objects.
print ''machine1.counter'', machine1.counter
print ''machine2.counter'', machine2.counter
print ''machine3.counter'', machine3.counter

El resultado será por

machine1.id 1 machine2.id 2 machine3.id 3 machine1.counter 3 machine2.counter 3 machine3.counter 3

Answer 5

Ax es una variable de clase . B ''s self.x es una variable de instancia .

es decir, la x se comparte entre las instancias.

Sería más fácil demostrar la diferencia con algo que se puede modificar como una lista:

#!/usr/bin/env python
class A:
x = []
def add(self):
self.x.append(1)
class B:
def __init__(self):
self.x = []
def add(self):
self.x.append(1)
x = A()
y = A()
x.add()
y.add()
print "A''s x:",x.x
x = B()
y = B()
x.add()
y.add()
print "B''s x:",x.x

Salida

A''s x: [1, 1]
B''s x: [1]