Ir al contenido principal

Ámbito de las variables: local y global

Introducción

Cuando trabajamos con variables en Python, es fundamental comprender dónde pueden ser utilizadas y accedidas. Esta característica, conocida como "ámbito" o "scope", determina la visibilidad y duración de vida de una variable en nuestro código. En Python existen principalmente dos ámbitos: local y global. Entender las diferencias entre ambos te permitirá escribir código más organizado, evitar errores comunes y aprovechar mejor las capacidades del lenguaje.

Ámbito local

El ámbito local se refiere a las variables que se definen dentro de una función y que solo son accesibles desde dentro de esa función.

Características de las variables locales

  • Se crean cuando se ejecuta la función
  • Solo existen mientras la función se está ejecutando
  • No son accesibles desde fuera de la función
  • Desaparecen cuando la función termina su ejecución

Ejemplo de variables locales

def calcular_area_rectangulo(base, altura):
    # Variables locales: base, altura, area
    area = base * altura
    print(f"El área del rectángulo es: {area}")
    return area

# Llamamos a la función
calcular_area_rectangulo(5, 3)  # Salida: El área del rectángulo es: 15

# Intentar acceder a variables locales desde fuera causará error
# print(area)  # NameError: name 'area' is not defined

En este ejemplo, base, altura y area son variables locales que solo existen dentro de la función calcular_area_rectangulo(). Si intentamos acceder a area fuera de la función, Python nos dará un error.

Ámbito global

El ámbito global se refiere a las variables definidas en el nivel principal del programa (fuera de cualquier función o clase) y que son accesibles desde cualquier parte del código.

Características de las variables globales

  • Se crean en el nivel principal del programa
  • Son accesibles desde cualquier parte del código, incluidas funciones
  • Existen durante toda la ejecución del programa
  • Pueden ser leídas desde cualquier función sin declaración especial

Ejemplo de variables globales

# Variable global
contador = 0

def incrementar_contador():
    # Accedemos a la variable global (solo lectura)
    print(f"Valor actual del contador: {contador}")
    
    # Si intentamos modificarla directamente, tendremos un error
    # contador += 1  # UnboundLocalError

incrementar_contador()  # Salida: Valor actual del contador: 0

En este ejemplo, contador es una variable global. Desde la función incrementar_contador() podemos leer su valor, pero si intentamos modificarla directamente obtendremos un error.

Modificando variables globales desde funciones

Para modificar una variable global desde dentro de una función, necesitamos usar la palabra clave global:

contador = 0

def incrementar_contador():
    # Declaramos que usaremos la variable global
    global contador
    print(f"Valor actual del contador: {contador}")
    contador += 1
    print(f"Nuevo valor del contador: {contador}")

incrementar_contador()  # Salida: Valor actual del contador: 0
                       #         Nuevo valor del contador: 1
print(f"Contador fuera de la función: {contador}")  # Salida: Contador fuera de la función: 1

Con la declaración global contador, le indicamos a Python que queremos usar la variable global contador y no crear una nueva variable local con el mismo nombre.

Variables no locales (ámbito encerrado)

Existe un tercer tipo de ámbito llamado "no local" o "encerrado", que es relevante cuando trabajamos con funciones anidadas:

def contador_externo():
    contador = 0
    
    def incrementar():
        nonlocal contador  # Accedemos a la variable de la función que la contiene
        contador += 1
        return contador
    
    return incrementar

# Creamos una función contador
mi_contador = contador_externo()
print(mi_contador())  # Salida: 1
print(mi_contador())  # Salida: 2
print(mi_contador())  # Salida: 3

Aquí, nonlocal nos permite acceder y modificar la variable contador que pertenece a la función externa contador_externo().

Buenas prácticas con ámbitos de variables

  1. Limitar el uso de variables globales: Las variables globales pueden hacer que el código sea difícil de mantener y depurar.

  2. Preferir paso de parámetros: En lugar de usar variables globales, es mejor pasar los valores como parámetros a las funciones.

# Mejor:
def calcular_precio_total(precio_base, impuesto=0.21):
    return precio_base * (1 + impuesto)

# En lugar de:
precio_base = 100
impuesto = 0.21

def calcular_precio_total_global():
    global precio_base, impuesto
    return precio_base * (1 + impuesto)
  1. Utilizar constantes para valores fijos: Si necesitas valores globales que no cambian, defínelos como constantes con nombres en mayúsculas.
PI = 3.1416
GRAVEDAD = 9.8

def calcular_area_circulo(radio):
    return PI * radio ** 2
  1. Documentar el uso de variables globales: Si es inevitable usar variables globales, documéntalo claramente.

Reglas de resolución de ámbitos en Python (LEGB)

Python sigue un orden específico para buscar variables, conocido como regla LEGB:

  1. L (Local): Primero busca en el ámbito local (dentro de la función actual)
  2. E (Enclosing): Luego en el ámbito de funciones que contienen a la actual (en caso de funciones anidadas)
  3. G (Global): Después en el ámbito global (variables del módulo)
  4. B (Built-in): Finalmente en el ámbito integrado (funciones y objetos predefinidos de Python)
x = "global"  # Variable global

def funcion_externa():
    x = "enclosing"  # Variable en ámbito encerrado
    
    def funcion_interna():
        x = "local"  # Variable local
        print(f"Dentro de funcion_interna: {x}")
    
    funcion_interna()
    print(f"Dentro de funcion_externa: {x}")

funcion_externa()
print(f"En ámbito global: {x}")

# Salida:
# Dentro de funcion_interna: local
# Dentro de funcion_externa: enclosing
# En ámbito global: global

Resumen

El ámbito de las variables en Python determina dónde pueden ser accedidas y modificadas. Las variables locales solo existen dentro de la función donde fueron creadas, mientras que las variables globales son accesibles desde cualquier parte del programa. Para modificar variables globales desde funciones, debemos usar la palabra clave global, y para modificar variables de funciones externas en funciones anidadas, usamos nonlocal. Comprender el ámbito de las variables es esencial para escribir código limpio, modular y libre de errores inesperados. En los próximos temas, exploraremos conceptos más avanzados como las funciones lambda, que complementarán tu dominio sobre las funciones en Python.

Volver arriba