A partir do momento que são criadas, as variáveis dependem de um local para serem armazenadas. Os namespaces são onde ficam registradas as variáveis, e funcionam como dicionários que são atualizados dinamicamente em tempo de execução, onde as chaves (keys) são os nomes das variáveis e os valores (values) são os valores contidos nelas. Existem três namespaces no Python: local, global e embutido.
Local
Cada função (ou método) possui seu próprio namespace – chamado de local, que mantém no seu dicionário as variáveis da função, inclusive seus parâmetros. Variáveis definidas em funções só podem ser acessadas de dentro delas. Exemplo:
1 def funcao_exemplo(x, y):
2 soma = x + y 3 print locals()
4
5 funcao_exemplo(1, 2) # Imprime {'soma': 3, 'y': 2, 'x': 1}
Repare que a função locals retorna na forma de um dicionário o namespace local da função em que está inserido. No namespace da função acima estão inseridas a variável soma, definida no corpo da função, os parâmetros x e y e seus respectivos valores.
Global
Cada módulo possui seu próprio espaço de nomes, chamado de global, onde encontra- se todas as variáveis, funções e classes definidas no módulo, além dos módulos importados no módulo corrente. Exemplo:
1 # modulo_exemplo.py 2 3 import numeros 4 5 var_local = 42 6 7 def funcao_exemplo(): 8 pass 9 10 class classe_exemplo: 11 pass 12 13 print globals(
O código anterior gera a seguinte saída:
{'funcao_exemplo': <function funcao_exemplo at 0x02CA47F0>,
'numeros' from 'C:/Modulos/numeros.pyc'>, 'classe_exemplo': <class __main__.classe_exemplo at 0x02C9B900>, '__package__': None,
'var_local': 42, '__name__': '__main__', '__doc__': None}
A função globals funciona igual locals, porém retorna um dicionário contendo todos os atributos globais do módulo. Acima podemos reparar que, além da função, classe e variável definidas no módulo, a função globals retornou o módulo importado numeros.py e os atributos embutidos __file__, __name__ e __doc__, explicados anteriormente.
As variáveis globais podem ser “ofuscadas” por variáveis locais, pois o namespace local é consultado antes do global ao referenciarmos um objeto de dentro de uma função. Para evitar isso é preciso declarar a variável como global no escopo local. Exemplo:
1 total = 0; 2
3 def soma(x, y):
4 total = x + y # Variável total definida na função 5 print "Valor de total dentro da função:", total 6
7 soma(10, 20) # Imprime 30 8 print "Valor de total fora da função:", total # Imprime 0
No exemplo acima, definimos uma variável total no escopo global iniciada com 0 (zero). Dentro da função soma definimos outra variável total, para armazenar o resultado da soma dos dois parâmetros. Na linha 5, total vale 30 – resultado da soma de 10 e 20 passados por argumento. Na linha 8, imprimimos o valor de total do escopo global, cujo valor não foi alterado desde sua inicialização. Para que a variável total do escopo global seja utilizada pela função soma, devemos definí-la como global. Exemplo:
1 total = 0 2
3 def soma(x, y):
4 global total
5 total = x + y # Variável total definida na função 6 print "Valor de total dentro da função:", total 7
8 soma(10, 20)
9 print "Valor de total fora da função:", total Que imprime:
Valor de total dentro da função: 30 Valor de total fora da função: 30
Embutido ou Built-in
É onde todas as funções, constantes e exceções embutidas do Python são definidas. É acessível de qualquer módulo, é criado quando o interpretador Python é aberto, e dura até ele
ser fechado. Os atributos desse namespace ficam em um módulo chamado __builtins__, e alguns exemplos de atributos definidos são:
As funções print, raw_input, etc.;
Funções de coerção – int, float, str, etc.;
Pacotes
Pacotes, ou packages, são pastas que contém um arquivo-fonte, normalmente vazio, chamado __init__.py. Eles são utilizados como coleções para organizar módulos de forma hierárquica. Exemplo:
+ bancos_dados -> Pasta (Pacote)
| +-__init__.py -> Identifica pasta como pacote | +-mysql.py -> Módulo para MySQL
| +-conecta() -> Função do módulo mysql | +-desconecta() -> Função do módulo mysql | +-executa() -> Função do módulo mysql | +-sqlite.py -> Módulo para SQLite | +-conecta() -> Função do módulo sqlite | +-desconecta() -> Função do módulo sqlite | +-executa() -> Função do módulo sqlite |
+ aplicacao.py
Acima apresentamos uma estrutura hierárquica onde banco_dados é uma pasta que contém o arquivo __init__.py, que identifica a pasta como um pacote. Nela estão contidos os módulos mysql.py e sqlite.py, ambos possuindo os métodos conecta, desconecta e executa. O módulo aplicacao.py está no mesmo nível hierárquico do pacote
banco_dados, então para acessar dele os módulos contidos no pacote banco_dados, temos que referenciá-lo. Exemplo:
1 from base_dados import sqlite 2
3 sqlite.conecta()
No exemplo acima importamos o módulo sqlite do pacote base_dados. Note que apesar de utilizarmos o from para a importação, ainda precisamos identificar o módulo quando chamamos a função conecta, ou seja, é uma importação relativa. Para importar todos os módulos de um pacote, basta utilizar o curinga asterisco, exemplo:
1 from base_dados import *
2
3 sqlite.conecta()
4 mysql.conecta()
Para fazer uma importação absoluta de um módulo contido em um pacote, a sintaxe é similar a da mostrada anteriormente. Exemplo:
1 from base_dados.sqlite import *
2
3 conecta()
4 executa()
Caso se lembre, quando vimos os atributos embutidos de módulos ficamos de explicar o atributo __package__. Este atributo simplesmente armazena a qual pacote o módulo corrente pertence.
É comum que o arquivo __init__.py esteja vazio, que exista somente para tornar a pasta em que está contido em um pacote, mas também podemos inserir código-fonte nele como em qualquer outro arquivo. Dentro dele podemos definir código de inicialização do pacote – que será executado sempre que um ou mais módulos do pacote forem importados – e controlar quais os módulos do pacote serão importados quando realizamos a importação relativa utilizando o curinga asterisco – from pacote import * – definindo o nome desses módulos em uma variável chamada __all__ na forma de tupla ou de lista.
Tomando como base a estrutura de pacotes definida no início desse capítulo, podemos definir o seguinte código no arquivo __init__.py do pacote banco_dados:
1 -*- coding: latin-1 -*-
2 __all__ = ('mysql',)
3 print u'Módulo' __name__ 'importado'
Na linha 2 definimos a variável __all__ e atribuímos a ela uma tupla contendo o nome do módulo mysql, assim, quando executarmos a instrução from banco_dados import *, somente o módulo mysql será importado para nosso namespace.
A instrução print da linha 3 será executada todas as vezes que houver uma
importação envolvendo o pacote banco_dados, seja ele por importação absoluta ou relativa, importando um módulo contido nele ou o pacote como um todo.