Antes de prosseguir leia os artigos anteriores aqui

Olá pessoal! Agora estamos entrando em um assunto muito mais "pesado". Vamos logo ao conteúdo!

Escopo de Variáveis Parte 1

Inicialmente vamos entender o que é escopo. Escopo é o mesmo que extensão, alcance, âmbito e/ou competência. Dessa forma o escopo de uma variável é a "área" na qual ela pode ser utilizada.

O Python tem 3 escopos principais:

• locais;
• globais;
• built-ins.

O escopo mais simples de se entender é o global. Existe um e apenas um escopo global. Você pode consultar o escopo global do seu programa usando a função globlas():

Código:

>>> globals()
{'__builtins__': <module '__builtin__' (built-in)>, '__name__': '__main__', '__d
oc__': None, '__package__': None}

A função globals() retorna um dicionário contendo diversos itens. Como o dicionário é composto por chaves e valores ele nos apresenta o nome do item e o seu respectivo valor. Para facilitar a visualização, vou usar um método do dicionário que imprime somente suas chaves, o método keys():

Código:

>>> globals().keys()
['__builtins__', '__package__', '__name__', '__doc__']
>>>

Como podemos ver o nosso escopo global apresenta 4 "itens" que sempre estarão presentes: __builtins__, __main__, __doc__ e __package__.

No momento não vou me ater a explicar o que seriam esses nomes pois eles serão entendidos à medida que vemos outros conteúdos, vamos focar no momento no que o globals representa, para isso vou mostrar um outro exemplo:

Código:

>>> globals().keys()
['__builtins__', '__name__', '__doc__', '__package__']
>>> x = 12
>>> texto = 'teste'
>>> lista = [1, 2, 3]
>>> globals().keys()
['__builtins__', 'texto', '__package__', 'x', '__name__', 'lista', '__doc__']
>>> globals()
{'__builtins__': <module '__builtin__' (built-in)>, 'texto': 'teste', '__package
__': None, 'x': 12, '__name__': '__main__', 'lista': [1, 2, 3], '__doc__': None}

>>>

Conforme apresentado, a função globals() agora apresenta as variáveis criadas (x, texto e lista). Podemos ver que o nome das variáveis são as chaves dos dicionários enquanto os valores das variáveis são os itens vinculados às chaves. Com isso podemos "chamar" as variáveis utilizando o dicionário:

Código:

>>> globals()['x']
12
>>> globals()['texto']
'teste'
>>> globals()['lista']
[1, 2, 3]
>>>

Claro, isso não tem utilidade nenhuma para nós no momento, mas é sempre bom ressaltar as possibilidades. Vamos criar agora algumas funções:

Código:

>>> def funcao_1():
...     print 'Estou na função 1'
...
>>> def funcao_2():
...     print 'Estou na função 2'
...
>>>
>>> globals().keys()
['funcao_2', '__builtins__', 'texto', '__package__', 'x', '__name__', 'funcao_1'
, 'lista', '__doc__']
>>>

Podemos ver que o comando globals mostra também as funções existentes no programa. Isso pode ser útil caso você precise descobrir se uma dada função já existe no seu programa. Vamos ver como as funções são apresentadas nos itens do dicionário retornado pelo comando globals():

Código:

>>> globals()
{'funcao_2': <function funcao_2 at 0x00B41130>, '__builtins__': <module '__built
in__' (built-in)>, 'texto': 'teste', '__package__': None, 'x': 12, '__name__': '
__main__', 'funcao_1': <function funcao_1 at 0x00B41030>, 'lista': [1, 2, 3], '_
_doc__': None}
>>>

Vinculado ao nome da função (por exemplo a funcao_2) temos o endereço de memória que a função está ocupando: <function funcao_2 at 0x00B41130>. Como se pode imaginar, é possível chamar a função dada o seu nome em string:

Código:

>>> globals()['funcao_1']
<function funcao_1 at 0x00B41030>
>>> globals()['funcao_1']()
Estou na função 1
>>>

Por enquanto vamos parar por aqui e deixar que todos se acostumem com a idéia. Em seguida vamos utilizar essa função para podermos descobrir a "abrangência" de uma função e/ou variável.

Até mais...