Een basislijnplot maken in Matplotlib
We beginnen met het maken van een eenvoudige lijnplot en passen die vervolgens aan zodat hij overzichtelijker en informatiever wordt.
Een lijnplot maken met plt.plot()
Voor een lijnplot gebruiken we de functie plt.plot(). Deze functie neemt twee parameters: de waarden voor de x-as en de y-as. In ons geval gebruiken we de kolom met datums voor de x-as en de kolom met slotkoersen voor de y-as. Hier is de code:
# Extract the date and close price columns
dates = df['Date']
closing_price = df['Close']
# Create a line plot
plt.plot(dates, closing_price)
# Show the plot
plt.show()Als je de bovenstaande code uitvoert, zie je een eenvoudige lijnplot van de DJIA-koers.
De lijnplot aanpassen
Matplotlib biedt veel mogelijkheden voor verdere aanpassingen, die je naar eigen behoefte kunt inzetten.
De lijnkleur instellen
Standaard tekent plt.plot() een blauwe lijn. Je kunt de lijnkleur wijzigen door de parameter color mee te geven. Deze parameter kan een kleurnaam of een hex-code zijn.
Voorbeeld:
# Plot in rode kleur
plt.plot(dates, closing_price, color='red')
# Show the plot
plt.show()Deze code tekent een rode lijn in plaats van een blauwe, zoals hieronder:
Eenvoudige lijnplot in het rood
De lijndikte instellen
Je kunt ook de lijndikte aanpassen met de parameter linewidth in plt.plot(). Deze parameter neemt een drijvende-kommagetal dat de dikte van de lijn aangeeft.
Voorbeeld:
# Lijndikte vergroten
plt.plot(dates, closing_price, linewidth=3)
# Show the plot
plt.show()Deze code tekent een lijn met dikte 3 in plaats van de standaarddikte, zoals hieronder:
Dikkere lijnen in de plot door hogere linewidth
De lijnstijl instellen
Je kunt de lijnstijl aanpassen met de parameter linestyle van plt.plot(). Deze parameter neemt een string die de lijnstijl voorstelt. De documentatie van Matplotlib geeft een uitgebreide lijst met stijlen.
Zo gebruik je deze in code:
# Lijnen afzonderlijk plotten als solid, dotted, dashed en dashdot
plt.plot(dates, closing_price, linestyle='solid') # Default line style
plt.plot(dates, closing_price, linestyle='dotted')
plt.plot(dates, closing_price, linestyle='dashed')
plt.plot(dates, closing_price, linestyle='dashdot')
# Show the plot
plt.show()Markers toevoegen aan lijnplots
Met markers kun je specifieke punten op de lijnplot accentueren. Er zijn allerlei symbolen beschikbaar als marker; zie de Matplotlib-documentatie voor een overzicht.
Voorbeeld van markers in een lijnplot:
# Voeg een kruisje toe als marker voor elk punt
plt.plot(df['Date'], df['Close'], marker='x')
# Show the plot
plt.show()In de bovenstaande code gebruiken we kruisjes (x) om de Close-prijzen van de DJIA te markeren, zoals hieronder:
Labels en titel toevoegen
Om de plot informatiever te maken, kunnen we aslabels en een titel toevoegen. Dat kan met plt.xlabel(), plt.ylabel() en plt.title().
Voorbeeld:
plt.plot(dates, closing_price, color='red', linewidth=2)
plt.xlabel('Date')
plt.ylabel('Closing Price')
plt.title('DJIA Stock Price')
# Show the plot
plt.show()Deze code tekent een rode lijn met dikte 2, met op de x-as het label ‘Date’, op de y-as ‘Closing Price’ en de titel ‘DJIA Stock Price’.
Rasterlijnen toevoegen
We kunnen ook rasterlijnen toevoegen om de plot beter leesbaar te maken. Dat kan met de functie plt.grid(), die een booleaanse waarde neemt om het raster al dan niet te tonen.
Voorbeeld:
plt.plot(dates, closing_price, color='red', linewidth=2)
plt.xlabel('Date')
plt.ylabel('Closing Price')
plt.title('DJIA Stock Price')
# Add the grid
plt.grid(True)
# Show the plot
plt.show()Je ziet dan rasterlijnen in de plot:
Matplotlib-lijnplots met meerdere lijnen
Soms wil je meerdere lijnen in dezelfde grafiek plotten. Dat kan door plt.plot() meerdere keren aan te roepen met verschillende data. Voorbeeld:
# Lijnplot van de Open- en Close-prijzen
plt.plot(df['Date'], df['Open'])
plt.plot(df['Date'], df['Close'])
plt.title('DJIA Open and Close Prices')
plt.xlabel('Date')
plt.ylabel('Price')
plt.show()In de bovenstaande code plotten we zowel de Open- als de Close-prijzen van de DJIA in één grafiek.
Matplotlib-lijnplots met dubbele y-assen
Het kan voorkomen dat je twee variabelen met verschillende schalen in dezelfde plot wilt weergeven. In zulke gevallen zijn dubbele y-assen een effectieve manier om de relatie tussen variabelen te visualiseren zonder de duidelijkheid van de afzonderlijke schalen te verliezen.
Voor een lijnplot met dubbele y-assen gebruiken we de functie twinx(). Deze maakt een nieuwe y-as die dezelfde x-as deelt als de oorspronkelijke plot.
Hier is een voorbeeld:
# Create a new variable for demonstration purposes
df['High_minus_Low'] = df['High'] - df['Low']
# Create a basic line plot for the Close prices
fig, ax1 = plt.subplots()
ax1.plot(df['Date'], df['Close'], color='blue', label='Close Price')
ax1.set_xlabel('Date')
ax1.set_ylabel('Closing Price', color='blue')
ax1.tick_params(axis='y', labelcolor='blue')
# Create a twin axis for the High_minus_Low variable
ax2 = ax1.twinx()
ax2.plot(df['Date'], df['High_minus_Low'], color='green', label='High - Low')
ax2.set_ylabel('High minus Low', color='green')
ax2.tick_params(axis='y', labelcolor='green')
# Add a title and show the plot
plt.title('DJIA Stock Price and High-Low Difference with Twin Axes')
plt.show()En de resulterende plot met dubbele y-assen:
Statistische informatie toevoegen aan Matplotlib-lijnplots
Naast het visualiseren van trends en patronen kunnen lijnplots ook statistische informatie tonen, zoals regressielijnen en foutmarges.
Een regressielijn toevoegen in Matplotlib
Een regressielijn is een lijn die het best bij de punten in de plot past en kan worden gebruikt om toekomstige waarden te modelleren en te voorspellen. We kunnen een regressielijn toevoegen met de functie polyfit() uit NumPy, die een polynomiale regressielijn op onze datapuntenset fit.
import matplotlib.dates as mdates
# Convert Date column to numeric value
df['Date'] = mdates.date2num(df['Date'])
# Add regression line to plot
coefficients_open = np.polyfit(df['Date'], df['Open'], 1)
p_open = np.poly1d(coefficients_open)
coefficients_close = np.polyfit(df['Date'], df['Close'], 1)
p_close = np.poly1d(coefficients_close)
fig, ax = plt.subplots()
ax.plot(df['Date'], df['Open'], '.', label='Open Price')
ax.plot(df['Date'], p_open(df['Date']), '-', label='Open Regression Line')
ax.plot(df['Date'], df['Close'], '.', label='Close Price')
ax.plot(df['Date'], p_close(df['Date']), '-', label='Close Regression Line')
ax.set_title('DIJA Stock Prices')
ax.set_xlabel('Date')
ax.set_ylabel('Price')
ax.legend()
# Format x-axis labels as dates
date_form = mdates.DateFormatter("%Y-%m-%d")
ax.xaxis.set_major_formatter(date_form)
plt.gcf().autofmt_xdate()
plt.show()In deze code converteren we eerst datums naar numerieke waarden met de functie date2num() en gebruiken daarna polyfit() om de coëfficiënten voor de regressielijn te verkrijgen. We gebruiken poly1d() om de lijn te plotten. De originele datapunten plotten we als punten en de regressielijn als een doorgetrokken lijn.
Foutbalken toevoegen
Foutbalken zijn een grafische weergave van de variabiliteit in data en kunnen de onzekerheid in metingen aangeven.
Dit is vooral nuttig wanneer je fouten in het verzamelproces verwacht, zoals bij temperatuur- of luchtkwaliteitsdata. Hoewel koersen zeker zijn, nemen we voor dit voorbeeld een potentiële fout van één standaarddeviatie aan en plotten we die met de functie errorbar in Matplotlib.
# Calculate standard deviation of data
std = df['Close'].std()
# Add error bars to plot
plt.errorbar(df['Date'], df['Close'], yerr=std/2, fmt='.', label='Close Price')
plt.title('DIJA Stock Prices')
plt.xlabel('Date')
plt.ylabel('Price')
plt.legend()
plt.show()In deze code berekenen we eerst de standaarddeviatie van de Close-prijzen in ons dataset. Vervolgens gebruiken we de functie errorbar() om foutbalken aan de lijnplot toe te voegen, met de hoogte ingesteld op de helft van de standaarddeviatie.
Met deze technieken kun je statistische informatie aan je lijnplots toevoegen en diepere inzichten uit je data halen.
Conclusie
Lijnplots zijn een krachtig middel om trends en patronen in data te visualiseren, en Matplotlib biedt een gebruiksvriendelijke interface om ze te maken.
Als volgende stap kun je onze cursus Intermediate Python volgen, waarin je alles toepast wat je hebt geleerd in een case study over hackerstatistiek.
We hopen dat deze tutorial je heeft geholpen om aan de slag te gaan met lijnplots in Matplotlib. We hebben ook uitgebreid de andere Matplotlib-plots behandeld in een andere tutorial, die je kort laat zien wat je nog meer met Matplotlib kunt doen.
Blijf vooral verkennen en experimenteren met het maken van prachtige visualisaties en het ontdekken van inzichten uit je data!
