Neste tutorial, você aprenderá sobre namespace, mapeamento de nomes para objetos e escopo de uma variável.
O que é nome em Python?
Se você já leu 'The Zen of Python' (digite import thisno interpretador Python), a última linha declara: Namespaces são uma ótima ideia - vamos fazer mais disso! Então, quais são esses namespaces misteriosos? Vejamos primeiro o que é o nome.
Nome (também chamado de identificador) é simplesmente um nome dado a objetos. Tudo em Python é um objeto. O nome é uma forma de acessar o objeto subjacente.
Por exemplo, quando fazemos a atribuição a = 2, 2é um objeto armazenado na memória e a é o nome com o qual o associamos. Podemos obter o endereço (na RAM) de algum objeto por meio da função embutida id(). Vamos ver como usá-lo.
# Note: You may get different values for the id a = 2 print('id(2) =', id(2)) print('id(a) =', id(a))
Resultado
id (2) = 9302208 id (a) = 9302208
Aqui, ambos se referem ao mesmo objeto 2, portanto, eles têm o mesmo id(). Vamos tornar as coisas um pouco mais interessantes.
# Note: You may get different values for the id a = 2 print('id(a) =', id(a)) a = a+1 print('id(a) =', id(a)) print('id(3) =', id(3)) b = 2 print('id(b) =', id(b)) print('id(2) =', id(2))
Resultado
id (a) = 9302208 id (a) = 9302240 id (3) = 9302240 id (b) = 9302208 id (2) = 9302208
O que está acontecendo na sequência de etapas acima? Vamos usar um diagrama para explicar isso:
Diagrama de memória de variáveis em Python
Inicialmente, um objeto 2é criado e o nome a é associado a ele, quando o fazemos a = a+1, um novo objeto 3é criado e agora a é associado a este objeto.
Observe que id(a)e id(3)têm os mesmos valores.
Além disso, quando b = 2é executado, o novo nome b fica associado ao objeto anterior 2.
Isso é eficiente, pois o Python não precisa criar um novo objeto duplicado. Essa natureza dinâmica da vinculação de nomes torna o Python poderoso; um nome pode se referir a qualquer tipo de objeto.
>>> a = 5 >>> a = 'Hello World!' >>> a = (1,2,3)
Todos estes são válidos e se referirá a três tipos diferentes de objetos em instâncias diferentes. Funções também são objetos, portanto, um nome também pode se referir a elas.
def printHello(): print("Hello") a = printHello a()
Resultado
Olá
O mesmo nome a pode referir-se a uma função e podemos chamar a função usando esse nome.
O que é um namespace em Python?
Agora que entendemos o que são nomes, podemos passar ao conceito de namespaces.
Para simplificar, um namespace é uma coleção de nomes.
Em Python, você pode imaginar um namespace como um mapeamento de todos os nomes que você definiu para objetos correspondentes.
Diferentes namespaces podem coexistir em um determinado momento, mas são completamente isolados.
Um namespace contendo todos os nomes embutidos é criado quando iniciamos o interpretador Python e existe enquanto o interpretador é executado.
Este é o motivo pelo qual as funções integradas id(), como print()etc. , estão sempre disponíveis para nós em qualquer parte do programa. Cada módulo cria seu próprio namespace global.
Esses diferentes namespaces são isolados. Portanto, o mesmo nome que pode existir em módulos diferentes não colide.
Os módulos podem ter várias funções e classes. Um namespace local é criado quando uma função é chamada, que contém todos os nomes definidos. Semelhante, é o caso da classe. O diagrama a seguir pode ajudar a esclarecer esse conceito.
Um diagrama de diferentes namespaces em Python
Python Variable Scope
Embora existam vários namespaces exclusivos definidos, podemos não ser capazes de acessar todos eles de todas as partes do programa. O conceito de escopo entra em jogo.
Um escopo é a parte de um programa de onde um namespace pode ser acessado diretamente sem qualquer prefixo.
A qualquer momento, existem pelo menos três escopos aninhados.
- Escopo da função atual que tem nomes locais
- Escopo do módulo que tem nomes globais
- Escopo mais externo que possui nomes integrados
Quando uma referência é feita dentro de uma função, o nome é pesquisado no namespace local, depois no namespace global e, finalmente, no namespace integrado.
Se houver uma função dentro de outra função, um novo escopo é aninhado dentro do escopo local.
Exemplo de escopo e namespace em Python
def outer_function(): b = 20 def inner_func(): c = 30 a = 10
Here, the variable a is in the global namespace. Variable b is in the local namespace of outer_function() and c is in the nested local namespace of inner_function().
When we are in inner_function(), c is local to us, b is nonlocal and a is global. We can read as well as assign new values to c but can only read b and a from inner_function().
If we try to assign as a value to b, a new variable b is created in the local namespace which is different than the nonlocal b. The same thing happens when we assign a value to a.
However, if we declare a as global, all the reference and assignment go to the global a. Similarly, if we want to rebind the variable b, it must be declared as nonlocal. The following example will further clarify this.
def outer_function(): a = 20 def inner_function(): a = 30 print('a =', a) inner_function() print('a =', a) a = 10 outer_function() print('a =', a)
As you can see, the output of this program is
a = 30 a = 20 a = 10
Neste programa, três variáveis diferentes a são definidas em namespaces separados e acessadas de acordo. Enquanto estiver no programa a seguir,
def outer_function(): global a a = 20 def inner_function(): global a a = 30 print('a =', a) inner_function() print('a =', a) a = 10 outer_function() print('a =', a)
A saída do programa é.
a = 30 a = 30 a = 30
Aqui, todas as referências e atribuições são para o a global devido ao uso da palavra-chave global.
