def soma_recursiva(n):
# Caso base
if n == 1:
return 1
# Passo recursivo
else:
return n + soma_recursiva(n - 1)
# Exemplo de uso:
numero = int(input("Digite um número: "))
resultado = soma_recursiva(numero)
print(f"A soma de 1 a {numero} é: {resultado}")
Entrada:
Digite um número: 7
Saída:
A soma de 1 a 7 é: 28
Olá, Aristóteles. Como vai?
Seu código está absolutamente impecável! Você estruturou os dois pilares fundamentais de uma função recursiva com muita clareza: o caso base (if n == 1), que impede que a função rode infinitamente e estoure a memória, e o passo recursivo (else), que quebra o problema original em subproblemas menores.
A recursividade é um conceito elegante e poderoso na ciência da computação. Para fixar ainda mais o que acontece por baixo dos panos quando você digita o número 7, o Python cria uma estrutura na memória chamada Pilha de Execução (Stack). O cálculo funciona de trás para frente, empilhando as chamadas até chegar no caso base e depois somando os valores na volta:
soma_recursiva(7) espera o resultado de 7 + soma_recursiva(6)soma_recursiva(6) espera o resultado de 6 + soma_recursiva(5)soma_recursiva(1) atinge o caso base e retorna 1.A partir daí, a pilha começa a desempilhar resolvendo as somas matemáticas: $1 + 2 + 3 + 4 + 5 + 6 + 7 = 28$.
Para agregar ainda mais valor aos seus estudos sobre funções e recursividade em Python, gostaria de compartilhar duas dicas e boas práticas importantes:
Do jeito que o código está, se um usuário distraído digitar 0 ou um número negativo como -5, o programa entrará em um loop infinito de chamadas negativas (-5, -6, -7...) até travar e disparar um erro de limite de recursão atingido (RecursionError).
Uma excelente prática de programação defensiva é ajustar o seu caso base para cobrir esses cenários:
def soma_recursiva(n):
# Caso base protegido: se for menor ou igual a 1, interrompe a recursão
if n <= 1:
return max(0, n) # Garante que se for zero ou negativo, não quebre a lógica
else:
return n + soma_recursiva(n - 1)
É importante saber que o Python, por padrão, limita a quantidade de chamadas recursivas seguidas (geralmente em torno de $1000$ chamadas) para proteger o seu computador de ficar sem memória. Se você tentar rodar o seu programa digitando o número 2000, ele vai falhar.
Para problemas de somatórios muito grandes, a boa e velha estrutura de repetição com o laço for ou a função nativa sum(range(1, numero + 1)) acabam sendo mais eficientes e seguras em Python.
Parabéns pela excelente implementação e lógica de código! Você demonstrou total domínio sobre o fluxo de funções recursivas.
Espero que possa ter lhe ajudado!