diferencia entre variables dentro y fuera de __init __ ()

Solución:

Conjunto de variables en el exterior __init__ pertenecen a la clase. Son compartidos por todas las instancias.

Variables creadas dentro __init__ (y todas las demás funciones del método) y precedido de self. pertenecen a la instancia del objeto.

Sin yo

Crea algunos objetos:

class foo(object):
    x = 'original class'

c1, c2 = foo(), foo()

Puedo cambiar la instancia c1 y no afectará a la instancia c2:

c1.x = 'changed instance'
c2.x
>>> 'original class'

Pero si cambio la clase foo, también se cambiarán todas las instancias de esa clase:

foo.x = 'changed class'
c2.x
>>> 'changed class'

Tenga en cuenta cómo funciona el alcance de Python aquí:

c1.x
>>> 'changed instance'

Con uno mismo

Cambiar la clase no afecta las instancias:

class foo(object):
    def __init__(self):
        self.x = 'original self'

c1 = foo()
foo.x = 'changed class'
c1.x
>>> 'original self'

Me gustaría agregar algo a las respuestas que leí en este hilo y en este hilo (que hace referencia a este).

Descargo de responsabilidad: estas observaciones provienen de los experimentos que realicé

Variables externas __init__:

Estos son, de hecho, variables de clase estáticas y son, por tanto, accesibles a todas las instancias de la clase.

Variables dentro __init__:

El valor de estos variables de instancia solo son accesibles a la instancia en cuestión (a través del self referencia)

Mi contribución:

Una cosa que los programadores deben considerar al usar variables de clase estáticas es que pueden ser ensombrecidos por variables de instancia (si está accediendo al variables de clase estáticas a través de self referencia).

Explicación:

Anteriormente, pensaba que ambas formas de declarar las variables eran exactamente las mismas (tonto), y eso se debía en parte a que podía acceder a ambos tipos de variables a través del self referencia. Fue ahora, cuando me metí en problemas, que investigué el tema y lo aclaré.

El problema de acceder variables de clase estáticas a través de
self referencia es que solo hace referencia al variable de clase estática si no hay Instancia variable con el mismo nombre, y para empeorar las cosas, intentar redefinir un variable de clase estática a través de self la referencia no funciona porque una Instancia variable se crea que luego sombrea los previamente accesibles variable de clase estática.

Para solucionar este problema, siempre debe hacer referencia variables de clase estáticas a través del nombre de la clase.

Ejemplo:

#!/usr/bin/env python

class Foo:
    static_var="every instance has access"

    def __init__(self,name):
        self.instance_var="I am %s" % name

    def printAll(self):
        print 'self.instance_var = %s' % self.instance_var
        print 'self.static_var = %s' % self.static_var
        print 'Foo.static_var = %s' % Foo.static_var

f1 = Foo('f1')

f1.printAll()

f1.static_var="Shadowing static_var"

f1.printAll()

f2 = Foo('f2')

f2.printAll()

Foo.static_var="modified class"

f1.printAll()
f2.printAll()

Producción:

self.instance_var = I am f1
self.static_var = every instance has access
Foo.static_var = every instance has access
self.instance_var = I am f1
self.static_var = Shadowing static_var
Foo.static_var = every instance has access
self.instance_var = I am f2
self.static_var = every instance has access
Foo.static_var = every instance has access
self.instance_var = I am f1
self.static_var = Shadowing static_var
Foo.static_var = modified class
self.instance_var = I am f2
self.static_var = modified class
Foo.static_var = modified class

Espero que esto sea de ayuda para alguien

---

---

Utiliza Nuestro Buscador