Python · Lección 22 de 27

Scope de variables

Cuando escribís x = 10 dentro de una función, ¿es la misma x que la de afuera? No. Python tiene reglas estrictas sobre dónde "vive" cada variable. Entender el scope te evita bugs invisibles y te permite escribir funciones seguras.

60–80 min Prerrequisitos: 18-19 Funciones

Concepto teórico

¿Qué es el scope?

El scope (ámbito) de una variable es la zona del código donde esa variable es visible y accesible. Cuando usás un nombre (x, saldo, print), Python busca en un orden específico hasta encontrarlo. Si no lo encuentra en ningún nivel, da NameError.

La regla LEGB

Python busca nombres en este orden estricto (de más interno a más externo):

L — Local: variables definidas DENTRO de la función actual
E — Enclosing: variables de funciones externas (en funciones anidadas / closures)
G — Global: variables definidas a nivel del módulo (fuera de toda función)
B — Built-in: nombres integrados de Python (print, len, range, True)

Regla de oro: Python SIEMPRE busca de adentro hacia afuera: L → E → G → B. Usa la primera coincidencia que encuentra. Si definís print = 42 en tu código, sobreescribís el built-in print y ya no podés imprimir (¡no lo hagas!).

Scope local — variables dentro de funciones

Cada función crea su propio scope local. Las variables definidas dentro de una función solo existen dentro de esa función. Cuando la función termina, desaparecen:

def calcular():
    resultado = 42    # LOCAL a calcular()
    return resultado

calcular()
# print(resultado)  # NameError: resultado no existe acá afuera

Esto es una VENTAJA: cada función trabaja con sus propias variables sin interferir con el resto del programa. Es como oficinas privadas — lo que pasa adentro no afecta a las demás.

Scope global — variables del módulo

Las variables definidas fuera de toda función son globales. Se pueden LEER desde cualquier función, pero NO se pueden MODIFICAR sin declarar global:

IVA = 0.21  # global

def con_iva(precio):
    return precio * (1 + IVA)  # ✅ LEER global: funciona

def cambiar_iva():
    # IVA = 0.27  ← esto crea una LOCAL nueva, no modifica la global
    global IVA   # ← esto SÍ permite modificar la global
    IVA = 0.27

Evitá global siempre que puedas. Las variables globales mutables son una fuente de bugs porque cualquier función puede cambiarlas en cualquier momento. Es como tener una planilla de Excel compartida sin control de cambios. Preferí pasar valores como parámetros y devolver resultados con return.

Nonlocal — closures y funciones anidadas

nonlocal permite que una función interna modifique variables de la función externa (scope Enclosing). Se usa en closures con estado:

def crear_contador():
    cuenta = 0          # scope Enclosing
    def incrementar():
        nonlocal cuenta  # sin esto, Python crea una local nueva
        cuenta += 1
        return cuenta
    return incrementar

cont = crear_contador()
print(cont())  # 1
print(cont())  # 2 — recuerda el estado

Errores comunes de scope

Error	Causa	Solución
`UnboundLocalError`	Asignás a una variable que Python ya interpretó como local	Usá `global` o pasá como parámetro
`NameError`	La variable no existe en ningún scope	Verificá el nombre, ¿la definiste?
Sobreescribir built-in	`list = [1,2]` oculta `list()`	Nunca uses nombres de built-ins
Mutación accidental	Modificar una lista global desde una función	Trabajá con copias o pasá explícitamente

Analogía: el scope es como la organización de una empresa. Una variable local es una nota en tu escritorio (solo vos la ves). Una global es un memo en el pizarrón de la oficina (todos lo leen). global es como editar el pizarrón directamente. nonlocal es como editar el post-it de tu jefe directo. Lo ideal es que cada uno trabaje con sus propias notas y las comparta mediante reportes (return).

En el trabajo: el 90% de los bugs de scope se evitan con una regla simple: las funciones reciben datos por parámetro y devuelven resultados por return. No lean ni escriban globales directamente. Esto hace tu código testeable, predecible y libre de efectos secundarios.

Ejemplos explicados paso a paso

Ejemplo 1: LEGB en acción

ejemplo_01_legb.pyPython

# B — Built-in: print, len, etc. siempre disponibles
# G — Global
x = "global"

def externa():
    # E — Enclosing
    x = "enclosing"
    
    def interna():
        # L — Local
        x = "local"
        print(f"  Dentro de interna: x = {x}")  # L → "local"
    
    interna()
    print(f"  Dentro de externa: x = {x}")  # E → "enclosing"

externa()
print(f"Fuera de todo: x = {x}")  # G → "global"

# Cada x es INDEPENDIENTE — son variables distintas
# con el mismo nombre en scopes distintos

# Sin reasignación local, Python busca hacia afuera
print(f"\n=== Busca hacia afuera ===")
mensaje = "soy global"

def leer():
    print(f"  Función lee: {mensaje}")  # no hay local → busca global

leer()

Hacé clic en ▶ Ejecutar

Ejemplo 2: El error UnboundLocalError

ejemplo_02_error.pyPython

saldo = 100000

# ❌ Esto falla con UnboundLocalError
def depositar_mal(monto):
    # Python VE que saldo se asigna más abajo → la marca como LOCAL
    # Pero intentamos leerla ANTES de asignarla → error
    try:
        saldo = saldo + monto  # UnboundLocalError!
        return saldo
    except UnboundLocalError as e:
        print(f"  ❌ Error: {e}")
        return None

print("=== Sin global (error) ===")
depositar_mal(50000)

# ✅ Solución 1: global (funciona pero no es ideal)
def depositar_global(monto):
    global saldo
    saldo = saldo + monto
    return saldo

saldo = 100000
print(f"\n=== Con global ===")
print(f"  Antes: ${saldo:,}")
depositar_global(50000)
print(f"  Después: ${saldo:,}")

# ✅ Solución 2: pasar como parámetro (MEJOR)
def depositar_correcto(saldo_actual, monto):
    return saldo_actual + monto

saldo = 100000
print(f"\n=== Con parámetro (mejor) ===")
nuevo_saldo = depositar_correcto(saldo, 50000)
print(f"  Original: ${saldo:,} (no se modificó)")
print(f"  Nuevo: ${nuevo_saldo:,}")

Hacé clic en ▶ Ejecutar

Ejemplo 3: nonlocal en closures con estado

ejemplo_03_nonlocal.pyPython

# Closure con estado: simulación de cuenta bancaria
def crear_cuenta(saldo_inicial):
    saldo = saldo_inicial  # scope Enclosing
    movimientos = []
    
    def operar(tipo, monto):
        nonlocal saldo  # permitir modificar el saldo del scope externo
        if tipo == "deposito":
            saldo += monto
            movimientos.append(f"+${monto:,}")
        elif tipo == "extraccion":
            if monto > saldo:
                return f"Fondos insuficientes (saldo: ${saldo:,})"
            saldo -= monto
            movimientos.append(f"-${monto:,}")
        return f"Saldo: ${saldo:,}"
    
    def ver_movimientos():
        return movimientos.copy(), saldo
    
    return operar, ver_movimientos

# Crear una cuenta
operar, ver = crear_cuenta(100000)
print(operar("deposito", 50000))
print(operar("extraccion", 30000))
print(operar("deposito", 80000))
print(operar("extraccion", 500000))  # insuficiente

movs, saldo_final = ver()
print(f"\nMovimientos: {movs}")
print(f"Saldo final: ${saldo_final:,}")

Hacé clic en ▶ Ejecutar

Ejemplo 4: Peligro de sobreescribir built-ins

ejemplo_04_builtins.pyPython

# ❌ NUNCA hagas esto: sobreescribir nombres built-in
# list = [1, 2, 3]         # ahora list() no funciona más
# dict = {"a": 1}           # ahora dict() no funciona más
# print = "hola"            # ahora print() no funciona más
# type = "cliente"          # ahora type() no funciona más
# id = 12345                # ahora id() no funciona más
# input = "datos"           # ahora input() no funciona más

# Nombres built-in que la gente sobreescribe sin querer:
nombres_peligrosos = ["list", "dict", "set", "type", "id", "input",
                       "print", "len", "min", "max", "sum", "map",
                       "filter", "range", "str", "int", "float", "bool"]
print(f"Nombres que NUNCA debés usar como variable:")
print(f"  {', '.join(nombres_peligrosos[:9])}")
print(f"  {', '.join(nombres_peligrosos[9:])}")

# ✅ Alternativas seguras
mi_lista = [1, 2, 3]         # en vez de list = ...
datos_dict = {"a": 1}        # en vez de dict = ...
tipo_cliente = "Premium"     # en vez de type = ...
id_cliente = 12345           # en vez de id = ...

# Verificar qué es built-in
import builtins
total_builtins = len(dir(builtins))
print(f"\nTotal built-ins: {total_builtins}")
print(f"Algunos: {dir(builtins)[-10:]}")

Hacé clic en ▶ Ejecutar

Ejemplo 5: Scope y mutabilidad — la trampa de las listas globales

ejemplo_05_mutabilidad.pyPython

# Las listas globales se pueden MUTAR desde funciones sin global
# Esto es porque no estás reasignando, sino modificando el objeto
datos = [100, 200, 300]

def agregar(valor):
    datos.append(valor)  # ✅ funciona sin 'global' (muta, no reasigna)

def resetear():
    # datos = []  # ❌ esto crea una LOCAL nueva, no resetea la global
    global datos
    datos = []     # ✅ con global SÍ reasigna

print(f"Original: {datos}")
agregar(400)
print(f"Después de agregar: {datos}")  # [100, 200, 300, 400]

# ⚠️ Esto es PELIGROSO: una función modifica datos globales silenciosamente
# MEJOR: recibir la lista como parámetro y devolver nueva lista

def agregar_seguro(lista, valor):
    nueva = lista.copy()  # no mutar la original
    nueva.append(valor)
    return nueva

original = [100, 200, 300]
resultado = agregar_seguro(original, 400)
print(f"\nOriginal: {original}")     # no cambió
print(f"Resultado: {resultado}")      # nueva lista

# Moraleja: SIEMPRE trabajá con copias si no querés efectos secundarios

Hacé clic en ▶ Ejecutar

Referencia rápida

Scope	Dónde vive	Leer	Modificar
Local	Dentro de la función	Directo	Directo
Enclosing	Función externa (closure)	Directo	Con `nonlocal`
Global	Nivel del módulo	Directo	Con `global`
Built-in	Python interno	Directo	No (no lo hagas)

Buena práctica	Mala práctica
Pasar datos como parámetros	Leer variables globales dentro de funciones
Devolver resultados con return	Modificar globales con `global`
Trabajar con copias de listas/dicts	Mutar argumentos mutables silenciosamente
Usar nombres descriptivos	Sobreescribir built-ins (list, dict, type)

Ejercicios

Nivel 1 · Básico

Ejercicio 1: Identificar scopes

Dado el código, predecí qué imprime ANTES de ejecutar. Después ejecutá para verificar. Debe incluir local.

ejercicio_01.pyDebe incluir "local"

x = "global"

def f():
    x = "local"
    print(x)

f()
print(x)

Hacé clic en ▶ Ejecutar

Nivel 1 · Básico

Ejercicio 2: Leer global desde función

Definí IVA = 0.21 como global. Creá una función con_iva(precio) que la USE (sin global). Debe incluir 12100.

ejercicio_02.pyDebe incluir "12100"

IVA = 0.21

def con_iva(precio):
    # Usá IVA (se lee desde global):
    pass

print(con_iva(10000))

Hacé clic en ▶ Ejecutar

Nivel 1 · Básico

Ejercicio 3: UnboundLocalError

Reproducí el error UnboundLocalError y después arreglalo pasando el valor como parámetro. Debe incluir 150000.

ejercicio_03.pyDebe incluir "150000"

saldo = 100000

# ❌ Versión que falla:
# def depositar(monto):
#     saldo = saldo + monto
#     return saldo

# ✅ Versión correcta (con parámetro):
def depositar(saldo_actual, monto):
    pass  # completá

print(depositar(100000, 50000))

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 4: Global keyword

Creá un contador global operaciones = 0 y una función registrar() que lo incremente con global. Llamala 5 veces e imprimí. Debe incluir 5.

ejercicio_04.pyDebe incluir "5"

operaciones = 0

def registrar():
    pass  # usá global

for _ in range(5):
    registrar()

print(f"Operaciones: {operaciones}")

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 5: Nonlocal en closure

Creá un closure crear_acumulador() que devuelva una función agregar(monto) que acumule un total con nonlocal. Debe incluir 300.

ejercicio_05.pyDebe incluir "300"

def crear_acumulador():
    total = 0
    def agregar(monto):
        pass  # usá nonlocal
    return agregar

acc = crear_acumulador()
print(acc(100))
print(acc(200))

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 6: Evitar sobreescribir built-ins

Corregí este código que sobreescribe list y sum. Después usá los verdaderos list() y sum(). Debe incluir 15.

ejercicio_06.pyDebe incluir "15"

# ❌ Corregí estos nombres:
# list = [1, 2, 3, 4, 5]
# sum = 0
# for x in list:
#     sum += x
# print(sum)

# ✅ Versión correcta (sin sobreescribir built-ins):

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 7: Función pura vs impura

Creá una versión "impura" (modifica global) y una "pura" (parámetro + return) de una función que aplique descuento a un precio. La pura debe devolver el resultado sin modificar nada. Debe incluir 8500.

ejercicio_07.pyDebe incluir "8500"

# Versión PURA (solo parámetros y return):
def aplicar_descuento(precio, descuento=0.15):
    pass  # completá

print(aplicar_descuento(10000))

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 8: Scope en comprehensions

Las variables de for en list comprehensions tienen scope local (Python 3+). Demostralo: creá x = "global", después resultado = [x for x in range(5)], e imprimí x para ver que sigue siendo "global". Debe incluir global.

ejercicio_08.pyDebe incluir "global"

x = "global"

# La x del comprehension NO afecta la x global:
resultado = [x for x in range(5)]

print(f"resultado: {resultado}")
print(f"x: {x}")

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 9: Closure con scope aislado

Creá una fábrica de funciones crear_filtro(umbral) que devuelva una función que filtre elementos mayores al umbral de una lista. Creá dos filtros con umbrales distintos. Debe incluir [890000].

ejercicio_09.pyDebe incluir "[890000]"

def crear_filtro(umbral):
    pass  # completá

filtro_100k = crear_filtro(100000)
filtro_500k = crear_filtro(500000)

saldos = [150000, 320000, 45000, 890000, 72000]
print(f"> $100K: {filtro_100k(saldos)}")
print(f"> $500K: {filtro_500k(saldos)}")

Hacé clic en ▶ Ejecutar

Nivel 4 · Desafío

Ejercicio 10: Mini sistema bancario con closures

Creá crear_cuenta(titular, saldo_inicial) que devuelva 3 funciones: depositar(monto), extraer(monto) y consultar(). Usá nonlocal para manejar el saldo. Probá con operaciones. Debe incluir Saldo:.

ejercicio_10_desafio.pyDebe incluir "Saldo:"

# Creá el sistema:
def crear_cuenta(titular, saldo_inicial):
    pass  # completá

depositar, extraer, consultar = crear_cuenta("García", 100000)

depositar(50000)
extraer(20000)
depositar(80000)
print(consultar())

Hacé clic en ▶ Ejecutar

Resumen y conexión

Python busca variables en orden LEGB: Local → Enclosing → Global → Built-in.
Variables locales solo existen dentro de su función. Al terminar, desaparecen.
global permite modificar una global desde una función. Evitalo siempre que puedas.
nonlocal permite modificar variables del scope Enclosing (closures).
NUNCA sobreescribas built-ins (list, dict, type, id, sum).
Funciones puras (parámetro → return) son más seguras que funciones que mutan globales.

En la siguiente lección (23 · Strings avanzado) vas a profundizar en slicing, regex con re, encoding UTF-8 y patrones avanzados de procesamiento de texto.

Recursos: Python docs — Scopes

Hecho con ❤️ por Rodri Gonzalez