Al hacer referencia a variables globales, se puede ver que las funciones y las clases manejan esto de manera diferente. El primero está bien y el segundo provoca un error:
x = 10 class Foo(): x = x + 1 a = foo()contra:
x = 10 def faa(): x = x + 1 faa()En el modelo de ejecución de Python , esto se describe como:
Una definición de clase es una declaración ejecutable que puede usar y definir nombres. Estas referencias siguen las reglas normales para la resolución de nombres con la excepción de que las variables locales independientes se buscan en el espacio de nombres global.
¿Pero por qué?
La única otra pista que he encontrado es esta parte :
A continuación, el conjunto de la clase se ejecuta en un nuevo marco de ejecución (consulte la sección Denominación y vinculación), utilizando un espacio de nombres local recién creado y el espacio de nombres global original. (Por lo general, el conjunto contiene solo definiciones de funciones). Cuando el conjunto de la clase termina de ejecutarse, su marco de ejecución se descarta pero se guarda su espacio de nombres local. 4 A continuación, se crea un objeto de clase utilizando la lista de herencia para las clases base y el espacio de nombres local guardado para el diccionario de atributos.
Lo que aún no ofrece ninguna explicación de por qué esto debería tener la consecuencia de que los locales no vinculados se busquen en el espacio de nombres global.
Sin embargo, ambos enlaces son de esta respuesta que no aborda el por qué con más detalles.
Como se explica en Preguntas frecuentes sobre Python: ¿Por qué obtengo un UnboundLocalError?
... porque cuando realiza una asignación a una variable en un ámbito, esa variable se vuelve local para ese ámbito y sombrea cualquier variable con un nombre similar en el ámbito externo. Dado que la última declaración en foo asigna un nuevo valor a x, el compilador lo reconoce como una variable local.
En consecuencia, al intentar acceder anteriormente a la variable local no inicializada, se produce un error.
Esto explica por qué esto:
x = 10 def foo(): x = x+1 # raises UnboundLocalError foo()plantea una excepción, pero no esto:
x = 10 def faa(): y = x+1 # x stays in global scope, since it is not assigned in local faa() Para la class foo() es lo mismo, ya que python permite asignaciones de atributos a objetos en cualquier momento dado. El código de clase asigna x como nuevo atributo del objeto a .
x = 10 class foo(): x = x+1 # scope of x: class a = foo() # x = 10; ax = foo.x = 11es lo mismo que:
x = 10 class foo(): def __init__(self): self.x = x+1 # scope of x: instance a = foo() # x = 10; ax = 11 donde obviamente se asigna self.x en lugar de x , por lo que también permanece en el ámbito global. (ver también aquí )