Många finansexperter är skickliga på att använda Excel för att bygga finansiella modeller. Men på grund av svårigheter med referentgranskning, versionskontroll och oförmågan att skapa rekursiva funktioner, kanske Excel inte är det bästa valet för mer sofistikerade modeller. Trots dessa nackdelar använder många finansexperter fortfarande Excel eftersom de är mindre säkra på programmeringsspråk som Python.

Python är ett av de enklaste programmeringsspråken att lära sig. Eftersom den designades med läsbarhet och användarvänlighet i åtanke, är dess kod kortfattad och nära vanlig engelska. I den här artikeln visar jag hur enkelt det är att bygga en Python-kassaflödesmodell för lånebetalningar genom att använda de mest grundläggande funktionerna, paketen och datastrukturerna.

För att följa med måste du använda Colaboratory ("Colab" förkortat), Googles gratis webbaserade anteckningsbokapplikation som låter dig skriva och köra kod. Colab är en Python-tolk som använder celler som kan innehålla kod, Markdown (för lättstilad text), bilder eller annan data. Colab lagrar kontinuerligt värdena på din kod medan du skriver, vilket gör det snabbt och enkelt att fånga fel eller buggar när de dyker upp. (Om du inte vill hoppa in ännu, följ med det här exemplet på Colab-anteckningsboken.)

Se först till att du har de verktyg du behöver

Vi kommer att bygga en modell för ett amorterat lån som har en schemalagd, periodisk betalning som tillämpas på både lånets kapital och ränta. Den har en fast avbetalning för varje period och räntedelen av betalningarna minskar med tiden. Du behöver tre Python-bibliotek, samlingar av mjukvarurutiner som förhindrar utvecklare från att behöva skriva kod från början, för denna modell—NumPy, Pandas och Matplotlib:

• numpy-financial==1.0.0
• pandas==1.2.3
• matplotlib==3.2.2

I Colab är paketen Pandas och Matplotlib installerade som standard, så du behöver bara installera numpy-financial-biblioteket, vilket du kan göra direkt från Colab. För att installera numpy-financial och importera alla tre bibliotek du behöver senare, öppna en ny Colab-anteckningsbok från Arkiv-menyn och klistra in följande i den första kodcellen:

# 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

Innan vi går vidare till nästa steg, låt mig förklara den tidigare koden och varför den är skriven som den är skriven. Även om numpy-financials namn innehåller ett bindestreck måste du använda ett understreck i namnet när du installerar och importerar det. (För mer information och förklaringar om hur du installerar numpy_financial, kolla in dokumentationen.) Du kanske också märker förkortningar. Fördefinierade alias används vanligtvis för paket—NumPy skrivs som np, Pandas som pd. Dessa alias används för att rädda dig från att skriva paketets fullständiga namn varje gång du vill använda det och hjälper även till att göra din kod mer läsbar.

Använd nu NumPy för att ställa in låneegenskaperna

NumPy är ett av de mest populära Python-biblioteken som lägger till stöd för stora, flerdimensionella arrayer, tillsammans med en betydande samling av matematiska funktioner på hög nivå för att fungera på dessa arrayer. Numpy-financial-biblioteket är ett relativt nytt paket som består av en samling vanliga finansiella funktioner som har separerats från NumPy-huvudbiblioteket och fått sin egen stolthet.

Det enklaste sättet att beräkna de planerade ränte- och kapitalvektorerna för vårt amorterade låns löptid är att använda funktionerna PMT, IPMT och PPMT från numpy-financial-paketet. PMT-funktionen tillhandahåller den fasta lånebetalningen för att betala hela lånet under ett givet antal perioder. IPMT- och PPMT-funktionerna tillhandahåller ränte- respektive amorteringsbetalningar. Beroende på indata till perioden kan funktionerna IPMT och PPMT returnera värden för en enstaka period eller ett antal perioder.

För det här exemplet kommer vi att tillhandahålla ett intervall med hela lånetiden som indata för perioden. Som sådana kommer vi att få vektormatriser med räntan på amorteringar för varje period av lånets livslängd:

# 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 kommer inte att "se" något hända i din Colab-fil efter att du har skrivit in koden – det är den grundläggande låneinformationen som behövs för att göra resten av den här övningen. (En lista över alla numpy-ekonomiska funktioner jag har använt, deras definitioner och deras indata finns i den officiella dokumentationen.)

Använd sedan Matplotlib för att skapa ett diagram

Även om det är bra att ha vektorerna som en utdata, kan det vara bäst att visualisera utdata i form av ett diagram, speciellt som en stackplot. För att ställa in diagrammet använder vi plt , aliaset för pyplotsamlingen av funktioner från matplotlib-biblioteket. I vårt exempel kommer vi att lägga till en förklaring i det övre vänstra hörnet och lägga till titlar till x-axeln och y-axeln. Eftersom vi inte vill ha en inre gräns sätter vi marginalerna till 0.

Lägg till ytterligare en kodcell och infoga följande kod:

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 minskar intresset med tiden. Lånesaldot minskar också på grund av amorteringarna i varje period. För att behålla den fasta avbetalningen måste huvuddelen ökas.

Slutligen, använd pandor för att skapa en tabell

Pandas-paketet är det mest använda Python-paketet för att manipulera numeriska tabeller och tidsserier. Den tillhandahåller snabba, flexibla och uttrycksfulla datastrukturer utformade för att göra arbetet med relationsdata eller märkta data både enkelt och intuitivt. Vi kommer att skapa en tabell som inkluderar kapitalbelopp och räntebetalningar, samt start- och slutlånesaldon för varje period:

_# 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örsta raden i koden tillämpar regler för visningsformatering för att göra tabellen mer läsbar genom att lägga till tusen avgränsare och visa siffrorna med bara två decimaler.

Den andra delen av koden instruerar Colab att inkludera räntebetalning, kapitalbetalning, slutsaldo och originalsaldo för varje låneperiod. Omvända snedstreck fungerar som radbrytningar eftersom vi inte kan ha mer än 79 tecken på en enda rad.

Om du har följt med i din egen Colab-anteckningsbok, grattis! Du har nu kodat en enkel schemalagd amorteringslåneportföljprofil med Python.

Det finns mycket mer du kan göra med Python för finansiering, inklusive modellering för lån med rörliga räntekuponger kopplade till en referensränta och andra lånestrukturer. Förhoppningsvis har denna lånemodell gett dig ett smakprov på hur enkel ekonomisk kodning i Python kan vara.