Variables globales

0.1 Motivación

Cuando trabajas con funciones, necesitas entender cómo Python maneja las variables en diferentes contextos. Las variables globales son accesibles desde cualquier parte de tu programa, pero modificarlas dentro de funciones requiere cuidado. Dominar el alcance (scope) de las variables es esencial para escribir código predecible y evitar errores difíciles de depurar.

0.2 Intuición

Imagina que tienes una pizarra en la entrada de tu casa (variable global) donde toda la familia puede escribir mensajes. Todos pueden leer lo que está en la pizarra. Pero si alguien escribe un mensaje en su propia libreta personal (variable local) con el mismo título, no afecta lo que está en la pizarra. Python funciona igual: una variable dentro de una función es como una libreta privada, separada de la pizarra global.

0.3 Modelo mental

Python sigue las reglas LEGB para la resolución de variables:

1. Local → dentro de la función actual
2. Enclosing → funciones externas (anidadas)
3. Global → variables definidas fuera de funciones
4. Built-in → funciones y variables incorporadas de Python

Cuando usas una variable dentro de una función, Python busca en ese orden: primero local, luego global si no encuentra local.

0.4 Desarrollo

x = "awesome"  # Variable global

def myfunc():
    print("Python is " + x)  # Accede a la variable global

myfunc()  # Salida: Python is awesome

x = "awesome"  # Global

def myfunc():
    x = "fantastic"  # Local (independiente)
    print("Python is " + x)  # Usa la local

myfunc()  # Salida: Python is fantastic
print("Python is " + x)  # Salida: Python is awesome (global)

x = "awesome"  # Global

def myfunc():
    global x  # Declara que vas a usar/modificar la global
    x = "fantastic"  # Modifica la global

myfunc()
print("Python is " + x)  # Salida: Python is fantastic

def myfunc():
    global x
    x = "nueva variable"  # Crea una variable global

myfunc()
print(x)  # Salida: nueva variable

contador = 0  # Global

def incrementar():
    global contador  # Necesario para modificar
    contador += 1

def mostrar():
    print(contador)  # Solo lectura, no necesita global

incrementar()
incrementar()
mostrar()  # Salida: 2

0.5 Ejemplos

Mínimo — Acceso a global:

nombre = "Ana"  # Global

def saludar():
    print("Hola", nombre)  # Accede a la global

saludar()  # Hola Ana

Progresivo — Local vs Global:

mensaje = "Global"

def funcion1():
    mensaje = "Local"
    print("Dentro:", mensaje)  # Local

def funcion2():
    print("Fuera:", mensaje)  # Global

funcion1()  # Dentro: Local
funcion2()  # Fuera: Global
print("Principal:", mensaje)  # Principal: Global

Real — Contador de visitas:

visitas = 0  # Global

def visitar_pagina():
    global visitas
    visitas += 1
    print(f"Visitante #{visitas}")

def mostrar_estadisticas():
    print(f"Total de visitas: {visitas}")

# Simulación de visitas
visitar_pagina()  # Visitante #1
visitar_pagina()  # Visitante #2
visitar_pagina()  # Visitante #3
mostrar_estadisticas()  # Total de visitas: 3

0.6 Errores comunes

0.7 Buenas prácticas

1. Evita usar variables globales a menos que sea necesario: pasa valores como argumentos a las funciones.

2. Usa globales solo para configuraciones o contadores:

   python

   # ✅ Aceptable
   CONFIG = {"debug": True, "timeout": 30}
   
   # ✅ Buen uso de global
   visitas = 0
   def incrementar_visitas():
       global visitas
       visitas += 1

3. Nombra las globales con mayúsculas (por convención):

   python

   MAX_INTENTOS = 3  # Constante global
   BASE_URL = "https://api.ejemplo.com"  # Configuración

4. Si necesitas modificar una variable, considera pasar por parámetros:

   python

   # ❌ Uso global innecesario
   saldo = 100
   def sumar(monto):
       global saldo
       saldo += monto
   
   # ✅ Mejor usar parámetros
   def sumar(saldo, monto):
       return saldo + monto

5. Documenta las variables globales para que sea claro qué hacen.

0.8 Ejercicio

Básico — Análisis de alcance

Analiza el siguiente código y determina qué imprime cada print():

mensaje = "Hola mundo"

def funcion_a():
    mensaje = "Hola desde A"
    print(mensaje)  # 1

def funcion_b():
    global mensaje
    mensaje = "Modificado globalmente"
    print(mensaje)  # 2

def funcion_c():
    print(mensaje)  # 3

funcion_a()
print(mensaje)  # 4
funcion_b()
print(mensaje)  # 5
funcion_c()

Solución (no mires hasta haberlo intentado):

mensaje = "Hola mundo"

def funcion_a():
    mensaje = "Hola desde A"  # Variable local
    print(mensaje)  # 1. Imprime: Hola desde A

def funcion_b():
    global mensaje  # Acceso a la global
    mensaje = "Modificado globalmente"  # Cambia la global
    print(mensaje)  # 2. Imprime: Modificado globalmente

def funcion_c():
    print(mensaje)  # 3. Imprime la global (que es: Modificado globalmente)

funcion_a()
# 4. Imprime: Hola mundo (la global no cambió)

funcion_b()
# 5. Imprime: Modificado globalmente (la global cambió)

funcion_c()
# 6. Imprime: Modificado globalmente (la global sigue igual)

Salida esperada:

Hola desde A
Hola mundo
Modificado globalmente
Modificado globalmente
Modificado globalmente

0.9 Síntesis

• Global: variable definida fuera de funciones, accesible en todo el programa.
• Local: variable definida dentro de una función, solo accesible allí.
• Leer global no requiere global; solo usas el nombre.
• Modificar global requiere global variable.
• Crear global dentro de función: usa global para crearla.
• global declara que la variable pertenece al scope global.
• Buena práctica: minimiza el uso de variables globales.

0.10 Qué sigue

• Relacionado: funciones (alcance de variables, parámetros y argumentos)
• Siguiente tema: Funciones — aprenderás a crear y usar funciones, y a manejar correctamente el alcance de variables en diferentes contextos.