HOWTO · Python
Convertir una cadena en nombre de variable en Python
En este artículo discutiremos varias formas de convertir un valor de cadena en un nombre de variable en Python.
En esta página
Python no utiliza el valor de una cadena como nombre en el lado izquierdo de una asignación normal de variable. Para crear o acceder a un nombre en tiempo de ejecución, elige el espacio de nombres que debe contenerlo: globals() para variables de nivel de módulo, locals() para inspeccionar nombres locales, exec() para código fuente generado, setattr() para atributos de objetos, o un diccionario cuando los nombres son en realidad datos.
Nota: los nombres de variables dinámicos pueden ocultar dependencias, contaminar un espacio de nombres y producir un
NameErrorcuando el código lee un nombre que nunca se creó. Rara vez son la mejor opción para software de producción; prefiere un diccionario a menos que necesites una variable global real o un atributo de objeto.
Convertir una cadena en un nombre de variable con globals() y locals() en Python
La función incorporada globals() devuelve el diccionario de la tabla de símbolos global actual. Ese diccionario asigna el nombre de cada variable global a su valor. En el ámbito del módulo, escribir una clave nueva mediante este diccionario crea una variable global real cuyo nombre es esa cadena.
Ejecuta este ejemplo:
El código y las etiquetas o salidas visibles de esta sección se mantienen en inglés.
def create_global_variable(name, value):
globals()[name] = value
variable_name = "dynamicGlobalVar"
variable_value = 10
create_global_variable(variable_name, variable_value)
print(dynamicGlobalVar)
10
La función recibe "dynamicGlobalVar" como argumento name y almacena 10 bajo esa clave en la tabla de símbolos global. La expresión posterior dynamicGlobalVar funciona porque el módulo ahora tiene una variable global con ese nombre exacto. La cadena debe ser un identificador válido de Python cuando el código fuente vaya a acceder a ella por nombre; en caso contrario, recupérala mediante globals()[name].
Un nombre global debe crearse antes de leerse. Si dynamicGlobalVar no se hubiera añadido primero a la tabla de símbolos global, la última línea generaría un NameError. En código real, prefiere una variable como variable_name para la escritura en lugar de incorporar una cadena no verificada por todo el programa.
Usar locals() para acceder a una variable local
La función locals() devuelve un mapeo que representa la tabla de símbolos local actual. Dentro de una función, resulta útil para buscar un nombre local contenido en una cadena:
def demonstrate_locals():
temp_var = "Dynamic Content"
name = "temp_var"
return locals().get(name)
print(demonstrate_locals())
Dynamic Content
Aquí, locals().get(name) resuelve "temp_var" mientras la función se ejecuta y devuelve el valor de la variable local existente. Usar .get() es más seguro que indexar el mapeo directamente porque devuelve None cuando el nombre solicitado no existe.
No confíes en locals()[name] = value para crear una variable local de función. Las implementaciones de Python pueden optimizar las variables locales, y no se exige que las escrituras en el mapeo devuelto actualicen los enlaces locales reales del intérprete. Trata locals() principalmente como una herramienta de búsqueda e inspección; usa globals(), setattr() o un diccionario cuando el programa necesite un nombre dinámico escribible.
Convertir una cadena en un nombre de variable con exec() en Python
La función exec() ejecuta código fuente de Python suministrado como cadena. Si esa cadena contiene una asignación, ejecutarla crea la variable correspondiente en el contexto de ejecución actual.
El código y las etiquetas o salidas visibles de esta sección se mantienen en inglés.
variable_name = "dynamicVar"
value = 42
exec(f"{variable_name} = {value}")
print(dynamicVar)
42
La f-string construye el texto fuente dynamicVar = 42 y exec() ejecuta esa asignación. En el nivel del módulo, el resultado es una nueva variable global llamada dynamicVar. Al insertar valores no numéricos, usa repr() o un formato equivalente para que el código fuente generado contenga un literal de Python válido.
exec() es potente porque la cadena puede contener más que una sola asignación: puede ejecutar bucles, importaciones, definiciones de funciones o llamadas arbitrarias. Esa potencia también es su principal peligro. Nunca pases texto controlado por el usuario o que no sea de confianza a exec(); incluso un fragmento malicioso de nombre o valor puede ejecutar código dañino. Al igual que locals(), tampoco se puede confiar en exec() para actualizar variables locales de función optimizadas, por lo que esta técnica es más clara en el ámbito del módulo o en un diccionario de espacio de nombres explícito.
Convertir una cadena en un nombre de variable con setattr() en Python
Cuando la “variable” deseada es en realidad un atributo de un objeto, una clase o un módulo, setattr() es la herramienta directa. Acepta un objeto, un nombre de atributo como cadena y el valor que se va a asignar.
El código y las etiquetas o salidas visibles de esta sección se mantienen en inglés.
class Settings:
pass
settings = Settings()
attribute_name = "theme"
attribute_value = "dark"
setattr(settings, attribute_name, attribute_value)
print(settings.theme)
dark
La llamada equivale a settings.theme = "dark", salvo que el nombre del atributo procede de attribute_name en tiempo de ejecución. Esto es útil para objetos de configuración, registros, ganchos de complementos y otros lugares donde un objeto de espacio de nombres ya forma parte del diseño.
setattr() no crea una variable ordinaria de módulo o función; actualiza el espacio de nombres de atributos del objeto de destino. Usa getattr(settings, attribute_name) para leer el valor dinámicamente, o getattr(settings, attribute_name, default_value) cuando necesites un valor de respaldo.
Usar un diccionario en lugar de nombres de variables dinámicos en Python
Un diccionario suele ser la respuesta más clara cuando un programa almacena valores bajo nombres conocidos solo en tiempo de ejecución. La cadena sigue siendo una clave, por lo que la colección de nombres dinámicos permanece explícita y es fácil de inspeccionar.
El código y las etiquetas o salidas visibles de esta sección se mantienen en inglés.
dynamic_vars = {}
var_name = "temperature"
var_value = 23
dynamic_vars[var_name] = var_value
print(dynamic_vars["temperature"])
23
Esto crea la misma asociación que una variable llamada temperature que contiene 23, pero sin añadir nombres a un espacio de nombres de Python. Las claves pueden listarse, pasarse a otra función, serializarse o eliminarse sin buscar entradas inesperadas en globals().
Las claves de un diccionario tampoco están limitadas por las reglas de identificadores de Python, por lo que nombres como "daily total" pueden usarse como datos. Accede a una clave obligatoria con dynamic_vars[var_name], o usa dynamic_vars.get(var_name) cuando una clave ausente deba producir un valor de respaldo en lugar de fallar. Esto evita gestionar NameError porque el programa consulta una estructura de datos en lugar de resolver variables a nivel de código fuente.
Conclusión
Python ofrece varias formas de convertir una cadena en tiempo de ejecución en un nombre utilizable. globals() puede crear una variable real de nivel de módulo mediante la tabla de símbolos global. locals() puede buscar nombres locales, pero no es fiable como mecanismo de escritura. exec() puede ejecutar una asignación generada, aunque conlleva los mayores riesgos de seguridad y claridad. setattr() es apropiado cuando el nombre dinámico pertenece a un objeto o módulo.
Para la mayoría de los programas, un diccionario es la opción más segura y mantenible. Mantiene los nombres dinámicos como datos, evita contaminar los espacios de nombres de Python y hace explícito el comportamiento cuando falta un nombre. Reserva las variables o atributos dinámicos reales para diseños que realmente los necesiten.