24.Ámbito de variables

El ámbito (scope) de una variable es la parte del programa donde existe y se puede usar. Una variable creada dentro de una función solo vive dentro de esa función.

Es como lo que se dice dentro de un salón: lo que se habla en el 3.º A no se escucha en el 3.º B. Cada salón (función) tiene sus propias conversaciones (variables), aunque usen los mismos nombres.

La regla LEGB de Python

Cuando Python busca una variable, revisa en este orden: Local (la función) → Envolvente (una función que contiene a otra) → Global (el archivo) → Built-in (las predefinidas como print).

PSeInt

En PSeInt cada Funcion y el Algoritmo principal tienen sus propias variables; para compartir datos se usan parámetros y valores de retorno.

Funcion r <- Triple(n)
	Definir x Como Entero
	x <- n * 3        // x es local de Triple
	r <- x
FinFuncion

Algoritmo Principal
	Definir x Como Entero
	x <- 10           // esta x es otra, la del algoritmo
	Escribir Triple(4)
	Escribir x        // sigue valiendo 10
FinAlgoritmo

Python

x = 10            # global

def triple(n):
    x = n * 3     # local: es otra variable, aunque se llame igual
    return x

print(triple(4))  # 12
print(x)          # 10: la global no cambió

Leer y modificar una global

contador = 0

def mostrar():
    print("Contador:", contador)   # leer una global: sí se puede

def incrementar():
    global contador                # para modificarla hay que declararlo
    contador += 1

incrementar()
incrementar()
mostrar()   # Contador: 2

Problema: llevar el saldo de una cuenta. Comparemos dos versiones.

Con una variable global (funciona, pero no es buena idea):

saldo = 1000

def retirar_global(monto):
    global saldo
    saldo -= monto

retirar_global(200)
print("Saldo:", saldo)

Con parámetros y retorno (mejor):

def retirar(saldo, monto):
    if monto > saldo:
        print("Fondos insuficientes")
        return saldo
    return saldo - monto

saldo = 1000
saldo = retirar(saldo, 200)
saldo = retirar(saldo, 1500)
print("Saldo:", saldo)

Salida esperada de la segunda versión:

Fondos insuficientes
Saldo: 800

En la segunda versión, la función no depende de nada «escondido»: todo lo que usa entra por parámetros y todo lo que produce sale con return. Es más fácil de probar y de reutilizar.

# ✗ Incorrecto
def calcular():
    resultado = 42

calcular()
print(resultado)

NameError: name 'resultado' is not defined

# ✗ Incorrecto
total = 0

def sumar(n):
    total += n

sumar(5)

UnboundLocalError: cannot access local variable 'total' where it is not associated with a value

• Evita las variables globales que cambian: hacen difícil saber quién modificó qué.
• Las constantes globales sí están bien (IVA = 0.16), porque no cambian.
• Todo entra por parámetros y sale por return.
• No repitas nombres de variables globales dentro de funciones, para no confundir.
• Pon el programa principal en una función main() y llámala al final: así sus variables tampoco son globales.

• Python Software Foundation. Tutorial de Python: ámbitos y espacios de nombres. https://docs.python.org/es/3/tutorial/classes.html#python-scopes-and-namespaces
• Python Software Foundation. Preguntas frecuentes: reglas para variables locales y globales. https://docs.python.org/es/3/faq/programming.html#what-are-the-rules-for-local-and-global-variables-in-python
• Novara, P. PSeInt — Documentación (funciones). https://pseint.sourceforge.net/