Establecer dinámicamente la variable local [duplicar]

Otros han sugerido asignar a locals(). Esto no funcionará dentro de una función, donde se accede a los locales usando el opcode LOAD_FAST, a menos que tenga una instrucción exec en algún lugar de la función. Para soportar esta instrucción, que podría crear nuevas variables que no se conocen en tiempo de compilación, Python se ve obligado a acceder a las variables locales por nombre dentro de la función, por lo que escribir en locals() funciona. El exec puede estar fuera de la ruta de código que se ejecuta.

def func(varname):
    locals()[varname] = 42
    return answer           # only works if we passed in "answer" for varname
    exec ""                 # never executed

func("answer")
>>> 42

Nota: Esto solo funciona en Python 2.x. Acabaron con esta tontería en Python 3, y otras implementaciones(Jython, IronPython, etc.) no puede apoyarlo tampoco.

Esta es una mala idea, sin embargo. ¿Cómo accederás a las variables si no sabes su nombre? Por locals()[xxx], probablemente. Entonces, ¿por qué no usar su propio diccionario en lugar de contaminar locals() (y arriesgarse a sobrescribir una variable que su función realmente necesita)?

(Solo una nota rápida para otros googlin')

Ok, modificando locals() no es el camino a seguir (mientras se modifica globals() se supone que funciona ). Mientras tanto, exec podría ser, pero es dolorosamente lento, así que, como con las expresiones regulares, podemos querer compile() primero:

# var0 = 0; var1 = 1; var2 = 2
code_text = '\n'.join( "var%d = %d" % (n, n) for n in xrange(3) )

filename = ''
code_chunk = compile( code_text, filename, 'exec' )

# now later we can use exec:
exec code_chunk # executes in the current context

He pasado el último... un par de horas, supongo, tratando de hackear la falta de cierres de funciones, y se me ocurrió esto, lo que podría ayudar:

common_data = ...stuff...
def process(record):
    ...logic...

def op():
    for fing in op.func_dict: # Key line number 1
        exec(fing + " = op.func_dict[fing]") # Key line number 2

    while common_data.still_recieving:
        with common_data._lock:
            if common_data.record_available:
                process(common_data.oldest_record)
        time.sleep(1.0)

op.func_dict.update(locals()) # Key line number 3
threading.Thread(target = op).start()

...

Es un ejemplo bastante pesado / artificial, pero si hay muchos locales o todavía estás en el proceso de prototipado, este patrón se vuelve útil. En su mayoría, estaba amargado por que todos los almacenes de datos se replicaran o movieran para manejar delegados de devolución de llamada, etc.

Puedes modificar locals() directamente:

locals()['foo'] = 'bar'

Pero una mejor manera sería tener algún dict que contenga todos los nombres de variables dinámicas como claves de diccionario:

d = {}
for some in thing:
    d[some] = 'whatever'

Puede usar un diccionario local y poner todos los enlaces dinámicos como elementos en el diccionario. Luego, conociendo el nombre de una "variable dinámica", puede usar el nombre como clave para obtener su valor.

Digamos que tenemos el siguiente diccionario:

DictionaryA = {'No Rating': ['Hobbit', 'Movie C', 'Movie G'],
               'Forget It': ['Avenger', 'Movie B'], 
               'Must See': ['Children of Men', 'Skyfall', 'Movie F'], 
               '3': ['X-Men', 'Movie D'],
               '2': ['Captain America', 'Movie E'], 
               '4': ['Transformers', 'Movie A']} 

Quiero crear nuevos diccionarios de la siguiente manera:

NewDictionary1 = {'No Rating': ['Hobbit', 'Movie C', 'Movie G']} 
NewDictionary2 = {'Forget It': ['Avenger', 'Movie B']} 
NewDictionary3 = {'Must See': ['Children of Men', 'Skyfall', 'Movie F']}

Una sola frase:

dics = [{k:v} for k,v in DictionaryA.iteritems()]

Sería enviado a:

[{'Must See': ['Children of Men', 'Skyfall', 'Movie F']}, {'Forget It': ['Avenger', 'Movie B']}, {'No Rating': ['Hobbit', 'Movie C', 'Movie G']}, {'3': ['X-Men', 'Movie D']}, {'2': ['Captain America', 'Movie E']}, {'4': ['Transformers', 'Movie A']}]

Pero para declarar con precisión las variables podríamos ir con:

>>> i=0
>>> lcl = locals()
>>> for key,val in DictionaryA.iteritems():
        lcl["Dict" + str(i)] = {key:val}
        i += 1

Como se puede ver las primeras 3 Dict variables:

>>> Dict0
{'Must See': ['Children of Men', 'Skyfall', 'Movie F']}
>>> Dict1
{'Forget It': ['Avenger', 'Movie B']}
>>> Dict2
{'No Rating': ['Hobbit', 'Movie C', 'Movie G']}

Como han mencionado otros, si quieres ponerlo en una función debes añadirlo a globals():

>>> glb = globals()
>>> for key,val in DictionaryA.iteritems():
        glb["Dict" + str(i)] = {key:val}
        i += 1