Neste tutorial, aprenderemos sobre o namespace em Python, a estrutura usada para organizar os nomes simbólicos atribuídos a objetos em um programa Python, por que o namespace é importante e como podemos usá-los em nosso programa Python. Vamos fazer uma breve introdução a um namespace.
O que é espaço para nome?
Em Python, uma maneira de dar a cada objeto um nome exclusivo é por meio de um namespace. Variáveis e métodos são exemplos de objetos em Python. Em outras palavras, é uma coleção de nomes simbólicos conhecidos e os detalhes sobre aquilo a que cada nome se refere. Um nome pode ser considerado uma chave em um dicionário e os objetos são os valores em um namespace. Deveríamos descobrir isso com um modelo genuíno - um namespace se assemelha a um sobrenome. Se houver vários nomes de 'Pedro' na classe, pode ser difícil localizar um nome de 'Pedro'; no entanto, quando solicitamos especificamente 'Peter Warner' ou 'Peter Cummins', em uma turma, pode não ser comum que vários alunos tenham o mesmo nome e sobrenome.
string.valorde java
O interpretador Python pode compreender melhor o método ou variável exata no código graças ao namespace. Como resultado, seu nome contém informações adicionais, incluindo Espaço (relacionado ao escopo) e Nome, que denota um identificador exclusivo.
Em Python, existem quatro tipos de namespaces fornecidos a seguir.
- Construídas em
- Global
- Fechando
- Local
Como vários desses namespaces têm vida útil, o interpretador Python cria namespaces conforme necessário e os exclui quando não são mais necessários.
Vamos entender os vários tipos de namespace em Python.
O namespace integrado
Como o próprio nome sugere, ele contém nomes predefinidos de todos os objetos integrados do Python já disponíveis em Python. Vamos listar esses nomes com o seguinte comando.
Abra o terminal Python e digite o seguinte comando.
Comando -
dir(__builtins__)
Saída:
['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']
O namespace integrado é criado pelo interpretador Python quando ele é inicializado. Eles são encerrados quando o interpretador Python termina.
O espaço para nome global
O namespace global consiste em quaisquer nomes em Python em qualquer nível do programa principal. Ele é criado quando o corpo principal é executado e permanece existindo até o intérprete terminar.
15 de 100,00
O interpretador Python cria um namespace global para qualquer módulo que nosso Python carrega com a instrução import. Para obter mais informações, visite nosso Módulo Python.
Os namespaces locais e anexos
Os namespaces locais são usados pela função; Quando a função é executada, o interpretador Python cria um novo namespace. Os namespaces locais continuam a existir após a conclusão da execução da função. A capacidade também pode incluir outra capacidade. Conforme mostrado abaixo, podemos definir uma função dentro de outra.
Exemplo -
def f(): print('Initiate f()') def g(): print('Initiate g()') print('End g()') return g() print('Initiate f()') return f()
No modelo acima, a capacidade g() é caracterizada dentro da coleção de f(). Chamamos a função g() dentro de f() e a função principal f(). Vejamos como funciona a função acima:
- Python cria um novo namespace para f() quando o chamamos.
- Da mesma forma, f() chama g(), g() obtém seu próprio namespace diferente.
- O namespace local g() foi criado para o namespace envolvente, f().
Cada um desses namespaces é encerrado quando a função é encerrada.
Escopo do Objeto/Variável
O termo 'escopo' especifica qual região de codificação de um objeto Python específico pode ser acessada. Cada objeto e variável possui um escopo no programa a partir do qual podemos acessar essa variável. Por exemplo, uma variável de função só pode ser acessada dentro da função. Vamos examinar a seguinte ilustração:
Exemplo -
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()
Saída:
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
Dicionários de namespace Python
No tutorial anterior, falamos sobre como os namespaces são como dicionários, com chaves representando nomes de objetos e valores representando objetos reais. Como dicionários, Python usa namespaces globais e locais. O acesso aos dicionários de namespace globais e locais é possível pelos métodos globals() e locals() do Python.
O método global()
O método globals() retorna uma referência ao dicionário de namespace global atual. Podemos usá-lo para acessar os objetos no namespace global. Vejamos o exemplo abaixo.
Exemplo -
>>> type(globals()) >>> globals() {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': , '__spec__': None, '__annotations__': {}, '__builtins__': } Como podemos ver, existem muitas entradas integradas em globais() método. Pode ser diferente de acordo com seu sistema operacional e versão do Python. Agora vamos definir a variável global e observar as diferenças.
tigre comparado ao leão
>>> a = 20 >>> globals() {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': , '__spec__': None, '__annotations__': {}, '__builtins__': , 'a': 20} Após a atribuição de a = 20, uma nova variável global é atribuída ao dicionário de namespace global. Podemos acessar os valores como acessamos nos dicionários. Vejamos o exemplo abaixo.
>>> a = 20 >>> globals() {'__name__': '__main__', '__doc__': None, '__package__': None, '__loader__': , '__spec__': None, '__annotations__': {}, '__builtins__': , 'a': 20} >>> a 20 >>> globals()['a'] 20 Podemos modificar o valor do dicionário usando a função globals().
>>> globals()['a'] = 100 >>> a 100
Agora o novo valor de a aparecerá nos dicionários globais.
A função locals()
Python também fornece o método locals() semelhante a globals(), mas em vez disso acessa objetos no namespace local. Vejamos o exemplo a seguir.
Exemplo -
>>> def func(a, b): ... str1 = 'Hello' ... loc = locals() ... print(loc) ... >>> func(10, 20) {'a': 10, 'b': 20, 'str1': 'Hello'} Quando chamamos func(10, 20), locals() retorna o dicionário que representa o namespace local da função. No escopo da função, definimos a variável local str1; o namespace local incluía os argumentos da função, uma vez que eles são locais para func().
Não obstante, quando chamamos a capacidade local people(), ela atua de forma equivalente à capacidade globals(). A função globals() e a função locals() diferem ligeiramente. A função globals() não apenas define variáveis adicionais, mas também armazena o valor de retorno. O dicionário conterá as novas variáveis e seus valores. Dê uma olhada no exemplo abaixo.
Exemplo -
>>> 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'} Aqui o glob_var é uma referência ao dicionário de namespace global. As novas declarações de atribuição x e e apareceu no glob_var dicionário.
Alterando Variáveis Fora do Escopo
No ambiente de chamada, a função pode alterar o argumento passando um valor diferente, mas às vezes não pode alterar o valor.
bloquear um aplicativo Android
Um argumento imutável não pode ser modificado por uma função.
Um argumento mutável pode ser alterado, mas não pode ser completamente redefinido.
Vamos entender o seguinte cenário.
Exemplo -
x = 20 def func(): x = 40 print(x) func() print(x)
Saída:
40 20
Definimos uma variável global x = 20 e também em função com o mesmo nome. Quando func() é executado, ele cria a nova referência de variável local para um objeto inteiro cujo valor é 40. Dentro do função() body, a instrução de atribuição não afetará o objeto global.
No entanto, uma função pode modificar um objeto de tipo mutável fora de seu escopo local. Vamos entender o exemplo abaixo.
dividindo uma string em c++
Exemplo -
my_list = ['Hello', 'From', 'JavaTpoint'] def func(): my_list[1] = 'Welcome to' return my_list print(func())
O my_list é uma lista e é do tipo mutável. O func() pode ser modificado dentro de my_list mesmo que esteja fora do escopo local. Mas, se tentarmos reatribuir minha_lista, ele criará o novo objeto local e não modificará a minha_lista global. Vejamos o exemplo abaixo.
Exemplo -
my_list = ['Hello', 'from', 'JavaTpoint'] def func(): my_list = ['A', 'B', 'C', 'D', 'E', ''] return my_list print(func())
Saída:
['A', 'B', 'C', 'D', 'E']
Conclusão
Cuidamos do namespace, como podemos utilizá-lo e do grau da variável. Vários objetos distintos podem ser criados com um breve programa Python. Este número pode exceder mil em um programa Python complicado. O namespace Python torna mais fácil para o intérprete lembrar os nomes desses objetos.