Variables globales en Python: Problemas y cómo evitarlos

Las variables globales pueden ser útiles en algunas situaciones, pero un excesivo o inadecuado de estas generan problemas. Desde un código difícil de mantener, pasado por efectos secundarios inesperados o errores de los programas en tiempo de ejecución. En esta entrada veremos qué son las variables globales en Python, los principales problemas de sus uso excesivo y cómo evitarlos con buenas prácticas.

¿Qué es una variable global en Python?

Una variable global es aquella definida fuera de cualquier función o clase y que, por lo tanto, es accesible desde cualquier parte del código. Un ejemplo de una variable global es la variable contador en el siguiente código:

contador = 0  # Variable global

def incrementar():
    global contador  # Modificamos la variable global
    contador += 1

incrementar()
print(contador)  # 1

Aunque esto puede parecer una práctica válida para esta tarea, cuando el código aumenta en complejidad pueden aparecer varios problemas.

Problemas con las variables globales en Python

Entre los principales problemas que puede traer el uso de variables globales en Python se pueden enumerar los siguientes.

Código menos mantenible y difícil de depurar

El uso de variables globales hace que el código sea menos predecible. Si varias funciones modifican la misma variable global, puede ser difícil rastrear dónde y por qué ha cambiado.

En Analytics Lane

Tutorial de Mypy para Principiantes

estado = "inicial"

def cambiar_estado():
    global estado
    estado = "modificado"

cambiar_estado()
print(estado)  # "modificado"

Este tipo de código es difícil de depurar cuando el programa aumenta de tamaño.

Solución: Usa variables locales y pasa valores como parámetros en lugar de depender de variables globales

Una solución a este problema es pasar la variable que se desea modificar como un parámetro y recuperar esta, de este modo los cambios siempre estarán acotados. Evitando que se produzcan cambios accidentales.

def cambiar_estado(estado):
    return "modificado"

estado = "inicial"
estado = cambiar_estado(estado)
print(estado)  # "modificado"

Problemas con efectos secundarios en funciones

Si una función usa una variable global, su comportamiento puede cambiar de forma impredecible según el estado global.

descuento = 0.1  # Variable global

def calcular_precio(precio):
    return precio * (1 - descuento)  # Depende de la variable global

print(calcular_precio(100))  # 90.0
descuento = 0.2
print(calcular_precio(100))  # 80.0 (Resultado inesperado)

En este caso el descuento puede ser modificado con un valor que no es el esperado o no recuperar el valor original

Solución: Usa parámetros explícitos para mejorar la claridad y evitar dependencias ocultas.

Para este caso, la solución es pasar el descuento como un parámetro de modos que se pueda modificar en cualquier momento. Un valor que se puede dejar como opcional con un descuento por defecto

def calcular_precio(precio, descuento=0.2):
    return precio * (1 - descuento)

print(calcular_precio(100))       # 80.0
print(calcular_precio(100, 0.1))  # 90.0
print(calcular_precio(100, 0.2))  # 80.0

Cuándo es seguro usar variables globales

En algunos casos, las variables globales pueden ser útiles.

Para definir constantes globales

Se pueden usar para definir valores que no mutan a lo largo del programa.

PI = 3.1416  # Se usa mayúsculas para indicar que es constante

Para configuraciones compartidas

Los parámetros de configuración, que tampoco suelen mutar durante la ejecución del programa también se pueden guardar en una variable global

config = {
   "modo_debug": True,
   "version": "1.0.0"
}

Cuando se usan de forma controlada en scripts pequeños

En script pequeños, tampoco suele ser un problema recurrir a variables globales.

contador = 0

def incrementar():
    global contador
    contador += 1

Mejores prácticas recomendadas

Si necesitas compartir datos entre funciones, considera las siguientes opciones antes de recurrir a una variable global.

Usar parámetros y valores de retorno

La primera opción debería ser usar parámetros y valores de retorno para gestionar mejor los cambios en los valores de las variables.

def actualizar_dato(valor):
    return valor + 1

dato = 0
dato = actualizar_dato(dato)

Usar clases y atributos de instancia

En lugar de variables globales, se pueden crear clases para compartir valores en cada una de las instancias de la clase.

class Contador:
    def __init__(self):
        self.valor = 0

    def incrementar(self):
        self.valor += 1

c = Contador()
c.incrementar()
print(c.valor)  # 1

Usar un espacio de nombres (módulo)

En lugar de usar una variable global en el mismo archivo, defínela en un módulo separado.

Archivo config.py:

config = {
    "modo_debug": True,
    "version": "1.0.0"
}

Uso en otro archivo:

import config

print(config.config["modo_debug"])  # True

Conclusiones

Las variables globales en Python pueden parecer una solución rápida para compartir datos entre funciones, pero su uso excesivo puede causar problemas de mantenimiento, depuración y concurrencia.

Para evitar estos problemas:

• Usa variables locales y pásalas como parámetros.
• Usa clases y estructuras de datos adecuadas.
• Usa módulos para gestionar configuraciones globales.
• Si es necesario usar variables globales, hazlo de manera controlada.

Adoptar buenas prácticas hará que tu código sea más seguro, claro y mantenible.

Nota: La imagen de este artículo fue generada utilizando un modelo de inteligencia artificial.