def calcular_valores(n):
if n == 1:
return 1
return n + calcular_valores(n - 1)
if __name__ == "__main__":
n1 = int(input("Digite um número: "))
resultado = calcular_valores(n1)
print(f"A soma de 1 a {n1} é: {resultado}")
Dúvida: Em valores muito grandes, o sistema gera um RecursionError qual seriam as saídas para resolver o problema?
Olá, Luísa. Como vai?
O seu código de soma recursiva está matematicamente impecável! A estrutura com o caso base (if n == 1) e o caso recursivo está muito bem desenhada.
Sobre a sua dúvida: esse erro RecursionError: maximum recursion depth exceeded acontece porque, por padrão, o Python estipula um limite máximo para a sua pilha de chamadas (geralmente em torno de 1000 chamadas consecutivas). Isso é uma trava de segurança do próprio interpretador para evitar que o script consuma toda a memória RAM do computador e trave a máquina (o famoso estouro de pilha ou stack overflow).
Para lidar com valores muito grandes, existem três saídas principais no Python:
A forma mais segura e eficiente na computação para resolver esse problema sem estourar a memória é substituir a recursão por um laço de repetição (while ou for). O laço não cria novas pilhas de contexto na memória, permitindo calcular números gigantescos.
def calcular_valores_iterativo(n):
soma = 0
for i in range(1, n + 1):
soma += i
return soma
Como o seu objetivo é somar todos os números de 1 até $n$, podemos usar a famosa fórmula da Soma de uma Progressão Aritmética (PA), desenvolvida pelo matemático Carl Friedrich Gauss. Ela resolve o problema instantaneamente com apenas uma linha de cálculo matemático, sem laços e sem recursão (complexidade constante de tempo O(1)).
def calcular_valores_matematico(n):
return n * (n + 1) // 2
Se o objetivo do seu projeto for estritamente pedagógico e você precisar manter a recursão rodando com números grandes, você pode instruir o Python a aumentar o limite da pilha de chamadas usando a biblioteca nativa sys.
import sys
# Aumentando o limite para 100.000 chamadas
sys.setrecursionlimit(100000)
def calcular_valores(n):
if n == 1:
return 1
return n + calcular_valores(n - 1)
Nota de boa prática: Use a terceira opção com muito cuidado no dia a dia, pois se o número for excessivamente grande, o programa pode fechar abruptamente devido à falta de memória física no sistema operacional.
Para complementar o seu aprendizado sobre funções em Python, é legal saber que linguagens puramente funcionais utilizam uma técnica chamada Tail Call Optimization (Otimização de Chamada de Cauda) para resolver esse problema de memória em recursões, mas o criador do Python (Guido van Rossum) optou por não implementar isso nativamente no Python, preferindo focar na clareza dos laços iterativos (for/while).
Espero que possa ter lhe ajudado!