Entendiendo el Scope en Python: Variables y Funciones

Clase 14 de 44 • Curso de Python: Comprehensions, Funciones y Manejo de Errores

Resumen

¿Qué es el scope en programación?

Imagina un mundo donde cada elemento tiene su propia habitación, y solo es accesible dentro de esa habitación. Esa es la esencia del concepto de scope o alcance en programación. Tener un buen manejo del scope es vital para evitar errores y lograr un código más limpio y eficiente. Este concepto dicta dónde y cómo puedes utilizar una variable o, incluso, una función. Es un principio fundamental al momento de desarrollar proyectos en cualquier lenguaje de programación.

¿Cómo se define el scope?

El scope se clasifica en diferentes tipos:

Local scope: Este es el alcance que se le da a una variable dentro de un bloque específico, como una función. Solo puede ser utilizada en ese contexto particular.
Enclosing scope: Es el contexto que engloba al local. Por ejemplo, una función dentro de otra.
Global scope: Variables que se pueden acceder desde cualquier parte del programa, fuera o dentro de funciones u otros bloques.
Built-in scope: El alcance más amplio; estos son los elementos integrados en el lenguaje de programación mismo (como funciones integradas).

¿Cómo aplicar el scope en el código?

Veamos cómo se traduce este concepto en código Python:

# Variable de alcance global
prides = 100

def aumentar_precio():
    # Variable de alcance local
    price = 200
    result = price + 10
    return result

print(prides)  # Accede a la variable global
resultado_local = aumentar_precio()  # Usa la variable local dentro de la función

# Al ejecutar el código
# Salida: 100 y luego 210 a través de resultado_local

En este ejemplo, prides es una variable global, y price es una variable local dentro de la función aumentar_precio. Ambas tienen el mismo nombre pero residen en diferentes contextos y no interfieren entre sí.

Errores comunes al manejar el scope

Uno de los errores más frecuentes al trabajar con scope es intentar acceder a una variable local fuera de su contexto, lo cual genera un error de NameError. Esto sucede porque esa variable no tiene un valor asignado en el ámbito desde el que se intenta acceder.

Otro error típico es la confusión entre variables globales y locales. Aunque tengan el mismo nombre, no son intercambiables. Las actualizaciones hechas a una variable local no afectarán a la variable global.

def muestra_error():
    # Intenta usar una variable local fuera de su contexto
    print(result)  # Error: NameError, ya que 'result' solo existe dentro de la función

muestra_error()

Prueba y error: clave para entender el scope

A medida que aumentes tu práctica, te encontrarás con situaciones donde el manejo del scope se convierte en un reto. Sin embargo, cada error es una oportunidad de aprendizaje; cada error detectado se convertirá en una lección valiosa.

Practica regularmente estos conceptos para mejorar tu entendimiento y manejo de variables en diferentes contextos. Así, lograrás dominar el arte del scope, creando código eficiente y prevenido de errores. ¡Sigue adelante y sigue aprendiendo!

Ingrid Tatiana Barrios Villamizar

student•

Creo que esto te puede ayudar a entender mejor: Dentro de una función puede haber variables, las cuales se llaman variables locales. Estas variables locales, se identifican porque están escritas dentro de la definición de la función; y únicamente funcionan mientras que la función sea llamada o utilizada. Si vas a llamar a una variable local por fuera de la función, no servirá. Y existen variables globales, que son las que están escritas fuera de una función. Estas variables si funcionan al ser llamadas sin la función, porque no están determinadas dentro de la función.

Jhins Ledys Cárdenas Pardo

student•

Exactamente. Creo que las palabras usadas no son las adecuadas y se presta para confusiones. De manera simple se entiende que las variables se pueden definir como globales, es decir, fuera de las funciones y locales, es decir, que solo son creadas dentro de esa función especifica y si es llamada fuera de ese bloque de codigo (me refiero a la variable local), pues no dara resultado porque simplemente no existe.

Daniel Carmona

student•

Gracias por el aporte

Camilo Enrique Mejia

student•

SCOPE

Scope o Alcance, es cuando una variable solo esta disponible desde donde fue construida y para ello existen dos ambitos, el local y el global.

Scope Local

Cuando una variable es construida dentro de una función pertenece al ámbito local de esa función y solo se puede usar dentro de esa función.

def incrementar():
  x = 150
  print(x)

incrementar()

_Produccion:_
150

En este ejemplo el valor a incrementar esta dentro de la función siendo invocada por x = 150 y su resultado será 150 a esto se le llama ámbito local

_Scope Global

A diferencia del Scope Local, el Scope Global esta creada en la parte externa de la función y esta puede ser utilizada tanto de manera global como local.

y = 150
def incrementar_2():
  print(y)

print(y)

_Producción:_
150

En este caso mi valor y = 150 esta en la parte externa de la función y es invocada por la función para mostrar su resultado.

Ahora si tenemos dos variables una global y la otra local con el mismo nombre de variable, Python lo que hará es tomar los dos variables por separado siendo una de tipo global (fuera de la función) y la otra de tipo local (dentro de la función)

y = 150
def incrementar_2():
  y = 300
  print(y)

incrementar_2()
print(y)

_Producción:_
300
150

En este caso observamos que el ámbito global tiene 'y = 150' y el ámbito local tiene 'y = 300', en donde al imprimir el resultado mostrara primero el ámbito local 300 y luego mostrará el resultado del ámbito global 150

Truco

Si dentro de una variable global que fue creada esta dentro de un ámbito local, podemos utilizar global para que la variable se vuelva de ámbito global dentro de la función.

def incrementar_3():
  global x
  x = 250
  
incrementar_3()
print(x)

_Producción:_
250

También podemos utilizar nuestra palabra global dentro de una función para remplazar un valor de tipo local a uno global de la siguiente manera:

y = 150
def incrementar_2():
  global y
  y = 300

incrementar_2()
print(y)

_Producción:_
300

Sara María Mejia Sánchez

student•

Excelente resumen de la clase 💚

Juan R. Vergara M.

student•

Gran resumen amigo.

Oliver Asero

student•

Me esta gustando mucho el curso, son cosas ''basicas'' pero realmente importantes.

Diego Jurado

student•

Si estamos en lo básico, significa que aún me esta faltando mucho estudio!

Juan R. Vergara M.

student•

Así es, vale la pena aprender las bases.

Zahira Rosales

student•

Jeinfferson Bernal G

student•

Gracias por el aporte!

Erick Alay

student•

Una regla de oro:

Una variable solo esta disponible dentro de la región donde fue creada

Local Scope

Es la región que corresponde el ámbito de una función, donde podremos tener una o mas variables, estas van a ser accesibles solo en este bloque de código y no serán visibles para otros bloques o regiones.

Global Scope

Al escribir una o mas variables en esta región, estas podrán ser accesibles desde cualquier parte del código, incluido dentro de funciones.

Juan R. Vergara M.

student•

👍✔

Eduardo Monzón

student•

Buen resumen

María Herlandia Copete Perea

student•

El scope hace referencia al alcance de las variables en el programa. Así pues, una variable está disponible solo en la región en la que se crea.

Local scope. Este tipo de alcance lo tienen las variables declaradas al interior de una estructura, como una función, y pueden ser empleadas únicamente al interior de la misma.
Enclosing Scope. También conocido como Non-local Scope, se refiere a variables definidas en funciones anidadas; estas variables no son locales pero tampoco globales.
Global scope. Variables creadas en el cuerpo principal del código de Python y que pueden ser accedidas desde cualquier scope, global o local.
Built-in scope. Cuando una variable no se encuentra en ninguno de los scope anteriores, Python empieza a buscar en el built-in scope, el cual cubre todas las palabras reservadas del lenguaje. Pueden ser llamadas en cualquier lugar sin necesidad de ser definidas:

Es importante resaltar que si se da el mismo nombre a variables dentro y fuera de una función, Python reconocerá dichas variables como 2 variables diferentes como scope diferenciado: uno global y otro local:

price = 100 # Global

def increment():
  # price = price + 10 # UnboundLocalError: local variable 'price' referenced before assignment

  price = 200 # Local

  price = price + 10
  
  return price

price_2 = increment()
print(price_2) # 210
print(price) # 100

Reinaldo Mendoza

student•

Si se retornan varios valores y queremos ignorar alguno que no vayamos a usar con _

val1, _, val3 = funReturn3Values()

Antonio Demarco Bonino

student•

La verdad es que es un concepto complejo de entender pero con el tiempo se va comprendiendo mejor. Se usa MUCHO en el backend y es usado en Ciencias de Datos. Pretendo darle mucho protagonismo en mi futura caja de herramientas de pythonista:

prince = 100 # global

def scope():
  prince = 200 # funcion
  prince += 10
  return prince


print(prince) # global
prince_2 = scope()
print(prince_2) # funcion

Samuel Molina

student•

Tengo 19 años, me duele la cabeza, pero aqui sigo intentando aprender, ya termine el de fundamentos de python y tengo el certificado, voy a por este

Alexandra Gabriela

student•

Yo también tengo 19 y también me duele la cabeza ^^ We can do this.

Diego Alejandro Pinto Moreno

student•

En el mismo barco

Leonardo Medina

student•

Un video para complementar la clase: https://www.youtube.com/watch?v=nKefMgHBNh0

Jefferson Osorio Lozano

student•

Cuando necesitamos hacer un llamado de una variable global dentro del entorno local como lo es el de la función, la palabra global antes del nombre de la funcion, resuelve el "UnboundLocalError":

price = 200 #Variable global

def increment():
    global price #Llama la funcion Global
    print(price)
    price = price + 30
    print(type(price))
    
increment()

Edward Alexis Vásquez Becerra

student•

Buen aporte, gracias

Nestor Jesus Rodriguez Rodriguez

student•

Si me di cuenta que en algunos ejercicios aparece ese error, pero en otros no, aún cuando son similares 🤔 Gracias por la solución :thumbsup:

Camilo Santana

student•

Entonces no se pueden modificar variables del scope global estando dentro de una función? Es decir, tener un 'side effect'?

Luis Lagardera

student•

Hola Alejandro, te lo explico según lo entendí. Para hacer eso deberías declarar la variable dentro de la función como global, para que tenga el side effect que estas requiriendo. De lo contrario no permite la modificación fuera del scope.

Mario Hidalgo

student•

Aquí está la respuesta a tu pregunta: https://www.w3schools.com/python/python_scope.asp#:~:text=Try%20it%20Yourself%20%C2%BB-,Global%20Keyword,-If%20you%20need

Jonatan Martin

student•

Muy buena la clase y los aportes son excelente, para variar un poco, este es mi aporte:

Local Scope

Son todas la variables, tuplas, lista, diccionarios, etc. Que están dentro de una función y solo se pueden trabajar con ellas en esa misma función. Si tratamos de llamar una variable de una función fuera de la misma nos dará error porque solo existe en el contexto de la función.

Gobla Scope

Son todas la variables, tuplas, lista, diccionarios, etc. Que están fuera de una función y con las cuales se pueden llamar y trabajar desde cualquier parte del código sin problema.

Nota Importante

La programación es como leer un libro, se inicia de arriba hacia abajo y de izquierda a derecha. Es decir, si tenemos una función que trabaja con una variable global scope pero la función ha sido declarada antes de la variable nos dará un error. Por ejemplo:

def level_up_damage(damage):
    return damage + 5

damage = 10 # global scope

print(level_up_damage())

Aqui tenemos una variable global scope llamada damage, que tiene un valor de 10. Tenemos una función llamada level_up_damage que suma 5 puntos a damage; Aunque damage es una global scope y se puede usar en cualquier función, se debe declarar primero antes de usarla sino nos dará este error:

 File "D:\Document\pythonZen\13_scope.py", line 26, in <module>
    print(level_up_damage())
          ^^^^^^^^^^^^^^^^^
  File "D:\Document\pythonZen\13_scope.py", line 24, in level_up_damage
    return damage + 5
           ^^^^^^
NameError: name 'damage' is not defined

NameError: name 'damage' is not defined ¿Porqué ocurre esto? Por lo mencionado anteriormente que la programación es como un libro.

Ahora bien, de lo siguiente que voy a aportar es que hay lenguajes como js en los cuales puedes hacer el codigo y luego si declaras las variables sin problemas, no estoy seguro pero supongo que es así. Pero en Python no funciona, sino declaras primero las cosas no funcionan.

David Rangel

student•

Una forma que puede ayudar a reforzar este contexto es usando la función id(), esta función les permite saber en qué parte de la memoria se almacena cada variable.

Corriendo este código podrán ver que están almacenadas las variables en sitios distintos aunque compartan el nombre:

price = 100 # alcance global

def increment():
    # aqui estas una nueva variable dentro del contexto que se llama price 
    price = 10
    # pero ahora price tiene un contexto local
    print(price)
    print(f'aqui esta almacenado el price local {id(price)}')
    

print(price)
print(f'esto es donde esta almacenado el price global {id(price)}')

increment()

Alejandro Bahamon

student•

Hice este este esquema para entender los scope que no sólo son aplicables a funciones sino también a bloques de código con condicionales o ciclos

Piero Blanco

student•

La diferencia principal entre return y print en Python es su propósito y cómo afectan a la ejecución del programa.

return en una Función:

Propósito: La declaración return se utiliza en una función para devolver un valor calculado por esa función. Puede devolver un solo valor o una tupla de valores.
Efecto en la Ejecución: Cuando se encuentra una declaración return en una función, la función termina su ejecución inmediatamente y devuelve el valor especificado. El valor puede ser asignado a una variable cuando se llama a la función.
```
def suma(a, b):
    resultado = a + b
    return resultado

total = suma(3, 4)
print(total)  # Imprime 7
```
Accesibilidad del Valor: Puedes usar el valor devuelto por una función para realizar operaciones adicionales o para almacenarlo en una variable.

print en Python:

Propósito: La función print se utiliza para mostrar información en la consola. No devuelve un valor que pueda ser utilizado por otras partes del programa.
Efecto en la Ejecución: La función print imprime el valor o los valores proporcionados en la consola, pero no afecta el flujo de ejecución del programa.
```
def saludar(nombre):
    print("Hola, " + nombre)

saludar("Juan")  # Imprime "Hola, Juan"
```
Accesibilidad del Valor: print no proporciona un valor que pueda ser utilizado posteriormente en el programa. Simplemente muestra información en la consola.

Ejemplo de Distinción:

def cuadrado(x):
    return x**2

def cuadrado_e_imprimir(y):
    print(y**2)

resultado1 = cuadrado(5)
print(resultado1)  # Imprime 25

resultado2 = cuadrado_e_imprimir(5)
print(resultado2)  # Imprime None (el valor devuelto por la función print)

En este ejemplo, cuadrado devuelve un valor que puede ser utilizado en el programa, mientras que cuadrado_e_imprimir simplemente imprime el resultado en la consola pero no devuelve un valor útil. La variable resultado2 contiene None, ya que la función print no devuelve un valor utilizable.

En resumen, return se utiliza para devolver un valor desde una función y afecta el flujo de ejecución, mientras que print se utiliza para mostrar información en la consola y no devuelve un valor que pueda ser utilizado por otras partes del programa.

Piero Blanco

student•

En Python, el término "scope" (alcance) se refiere a la región de un programa en la cual una variable es válida y accesible. En otras palabras, el alcance de una variable determina dónde puede ser utilizada en el código. Python tiene dos tipos principales de alcance: el alcance local y el alcance global.

Alcance Local:
- Un alcance local se refiere al área dentro de una función donde una variable es válida.
- Las variables definidas dentro de una función tienen un alcance local y solo pueden ser utilizadas dentro de esa función.
- Cuando la función se ejecuta, se crea su propio espacio de nombres local, y las variables definidas dentro de esa función son visibles solo en ese ámbito.
```
def ejemplo():
    x = 10  # x tiene alcance local
    print(x)

ejemplo()
# print(x)  # Esto generaría un error, ya que x no es visible fuera de la función
```
Alcance Global:
- Un alcance global se refiere al área fuera de cualquier función o bloque, donde una variable es válida.
- Las variables definidas fuera de las funciones o bloques tienen alcance global y son accesibles desde cualquier parte del código.
- Si una variable se declara fuera de cualquier función, es global y puede ser utilizada tanto dentro como fuera de funciones.
```
y = 20  # y tiene alcance global

def ejemplo():
    print(y)  # y es visible dentro de la función

ejemplo()
print(y)  # y es visible fuera de la función
```
Reglas de Alcance (LEGB):
- En Python, la búsqueda de una variable sigue el principio LEGB:
  - Local (L): Busca primero en el alcance local, es decir, dentro de la función actual.
  - Enclosing (E): Luego busca en alcances que engloban la función actual, si la función está anidada en otras funciones.
  - Global (G): Después busca en el alcance global, fuera de cualquier función.
  - Built-in (B): Finalmente, busca en el alcance incorporado, que son nombres predefinidos en Python.
```
x = 10  # Alcance global

def exterior():
    y = 20  # Alcance local
    
    def interior():
        z = 30  # Alcance local
        print(x, y, z)

    interior()

exterior()
```
En este ejemplo, interior tiene acceso a las variables en su alcance local, así como a las variables en el alcance de funciones que lo envuelven (exterior y alcance global).

Palabra Clave global:

Si necesitas modificar una variable global desde dentro de una función, puedes usar la palabra clave global.

global_variable = 50

def modificar_global():
    global global_variable
    global_variable = 100

print(global_variable)  # Imprime 50
modificar_global()
print(global_variable)  # Imprime 100

Entender el alcance en Python es crucial para evitar errores y para escribir código más claro y modular. Además, el manejo adecuado de los ámbitos contribuye a la legibilidad y mantenimiento del código.

Daniel Dobles

student•

El "scope" o ámbito se refiere a la región o contexto en el que una variable o nombre es válido y tiene significado dentro de un programa. En Python, como en muchos otros lenguajes de programación, se definen varios niveles de ámbito que determinan dónde una variable o función puede ser utilizada. Los dos ámbitos principales en Python son:

Ámbito Local (Local Scope): Este es el ámbito más interno y se refiere a las variables o nombres que están definidos dentro de una función. Las variables locales solo son accesibles dentro de esa función y no son visibles fuera de ella. Una vez que la función termina su ejecución, las variables locales desaparecen.
```
pythonCopy code
def funcion():
    x = 10  # Variable local
    print(x)

funcion()
print(x)  # Generará un error, ya que x no es accesible aquí
```
Ámbito Global (Global Scope): Este es el ámbito exterior a todas las funciones y se refiere a las variables o nombres que están definidos fuera de todas las funciones. Las variables globales son accesibles desde cualquier lugar del programa, tanto dentro como fuera de las funciones.
```
pythonCopy code
x = 10  # Variable global

def funcion():
    print(x)  # La variable global x es accesible aquí

funcion()
print(x)  # También es accesible fuera de la función
```

Las variables locales son visibles solo dentro de la función en la que están definidas. No pueden ser accedidas desde fuera de esa función.
Las variables globales son visibles desde cualquier lugar del programa, incluyendo dentro de funciones.

Es importante tener en cuenta que si tienes una variable local en una función con el mismo nombre que una variable global, la variable local tendrá prioridad dentro de la función y ocultará la variable global. Sin embargo, si deseas modificar una variable global desde dentro de una función, debes declararla como "global" dentro de la función para indicar que estás trabajando con la variable global y no creando una nueva variable local con el mismo nombre.

pythonCopy code
x = 10  # Variable global

def modificar_global():
    global x  # Declarando x como global
    x = 20  # Modifica la variable global x

modificar_global()
print(x)  # Imprimirá 20, ya que la variable global x fue modificada

El uso adecuado de los ámbitos es fundamental para evitar confusiones y errores en tu código, y te permite controlar la visibilidad y el alcance de las variables en tus programas.

Victoriano Arteaga González

student•

El scope o alcance en Python se refiere a la visibilidad y disponibilidad de las variables y objetos en diferentes partes del código. Existen dos tipos principales de scope en Python:

Scope global: las variables definidas a nivel de módulo, fuera de cualquier función, son globales y están disponibles y visibles en todo el código. Scope local: las variables definidas dentro de una función solo están disponibles y visibles dentro de esa función. Se llaman variables locales. Python aplica las siguientes reglas de resolución de nombres:

LEGB: Busca nombres en este orden: Local (función) Enclosing (externo) Global (módulo) Built-in (integrado) Las variables globales pueden ser leídas desde cualquier parte pero si se modifican dentro de una función se crea una variable local. Para modificar una global dentro de una función se usa la palabra global. Los closures recuerdan valores de variables de scopes anteriores incluso cuando se llaman fuera de ese scope. La palabra nonlocal permite asignar a variables en un scope externo pero no global. Los módulos permiten dividir las globales en múltiples archivos. Se usan imports para acceder a globales de otros módulos. En resumen, el scope en Python está determinado por bloques de código y sangría. Entender la regla LEGB y técnicas como global, nonlocal y closures ayuda a manejar el acceso a variables.

Flavia Almaraz Ramallo

student•

A mi parecer, ésta clase está súper mal explicada, me he sido un lío el seguirla y he tenido que buscar información fuera

Daniel Dobles

student•

Hola Flavia, que mal, oye a mi parecer no está mal explicada. Mira solo hay dos scope hasta ahora que hemos visto los cursos, el "Global" que está fuera de funciones específicas y el "Local" que pertenece a un contexto definido. Imagínate entonces el código como una estructura de bloques, con capas, cada bloque con capa tiene sus propios términos, pero al final todos forman una pieza como una muñeca matroska. También lo puedes ver como una nación, si tu nación está bien estructurada y no es corrupta va a funcionar así sería tu código también.