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

¿En qué se diferencian estas 2 clases?

class A():
    x=3

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

¿Existe alguna diferencia significativa?

A.xes una variable de clase . B's self.xes una variable de instancia .

es decir, A's xes compartida entre instancias.

Sería más fácil demostrar la diferencia con algo que se pueda 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]

Así como una nota al margen: selfen realidad es sólo una palabra elegido al azar, que todo el mundo utiliza, pero también se puede utilizar this, fooo myself, o cualquier otra cosa que desee, es sólo el primer parámetro de cada método no estático para una clase. Esto significa que la palabra selfno es una construcción del lenguaje, sino solo un nombre:

>>> class A:
...     def __init__(s):
...        s.bla = 2
... 
>>> 
>>> a = A()
>>> a.bla
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.

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

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

La salida entonces será

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

machine1.counter 3
machine2.counter 3
machine3.counter 3

Acabo de comenzar a aprender Python y esto también me confundió durante algún tiempo. Tratando de averiguar cómo funciona todo en general, se me ocurrió este 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 out2():

>>> obj.out2()

blue!

Cuando llamamos out3():

>>> obj.out3()

green!

Entonces, en el primer método se selfespecifica que Python debe usar la variable (atributo), que "pertenece" al objeto de la clase que creamos, no a uno global (fuera de la clase). Entonces usa color = "red". En el método, Python sustituye implícitamente selfel nombre de un objeto que creamos ( obj). self.colorsignifica "estoy obteniendo color="red"del obj"

En el segundo método no hay selfque especificar el objeto de donde se debe tomar el color, por lo que obtiene el global color = 'blue'.

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