3.1 A Pilha de Chamadas

Antes de escrevermos funções que chamam a si mesmas, precisamos entender como o computador se organiza para não perder o fio da meada.

Sempre que o seu código chama uma função, o computador precisa “pausar” o que estava fazendo, ir executar a nova função e, depois que ela terminar, voltar exatamente para onde tinha parado.

Mas como ele lembra de onde parou? Ele usa a Pilha de Chamadas (Call Stack).

A Mecânica da Pilha

Imagine uma pilha de pratos limpos em um restaurante. Quando o garçom traz pratos novos, ele os coloca no topo. Quando você vai se servir, pega o prato do topo.

Você não consegue puxar um prato do meio sem antes retirar todos os que estão acima dele. Na programação, chamamos essa regra de LIFO (Last In, First Out - O último a entrar é o primeiro a sair). A memória do seu computador funciona exatamente assim!

Execução na Prática

Veja como as funções se comportam na memória. Considere este programa simples:

def saudar(nome):
    print("Olá, " + nome + "!")
    dar_boas_vindas()
    print("Preparando para sair...")
    despedir()

def dar_boas_vindas():
    print("Como você está hoje?")

def despedir():
    print("Tchau, até logo!")

Quando você manda o computador rodar saudar("João"), ele usa a pilha de memória para se organizar:

1. Empilhando a base: O computador coloca a função saudar na pilha e imprime “Olá, João!”. A próxima linha manda executar outra função (dar_boas_vindas).
2. Pausa e novo prato: A função saudar é congelada no fundo da pilha (seu estado é salvo). A função dar_boas_vindas entra no topo da pilha e o computador passa a executá-la, imprimindo “Como você está hoje?”.
3. Desempilhando e retomando: Quando dar_boas_vindas termina, seu “prato” é jogado fora da pilha. O computador volta automaticamente para o prato de baixo (saudar), exatamente na linha onde havia parado.
4. Continuando o trabalho: Ele imprime “Preparando para sair…” e empilha a função despedir, que imprime o tchau e depois também é descartada.

O computador nunca se perde. Ele sabe que, ao terminar a tarefa do topo, basta descartá-la e voltar a ler o código do item que ficou esperando logo abaixo.

Quando a Pilha Transborda

Mas e se uma função chamar a si mesma repetidas vezes, sem nenhuma regra para parar? O computador vai empilhar um prato em cima do outro, infinitamente.

Como a memória RAM tem limite, chega a hora em que os pratos batem no teto. Quando a memória reservada acaba e o sistema desmorona, temos o famoso Stack Overflow (Estouro de Pilha).

Apesar desse risco, a recursividade é uma das ferramentas mais elegantes da computação. Para usá-la sem estourar a memória, só precisamos de uma regra de segurança: saber a hora exata de puxar o freio de emergência.

Na próxima página, vamos ver como usar esse freio dividindo problemas em pedaços menores!