El mundo de la programación en Python

Variables globales en Python: conceptos, usos, riesgos y buenas prácticas

Funciones, clases y estructuras
目次

1. ¿Qué es una variable global?

Concepto básico de las variables globales

En Python, una variable global es aquella a la que se puede acceder en todo el programa. Se define fuera de las funciones o clases y se utiliza para compartir datos entre diferentes funciones o módulos. Sin embargo, el uso excesivo de variables globales puede provocar errores inesperados, por lo que se recomienda usarlas con precaución.
# Ejemplo de variable global
global_var = "Variable global"

def show_global():
    print(global_var)

show_global()  # Salida: Variable global
Las variables globales se definen fuera de funciones o clases y se pueden referenciar desde cualquier parte del programa. No obstante, se debe tener especial cuidado al modificarlas.

Diferencia con las variables locales

A diferencia de las variables globales, las variables locales se definen dentro de una función y su alcance está limitado a dicha función. Una vez que la función termina, la variable local se destruye y no puede ser accedida desde fuera.
def example_func():
    local_var = "Variable local"
    print(local_var)

example_func()  # Salida: Variable local
# print(local_var)  # Error: no se puede acceder a una variable local fuera de la función
Comprender la diferencia entre variables locales y globales, y utilizarlas de manera adecuada, mejora la mantenibilidad del código.

2. Uso de variables globales dentro de funciones

Referencia y modificación de variables globales

Las variables globales pueden ser referenciadas dentro de una función, pero para modificarlas es necesario usar la palabra clave global. De lo contrario, se creará una variable local con el mismo nombre sin afectar a la global.
counter = 0  # Variable global

def increase_counter():
    global counter
    counter += 1

increase_counter()
print(counter)  # Salida: 1

Introducción a la palabra clave nonlocal

La palabra clave nonlocal se utiliza en funciones anidadas para modificar una variable local de la función externa. Es útil en el caso de cierres (closures) o cuando se necesita mantener estado dentro de una función.
def outer_func():
    outer_var = "Externa"

    def inner_func():
        nonlocal outer_var
        outer_var = "Externa modificada"

    inner_func()
    print(outer_var)

outer_func()  # Salida: Externa modificada
Con nonlocal, una función interna puede acceder y modificar variables de la función envolvente.
侍エンジニア塾

3. Precauciones al usar variables globales

Riesgos del uso excesivo de variables globales

Las variables globales son útiles, pero su abuso puede causar efectos inesperados en todo el programa. En particular, cuando varias funciones modifican la misma variable global, se complica rastrear qué función cambió el valor y cuándo.
counter = 0

def increment():
    global counter
    counter += 1

def decrement():
    global counter
    counter -= 1

increment()
decrement()
print(counter)  # Salida: 0
Cuando una variable global es modificada desde múltiples lugares, aumenta la probabilidad de errores. Por ello, se recomienda minimizar su uso y optar por otras formas de gestión de datos.

Manejo de errores y depuración

El uso de variables globales puede provocar errores inesperados. Agregar manejo de errores y utilizar el módulo logging facilita la detección y depuración de problemas.
import logging

logging.basicConfig(level=logging.DEBUG)

counter = 0

def increment():
    global counter
    try:
        counter += 1
        logging.debug(f"counter incrementado: {counter}")
    except Exception as e:
        logging.error(f"Error: {e}")

increment()
De esta manera, se puede registrar dónde y cómo se modificaron las variables globales, además de qué errores ocurrieron.

4. Buenas prácticas con variables globales

Minimizar el uso de variables globales

Se recomienda reducir al mínimo el uso de variables globales. En su lugar, se pueden utilizar parámetros y valores de retorno para intercambiar datos entre funciones, lo que hace más claro el flujo de información y evita modificaciones no intencionadas.
def add_points(score, points):
    return score + points

current_score = 0
current_score = add_points(current_score, 10)
print(current_score)  # Salida: 10
De este modo, se gestionan los datos sin depender de variables globales.

Gestión de estado con clases

El uso de clases permite manejar estados sin recurrir a variables globales. Las clases encapsulan datos y delimitan su alcance, ofreciendo una forma más segura de organización.
class Game:
    def __init__(self):
        self.score = 0

    def add_points(self, points):
        self.score += points

game = Game()
game.add_points(10)
print(game.score)  # Salida: 10
Con las clases, el estado queda aislado dentro de cada instancia, evitando modificaciones accidentales desde otras partes del programa.

5. Ejemplos prácticos y aplicaciones

Uso en desarrollo de videojuegos

En videojuegos, las variables globales a veces se usan para manejar estados como puntuaciones o vidas. Sin embargo, en proyectos grandes se recomienda usar clases o bases de datos.
score = 0  # Variable global

def increase_score(points):
    global score
    score += points

increase_score(10)
print(f"Puntuación del jugador: {score}")  # Salida: Puntuación del jugador: 10

Variables globales para gestión de configuración

En aplicaciones, información de configuración compartida (ej.: modo depuración o versión) suele manejarse como variable global, aunque es más eficiente integrarla con archivos de configuración o variables de entorno.
config = {
    'debug': True,
    'version': '1.0'
}

def print_config():
    print(f"Modo depuración: {config['debug']}, Versión: {config['version']}")

print_config()  # Salida: Modo depuración: True, Versión: 1.0
 

6. Conclusión y próximos pasos

Las variables globales pueden ser útiles en escenarios simples, pero su abuso complica el código y genera errores. Usar parámetros, valores de retorno o clases ayuda a reducir la dependencia de variables globales y promueve un diseño más seguro y eficiente.

Temas recomendados para continuar

Como siguiente paso, se recomienda aprender sobre closures, alcance de módulos y programación orientada a objetos (POO), lo cual permitirá diseñar programas más complejos sin depender de variables globales.

Recursos externos y enlaces de referencia

  • Documentación oficial de Python
    Explicación detallada sobre alcance, closures y POO en Python. Especialmente útil para comprender la regla LEGB (Local, Enclosing, Global, Built-in). Documentación oficial de Python
年収訴求