TechCodeview

En este tutorial, aprenderemos sobre el espacio de nombres en Python, la estructura utilizada para organizar los nombres simbólicos asignados a los objetos en un programa Python, por qué el espacio de nombres es importante y cómo podemos usarlos en nuestro programa Python. Hagamos una breve introducción a un espacio de nombres.

¿Qué es el espacio de nombres?

En Python, una forma de darle a cada objeto un nombre único es a través de un espacio de nombres. Las variables y los métodos son ejemplos de objetos en Python. Para decirlo de otra manera, es una colección de nombres simbólicos conocidos y los detalles sobre aquello a lo que se refiere cada nombre. Se puede considerar un nombre como una clave en un diccionario y los objetos son los valores en un espacio de nombres. Deberíamos resolverlo con un modelo genuino: un espacio de nombres se parece a un apellido. Si hay varios nombres de 'Peter' en la clase, puede resultar difícil localizar un nombre de 'Peter'; sin embargo, cuando solicitamos específicamente 'Peter Warner' o 'Peter Cummins', en una clase, puede que no sea común que varios estudiantes tengan el mismo nombre y apellido.

El intérprete de Python puede comprender mejor el método o variable exacto en el código gracias al espacio de nombres. Como resultado, su nombre contiene información adicional, incluido el espacio (relacionado con el alcance) y el nombre, que denota un identificador único.

En Python, existen cuatro tipos de espacios de nombres que se detallan a continuación.

• Incorporado
• Global
• encerrando
• Local

Como estos espacios de nombres tienen una vida útil, el intérprete de Python crea espacios de nombres según sea necesario y los elimina cuando ya no son necesarios.

bucle for en java

Comprendamos los distintos tipos de espacios de nombres en Python.

El espacio de nombres incorporado

Como sugiere su nombre, contiene nombres predefinidos de todos los objetos integrados de Python que ya están disponibles en Python. Enumeremos estos nombres con el siguiente comando.

Abra la terminal Python y escriba el siguiente comando.

Dominio -

 dir(__builtins__) 

Producción:

 ['ArithmeticError', 'AssertionError', 'AttributeError', 'BaseException', 'BlockingIOError', 'BrokenPipeError', 'BufferError', 'BytesWarning', 'ChildProcessError', 'ConnectionAbortedError', 'ConnectionError', 'ConnectionRefusedError', 'ConnectionResetError', 'DeprecationWarning', 'EOFError', 'Ellipsis', 'EnvironmentError', 'Exception', 'False', 'FileExistsError', 'FileNotFoundError', 'FloatingPointError', 'FutureWarning', 'GeneratorExit', 'IOError', 'ImportError', 'ImportWarning', 'IndentationError', 'IndexError', 'InterruptedError', 'IsADirectoryError', 'KeyError', 'KeyboardInterrupt', 'LookupError', 'MemoryError', 'ModuleNotFoundError', 'NameError', 'None', 'NotADirectoryError', 'NotImplemented', 'NotImplementedError', 'OSError', 'OverflowError', 'PendingDeprecationWarning', 'PermissionError', 'ProcessLookupError', 'RecursionError', 'ReferenceError', 'ResourceWarning', 'RuntimeError', 'RuntimeWarning', 'StopAsyncIteration', 'StopIteration', 'SyntaxError', 'SyntaxWarning', 'SystemError', 'SystemExit', 'TabError', 'TimeoutError', 'True', 'TypeError', 'UnboundLocalError', 'UnicodeDecodeError', 'UnicodeEncodeError', 'UnicodeError', 'UnicodeTranslateError', 'UnicodeWarning', 'UserWarning', 'ValueError', 'Warning', 'WindowsError', 'ZeroDivisionError', '__build_class__', '__debug__', '__doc__', '__import__', '__loader__', '__name__', '__package__', '__spec__', 'abs', 'all', 'any', 'ascii', 'bin', 'bool', 'breakpoint', 'bytearray', 'bytes', 'callable', 'chr', 'classmethod', 'compile', 'complex', 'copyright', 'credits', 'delattr', 'dict', 'dir', 'divmod', 'enumerate', 'eval', 'exec', 'exit', 'filter', 'float', 'format', 'frozenset', 'getattr', 'globals', 'hasattr', 'hash', 'help', 'hex', 'id', 'input', 'int', 'isinstance', 'issubclass', 'iter', 'len', 'license', 'list', 'locals', 'map', 'max', 'memoryview', 'min', 'next', 'object', 'oct', 'open', 'ord', 'pow', 'print', 'property', 'quit', 'range', 'repr', 'reversed', 'round', 'set', 'setattr', 'slice', 'sorted', 'staticmethod', 'str', 'sum', 'super', 'tuple', 'type', 'vars', 'zip'] 

El espacio de nombres integrado lo crea el intérprete de Python cuando se inicia. Estos finalizan cuando finaliza el intérprete de Python.

El espacio de nombres global

El espacio de nombres global consta de cualquier nombre en Python en cualquier nivel del programa principal. Se crea cuando el cuerpo principal se ejecuta y permanece vigente hasta que finaliza el intérprete.

El intérprete de Python crea un espacio de nombres global para cualquier módulo que nuestro Python cargue con la declaración de importación. Para obtener más información, visite nuestro módulo Python.

Los espacios de nombres locales y adjuntos

La función utiliza los espacios de nombres locales; Cuando se ejecuta la función, el intérprete de Python crea un nuevo espacio de nombres. Los espacios de nombres locales siguen existiendo una vez que la función ha terminado de ejecutarse. La capacidad también puede formar parte de otra capacidad. Como se muestra a continuación, podemos definir una función dentro de otra.

Ejemplo -

 def f(): print('Initiate f()') def g(): print('Initiate g()') print('End g()') return g() print('Initiate f()') return f() 

En el modelo anterior, la capacidad g() se caracteriza dentro de la colección de f(). Llamamos a la función g() dentro de f() y a la función principal f(). Veamos cómo funciona la función anterior:

• Python crea un nuevo espacio de nombres para f() cuando lo llamamos.
• Del mismo modo, f() llama a g(), g() obtiene su propio espacio de nombres diferente.
• El espacio de nombres local g() se creó para el espacio de nombres adjunto, f().

Cada uno de estos espacios de nombres finaliza cuando finaliza la función.

Alcance del objeto/variable

El término 'alcance' especifica a qué región de codificación de un objeto Python en particular se puede acceder. Cada objeto y variable tiene un alcance en el programa desde el cual podemos acceder a esa variable. Por ejemplo, solo se puede acceder a una variable de función dentro de la función. Examinemos la siguiente ilustración:

patrón de diseño singleton java

Ejemplo -

 def scope_func(): print('Inside scope_func') def scope_inner_func(): var = 20 print('Inside inner function, value of var:',var) scope_inner_func() print('Try printing var from outer function: ',var) scope_func() 

Producción:

 Inside scope_func Inside inner function, value of var: 20 Traceback (most recent call last): File 'd:/Python Project/listproblems.py', line 343, in scope_func() File 'd:/Python Project/listproblems.py', line 342, in scope_func print('Try printing var from outer function: ',var) NameError: name 'var' is not defined 

Diccionarios de espacios de nombres de Python

En el tutorial anterior, hablamos de cómo los espacios de nombres son como diccionarios, con claves que representan nombres de objetos y valores que representan objetos reales. Como diccionarios, Python utiliza espacios de nombres tanto globales como locales. El acceso a diccionarios de espacios de nombres globales y locales es posible gracias a los métodos globals() y locals() de Python.

El método global()

El método globals() devuelve una referencia al diccionario de espacio de nombres global actual. Podemos usarlo para acceder a los objetos en el espacio de nombres global. Veamos el siguiente ejemplo.

Ejemplo -

 >>> type(globals()) >>> globals() {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': , '__spec__': None, '__annotations__': {}, '__builtins__': } 

Como podemos ver, hay muchas entradas integradas en globales() método. Puede variar según su sistema operativo y la versión de Python. Ahora definamos la variable global y observemos las diferencias.

alfabeto a numero

 >>> a = 20 >>> globals() {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': , '__spec__': None, '__annotations__': {}, '__builtins__': , 'a': 20} 

Después de la asignación de a = 20, se asigna una nueva variable global al diccionario de espacio de nombres global. Podemos acceder a los valores como accedemos en los diccionarios. Veamos el siguiente ejemplo.

 >>> a = 20 >>> globals() {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': , '__spec__': None, '__annotations__': {}, '__builtins__': , 'a': 20} >>> a 20 >>> globals()['a'] 20 

Podemos modificar el valor del diccionario usando la función globals().

 >>> globals()['a'] = 100 >>> a 100 

Ahora el nuevo valor de a aparecerá en los diccionarios globales.

La función local()

Python también proporciona el método locals() similar a globals() pero en su lugar accede a objetos en el espacio de nombres local. Veamos el siguiente ejemplo.

Ejemplo -

 >>> def func(a, b): ... str1 = 'Hello' ... loc = locals() ... print(loc) ... >>> func(10, 20) {'a': 10, 'b': 20, 'str1': 'Hello'} 

Cuando llamamos a func(10, 20), locals() devuelve el diccionario que representa el espacio de nombres local de la función. En el alcance de la función, definimos la variable local str1; el espacio de nombres local incluía los argumentos de la función, ya que son locales de func().

No obstante, cuando llamamos a la capacidad local people(), actúa de manera equivalente a la capacidad globals(). La función globals() y la función locals() difieren ligeramente. La función globals() no solo define variables adicionales sino que también almacena el valor de retorno. El diccionario contendrá las nuevas variables y sus valores. Eche un vistazo al ejemplo siguiente.

Ejemplo -

 >>> glob_var = globals() >>> glob_var {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': , '__spec__': None, '__annotations__': {}, '__builtins__': , 'a': 100, 'func': , 'glob_var': {...}, 'x': 100, 'y': 'JavaTpoint'} >>> x = 100 >>> glob_var {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': , '__spec__': None, '__annotations__': {}, '__builtins__': , 'a': 100, 'func': , 'glob_var': {...}, 'x': 100, 'y': 'JavaTpoint'} 

Aquí el glob_var es una referencia al diccionario global de espacios de nombres. Las nuevas declaraciones de asignación. X y y apareció en el glob_var diccionario.

Cambiar variables fuera del alcance

En el entorno de llamada, la función puede cambiar el argumento pasando un valor diferente, pero a veces no puede cambiar el valor.

convertir de cadena a entero java

Un argumento inmutable no puede ser modificado por una función.

Un argumento mutable se puede cambiar en su lugar, pero no se puede redefinir por completo.

Entendamos el siguiente escenario.

Ejemplo -

 x = 20 def func(): x = 40 print(x) func() print(x) 

Producción:

 40 20 

Definimos una variable global x = 20 y también en función con el mismo nombre. Cuando se ejecuta func(), crea la nueva variable local que hace referencia a un objeto entero cuyo valor es 40. Dentro del función() cuerpo, la declaración de asignación no afectará al objeto global.

Sin embargo, una función puede modificar un objeto de tipo mutable fuera de su ámbito local. Entendamos el siguiente ejemplo.

java está vacío

Ejemplo -

 my_list = ['Hello', 'From', 'JavaTpoint'] def func(): my_list[1] = 'Welcome to' return my_list print(func()) 

my_list es una lista y es de tipo mutable. func() puede modificarse dentro de my_list aunque esté fuera del alcance local. Pero, si intentamos reasignar my_list, creará el nuevo objeto local y no modificará my_list global. Veamos el siguiente ejemplo.

Ejemplo -

 my_list = ['Hello', 'from', 'JavaTpoint'] def func(): my_list = ['A', 'B', 'C', 'D', 'E', ''] return my_list print(func()) 

Producción:

 ['A', 'B', 'C', 'D', 'E'] 

Conclusión

Nos ocupamos del espacio de nombres, de cómo podemos utilizarlo y del grado de la variable. Se pueden crear numerosos objetos distintos con un breve programa Python. Este número puede superar los mil en un programa Python complicado. El espacio de nombres de Python facilita que el intérprete recuerde los nombres de estos objetos.