Analisando discrepâncias na calculadora de amortização de empréstimos: Excel vs. Python usando numpy financeiro

Resolvendo Discrepâncias nos Cálculos de Amortização de Empréstimos

Script de back-end Python para cálculo de amortização de empréstimos

import datetime as dt
from dateutil.relativedelta import relativedelta
import numpy_financial as npf
import pandas as pd

class Loan:
    def __init__(self, rate, term, loan_amount, amortization_type, frequency, start=dt.date.today().isoformat()):
        self.rate = rate
        self.term = term
        self.loan_amount = loan_amount
        self.start = dt.datetime.fromisoformat(start).replace(day=1)
        self.frequency = frequency
        self.periods = self.calculate_periods()
        self.period_rate = self.calculate_period_rate()
        self.pmt = npf.pmt(self.period_rate, self.periods, -self.loan_amount)
        self.amortization_type = amortization_type
        self.table = self.loan_table()

    def calculate_periods(self):
        if self.frequency == 'monthly':
            return self.term * 12
        elif self.frequency == 'quarterly':
            return self.term * 4
        elif self.frequency == 'semi-annual':
            return self.term * 2
        elif self.frequency == 'annual':
            return self.term
        else:
            raise ValueError("Unsupported frequency")

    def calculate_period_rate(self):
        if self.frequency == 'monthly':
            return self.rate / 12
        elif self.frequency == 'quarterly':
            return self.rate / 4
        elif self.frequency == 'semi-annual':
            return self.rate / 2
        elif self.frequency == 'annual':
            return self.rate
        else:
            raise ValueError("Unsupported frequency")

Abordagem de fórmula Excel para amortização de empréstimos

Fórmula Excel para Amortização Francesa

=PMT(4.5%/1, 10*1, -1500000)
=IPMT(4.5%/1, A2, 10*1, -1500000)
=PPMT(4.5%/1, A2, 10*1, -1500000)
=A2-P2
for each period

Implementando cálculo de cronograma de amortização em Python

Código Python para cronograma de amortização

def loan_table(self):
    if self.frequency == 'monthly':
        periods = [self.start + relativedelta(months=x) for x in range(self.periods)]
    elif self.frequency == 'quarterly':
        periods = [self.start + relativedelta(months=3*x) for x in range(self.periods)]
    elif self.frequency == 'semi-annual':
        periods = [self.start + relativedelta(months=6*x) for x in range(self.periods)]
    elif self.frequency == 'annual':
        periods = [self.start + relativedelta(years=x) for x in range(self.periods)]
    else:
        raise ValueError("Unsupported frequency")

    if self.amortization_type == "French":
        interest = [npf.ipmt(self.period_rate, month, self.periods, -self.loan_amount, when="end") for month in range(1, self.periods + 1)]
        principal = [npf.ppmt(self.period_rate, month, self.periods, -self.loan_amount) for month in range(1, self.periods + 1)]
        table = pd.DataFrame({'Payment': self.pmt, 'Interest': interest, 'Principal': principal}, index=pd.to_datetime(periods))
        table['Balance'] = self.loan_amount - table['Principal'].cumsum()
    elif self.amortization_type == "Italian":
        interest = [self.loan_amount * self.period_rate]
        principal_payment = self.loan_amount / self.periods
        principal = [principal_payment]
        payment = [interest[0] + principal[0]]
        for month in range(1, self.periods):
            interest_payment = (self.loan_amount - (month) * principal_payment) * self.period_rate
            interest.append(interest_payment)
            principal.append(principal_payment)
            payment.append(interest_payment + principal_payment)

        principal[-1] = self.loan_amount - sum(principal[:-1])
        payment[-1] = interest[-1] + principal[-1]

        table = pd.DataFrame({'Payment': payment, 'Interest': interest, 'Principal': principal}, index=pd.to_datetime(periods))
        table['Balance'] = self.loan_amount - table['Principal'].cumsum()
    else:
        raise ValueError("Unsupported amortization type")
    return table.round(2)

Perguntas frequentes sobre cálculos de amortização de empréstimos

1. Por que meus cronogramas de amortização em Python e Excel são diferentes?
2. As diferenças podem surgir de diversos métodos de composição, práticas de cálculo de juros e diferenças de arredondamento. Garantir a consistência nestes aspectos é crucial.
3. O que é numpy_financial biblioteca usada em cálculos de empréstimos?
4. numpy_financial fornece funções financeiras, como PMT, IPMT, e PPMT para calcular pagamentos, juros e principal de empréstimos e investimentos.
5. Como posso garantir que meus resultados do Python correspondam ao Excel?
6. Verifique se a frequência de capitalização, as taxas de juros e os métodos de arredondamento são consistentes entre Python e Excel.
7. O que faz o PMT função fazer?
8. O PMT A função calcula o pagamento fixo necessário para amortizar totalmente um empréstimo durante um determinado número de períodos com uma taxa de juros constante.
9. Por que a frequência composta é importante?
10. A frequência de capitalização afeta a forma como os juros são calculados e pode impactar significativamente o valor total do pagamento e o cronograma de amortização.
11. Qual é a diferença entre os métodos de amortização franceses e italianos?
12. A amortização francesa envolve pagamentos constantes com parcelas variadas de principal e juros, enquanto a amortização italiana tem pagamentos fixos de principal com valores decrescentes de juros.
13. Como é que cumsum() função ajuda nos cronogramas de amortização?
14. O cumsum() A função calcula a soma acumulada, útil para determinar o saldo restante do empréstimo após cada pagamento.
15. As diferenças de arredondamento podem afetar os cálculos dos empréstimos?
16. Sim, mesmo pequenas diferenças de arredondamento podem levar a discrepâncias perceptíveis em vários períodos. Práticas consistentes de arredondamento são essenciais.
17. O que são IPMT e PPMT funções usadas para?
18. IPMT calcula a parcela de juros de um pagamento, enquanto PPMT calcula a parcela do principal para um determinado período de um empréstimo.

Considerações finais sobre discrepâncias de amortização

Resolver as discrepâncias entre os cálculos de amortização de empréstimos em Python e Excel requer uma compreensão detalhada dos métodos subjacentes usados ​​por cada plataforma. Ao garantir frequências de composição consistentes, práticas de cálculo de juros e métodos de arredondamento, é possível obter resultados correspondentes. Esta exploração destaca a importância da atenção meticulosa aos detalhes nos cálculos financeiros para garantir precisão e confiabilidade em diferentes ferramentas e softwares.