Mange finansielle eksperter er dygtige til at bruge Excel til at bygge økonomiske modeller. Men på grund af vanskeligheder med peer review, versionskontrol og manglende evne til at danne rekursive funktioner, er Excel muligvis ikke det bedste valg til mere sofistikerede modeller. På trods af disse ulemper bruger mange finansielle fagfolk stadig Excel, fordi de er mindre sikre på programmeringssprog som Python.
Python er et af de nemmeste programmeringssprog at lære. Fordi den er designet med læsbarhed og brugervenlighed i tankerne, er dens kode kortfattet og tæt på almindeligt engelsk. I denne artikel viser jeg, hvor nemt det er at bygge en Python-likviditetsmodel for lånbetalinger ved at bruge de mest basale funktioner, pakker og datastrukturer.
For at følge med skal du bruge Colaboratory ("Colab" for kort), Googles gratis webbaserede notebook-applikation, der lader dig skrive og udføre kode. Colab er en Python-fortolker, der bruger celler, der kan indeholde kode, Markdown (til let stylet tekst), billeder eller andre data. Colab gemmer løbende værdierne af din kode, mens du skriver, hvilket gør det hurtigt og nemt at fange fejl eller fejl, når de dukker op. (Hvis du ikke ønsker at hoppe i endnu, så følg med i dette eksempel på Colab-notesbog.)
Vi vil bygge en model for et amortiseret lån, der har en planlagt, periodisk betaling på både lånets hovedstol og renter. Den har et fast afdrag for hver periode, og rentedelen af betalingerne falder over tid. Du skal bruge tre Python-biblioteker, samlinger af softwarerutiner, der forhindrer udviklere i at skulle skrive kode fra bunden, til denne model—NumPy, Pandas og Matplotlib:
numpy-financial==1.0.0 pandas==1.2.3 matplotlib==3.2.2 I Colab er Pandas- og Matplotlib-pakkerne installeret som standard, så du behøver kun at installere numpy-financial-biblioteket, hvilket du kan gøre direkte fra Colab. For at installere numpy-financial og importere alle tre biblioteker, du skal bruge senere, skal du åbne en ny Colab-notesbog fra menuen Filer og indsætte følgende i den første kodecelle:
# initial set-up
!pip install numpy_financial
import pandas as pd
import numpy_financial as npf
import matplotlib.pyplot as plt
from collections import namedtuple
Inden vi går videre til næste trin, lad mig forklare den forrige kode, og hvorfor den er skrevet, som den er skrevet. Selvom numpy-financials navn indeholder en bindestreg, skal du bruge en understregning i navnet, når du installerer og importerer det. (For mere information og forklaring på installation af numpy_financial, tjek dokumentationen.) Du vil muligvis også bemærke forkortelser. Foruddefinerede aliaser bruges almindeligvis til pakker - NumPy skrives som np, Pandas som pd. Disse aliaser bruges til at spare dig for at skrive det fulde navn på pakken, hver gang du gerne vil bruge den og hjælper også med at gøre din kode mere læsbar.
NumPy er et af de mest populære Python-biblioteker, der tilføjer understøttelse af store, multidimensionelle arrays sammen med en betydelig samling af matematiske funktioner på højt niveau til at fungere på disse arrays. Det numpy-finansielle bibliotek er en relativt ny pakke, der består af en samling af almindeligt anvendte finansielle funktioner, der er blevet adskilt fra NumPy-hovedbiblioteket og givet deres egen stolthed.
Den enkleste måde at beregne de planlagte rente- og hovedstolvektorer for vores amortiserede låns løbetid er at bruge PMT-, IPMT- og PPMT-funktionerne fra numpy-financial-pakken. PMT-funktionen giver den faste lånebetaling til at betale lånet fuldt ud over et givet antal perioder. IPMT- og PPMT-funktionerne sørger for henholdsvis rente- og afdragsbetalinger. Afhængigt af input til perioden kan IPMT- og PPMT-funktionerne returnere værdier for en enkelt periode eller et antal perioder.
For dette eksempel vil vi give et interval med hele lånets levetid som periodeinput. Som sådan vil vi få vektorarrays med renten i afdrag for hver periode af lånets levetid:
# loan characteristics
original_balance = 500_000
coupon = 0.08
term = 120
# payments
periods = range(1, term+1)
interest_payment = npf.ipmt(
rate=coupon / 12, per=periods, nper=term, pv=-original_balance)
principal_payment = npf.ppmt(
rate=coupon / 12, per=periods, nper=term, pv=-original_balance)
Du vil ikke "se" noget ske i din Colab-fil efter indtastning af koden - det er de grundlæggende låneoplysninger, der er nødvendige for at udføre resten af denne øvelse. (En liste over alle de numpy-økonomiske funktioner, jeg har brugt, deres definitioner og deres input, kan findes i den officielle dokumentation.)
Selvom det er godt at have vektorerne som output, kan det være bedst at visualisere outputtet i form af et diagram, specifikt som et stakplot. For at opsætte diagrammet bruger vi plt , alias for pyplot-samlingen af funktioner fra matplotlib-biblioteket. I vores eksempel vil vi tilføje en forklaring i øverste venstre hjørne og tilføje titler til x-aksen og y-aksen. Da vi ikke ønsker en indre grænse, sætter vi marginerne til 0.
Tilføj endnu en kodecelle, og indsæt følgende kode:
plt.stackplot(periods, interest_payment, principal_payment,
labels=['Interest', 'Principal'])
plt.legend(loc='upper left')
plt.xlabel("Period")
plt.ylabel("Payment")
plt.margins(0, 0)
Som vi kan se, falder interessen over tid. Lånebeholdningen falder også på grund af hovedstolbetalingerne i hver periode. For at opretholde det faste afdrag skal hoveddelen øges.
Pandas-pakken er den mest almindeligt anvendte Python-pakke til at manipulere numeriske tabeller og tidsserier. Det giver hurtige, fleksible og udtryksfulde datastrukturer designet til at gøre arbejdet med relationelle eller mærkede data både nemt og intuitivt. Vi vil oprette en tabel, der inkluderer hovedstol og rentebetalinger samt start- og slutlånsaldi for hver periode:
_# pandas float formatting_
pd.options.display.float_format = '{:,.2f}'.format
_# cash flow table_
cf_data = {'Interest': interest_payment, 'Principal': principal_payment}
cf_table = pd.DataFrame(data=cf_data, index=periods)
cf_table['Payment'] = cf_table['Interest'] + cf_table['Principal']
cf_table['Ending Balance'] = original_balance - \
cf_table['Principal'].cumsum()
cf_table['Beginning Balance'] = [original_balance] + \
list(cf_table['Ending Balance'])[:-1]
cf_table = cf_table[['Beginning Balance', 'Payment', 'Interest',
'Principal', 'Ending Balance']]
cf_table.head(8)
Den første kodelinje anvender visningsformateringsregler for at gøre tabellen mere læsbar ved at tilføje tusinde separatorer og vise tallene med kun to decimaler.
Den anden del af koden instruerer Colab om at inkludere rentebetaling, afdragsbetaling, slutsaldo og oprindelig saldo for hver låneperiode. Omvendte skråstreger fungerer som linjeskift, fordi vi ikke kan have mere end 79 tegn på en enkelt linje.
Hvis du har fulgt med i din egen Colab-notesbog, tillykke! Du har nu kodet en simpel planmæssig amortisering af låneporteføljeprofil ved hjælp af Python.
Der er meget mere, du kan gøre med Python til finansiering, herunder modellering for lån med variabel rentekuponer knyttet til en benchmarkrente og andre lånestrukturer. Forhåbentlig har denne lånemodel givet dig en forsmag på, hvor enkel økonomisk kodning i Python kan være.