Python - pourquoi utiliser "self" dans une classe?

Question

Comment ces 2 classes diffèrent-elles?

 class A():
    x=3

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

Y a-t-il une différence significative?

Answer 1

A.x est une variable de classe . B 's self.x est une variable d'instance .

c'est-à-dire que A 's x est partagé entre les instances.

Il serait plus facile de démontrer la différence avec quelque chose qui peut être modifié comme une liste:

 #!/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
 

Sortie

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

Answer 2

En guise de remarque: self n'est en réalité qu'un mot choisi au hasard, que tout le monde utilise, mais vous pouvez aussi utiliser this , foo ou myself ou tout ce que vous voulez, c'est juste le premier paramètre de chaque méthode non statique pour une classe. Cela signifie que le mot self n'est pas une construction de langage mais juste un nom:

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

Answer 3

Axe est une variable de classe et sera partagée par toutes les instances de A, sauf substitution spécifique dans une instance. Bx est une variable d'instance et chaque instance de B en a sa propre version.

J'espère que l'exemple suivant en Python pourra clarifier:

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

J'avais l'habitude de l'expliquer avec cet exemple

 # 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 sortie sera alors par

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

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

Answer 5

J'ai juste commencé à apprendre le Python et cela me troublait ainsi pendant un certain temps. Essayer de comprendre comment tout cela fonctionne en général je suis venu avec cette très simple morceau de code:

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

Lorsque nous appelons out() , nous obtenons:

>>> obj.out()

red!

Lorsque nous appelons out2():

>>> obj.out2()

blue!

Lorsque nous appelons out3():

>>> obj.out3()

green!

Ainsi, dans la première méthode, self indique que Python doit utiliser la variable(attribut), qui "appartient" à l'objet de classe que nous avons crée, pas un global(en dehors de la classe). De sorte qu'il utilise color = "red". Dans la méthode Python implicitement substituts self pour le nom d'un objet que nous avons créé(obj). self.color signifie: "je suis color="red" de la obj"

Dans la deuxième méthode, il n'y a pas d' self de spécifier l'objet où la couleur doit être pris, de sorte qu'il devient la mondiale color = 'blue'.

Dans la troisième méthode, au lieu de self nous avons utilisé obj2 - un nom d'un autre objet pour obtenir des color de. Il reçoit color = 'green'.