Saltar al contenido principal
InicioTutorialesPython

Alcance de las variables en Python

Aprende en qué consisten los visores variables y familiarízate con la regla "LEGB". También tratará escenarios en los que podrá ver en acción las palabras clave globales y no locales.
may 2024  · 9 min leer

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:

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.

Código de reglas LEGB Jerarquía de normas LEGB

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.

Temas

Más información sobre Python

Course

Introduction to Python

4 hr
5.5M
Master the basics of data analysis with Python in just four hours. This online course will introduce the Python interface and explore popular packages.
See DetailsRight Arrow
Start Course
Ver másRight Arrow
Relacionado

blog

Cómo aprender Python desde cero en 2024: Guía del experto

Descubre cómo aprender Python, sus aplicaciones y la demanda de conocimientos de Python. Comienza hoy tu andadura en Python ​con nuestra guía completa.
Matt Crabtree's photo

Matt Crabtree

19 min

tutorial

Tutorial de funciones de Python

Un tutorial sobre funciones en Python que cubre cómo escribir funciones, cómo invocarlas y mucho más.
Karlijn Willems's photo

Karlijn Willems

14 min

tutorial

Tutorial de Iteradores y Generadores de Python

Explore la diferencia entre Iteradores y Generadores de Python y aprenda cuáles son los mejores para usar en diversas situaciones.
Kurtis Pykes 's photo

Kurtis Pykes

10 min

tutorial

Tutorial de Python sobre conjuntos y teoría de conjuntos

Aprende sobre los conjuntos en Python: qué son, cómo crearlos, cuándo usarlos, funciones incorporadas y su relación con las operaciones de la teoría de conjuntos.
DataCamp Team's photo

DataCamp Team

13 min

tutorial

Programación orientada a objetos (POO) en Python: Tutorial

Aborda los fundamentos de la Programación Orientada a Objetos (POO) en Python: explora las clases, los objetos, los métodos de instancia, los atributos y ¡mucho más!
Théo Vanderheyden's photo

Théo Vanderheyden

12 min

tutorial

Tutorial de comprensión del diccionario Python

¡Aprende todo sobre la comprensión de diccionarios en Python: cómo puedes utilizarla para crear diccionarios, para sustituir los for loops (anidados) o las funciones lambda por map(), filter() y reduce(), ...!
Sejal Jaiswal's photo

Sejal Jaiswal

14 min

See MoreSee More