Python – Cómo hacer que una variable local (dentro de una función) sea global

Posible duplicado:
Uso de variables globales en una función distinta a la que las creó.

Estoy usando funciones para que mi progtwig no sea un desastre, pero no sé cómo convertir una variable local en global.

Aquí hay dos métodos para lograr lo mismo:

Uso de parámetros y retorno (recomendado)

def other_function(parameter): return parameter + 5 def main_function(): x = 10 print xx = other_function(x) print x 

Cuando ejecute main_function , obtendrá la siguiente salida

 >>> 10 >>> 15 

Usando globales (nunca hagas esto)

 x = 0 # The initial value of x, with global scope def other_function(): global x x = x + 5 def main_function(): print x # Just printing - no need to declare global yet global x # So we can change the global x x = 10 print x other_function() print x 

Ahora obtendrás:

 >>> 0 # Initial global value >>> 10 # Now we've set it to 10 in `main_function()` >>> 15 # Now we've added 5 in `other_function()` 

Simplemente declare su variable fuera de cualquier función:

 globalValue = 1 def f(x): print(globalValue + x) 

Si necesita asignar a lo global desde dentro de la función, use la statement global :

 def f(x): global globalValue print(globalValue + x) globalValue += 1 

Si necesita acceder a los estados internos de una función, posiblemente esté mejor usando una clase. Puede hacer que una instancia de clase se comporte como una función haciendo que sea invocable, lo que se hace definiendo __call__ :

 class StatefulFunction( object ): def __init__( self ): self.public_value = 'foo' def __call__( self ): return self.public_value >> f = StatefulFunction() >> f() `foo` >> f.public_value = 'bar' >> f() `bar` 

El uso de globales también hará que su progtwig sea un desastre. Le sugiero que se esfuerce mucho por evitarlos. Dicho esto, “global” es una palabra clave en python, por lo que puede designar una variable en particular como global, de esta manera:

 def foo(): global bar bar = 32 

Debería mencionar que es extremadamente raro que se use la palabra clave ‘global’, por lo que sugiero seriamente repensar su diseño.

Podrías usar el scope del módulo. Digamos que tienes un módulo llamado utils :

 f_value = 'foo' def f(): return f_value 

f_value es un atributo de módulo que puede ser modificado por cualquier otro módulo que lo importe. Como los módulos son singletons, cualquier cambio a utils desde un módulo será accesible a todos los demás módulos que lo hayan importado:

 >> import utils >> utils.f() 'foo' >> utils.f_value = 'bar' >> utils.f() 'bar' 

Tenga en cuenta que puede importar la función por nombre:

 >> import utils >> from utils import f >> utils.f_value = 'bar' >> f() 'bar' 

Pero no el atributo:

 >> from utils import f, f_value >> f_value = 'bar' >> f() 'foo' 

Esto se debe a que está etiquetando el objeto al que hace referencia el atributo del módulo como f_value en el ámbito local, pero luego lo vuelve a unir a la bar cadena, mientras que la función f aún se refiere al atributo del módulo.