Names y Namespaces en Python: Conceptos Fundamentales
En Python, un name, también conocido como identifier, es simplemente una forma de otorgarle un nombre a un objeto. Mediante el nombre, podemos acceder al objeto. Vamos a ver un ejemplo:
En este caso, el identifier my_var es simplemente una forma de acceder a un objeto en memoria (en este caso el espacio identificado por el número 4561204416). Es importante recordar que un name puede referirse a cualquier tipo de objeto (aún las funciones).
def echo(value):return value
a = echo
a(‘Billy’) # 3
Ahora que ya entendimos qué es un name podemos avanzar a los namespaces (espacios de nombres). Para ponerlo en palabras llanas, un namespace es simplemente un conjunto de names.
En Python, te puedes imaginar que existe una relación que liga a los nombres definidos con sus respectivos objetos (como un diccionario). Pueden coexistir varios namespaces en un momento dado, pero se encuentran completamente aislados. Por ejemplo, existe un namespace específico que agrupa todas las variables globales (por eso puedes utilizar varias funciones sin tener que importar los módulos correspondientes) y cada vez que declaramos una módulo o una función, dicho módulo o función tiene asignado otro namespace.
A pesar de existir una multiplicidad de namespaces, no siempre tenemos acceso a todos ellos desde un punto específico en nuestro programa. Es aquí donde el concepto de scope (campo de aplicación) entra en juego.
Scope es la parte del programa en el que podemos tener acceso a un namespace sin necesidad de prefijos.
En cualquier momento determinado, el programa tiene acceso a tres scopes:
El scope dentro de una función (que tiene nombres locales)
El scope del módulo (que tiene nombres globales)
El scope raíz (que tiene los built-in names)
Cuando se solicita un objeto, Python busca primero el nombre en el scope local, luego en el global, y por último, en el raíz. Cuando anidamos una función dentro de otra función, su scope también queda anidado dentro del scope de la función padre.
def outer_function(some_local_name): def inner_function(other_local_name): # Tiene acceso a la built-infunction print y al nombre local some_local_name
print(some_local_name) # También tiene acceso a su scope local
print(other_local_name)
Para poder manipular una variable que se encuentra fuera del scope local podemos utilizar los keywords global y nonlocal.
some_var_in_other_scope =10def some_function(): global some_var_in_other_scope
Some_var_in_other_scope+=1
En Python, la palabra clave global permite modificar la variable fuera del alcance actual. Se utiliza para crear una variable global y realizar cambios en la variable en un contexto local.
Reglas de palabra clave global
Las reglas básicas para la palabra clave global en Python son:
Cuando creamos una variable dentro de una función, es local por defecto.
Cuando definimos una variable fuera de una función, es global por defecto. No tienes que usar la palabra clave global.
Utilizamos la palabra clave global para leer y escribir una variable global dentro de una función.
El uso de global fuera de una función no tiene efecto
En lo referente a la palabra nonlocal, actúa de manera similar, solo que orientada a lo que sería un alcance de funciones y funciones anidadas, a continuación un ejemplo:
def method(): def method2(): # este método no tiene acceso a la
# variable value, por cuanto se usa
# nonlocal para poder acceder.nonlocal value
value =100 # Variable local.value=10method2()
Deben corregir como se muestra el codigo, se ve muy desorganizado y algunas palabras juntas.
Estaba pensando exactamente lo mismo.
defouter_function(some_local_name):
No se percibe el espacio despues de “def”.
Si después de las primeras `` ` al editar pones python se soluciona (```python)
def outer_function(some_local_name):
def outer_function(): b =20<------La variable b se encuentra en el namespace LOCAL def inner_func(): c =30<------La variable c se encuentra en el namespace LOCALANIDADOa =10<------La variable a se encuentra en el namespace GLOBAL```
¿Entiendo entonces que 'global' permite a una función, en cualquier nivel, acceder a variables que han sido declaradas en el scope global y, por otro lado, 'nonlocal' le permite a una función anidada ingresar a la variable que se encuentra al igual que ella dentro de determinada función, cierto? Si es así, ¿cuantos niveles puede escalar 'nonlocal'?
¡Hola Ismael! Pareciera que no tiene un limite de niveles para usar, pero no es lo recomendable, te recomiendo que declares global y no nonlocal en cada método en que vayas a usar.
Un ejemplo de esto pueden encontrarlo en la documentación:
def scope_test(): def do_local(): spam ="local spam" def do_nonlocal(): nonlocal spam
spam ="nonlocal spam" def do_global(): global spam
spam ="global spam" spam ="test spam"do_local()print("After local assignment:", spam)do_nonlocal()print("After nonlocal assignment:", spam)do_global()print("After global assignment:", spam)scope_test()print("In global scope:", spam)
¿A alguien más le recuerda al scope de JavaScript?
"nonlocal": Se usa para obtener el scope en funciones con funciones anidadas.
"Global": Se usa para tener el scope del módulo.
Igualmente me sale desordenado el código 😦
¡Hola @ingkstr! ¿Podrías compartirme una captura de pantalla? 🤔
Tengo un duda en el codigo
global some_var_in_other_scope
Some_var_in_other_scope+=1
En este caso no se está modificando la variable "some_var_in_other_scope = 10", ya que una comienza con mayúsculas y la otra no.
some_var_in_other_scope =10c =10def echo(value):return value
def outer_function(some_local_name): def inner_function(other_local_name): # Tiene acceso a la built-infunction print y al nombre local some_local_name
print(some_local_name) # También tiene acceso a su scope local
print(other_local_name)def some_function(): global some_var_in_other_scope
some_var_in_other_scope +=1def outer_function_2(): global c
c =20 def inner_function(): global c
c =30print('c =',c)inner_function()print('c =',c)if __name__ =='__main__': a = echo
a =a('Billy') # 3print(a) b = outer_function
print(b(some_var_in_other_scope))some_function()print(some_var_in_other_scope)outer_function_2()print('c =',c)```
name o identifier es el nombre que hace referencia a una variable y su contenido en memoria.
scope es el alcance que un objeto tiene para ser llamado.
los keywords global y nonlocal permiten tener acceso a variables que no esten declaradas en el scope local, pero si dentro del módulo.
complementa la información dada. (Está en ingles)
gracias!
Excelente la explicación, y creo que es parte de lo que vamos a estar usando en nuestro día a día!
Scope parte del programa desde donde los namespaces pueden ser accedidos
Es importante saber que cuando usas global dentro de la función estas tomando ese valor global de la variable, y si le realizas cambios estos afectaran a la variable global también.
Por otro lado nonlocal se utiliza sobretodo con funciones anidadas o nested functions, toma una variable definida dentro de la función, la utiliza y si se realizan cambios dentro de la segunda función esta solo afectará a la variable de la función una vez finalizada ya no estará el valor.
Creo que ya habíamos visto este tema antes, pero bueno, me imagino que es para entender mejor los módulos.
global nos permite acceder a variables del módulo, desde cualquier parte del código
![Francisco Garcia [C6]](https://static.platzi.com/media/avatars/avatars/garciafran_c845c2fe-2ea4-42db-a305-a7f4ef13b0fd.jpeg){kind=small}
