Alcance de las variables en Python

Si estás familiarizado con Python o con cualquier otro lenguaje de programación, sabrás sin duda que las variables deben definirse antes de que puedan utilizarse en tu programa. En este tutorial, empezarás con la inicialización de variables. A continuación, se familiarizará con los límites de las variables dentro de un programa: su "ámbito". Aprenderá sobre los cuatro ámbitos diferentes con la ayuda de ejemplos: local, envolvente, global e incorporado. Estos ámbitos juntos forman la base de la regla LEGB utilizada por el intérprete de Python cuando trabaja con variables. A continuación, se revisarán algunos ejemplos con una complejidad adicional para abrir el camino a la palabra clave global seguida de la palabra clave no local.

Variable

Una variable es una etiqueta o un nombre que se da a un lugar determinado de la memoria. Esta ubicación contiene el valor que desea que su programa recuerde, para su uso posterior. Lo bueno de Python es que no tienes que indicar explícitamente cuál es el tipo de variable que quieres definir - puede ser de cualquier tipo (cadena, entero, flotante, etc.). Para crear una nueva variable en Python, basta con utilizar el operador de asignación (=, un único signo igual) y asignarle el valor deseado.

first_string_var = "First String"  
first_int_var = 1
total = 1 + 2 * 3

Asignar un valor inicial a una variable se denomina inicializar la variable. Acaba de inicializar la variable: first_string_var con un valor de cadena de Primera Cadena y la variable first_int_var con un valor entero o numérico de 1.
La parte de la izquierda del operador de asignación es el nombre de la variable, y la parte de la derecha es su valor. El lado derecho también puede ser una operación aritmética, en cuyo caso se evaluará antes de que se produzca la asignación.

Python tiene algunas reglas que debes seguir al crear una variable...

• Sólo puede contener letras (mayúsculas o minúsculas), números o el carácter de subrayado _.
• Puede no empezar por un número.
• Puede que no sea una palabra clave (aprenderá sobre ellas más adelante).

Si no sigues estas reglas, obtendrás un error. Pruébelo usted mismo:

# No spaces are allowed in the variable
first string value = "First string"

  File "<ipython-input-1-2a2f77c0b400>", line 2
    first string value = "First string"
               ^
SyntaxError: invalid syntax

# Cannot start with a number
1st_string_value = "First String"

  File "<ipython-input-2-79b210888e10>", line 2
    1st_string_value = "First String"
                   ^
SyntaxError: invalid syntax

# Cannot be a keyword

True = "True"

  File "<ipython-input-3-5d4d2170e79c>", line 3
    True = "True"
                 ^
SyntaxError: can't assign to keyword

Ámbito variable

Ahora que ya sabes cómo inicializar una variable. Hablemos del alcance de estas variables. No se puede acceder a todas las variables desde cualquier parte de un programa. La parte de un programa en la que una variable es accesible se denomina ámbito. Existen cuatro tipos principales de ámbito variable y es la base de la norma LEGB. LEGB son las siglas en inglés de Local -> Enclosing -> Global -> Built-in.

Conozcamos mejor los ámbitos...

Ámbito local

Siempre que definas una variable dentro de una función, su ámbito se encuentra SOLO dentro de la función. Es accesible desde el momento en que se define hasta el final de la función y existe mientras la función se esté ejecutando(Fuente). Lo que significa que su valor no se puede cambiar o incluso acceder desde fuera de la función. Pongamos un ejemplo sencillo:

def print_number():
    first_num = 1
    # Print statement 1
    print("The first number defined is: ", first_num)

print_number()
# Print statement 2
print("The first number defined is: ", first_num)

The first number defined is:  1



---------------------------------------------------------------------------

NameError                                 Traceback (most recent call last)

<ipython-input-10-17d580e01222> in <module>
      6 print_number()
      7 # Print statement 2
----> 8 print("The first number defined is: ", first_num)


NameError: name 'first_num' is not defined

Pudimos imprimir la variable first_num llamando a la función print_number() (# Print statement 1). Pero al intentar acceder a la misma variable y luego imprimirla desde fuera de la función (# Print statement 2), se produjo un error NameError. Esto se debe a que first_num es "local" a la función - por lo tanto, no puede ser alcanzado desde fuera del cuerpo de la función.

Ámbito de aplicación

¿Qué ocurre si tenemos una función anidada (función definida dentro de otra función)? ¿Cómo cambia el ámbito de aplicación? Veámoslo con la ayuda de un ejemplo.

def outer():
    first_num = 1
    def inner():
        second_num = 2
        # Print statement 1 - Scope: Inner
        print("first_num from outer: ", first_num)
        # Print statement 2 - Scope: Inner
        print("second_num from inner: ", second_num)
    inner()
    # Print statement 3 - Scope: Outer
    print("second_num from inner: ", second_num)

outer()

first_num from outer:  1
second_num from inner:  2



---------------------------------------------------------------------------

NameError                                 Traceback (most recent call last)

<ipython-input-4-13943a1eb01e> in <module>
     11     print("second_num from inner: ", second_num)
     12
---> 13 outer()


<ipython-input-4-13943a1eb01e> in outer()
      9     inner()
     10     # Print statement 3 - Scope: Outer
---> 11     print("second_num from inner: ", second_num)
     12
     13 outer()


NameError: name 'second_num' is not defined

¿Hay algún error? Esto se debe a que no se puede acceder a second_num desde outer() (# Print statement 3). No se define dentro de esa función. Sin embargo, puede acceder a first_num desde inner() (# Print statement 1), porque el ámbito de first_num es mayor, está dentro de outer().
Las variables de Outer tienen un ámbito mayor y se puede acceder a ellas desde la función adjunta inner().

Ámbito mundial

Este es quizás el ámbito más fácil de entender. Siempre que una variable se define fuera de cualquier función, se convierte en una variable global, y su ámbito es cualquier lugar dentro del programa. Lo que significa que puede ser utilizado por cualquier función.

greeting = "Hello"

def greeting_world():
    world = "World"
    print(greeting, world)

def greeting_name(name):
    print(greeting, name)

greeting_world()
greeting_name("Samuel")

Hello World
Hello Samuel

Visor incorporado

Es el ámbito más amplio que existe. Todas las palabras clave especiales reservadas entran en este ámbito. Podemos llamar a las palabras clave en cualquier parte de nuestro programa sin tener que definirlas antes de utilizarlas.

Las palabras clave son simplemente palabras reservadas especiales. Se guardan para fines específicos y no se pueden utilizar para ningún otro propósito en el programa.
Estas son las palabras clave en Python:

Norma LEGB

LEGB (Local -> Enclosing -> Global -> Built-in) es la lógica que sigue un intérprete de Python cuando está ejecutando tu programa.

Digamos que estás llamando a print(x) dentro de inner(), que es una función anidada en outer(). Entonces Python buscará primero si "x" se definió localmente dentro de inner(). En caso contrario, se utilizará la variable definida en outer(). Esta es la función adjunta. Si tampoco se definió allí, el intérprete de Python subirá otro nivel - al ámbito global. Por encima de eso, sólo encontrarás el ámbito incorporado, que contiene variables especiales reservadas para el propio Python.

Hasta ahora, todo bien.

A continuación, volvamos a algunos ejemplos anteriores para ver si pueden crear problemas cuando el caso de uso se vuelve ligeramente más complejo.

Escenario 1: Ámbito mundial

¿Recuerdas la función greeting_world() de antes? Digamos que quieres poder cambiar la variable global greeting("Hola") para establecer un nuevo valor ("Hola") para el saludo, de forma que greeting_world() imprima "Hola Mundo"

greeting = "Hello"

def change_greeting(new_greeting):
    greeting = new_greeting

def greeting_world():
    world = "World"
    print(greeting, world)

change_greeting("Hi")
greeting_world()

Hello World

Bueno... ¡eso no salió como quería! ¿Por qué?

Esto se debe a que cuando establecimos el valor de greeting en "Hi", se creó una nueva variable local greeting en el ámbito de change_greeting(). No cambió nada para el global greeting. Aquí es donde la palabra clave global resulta útil.

Palabra clave global

Con global, le estás diciendo a Python que utilice la variable definida globalmente en lugar de crear una localmente. Para utilizar la palabra clave, basta con escribir "global", seguido del nombre de la variable. Veámoslo en acción en el Escenario 1.

greeting = "Hello"

def change_greeting(new_greeting):
    global greeting
    greeting = new_greeting

def greeting_world():
    world = "World"
    print(greeting, world)

change_greeting("Hi")
greeting_world()

Hi World

¡Funcionó! Pasemos al siguiente escenario...

Escenario 2: Ámbito de aplicación

Aquí, echamos un vistazo a las funciones anidadas outer() y inner() del ejemplo Enclosing Scope. Intentemos cambiar el valor de first_num de 1 a 0 desde inner().

def outer():
    first_num = 1
    def inner():
        first_num = 0
        second_num = 1
        print("inner - second_num is: ", second_num)
    inner()
    print("outer - first_num is: ", first_num)

outer()

inner - second_num is:  1
outer - first_num is:  1

No siempre es tan sencillo, ¿verdad? Para ello, utilizamos la palabra clave no local de Python.

Palabra clave no local

Esta es otra palabra clave útil que nos permite trabajar de forma más flexible y ordenada con ámbitos variables. La palabra clave no local es útil en funciones anidadas. Hace que la variable haga referencia a la variable vinculada previamente en el ámbito más cercano. En otras palabras, evitará que la variable intente enlazarse localmente primero, y la obligará a ir un nivel "más arriba". La sintaxis es similar a la de la palabra clave global.

def outer():
    first_num = 1
    def inner():
        nonlocal first_num
        first_num = 0
        second_num = 1
        print("inner - second_num is: ", second_num)
    inner()
    print("outer - first_num is: ", first_num)

outer()

inner - second_num is:  1
outer - first_num is:  0

¡Y ahí lo tienes!

Conclusión

Ahora ya sabes cuál es el ámbito de las variables en Python, la regla LEGB, y cómo debes usar las palabras clave globales y no locales. Podrás manipular fácilmente variables en funciones anidadas, sin ningún problema. Para aprender más sobre programación en Python, definitivamente deberías echar un vistazo al curso Intro to Python for Data Science de DataCamp. Se trata de un curso interactivo que cubre todos los aspectos básicos: desde variables y cálculos hasta listas, funciones y paquetes.