Cursos Empresas Blog Live Conf Eventos Precios

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:

my_var = 5

id(my_var) # 4561204416
id(5) # 4561204416

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-in function 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 = 10

def some_function():
     global some_var_in_other_scope
     
     Some_var_in_other_scope += 1

Names y Namespaces en Python: Conceptos Fundamentales

Curso Práctico de Python: Creación de un CRUD

Clase 37 de 49

Clase 37 / 49

Comentarios (33)33 comentarios

Victor Jaramillo

Hace 8 años

Rhonal Velasco

Buen aporte

Daniel Medina

Gracias por el aporte

Mario Barbero Santillán

Jesus Adolfo Osorio Ziga

Gracias por el aporte.

Neiro Rafael Vilchez Da Silva

Gracias, bien grafico.

Ingrid Natalia Rodriguez Ovalle

Hace 7 años

Acá otra explicación con ejemplos: https://www.programiz.com/python-programming/namespace

Andres Felipe Leal Mora

Genial, gracias por los aportes!!

Sergio Abel Gordon Dolimpio

buen aporte, mucho mas claro

Miguel Torres

Hace 6 años

Para complementar pueden checar esta clase en video del Curso de Introducción al Pensamiento Computacional con Python: https://platzi.com/clases/1764-python-cs/25241-scope-o-alcance/

Mauricio Gonzalez Falcon

Hace 5 años

Gracias!

Luis Mercado

Deben corregir como se muestra el codigo, se ve muy desorganizado y algunas palabras juntas.

Néstor Iván Cepeda Munevar

Estaba pensando exactamente lo mismo.

defouter_function(some_local_name):

No se percibe el espacio despues de “def”.

Kevin Lozoya Giner

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 LOCAL ANIDADO
a = 10 <------ La variable a se encuentra en el namespace GLOBAL```

Ismael Fajardo Plaza

¿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'?

Ana Lima

¡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.

Pablo .

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)

Vayan haciendo sus modificaciones para ir comprendiendo el comportamiento. Es interesante usar id(spam). https://docs.python.org/3/tutorial/classes.html

Francisco Garcia [C6]

Gracias por el tip

Miguel Angel Reyes Moreno

¿A alguien más le recuerda al scope de JavaScript?

Wilson Fernando Antury Torres

"nonlocal": Se usa para obtener el scope en funciones con funciones anidadas. "Global": Se usa para tener el scope del módulo.

José Emanuel Castelán Cortés

Igualmente me sale desordenado el código 😦

Facundo Nicolás García Martoni

Profesor

¡Hola @ingkstr! ¿Podrías compartirme una captura de pantalla? 🤔

Marcelo Sánchez

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 = 10 
c = 10

def echo(value):
	return value


def outer_function(some_local_name):
	def inner_function(other_local_name):
		# Tiene acceso a la built-in function 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 += 1


def outer_function_2():
    global c
    c = 20
    def inner_function():
        global c
        c = 30
        print('c =',c)

    inner_function()
    print('c =',c)


if __name__  == '__main__':
	a = echo
	a = a('Billy') # 3
	print(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)```

Lucas Ezequiel Veliz

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.

Jesús Maximiliano Manchuk

complementa la información dada. (Está en ingles)

alvamar zapata

gracias!

Carlos Enrique Ramírez Flores

Excelente la explicación, y creo que es parte de lo que vamos a estar usando en nuestro día a día!

Wilson Delgado

Scope parte del programa desde donde los namespaces pueden ser accedidos

Orlando Ramirez

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.

Nicolas Alpargatero

Hace 3 años

Creo que ya habíamos visto este tema antes, pero bueno, me imagino que es para entender mejor los módulos.

Cesar Hernández Ramírez

global nos permite acceder a variables del módulo, desde cualquier parte del código

Names y Namespaces en Python: Conceptos Fundamentales

Progreso del curso

Básicos del Lenguaje

Uso de strings y ciclos

Estructuras de Datos

Uso de objetos y módulos

Python en el mundo real

Conclusiones finales

Clases bonus