Namespaces, locals() e globals()

Quando nós criamos uma variável, onde ela fica guardada exatamente? Isso vai depender de onde ela foi criada. Caso tenha sido dentro de uma função, ela só existirá para aquela função, será uma variável local, pertencendo a um "namespace" local, e quando essa função não for mais usada, a variavel desaparecerá.

Namespaces são onde ficam registradas as variáveis, e funcionam como um dicionário, onde as chaves são os nomes das variáveis, e os valores são os valores dessas variáveis. Existem três tipos de namespaces:

- Namespace local: como citado acima, se refere a uma função ou método de classe. As variáveis desse namespace só poderão ser acessadas de sua função ou método de classse onde ela pertence.

- Namespace global: é onde ficam todas as variáveis, funções, classes, módulos importados, do módulo corrente. Normalmente esse namespace dura até o fim do programa.

- Namespace embutido: esse é acessível de qualquer módulo, e contém funções e excessões embutidas. Ele é criado quando o interpretador python é aberto, e dura até ele ser fechado. As variaveis desse namespace ficam em um módulo, chamado __builtin__.

Quando, no meio do código, existe uma chamada a uma variável, o interpretador python segue uma sequencia de busca pra achar o valor dessa variável. Primeiro ele procura no namespace local, não achando, procura no namespace global, em seguida no namespace embutido. Caso exista uma função aninhada ou lambda dentro de outra, procura-se primeiro no namespace dessa função, depois no da função ascendente e so depois no global e embutido.

Outra definição interessante é a de escopo. Escopo é uma região textual de um programa em Python, onde um namespace é diretamente acessível. O escopo local de uma função é a região de codigo dela, onde podemos chamar suas variáveis diretamente.

Python tem duas funções muito interessantes, com elas podemos acessar os namespaces em tempo de execução, são elas locals() e globals().

A função locals() retorna um dicionário, onde as chaves são os nomes das variáveis locais, e os valores são os valores dessas varáveis. Vamos ver um exemplo:

def f(n):
....mult = n * 2
....print locals()

Obeserve a função acima f(n), 'n' é o argumento da função, argumentos também pertencem ao namespace local, e dentro da função criamos a variável 'mult'. Agora vamos chamar a função atribuindo um valor para 'n':

>>> f(4)
{'mult': 8, 'n': 4}

Obeserve que locals() retornou o dicionario acima, com as variáveis e seus conteúdos.
O mesmo que locals() faz para um namespace local, globals() faz para o namespace global.

>>> import locais
>>> globals()
{'__builtins__': module '__builtin__' (built-in), '__name__': '__main__', '__doc__': None, 'locais': module 'locais' from 'locais.py'}

Vamos entender o que foi feito acima, direto da linha de comando. Primeiro eu importei o módulo criado acima,chamado de locais.py, que contém o exemplo de locals(). Depois, eu chamei a função globals() e ela me retornou o dicionário acima.
'__builtins__', como eu já citei, é o módulo que contém todas as funções, excessões embutidas, o que forma o namespace embutido.
'__name__' funciona da seguinte maneira. Ao rodar um módulo, ao invés de importá-lo, o valor embutido __name__ será __main__. E como nós estamos da linha de comando, __name__ é __main__
E observe também a presença do módulo que foi importadom 'locais', ao ser importado ele pertence ao namespace global.
'__doc__': None, mostra que nosso módulo corrente não tem nenhuma docstring

Uma utilidade para essas funções é a formatação de string com dicionários, eu falei um pouco disso no post anterior sobre dicionários.

Fonte:
- Livro Mergulhando no Python
- Python tutorial