2009-10-06 11 views
6

¿Cómo calcular la tarifa mensual de un préstamo?Python: forma más inteligente de calcular los pagos del préstamo

dado es:

  • una: una cantidad de préstamo.
  • b: el período de préstamo (número de meses).
  • c: la tasa de interés p.a. (los intereses se calculan y agregan cada mes, se agrega 1/12 del interés. Por lo tanto, si el interés es del 12%, se agrega un interés del 1% cada mes).
  • d: la cantidad de dinero que se debe al final del período.

Este problema es un poco diferente de lo habitual ya que, el objetivo no es que el préstamo se pague después de que haya finalizado el único período, sino que aún debe una cantidad que se otorga. Pude encontrar un algoritmo para resolver el problema si quería pagar la cantidad total, pero no va a funcionar para este problema donde el objetivo es terminar debiendo una cantidad determinada en lugar de no deber nada.

Me las arreglé para hacer una solución a este problema comenzando con una suposición y luego seguir mejorando esa suposición hasta que estuvo lo suficientemente cerca. Sin embargo, me preguntaba si existe una mejor manera de simplemente calcular esto, en lugar de simplemente adivinar.

Editar: Así es como lo estoy haciendo ahora.

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) 

la evolución es sólo una función que muestra cómo el préstamo se vería como pago para el pago y el interés de interés, resumiendo cantidad total de intereses pagados, etc.

Un ejemplo sería si quería averiguar los pagos mensuales de un préstamo a partir de $ 100k y terminando en $ 50k con un interés del 8% y una duración de 70 meses, llamando

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

en el caso anterior me gustaría terminar debiendo 49935, y Pasé por el ciclo 5 veces. La cantidad de veces que se necesita para pasar por el ciclo depende de cuán cerca esté de llegar al monto y varía un poco.

+1

tal vez si usted puede proporcionar la solución de adivinanzas, se vuelve más clara de lo que quiere hacer. – nosklo

+0

¿no es esto solo una simple progresión geométrica? http://en.wikipedia.org/wiki/Geometric_progression – Pod

+0

¿Qué está haciendo la función "evolution()"? ¿Dónde puedo encontrar esa función? –

Respuesta

9

Esto es básicamente un mortgage repayment calculation.

Suponiendo que inicio es mayor que fin, y que el interés es entre 0 y 1 (es decir, 0,1 para el 10% de interés)

Consideremos en primer lugar la parte del pago que desea pagar.

Principal = start - end 

El pago mensual es dada por:

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

este caso es necesario tener en cuenta el interés adicional. ¿Qué es exactamente igual a los tiempos principales restantes el interés mensual

pay_b = interest/12 * end 

lo tanto, el pago total es

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

En el ejemplo que diste de

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

Cuando probé estos valores en Excel, después de 70 pagos el préstamo restante fue de 50,000. Esto supone que pague el interés en el nocional antes de que el pago se realice cada mes.

0

Puede seguir pagando los intereses de cada mes; entonces, siempre deberás el mismo dinero.

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 
4

Tal vez la forma más fácil de pensar en esto es dividir el préstamo en dos partes, una parte que es para ser pagado en su totalidad y otra parte en la que no paga nada. Ya ha calculado la tarifa mensual para la primera parte.

+0

+1, ¡exactamente! La equivalencia contable más simple en los libros, realmente. –

+0

Inteligente para dividir el préstamo en dos partes, no pensó en eso. – googletorp

0

pitón código para calcular 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 

para obtener más información, visite: https://emilgeorgejames.wordpress.com/2015/07/29/python-emi-equated-monthly-installment-calculator/

0

Esta bien una forma detallada, pero dará todo el pago, así

# 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)) 
0

¿Qué tal ¿esta?

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(""" 

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

""") 
+1

¡Bienvenido a Stack Overflow! Gracias por este fragmento de código, que puede brindar alguna ayuda inmediata. Una explicación adecuada [mejoraría en gran medida] (// meta.stackexchange.com/q/114762) su valor educativo al mostrar * por qué * esta es una buena solución al problema, y ​​lo haría más útil para lectores futuros con similares, pero no idénticas, preguntas. Por favor [edite] su respuesta para agregar una explicación y dar una indicación de qué limitaciones y suposiciones se aplican. –

0

Aquí hay un fragmento de código que usa las funciones numpy. Esto le muestra el pago, el capital, el interés, el abono y la suma total cada mes. Ejecútelo y vea la salida. También puede verificar la sintaxis de las funciones "IPMT()" y "PPMT()" de Excel para obtener una explicación más detallada de los argumentos. 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) 
Cuestiones relacionadas