web-dev-qa-db-fra.com

Python - pourquoi utiliser "self" dans une classe?

En quoi 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?

pythonoop
80
ryeguy

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

c'est-à-dire que Ax 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

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

135
Douglas Leeder

Juste comme remarque: self n'est en fait qu'un mot choisi au hasard, que tout le monde utilise, mais vous pouvez également 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
53
André

A.x est une variable de classe et sera partagée entre toutes les instances de A, sauf si elle est spécifiquement remplacée dans une instance. B.x est une variable d'instance, et chaque instance de B en a sa propre version.

J'espère que l'exemple suivant Python peut 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
22
TerrorBite

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 __== '__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.counter 3 
 machine2.counter 3 
 machine3.counter 3
16
TMOTTM

Je viens de commencer à apprendre Python et cela m'a aussi dérouté pendant un certain temps. En essayant de comprendre comment tout cela fonctionne en général, j'ai trouvé ce morceau de code très 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()

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 spécifie que Python doit utiliser la variable (attribut), qui "appartient" à l'objet de classe que nous avons créé, pas un objet global (en dehors du Il utilise donc color = "red". Dans la méthode Python substitue implicitement self au nom d'un objet que nous avons créé (obj) . self.color Signifie "Je reçois color="red" Du obj"

Dans la deuxième méthode, il n'y a pas de self pour spécifier l'objet d'où la couleur doit être prise, donc il obtient le global color = 'blue'.

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

3
yabee-dabee