Introdução ao uso de funções em Python: variáveis locais, globais e aninhamento de funções

Nesta seção apresento um conceito mais "sutil" de programação, para entendê-lo é essencial que você copie os códigos apresentados, "cole" em seu editor preferido e os teste até que esteja tudo claro. Experimente alterar os exemplos e criar outros: grave-os e os rode. Para prender programação é preciso programar!

Cuidado com a sintaxe de função (erro de recorrência não desejada)

Um erro que as vezes ocorre é usar de modo equivocado o conceito de devolução do resultado, provocando uma recorrência infinita. Como a cada chamada da função todas suas variáveis locais precisam ser alocadas na memória, a cada chamada um novo espaço de memória é reservado, logo, em algum tempo o seu computador não mais "aguentará" e lançará uma mensagem de erro indicando algo como recursão excedeu profundidade máxima. O código abaixo ilustra esse engano, experimente copiá-lo e colá-lo em seu editor preferido e rode-o.

    <verm>def</verm> fat (n) :
      f = 1; i = 2;
      while (i<=n) :
        f *= i;
        i += 1;
      return fat(n); <cyan># Erro aqui! RuntimeError: maximum recursion depth exceeded</cyan>

    <verd>print</verd>(fat(5));

Cód. 1. Exemplo de engano implicando em recorrência "infinita".

Para corrigir o engano do código 1, troque a linha de devolução por `return f;`. Isso eliminará as recorrências. Por outro lado, é possível implementar uma versão correta e recursiva, veja este texto sobre recursividade.

Sobre o aninhamento de funções na linguagem Python

Em várias linguagens de programação, Python em particular, é possível declarar função dentro de função (aninhar). Por exemplo, dentro de uma função de nome funcao2, pode-se declarar outra função de nome funcao3. O resultado é que, dentro da primeira função, pode-se invocar a segunda, mas em nenhum outro local do código seria possível invocar esssa função funcao3.

Mas vale destacar que esse recurso só é efetivamente útil se a função interna (funcao3) só fizer sentido dentro da função que a contém. Pois em caso contrário, você poderia invocar a função interna em outros contextos. Um exemplo dessa situação é ilustrado no parágrafo seguinte, a função fatorial poderia ficar melhor se declarada fora da função combinacao.

Um exemplo simples de função contendo outra função, poderia ser o caso do cálculo da combinação de n, tomados k-a-k: Cn,k = n!/(k!(n-k)!). Como para o calculo de Cn,k é necessário invocar o cálculo do fatorial 3 vezes, podemos desejar fazer um implementação que deixe essa dependência clara, definindo uma função de nome combinacao e, dentro dela, declarar a função fatorial. Vide exemplo 1.

Porém, como anteriormente comentado, como a função fatorial tem potencial de aplicação mais amplo, ela ficaria melhor se declarada fora da função combinacao (vide a crítica a esse organização de código logo após o exemplo 1).

Exemplo 1. Declaração aninhada de funções.

    <verm>def</verm> combinacao (n, k) : <cyan># combinacao de n, k-a-k</cyan>
      <verm>def</verm> fatorial (n) : <cyan># fatorial de n (supondo n natural)</cyan>
        fat = 1;
        for i in range(2, n+1) :
          fat *= i;
        return fat;
      return fatorial(n) / (fatorial(k)*fatorial(n-k));

    <verm>def</verm> main () :
      n = 5; k = 3;
      <verd>print</verd>("Combinacao %d, %d-a-%d = %d" % (n, k, k, combinacao(n,k)));
      <cyan># Problema de declarar 'fatorial()' dentro de 'combinacao()': a linha abaixo daria erro!</cyan>
      <cyan># Erro: NameError: global name 'fatorial' is not defined</cyan>
      <cyan># <verd>print</verd>("fat(0)=%d, fat(1)=%d, fat(2)=%d, fat(3)=%d" % (fatorial(0), fatorial(1), fatorial(2), fatorial(3)));</cyan>

    main();

Note que o código acima apresenta a linha comentada `<verd>print</verd>("fat(0)=%d, fat(1)=%d, fat(2)=%d, fat(3)=%d" % (fatorial(0), fatorial(1), fatorial(2), fatorial(3)));`. A razão é que ela resultaria erro, pois a função fatorial foi declarada dentro da função combinacao e portanto só pode ser usando (invocada) dentro dessa segunda!

Uma vez que o uso do cálculo de fatorial é muito comum e pensando que o código acima seria parte de um maior, então provavelmente o desenho de código usado não é bom, pois implicaria em precisarmos definir outra função fatorial, essa fora do contexto da função combinacao. Nesse sentido, poderia ser melhor usar o código (pensando que ele seja o início de um sistema maior) do exemplo a seguir.

Exemplo 2. Declaração de funções sem aninhamento.

    <verm>def</verm> fatorial (n) : <cyan># fatorial de n (supondo n natural)</cyan>
        fat = 1;
        for i in range(2, n+1) :
          fat *= i;
        return fat;
    <verm>def</verm> combinacao (n, k) : <cyan># combinacao de n, k-a-k</cyan>
      return fatorial(n) / (fatorial(k)*fatorial(n-k));

    <verm>def</verm> main () :
      n = 5; k = 3;
      <verd>print</verd>("Combinacao %d, %d-a-%d = %d" % (n, k, k, combinacao(n,k)));
      <cyan># Note que agora pode-se invocar 'fatorial()' dentro da 'main'</cyan>
      <verd>print</verd>("fat(0)=%d, fat(1)=%d, fat(2)=%d, fat(3)=%d" % (fatorial(0), fatorial(1), fatorial(2), fatorial(3)));

    main();

Variáveis globais e locais

Outro conceito importante relacionado com funções é o de declaração de variáveis. Assim, uma variável é local se declarada dentro de uma função qualquer, quer dizer, essa variável será "conhecida" (poderá ser usada) apenas dentro dessa função. Por exemplo, no exemplo 2 acima, a variável fat é conhecida apenas dentro da função fatorial, portanto seu uso deve-se restringir a esse contexto.

Por outro lado, pode-se usar o mesmo nome para variáveis que estão em contextos distintos. Por exemplo, no código do exemplo 1, se fosse necessário poderíamos usar o nome de variável local i dentro da função combinacao e não haveria qualquer colisão com a variável i de fatorial.

Entretanto é necessário um critério que elimine ambiguidades, isto é, que seja possível identificar unicamente cada uma das variáries. Para isso usa-se o princípio da proximidade (ou da localidade), quer dizer, ao usar uma variável considera-se como sua declarção aquela mais próxima. Por isso, que poderiamos usar i tanto em combinacao, quanto em fatorial,

Fig. 1. Princípio da localidade para variáveis: `var2` e `var1` são aquelas declaradas dentro da `funcao2`.

Já uma variável global pode ser acessada em qualquer ponto do código. Mas por essa mesma razão deve evitada, sendo necessária apenas para casos excepcionais, sempre com um nome significativo, que evite qualquer confusão.

Em Python existem dois modos para se declarar uma variável global, ou seja, uma variável que pode ser acessada em qualquer ponto do código (em qualquer função). Ela pode estar no código "principal" (quer dizer não estar dentro de qualquer função) ou sendo declarada dentro de uma função usando a diretiva especial global, como ilustrado no próximo exemplo.

Exemplo 3. Declaração de variável global.

    var_global1 = "essa variavel e' uma global (1)";
    <verm>def</verm> funcao1 () :
      <verd>print</verd>("funcao1: var_global1 = %s" % var_global1);

    <verm>def</verm> funcao2 () :
      global var_global2; <cyan># define 'var_global2' como global </cyan>
      var_global2 = "essa variavel e' outra global (2)"; <cyan># atribui um primeiro valor a 'var_global2'</cyan>
      <verd>print</verd>("funcao2: var_global1 = %s" % var_global1);
      <verd>print</verd>("funcao2: var_global2 = %s" % var_global2);

    <verm>def</verm> main () :
      <verd>print</verd>("main   : var_global1 = %s" % var_global1);
      #Erro: <verd>print</verd>("main   : var_global2 = %s" % var_global2); <cyan># NAO pode usar essa linha pois 'var_global2' ainda NAO foi definida</cyan>
      funcao1();
      funcao2();
      <verd>print</verd>("main   : var_global2 = %s" % var_global2); <cyan># NAO pode usar essa linha pois 'var_global2' ainda NAO foi definida</cyan>

    main();

Aninhando funções e variáveis locais e globais

Deve-se notar que é possível aninhar tantas funções quantas forem necessárias e o mesmo para variáveis locais. O exemplo abaixo ilustra esses aninhamentos e o princípio da proximidade. Examine-o com atenção, copie-o em seu computador, utilizando um interpretador Python e altere seu código até que esteja certo de ter assimilado os conceitos.

Exemplo 4. Declaração de variáveis locais, usando globais e aninhamento de funções.

    glob1 = "glob1: variavel global, conhecida em qualquer local";

    <verm>def</verm> funcao1 () :
      loc1 = "loc1: conhecida apenas dentro da funcao 'funcao1'";
      glob1 = "funcao1.glob1: declarada dentro de 'funcao1' => uma variavel local `a funcao 'funcao1'";
      <verd>print</verd>("funcao1: loc1 = %s" % loc1); <cyan># note que: pode haver m</cyan>
      <verd>print</verd>("funcao1: glob1 = %s\n" % glob1);

    <verm>def</verm> funcao2 (param1) :
      <verm>def</verm> funcao3 () : <cyan># essa funcao so' e' conhecida dentro de 'funcao2'!</cyan>
        loc1 = "loc1: conhecida apenas dentro da funcao 'funcao3' - NAO sou a 'funcao1.loc1' e nem a 'funcao2.loc1'!";
        glob1 = "funcao3.glob1: declarada dentro de 'funcao3' => var. local `a funcao 'funcao3' - NAO e' global 'glob1' e nem 'funcao1.glob1'!";
        <verd>print</verd>("funcao3: loc1 = %s" % loc1); <cyan># note que: e' local com outra com esse nome; "principio do mais proximo" em acao!</cyan>
        <verd>print</verd>("funcao3: loc2 = %s" % loc2); <cyan># note que: e' local `a funcao 'funcao2' - variavel declarada fora de funcao3!</cyan>
        <verd>print</verd>("funcao3: glob1 = %s" % glob1);
      global glob2;
      glob2 = "glob2: variavel global, conhecida em qualquer local (mas declarada em 'funcao2')"; <cyan># mas depois desse comando ser executado!</cyan>
      loc1 = "loc1: conhecida apenas dentro da funcao 'funcao2 - NAO sou a 'funcao1.loc1'!'";
      loc2 = "loc2: conhecida apenas dentro da funcao 'funcao2'";
      <verd>print</verd>("funcao2: param1 = %s" % param1);
      <verd>print</verd>("funcao2: loc1 = %s" % loc1); <cyan># note que: e' local com outra com esse nome; "principio do mais proximo" em acao!</cyan>
      <verd>print</verd>("funcao2: loc2 = %s" % loc2); <cyan># note que: e' local</cyan>
      <verd>print</verd>("funcao2: glob1 = %s" % glob1);
      <verd>print</verd>("funcao2: chama funcao3\n");
      funcao3();
      <verd>print</verd>("funcao2: chama funcao1\n");
      funcao1();

    <verm>def</verm> funcao4 () :
      <verd>print</verd>("funcao4: glob2 = %s" % glob2);

    <verm>def</verm> main () :
      loc1 = "loc1: conhecida apenas dentro da funcao 'main'";
      <verd>print</verd>("main   : loc1 = %s" % loc1); <cyan># note que: e' local com outra com esse nome; "principio do mais proximo" em acao!</cyan>

      <verd>print</verd>("main   : glob1 = %s" % glob1);

      <cyan># A linha abaixo NAO pode ser usada, pois apesar de glob2 ser declarada como global (usando a diretiva 'global')</cyan>
      <cyan># isso e' feito apenas dentro da funcao 'funcao2', entao ela so' ficara' disponivel apos 'funcao2' ser executada!</cyan>
      <cyan># Se tirar o comentario da linha abaixo, resultaria o erro: NameError: global name 'glob2' is not defined</cyan>
      <cyan># <verd>print</verd>("main   : glob2 = %s" % glob2);</cyan>

      <verd>print</verd>("main   : chama funcao1\n");
      funcao1();
      <verd>print</verd>("main   : chama funcao2\n");
      funcao2("parametro efetivo passado para a funcao 'funcao2'");

      <cyan># Atencao: como a funcao 'funcao3' foi declarada dentro da funcao 'funcao2', entao ela so' pode se invocada em 'funcao2'</cyan>
      <cyan># Por exemplo, a linha abaixo resultaria no erro: NameError: global name 'funcao3' is not defined</cyan>
      <cyan># funcao3();</cyan>

      <cyan># Mas nesse ponto a global 'glob2' ja' foi definida</cyan>
      <verd>print</verd>("main   : glob2 = %s" % glob2);

      <verd>print</verd>("main   : chama funcao4\n");
      funcao4(); <cyan># note que 'funcao4' tambem pode usar a global 'glob2' (declarada dentro da 'funcao2'</cyan>

    main();

Leônidas de Oliveira Brandão
http://line.ime.usp.br

Alterações:
2020/08/09: formato, revisão geral;
2020/05/12: versão inicial