Hoe maak je een RSI indicator vanaf nul in Python zonder libraries?
Stel je voor: je zit achter je scherm, de markt beweegt, en je wilt een indicator die je helpt om timing te vinden. Je wilt geen library importeren die alles voor je doet. Je wilt het zelf bouwen, stap voor stap, zodat je precies weet wat er gebeurt.
Vandaag bouwen we een RSI indicator vanaf nul in Python. Geen libraries, gewoon pure code die je kunt vertrouwen.
We doen dit samen, alsof we aan de keukentafel zitten met een bak koffie en een plan. We focussen op wat jij nodig hebt voor algoritmische trading bots: een indicator die werkt in backtests, naadloos praat met broker APIs, en helpt bij risicomanagement.
Geen poespas, geen verborgen stappen. Jij bouwt, jij begrijpt, jij controleert.
Wat je nodig hebt voordat je start
Je hebt een computer nodig met Python 3.9 of nieuwer. Een simpele laptop van €500-€800 is meer dan genoeg.
Zorg dat je een editor hebt, bijvoorbeeld VS Code (gratis) of PyCharm Community (gratis).
Je hebt geen betaalde tools nodig. Je hebt een dataset nodig met koersen. Gebruik een CSV met een kolom ‘close’, bijvoorbeeld een bestand van 1000-5000 regels.
Je kunt dit halen uit een backtesting tool, of een broker API zoals Interactive Brokers of Alpaca. Voor deze oefening is een CSV met sluitkoersen voldoende.
Je hebt tijd nodig: reken op 45-60 minuten voor de eerste versie. Als je een fout maakt, tel dan 10-15 minuten extra per probleem. Hou pen en papier bij de hand voor aantekeningen. Veelgemaakte fouten: je vergeet de data te controleren op null-waarden, je gebruikt te weinig data voor de eerste RSI-waarde, of je maakt de formule te ingewikkeld. We pakken dit slim aan.
Stap 1: begrijp de RSI formule zonder jargon
RSI staat voor Relative Strength Index. Het laat zien of een markt over- of onderverkocht is.
De formule is simpel: RSI = 100 - (100 / (1 + RS)).
RS is de verhouding tussen gemiddelde winst en gemiddeld verlies over een periode, meestal 14 perioden. We berekenen per dag het verschil tussen de huidige close en de vorige close. Positief verschil = winst.
Negatief verschil = verlies. Vervolgens nemen we een gemiddelde van die winsten en verliezen over de afgelopen 14 dagen. Formule in mensentaal: pak de winsten, pak de verliezen, deel de gemiddelde winst door de gemiddelde verliezen, en zet dat om naar een waarde tussen 0 en 100. Simpel, maar krachtig. Veelgemaakte fouten: vergeten om alleen de positieve verschillen als winst te tellen en alleen de negatieve als verlies, of de eerste RSI-waarde te vroeg berekenen zonder voldoende data.
Stap 2: schrijf de code vanaf nul
Open je editor en maak een nieuw bestand: rsi_puur.py. We schrijven drie functions: bereken_winst_en_verlies, bereken_gemiddelden, en bereken_rsi met de PyRSI library.
Geen libraries, alleen basis Python. Eerst laad je de data. We gebruiken een CSV met een kolom ‘close’. Wil je liever technische indicatoren in Python berekenen met professionele tools? Dan zetten we de data eerst om in een lijst van floats.
Hier is een compacte start:
def laad_koersen(csv_pad):
# Verwacht een CSV met een kolom 'close'
koersen = []
with open(csv_pad, 'r') as f:
regels = f.readlines()
for regel in regels[1:]: # skip header
if regel.strip():
delen = regel.strip().split(',')
try:
koers = float(delen[0]) # pas index aan als kolom anders is
koersen.append(koers)
except:
continue
return koersen
Vervolgens berekenen we de verschillen tussen opeenvolgende koersen:
def bereken_winst_en_verlies(koersen):
winsten = []
verliezen = []
for i in range(1, len(koersen)):
verschil = koersen[i] - koersen[i-1]
if verschil > 0:
winsten.append(verschil)
verliezen.append(0.0)
else:
winsten.append(0.0)
verliezen.append(abs(verschil))
return winsten, verliezen
Nu berekenen we de gemiddelden over een periode, typisch 14. We gebruiken een eenvoudige loop:
def bereken_gemiddelden(winsten, verliezen, periode=14):
gem_winst = []
gem_verlies = []
for i in range(len(winsten)):
start = max(0, i - periode + 1)
slice_winst = winsten[start:i+1]
slice_verlies = verliezen[start:i+1]
gem_winst.append(sum(slice_winst) / periode)
gem_verlies.append(sum(slice_verlies) / periode)
return gem_winst, gem_verlies
Tot slot, voor het berekenen van de RSI:
def bereken_rsi(gem_winst, gem_verlies):
rsi = []
for i in range(len(gem_winst)):
if gem_verlies[i] == 0:
rs = float('inf')
else:
rs = gem_winst[i] / gem_verlies[i]
rsi_waarde = 100 - (100 / (1 + rs))
rsi.append(rsi_waarde)
return rsi
Veelgemaakte fouten: vergeten dat de eerste 14 waarden een gemiddelde zijn van minder dan 14 punten, waardoor je RSI te vroeg te extreem wordt. We lossen dit op door het gemiddelde te delen door het aantal beschikbare waarden binnen de periode. Pas de code hierboen licht aan: deel door min(i+1, periode) in plaats van periode. Dit voorkomt scheve eerste waarden.
Stap 3: integreer met backtesting en broker APIs
Als je een backtesting tool gebruikt, zoals Backtrader of een eigen loop, plug je de RSI erin als extra kolom.
Je kunt een signaal genereren als RSI onder 30 (koop) of boven 70 (verkoop). Voor risicomanagement voeg je stop-loss en position sizing toe. Bijvoorbeeld: risico per trade max 1% van je totale kapitaal. Sluit de RSI aan op een broker API, bijvoorbeeld Interactive Brokers via TWS API of Alpaca.
Je haalt elke minuut de nieuwe close, berekent de RSI, en stuurt een order als je signaal klopt. Test eerst met een paper trading account, zonder echt geld.
Pas de periode aan op je timeframe: 14 werkt voor dag- en uurdata, voor minuutdata kan een kortere periode (7-10) beter zijn.
Test dit in een backtest met een dataset van minimaal 5000 candles voor statistische betrouwbaarheid. Veelgemaakte fouten: te snel live gaan zonder backtest, of vergeten dat broker APIs rate limits hebben (bijv. 100-200 calls per minuut). Plan je polling interval op 1-5 minuten om limits te respecteren.
Stap 4: testen, verbeteren en valideren
Maak een simpele backtest: loop over je dataset, pas een basisstrategie toe (RSI onder 30 koop, boven 70 verkoop), en bereken rendement, drawdown en winstpercentage.
Gebruik een startkapitaal van €10.000 en risico van 1% per trade. Controleer de RSI-waarden op een bekende periode. Handmatig: pak 15 koersen, bereken winst/verlies per stap, en check of de eerste RSI-waarde klopt. Een handmatige check duurt 10-15 minuten maar geeft je vertrouwen.
Optimaliseer niet te veel. Kies een periode (bijv.
14) en houd die vast. Verander niet te vaak, anders curve-fit je de data.
Gebruik een out-of-sample dataset voor validatie, bijvoorbeeld de laatste 20% van je data. Veelgemaakte fouten: te veel parameters tunen, of vergeten om transactiekosten mee te nemen (bijv. €0-€2 per trade bij goedkope brokers). Zorg dat je backtest reëel is.
Verificatie-checklist
- Je Python-versie is 3.9 of nieuwer.
- Je CSV bevat een kolom ‘close’ zonder null-waarden.
- Je code berekent winst en verlies correct per stap.
- Je gemiddelden worden over maximaal 14 perioden berekend, met correcte deling bij minder data.
- Je RSI-waarden liggen tussen 0 en 100.
- Je backtest laat een rendement zien, met drawdown en winstpercentage.
- Je signaalregels zijn duidelijk: RSI onder 30 = koop, boven 70 = verkoop.
- Je risicomanagement is ingesteld: 1% risico per trade, stop-loss en position sizing.
- Je broker API is getest met een paper account, zonder echt geld.
- Je handmatige check van een periode klopt met je code.
Als je deze checklist afrondt, heb je een RSI indicator die je zelf hebt gebouwd, die werkt in backtests, en die je kunt inzetten in algoritmische trading bots. Je begrijpt elke stap, je kunt het uitleggen aan een vriend, en je bent klaar voor de volgende trade.