Python: modo più intelligente per calcolare i pagamenti dei prestiti

Question

Come calcolare il canone mensile su un prestito?

data è:

• una: un importo del prestito.
• b: il periodo di prestito (numero di mesi).
• c: il tasso di interesse p.a. (gli interessi vengono calcolati e aggiunti ogni mese, viene aggiunto 1/12 dell'interesse. Quindi se l'interesse è del 12%, l'interesse dell'1% viene aggiunto ogni mese).
• d: la quantità di denaro dovuta dopo la fine del periodo.

Questo problema è un po 'diverso dal solito poiché, l'obiettivo non è quello di avere il prestito pagato dopo che il periodo unico è terminato, ma deve ancora un importo che è stato dato. Sono stato in grado di trovare un algoritmo in modo da risolvere il problema se volessi pagare l'intero importo, ma di sicuro non funzionerebbe per questo problema in cui l'obiettivo è finire a causa di un dato ammontare piuttosto che non dover nulla.

Sono riuscito a trovare una soluzione a questo problema iniziando con un'ipotesi e poi continuando a migliorare tale ipotesi fino a quando non fosse abbastanza vicino. Mi chiedo tuttavia, se c'è un modo migliore per calcolare semplicemente questo, piuttosto che solo indovinare.

Modifica: Ecco come lo sto facendo ora.

def find_payment(start, end, months, interest): 
    difference = start 
    guess = int(start/months * interest) 
    while True: 
     total = start 
     for month in range(1, months + 1): 
      ascribe = total * interest/12 
      total = total + ascribe - guess 
     difference = total - end 
     # See if the guess was good enough. 
     if abs(difference) > start * 0.001: 
      if difference < 0: 
       if abs(difference) < guess: 
        print "payment is %s" % guess 
        return evolution(start, guess, interest, months) 
       else: 
        mod = int(abs(difference)/start * guess) 
        if mod == 0: 
         mod = 1 
        guess -= mod 
      else: 
       mod = int(difference/start * guess) 
       if mod == 0: 
        mod = 1 
       guess += mod 
     else: 
      print "payment is %s" % guess 
      return evolution(start, guess, interest, months) 

evoluzione è solo una funzione che consente di visualizzare come il prestito sarà simile pagamento per il pagamento e l'interesse per interessi, riassumendo importo totale degli interessi pagati ecc

Un esempio potrebbe essere se volevo scoprire i pagamenti mensili per un prestito a partire da $ 100k e termina a $ 50k con un interesse dell'8% e una durata di 70 mesi, chiamando

>>> find_payment(100000, 50000, 70, 0.08) 
payment is 1363 

Nel caso di cui sopra vorrei finire a causa 49935, e Ho attraversato il ciclo 5 volte. La quantità di volte necessaria per passare attraverso il ciclo dipende da quanto vicino non riesco ad ottenere l'importo e varia un po '.

Answer 1

Questo è fondamentalmente un mortgage repayment calculation.

Supponendo che inizio è maggiore di fine, e che l'interesse è compreso tra 0 e 1 (vale a dire 0,1 per il 10% di interesse)

prima prendere in considerazione la parte del pagamento che si desidera pagare.

Principal = start - end 

Il pagamento mensile è data da:

pay_a = (interest/12)/(1 - (1+interest/12)^(-months))) * Principal 

è quindi necessario prendere in considerazione l'interesse supplementare. Che è proprio uguale ai tempi principali rimanenti l'interesse mensile

pay_b = interest/12 * end 

Così il pagamento totale è

payment = (interest/12) * (1/(1 - (1+interest/12)^(-months))) * Principal + end) 

Sul esempio che ha dato di

Start: 100000 
End: 50000 
Months: 70 
Interest: 8% 
pay_a = 896.20 
pay_b = 333.33 
Payment = 1229.54 

Quando ho provato questi valori in Excel, dopo 70 pagamenti il ​​prestito rimanente era 50.000. Questo presuppone che tu paghi gli interessi sul nozionale prima che il pagamento venga effettuato ogni mese.

Answer 2

È possibile continuare a pagare gli interessi di ogni mese; allora, sarai sempre debitore della stessa situazione.

Owe_1 = a 

Int_2 = Owe_1*(InterestRate/12) 
Pay_2 = Int_2 
Owe_2 = Owe_1 + Int_2 - Pay_2 # ==> Owe_1 + Int_2 - Int_2 = Owe_1 

Int_3 = Owe_2*(InterestRate/12) 
Pay_3 = Int_3 
Owe_3 = Owe_2 + Int_3 - Pay_3 # ==> Owe_2 + Int_3 - Int_3 = Owe_2 = Owe_1 

Answer 3

Forse il modo più semplice per pensare a questo è quello di dividere il prestito in due parti, una parte che deve essere rimborsato in pieno e un'altra parte in cui non si paga fuori nulla. Hai già calcolato il canone mensile per la prima parte.

Answer 4

pitone codice per calcolare emi

class EMI_CALCULATOR(object): 
# Data attributes 
# Helps to calculate EMI 

    Loan_amount = None # assigning none values 
    Month_Payment = None # assigning none values 
    Interest_rate = None #assigning none values 
    Payment_period = None #assigning none values 

    def get_loan_amount(self): 
#get the value of loan amount 
     self.Loan_amount = input("Enter The Loan amount(in rupees) :") 
     pass 

    def get_interest_rate(self): 
    # get the value of interest rate 
     self.Interest_rate = input("Enter The Interest rate(in percentage(%)) : ") 
     pass 

    def get_payment_period(self): 
    # get the payment period" 
     self.Payment_period = input("Enter The Payment period (in month): ") 
     pass 


    def calc_interest_rate(self): 
    # To calculate the interest rate" 
     self.get_interest_rate() 

     if self.Interest_rate > 1: 
     self.Interest_rate = (self.Interest_rate /100.0) 

     else: 
     print "You have not entered The interest rate correctly ,please try again " 
     pass 

    def calc_emi(self): 
    # To calculate the EMI"   

     try: 

     self.get_loan_amount() #input loan amount 
     self.get_payment_period() #input payment period 
     self.calc_interest_rate() #input interest rate and calculate the interest rate 

     except NameError: 
      print "You have not entered Loan amount (OR) payment period (OR) interest rate correctly,Please enter and try again. " 

     try: 
     self.Month_Payment = (self.Loan_amount*pow((self.Interest_rate/12)+1, 
          (self.Payment_period))*self.Interest_rate/12)/(pow(self.Interest_rate/12+1, 
          (self.Payment_period)) - 1) 

     except ZeroDivisionError: 
        print "ERROR!! ZERO DIVISION ERROR , Please enter The Interest rate correctly and Try again." 

     else: 
     print "Monthly Payment is : %r"%self.Month_Payment 
     pass 


    if __name__ == '__main__':# main method 

     Init = EMI_CALCULATOR() # creating instances 


     Init.calc_emi() #to calculate EMI 

per maggiori info visita: https://emilgeorgejames.wordpress.com/2015/07/29/python-emi-equated-monthly-installment-calculator/

Answer 5

questo un modo piuttosto dettagliato, ma darà l'intero pagamento così

# Mortgage Loan that gives the balance and total payment per year 

# Function that gives the monthly payment 
def f1 (principle,annual_interest_rate,duration): 
    r = annual_interest_rate/1200 
    n = duration*12 
    a=principle*r*((1+r)**n) 
    b= (((1+r)**n)- 1) 
    if r > 0 : 
     MonthlyPayment = (a/b) 
    else : 
     MonthlyPayment = principle/n 

    return MonthlyPayment 

# Function that gives the balance 
def f2 (principle,annual_interest_rate,duration,number_of_payments): 
    r = annual_interest_rate/1200 
    n = duration*12 
    a= ((1+r)**n) 
    b= ((1+r)**number_of_payments) 
    c= (((1+r)**n)-1) 
    if r > 0 : 
     RemainingLoanBalance = principle*((a-b)/c) 
    else : 
     RemainingLoanBalance = principle*(1-(number_of_payments/n)) 

    return RemainingLoanBalance 
# Entering the required values 
principle=float(input("Enter loan amount: ")) 
annual_interest_rate=float(input("Enter annual interest rate (percent): ")) 
duration=int(input("Enter loan duration in years: ")) 

# Output that returns all useful data needed 
print ("LOAN AMOUNT:",principle,"INTEREST RATE (PERCENT):",annual_interest_rate) 
print ("DURATION (YEARS):",duration,"MONTHLY PAYMENT:",int(f1(principle,annual_interest_rate,duration))) 


k=duration+1 
BALANCE=principle 
total=0 
for i in range (1,k): 
    TOTALPAYMENT= f1(BALANCE,annual_interest_rate,k-i)*12 
    total+= TOTALPAYMENT 
    BALANCE= f2(principle,annual_interest_rate,duration,12*i) 
    print("YEAR:",i,"BALANCE:",int(BALANCE),"TOTAL PAYMENT",int(total)) 

Answer 6

Come su Questo?

def EMI_calc(principle, rate, time, frequency): 
    return (principle/((1-((1+(rate/frequency))**(-1*(time*frequency))))/(rate/frequency))) 

print(""" 
----- Welcome to EMI programe for Python ----- 
""") 
print("\n You have chosen to know the EMI for Loan.\n") 
input('\nTo Continue Press ENTER --- to ABORT Press ctrl+c > \n') 

print("\nPlease Enter amount of Loan to be taken: >\n") 
principle = int(input()) 
print("\nEnter rate of interst (%): >\n") 
rate = float(input())/100 
print("\nEnter Term (Years): >\n") 
time = float(input()) 
print("\nPlease enter the frequency of installments) : >\n") 
frequency = int(input()) 

EMI = round(EMI_calc(principle, rate, time, frequency),0) 

print(""" 

--------------------------------------------------------------------- 

""") 
print(f""" 
The EMI for Loan of Rs.{principle}; 
at interest rate of {rate*100} % for {time} years; 
would be: Rs.""", EMI) 

print(""" 

--------------------------------------------------------------------- 

""") 

Answer 7

Ecco uno snippet di codice che utilizza le funzioni di numpy. Questo mostra il pagamento, il capitale, gli interessi, la rata e il totale_ogni ogni mese. Eseguilo e vedi l'output. È anche possibile controllare la sintassi delle funzioni "IPMT()" e "PPMT()" di Excel per ulteriori spiegazioni degli argomenti. https://docs.scipy.org/doc/numpy-1.13.0/reference/generated/numpy.pmt.html#numpy.pmt

import math 
import numpy as np 
rate = 0.08 
start_amount = 100000.0 
end_amount = 50000.0 
diff_amount = start_amount - end_amount 
# nr_years = 4 
payment_frequency = int (12) 
nr_months = 70 # = nr_years * payment_frequency 
per_np = np.arange (nr_months) + 1 # +1 because index starts with 1 here 
pay_b = rate/payment_frequency * end_amount 
ipmt_np = np.ipmt (rate/payment_frequency, per_np, nr_months, diff_amount) - pay_b 
ppmt_np = np.ppmt (rate/payment_frequency, per_np, nr_months, diff_amount) 
for payment in per_np: 
    idx = payment - 1 
    principal = math.fabs (ppmt_np [idx]) 
    start_amount = start_amount - principal 
    interest = math.fabs (ipmt_np [idx]) 
    instalment = principal + interest 
    print payment, "\t", principal, "\t", interest, "\t\t", instalment, "\t\t", start_amount 
print np.sum (ipmt_np)