unboundlocalerror - variables globales python

Python-Cómo hacer una variable local(dentro de una función) global

Question

Posible duplicado:
Usar variables globales en una función que no sea la que las creó

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

Answer 1

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

Usando parámetros y retorno (recomendado)

def other_function(parameter):
    return parameter + 5

def main_function():
    x = 10
    print x    
    x = other_function(x)
    print x

Cuando ejecutas main_function , obtendrás la siguiente salida

>>> 10
>>> 15

Usar globales (nunca hacer 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()`

Answer 2

Puede usar el alcance 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 singleton, cualquier cambio en las utils de un módulo será accesible para todos los demás módulos que lo tengan 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 vincular a la bar cadenas, mientras que la función f todavía se refiere al atributo del módulo.

Answer 3

Si necesita acceder a los estados internos de una función, posiblemente sea mejor que use una clase. Puede hacer que una instancia de clase se comporte como una función convirtiéndola en 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`

Answer 4

Simplemente declare su variable fuera de cualquier función:

globalValue = 1

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

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

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

Answer 5

Usar globos globales también hará que tu programa sea un desastre, te sugiero que intentes evitarlo. Dicho esto, "global" es una palabra clave en python, por lo que puedes designar una variable particular como global, como sigue:

def foo():
    global bar
    bar = 32

Debo mencionar que es extremadamente raro que se use la palabra clave ''global'', por lo que sugiero que se replantee su diseño.