Python
Criando uma classe Python para cálculo do Sistema de Amortização Constante (SAC)

Criando uma classe Python para cálculo do Sistema de Amortização Constante (SAC)

“Amortizar pode ser definido como o processo de saldar uma dívida, originada por meio de empréstimo ou financiamento, de forma parcelada em um determinado período de tempo e de acordo com um sistema previamente estabelecido em contrato” – Livro: Introdução a Administração Financeira com HP12C

A amortização de uma dívida pode ser feita por meio de diferentes tipos de sistemas de cálculo. Em alguns financiamentos imobiliários, como no caso do programa Minha Casa Minha Vida, é utilizado o sistema de amortização constante (SAC). A principal característica do SAC é que a amortização é feita por meio de parcelas iguais, desta forma os valores dos juros e prestações são decrescentes. 

Neste tutorial iremos aprender como criar uma classe Python para o cálculo do SAC. 

Criando a classe SAC

Na Figura 1 temos a representação em UML da estrutura da classe SAC a ser criada. Como pode ser observado ela é composta de três atributos e dois métodos.

Figura 1: Classe SAC

As fórmulas a serem utilizadas são:

amortizacao = saldo devedor / parcelas

juros = (taxa * saldo devedor) / 100

pagamento = juros + amortizacao

saldo devedor = saldo devedor anterior - amortizacao

A seguir temos a implementação da classe em código Python. 

# Classe para Calculo de Amortizacao com SAC

class SAC:
  def __init__(self, principal, taxa, parcelas):
    self.__principal = principal
    self.__taxa = taxa
    self.__parcelas = parcelas
  
  def show(self):
    dash  = '-'*42
    amort = self.__principal/self.__parcelas
    saldo = self.__principal
    print(dash) 
    print('{:<2}{:>10}{:>10}{:>10}{:>10}'.format('#','juros','amort','pgto','saldo')) 
    print(dash) 
    for n in range(1,self.__parcelas+1):
      juros = (saldo * self.__taxa)/100
      pgto  = juros + amort
      saldo -= amort
      print('{:<2}{:>10}{:>10}{:>10}{:>10}'.format(n,juros,amort,pgto,saldo)) 
    print(dash)  

Agora iremos criar um código para testar a classe criada. Para isto podemos utilizar o seguinte problema:

Um advogado comprou uma sala para instalar seu escritório por $ 120.000,00 utilizando o sistema de amortização constante (SAC). O banco financiou a compra dessa sala em 24 meses com juros de 2% ao mês. 

A seguir temos a solução utilizando a classe SAC:

sac = SAC(120000,2,24)
sac.show()

Ao ser executado o código acima retornará à seguinte saída:

------------------------------------------
#      juros     amort      pgto     saldo
------------------------------------------
1       2400      5000      7400    115000
2       2300      5000      7300    110000
3       2200      5000      7200    105000
4       2100      5000      7100    100000
5       2000      5000      7000     95000
6       1900      5000      6900     90000
7       1800      5000      6800     85000
8       1700      5000      6700     80000
9       1600      5000      6600     75000
10      1500      5000      6500     70000
11      1400      5000      6400     65000
12      1300      5000      6300     60000
13      1200      5000      6200     55000
14      1100      5000      6100     50000
15      1000      5000      6000     45000
16       900      5000      5900     40000
17       800      5000      5800     35000
18       700      5000      5700     30000
19       600      5000      5600     25000
20       500      5000      5500     20000
21       400      5000      5400     15000
22       300      5000      5300     10000
23       200      5000      5200      5000
24       100      5000      5100         0
------------------------------------------

Com isso concluímos o nosso tutorial da classe SAC em Python. Logicamente, é possível criar essa classe em outras linguagens de programação, basta que sejam aplicadas as mesmas regras usando os recursos da linguagem que deseja usar.