Como desenvolver uma calculadora de empréstimo consignado em Python

Onde:

• PMT é o valor da parcela;
• P é o valor do principal (empréstimo total);
• r é a taxa de juros mensal;
• n é o número total de parcelas.

Com essa fórmula, podemos construir a lógica principal do nosso código. A seguir, vamos começar a desenvolver a calculadora.

Criando a estrutura inicial da calculadora

Agora que você já conhece os conceitos básicos, o próximo passo é criar a estrutura inicial da calculadora em Python. Para começar, você precisará definir as variáveis que representarão o valor do empréstimo, a taxa de juros e o número de parcelas. Além disso, é importante garantir que o usuário possa inserir esses valores de forma dinâmica, permitindo simulações personalizadas.

Aqui está o esqueleto básico do código:

def calcular_parcela(valor_emprestimo, taxa_juros, num_parcelas):
taxa_mensal = taxa_juros / 100 / 12
parcela = valor_emprestimo * (taxa_mensal * (1 + taxa_mensal)**num_parcelas) / ((1 + taxa_mensal)**num_parcelas – 1)
return parcela

# Exemplo de uso
valor_emprestimo = float(input(“Digite o valor do empréstimo: “))
taxa_juros = float(input(“Digite a taxa de juros anual (%): “))
num_parcelas = int(input(“Digite o número de parcelas: “))

valor_parcela = calcular_parcela(valor_emprestimo, taxa_juros, num_parcelas)
print(f”O valor da parcela é: R$ {valor_parcela:.2f}”)

Essa estrutura simples pede ao usuário para fornecer o valor do empréstimo, a taxa de juros anual e o número de parcelas. Em seguida, utiliza a fórmula que mencionamos anteriormente para calcular o valor da parcela mensal. Essa lógica é a base de qualquer calculadora de empréstimo consignado.

3. Adicionando funcionalidades extras

Agora que temos a estrutura básica, podemos adicionar algumas funcionalidades extras para melhorar a experiência do usuário e tornar a calculadora mais completa. Por exemplo, podemos permitir que o usuário veja o valor total pago ao final do empréstimo e o valor dos juros pagos. Para isso, vamos ajustar o código para incluir essas informações:

def calcular_parcela(valor_emprestimo, taxa_juros, num_parcelas):
taxa_mensal = taxa_juros / 100 / 12
parcela = valor_emprestimo * (taxa_mensal * (1 + taxa_mensal)**num_parcelas) / ((1 + taxa_mensal)**num_parcelas – 1)
return parcela

def calcular_total_pago(parcela, num_parcelas):
return parcela * num_parcelas

def calcular_juros_totais(total_pago, valor_emprestimo):
return total_pago – valor_emprestimo

# Exemplo de uso
valor_emprestimo = float(input(“Digite o valor do empréstimo: “))
taxa_juros = float(input(“Digite a taxa de juros anual (%): “))
num_parcelas = int(input(“Digite o número de parcelas: “))

valor_parcela = calcular_parcela(valor_emprestimo, taxa_juros, num_parcelas)
total_pago = calcular_total_pago(valor_parcela, num_parcelas)
juros_totais = calcular_juros_totais(total_pago, valor_emprestimo)

print(f”O valor da parcela é: R$ {valor_parcela:.2f}”)
print(f”O total pago ao final do empréstimo será: R$ {total_pago:.2f}”)
print(f”O valor total de juros pagos será: R$ {juros_totais:.2f}”)

Com essas novas funções, o usuário pode visualizar não apenas o valor da parcela mensal, mas também o total pago ao final do empréstimo e o valor dos juros pagos ao longo do contrato. Isso é particularmente útil para quem deseja simular diferentes cenários e ter uma visão clara do impacto financeiro do crédito consigando.

4. Melhorando a usabilidade

Agora que a calculadora está funcional, podemos pensar em como melhorar a usabilidade e a interface com o usuário. Uma opção interessante seria implementar uma validação dos dados inseridos, garantindo que o usuário não digite valores incorretos, como taxas de juros negativas ou um número de parcelas muito baixo. Isso ajuda a evitar erros na execução do código e melhora a experiência geral.

Aqui está um exemplo de como adicionar uma validação básica:

def validar_entrada(valor, tipo):
if tipo == “emprestimo” and valor <= 0:
return False
if tipo == “juros” and (valor <= 0 or valor > 100):
return False
if tipo == “parcelas” and valor < 1:
return False
return True

valor_emprestimo = float(input(“Digite o valor do empréstimo: “))
while not validar_entrada(valor_emprestimo, “emprestimo”):
print(“Valor inválido. O valor do empréstimo deve ser positivo.”)
valor_emprestimo = float(input(“Digite o valor do empréstimo: “))

taxa_juros = float(input(“Digite a taxa de juros anual (%): “))
while not validar_entrada(taxa_juros, “juros”):
print(“Taxa de juros inválida. Deve estar entre 0 e 100%.”)
taxa_juros = float(input(“Digite a taxa de juros anual (%): “))

num_parcelas = int(input(“Digite o número de parcelas: “))
while not validar_entrada(num_parcelas, “parcelas”):
print(“Número de parcelas inválido. Deve ser pelo menos 1.”)
num_parcelas = int(input(“Digite o número de parcelas: “))

Com essa validação, garantimos que o usuário insira apenas dados válidos, evitando possíveis erros no cálculo.

5. Exportando resultados para um arquivo

Por fim, uma funcionalidade interessante que você pode adicionar à sua calculadora de empréstimo consignado é a capacidade de exportar os resultados para um arquivo de texto. Isso permite que o usuário tenha um registro das simulações feitas, algo útil para quem está comparando diferentes propostas de empréstimo.

Aqui está um exemplo simples de como implementar essa função:

def exportar_resultado(valor_emprestimo, valor_parcela, total_pago, juros_totais):
with open(“resultado_emprestimo.txt”, “w”) as arquivo:
arquivo.write(f”Valor do empréstimo: R$ {valor_emprestimo:.2f}\n”)
arquivo.write(f”Valor da parcela: R$ {valor_parcela:.2f}\n”)
arquivo.write(f”Total pago: R$ {total_pago:.2f}\n”)
arquivo.write(f”Juros totais: R$ {juros_totais:.2f}\n”)

# No final do código, adicione a chamada para a função
exportar_resultado(valor_emprestimo, valor_parcela, total_pago, juros_totais)
print(“Os resultados foram exportados para o arquivo ‘resultado_emprestimo.txt'”)

Com essa funcionalidade, o usuário pode salvar os resultados da simulação e consultá-los posteriormente, facilitando o planejamento financeiro.

Considerações finais

Desenvolver uma calculadora de empréstimo consignado em Python é uma excelente maneira de aplicar conceitos financeiros e aprimorar suas habilidades de programação. Com uma estrutura simples, é possível calcular o valor das parcelas, o total pago e os juros de forma precisa, oferecendo ao usuário uma ferramenta útil para simular diferentes cenários.

Além disso, adicionar funcionalidades como validação de dados e exportação de resultados torna a calculadora ainda mais robusta e prática. Se você deseja expandir ainda mais esse projeto, pode integrar a calculadora a uma interface gráfica ou mesmo adicionar mais variáveis, como seguros ou taxas administrativas.

Ao seguir esse passo a passo, você estará no caminho certo para criar uma calculadora de empréstimos funcional e personalizada.