Als iemand die al een tijdje bezig is met data visualisatie, weet ik dat beginnen met de juiste tools een groot verschil kan maken. Toen ik voor het eerst Plotly ontdekte voor Python, viel het me op hoe goed het de kracht met eenvoud wist te balanceren. Plotly is een open-source grafiekbibliotheek waarmee je interactieve, publicatiekwaardige grafieken online kunt maken.

Hier is hoe je aan de slag kunt gaan met Plotly in een Python-omgeving. Allereerst moet je het installeren.

!pip install plotly

Zodra het geïnstalleerd is, kun je Plotly net als elke andere Python-bibliotheek importeren. In tegenstelling tot meer traditionele opties zoals matplotlib, ligt Plotly's sterkte in de interactiviteit en web-vriendelijkheid. Hier is een snel voorbeeld dat laat zien wat ik bedoel:

import plotly.express as px

# Laten we een eenvoudige scatter plot maken
df = px.data.iris()  # Het Iris-dataset gebruiken
fig = px.scatter(df, x="sepal_width", y="sepal_length")
fig.show()

Als je deze code uitvoert, krijg je geen statische afbeelding. In plaats daarvan zie je een interactieve plot waar je kunt zoomen, pannen of over de punten kunt zweven om meer informatie te zien. Dit wordt vooral handig bij grote datasets waar het moeilijk kan zijn om trends en uitschieters te ontdekken.

Plotly integreert ook prachtig met Pandas, de de facto bibliotheek voor datamanipulatie in Python. Als je data in een DataFrame staat, wordt het plotten ervan heel natuurlijk. Hier is een voorbeeld van het plotten van een tijdreeks:

import pandas as pd
import plotly.express as px
import numpy as np

# Maak een eenvoudige DataFrame
df = pd.DataFrame({'Date': pd.date_range(start='2024-01-01', periods=30),
'Value': np.random.randn(30).cumsum()})

# Plot een tijdreeksdiagram
fig = px.line(df, x='Date', y='Value', title='Willekeurige Tijdreeks')
fig.show()

Wat is er niet leuk aan de eenvoud hier? Ik kan met minimale code een grafiek aanpassen, me meer focussen op het verhaal dat ik wil vertellen met mijn data, in plaats van vast te zitten aan complexe plottingsyntax.

Het is belangrijk om op te merken dat Plotly niet slechts één enkel instrument is. De bibliotheek is uitgebreid, waarbij Plotly Express een hoger niveau-interface is die het maken van veelvoorkomende grafiektypen vereenvoudigt. Plotly.graph_objects daarentegen, geeft je meer controle en wordt meestal gebruikt voor maatwerk of meer complexe visualisaties.

Om je een idee te geven van hoe graph_objects werkt, laten we dit volgen met een staafdiagram:

from plotly.graph_objs import Bar, Layout
from plotly import offline

data = [Bar(x=['A', 'B', 'C'], y=[20, 14, 23])]

layout = Layout(title='Eenvoudig Staafdiagram',
xaxis=dict(title='Categorie'),
yaxis=dict(title='Waarden'))

fig = dict(data=data, layout=layout)
offline.iplot(fig)

Het gebruik van graph_objects is iets omslachtiger, maar het opent een wereld van aanpassingsmogelijkheden die vaak nodig zijn voor meer genuanceerde visuele verhalen.

Als iemand die de essentie van strak design en interactieve visualisatie waardeert, is Plotly een vaste keuze geworden voor mijn data-plotbehoeften. Het is een tool die met je vaardigheden meegroeit. Of je nu net begint en een gevoel wilt krijgen voor je data, of diep in de data-analyse zit en gedetailleerde en interactieve visuele verhalen moet maken, Plotly biedt een suite die divers genoeg is voor je reis.

Kort samengevat, aan de slag gaan met Plotly is eenvoudig, en het rendement is groot. Slechts een paar regels code kunnen inzichten verschaffen die anders veel moeite zouden kosten met minder interactieve tools. En we weten allemaal, als het om data gaat, is het vermogen om effectief te begrijpen en te communiceren de helft van de strijd gewonnen.

Toen ik voor het eerst met Plotly begon om data te visualiseren, was ik verrast door hoe simpel en krachtig het was. Hier is hoe ik mijn eerste Plotly-grafiek bouwde, en hopelijk helpt dit jou om makkelijk te starten met Plotly.

Je moet Plotly geïnstalleerd hebben. Als dat nog niet het geval is, voer dan gewoon het volgende commando uit:

pip install plotly

Nu het leuke deel. Laten we beginnen met het plotten van een simpele lijngrafiek. We gebruiken Plotly's graph_objs module, die een makkelijke manier biedt om verschillende soorten grafieken te maken.

import plotly.graph_objs as go
import plotly.offline as pyo

# Voorbeelddata voor onze lijngrafiek
x_data = [0, 1, 2, 3, 4]
y_data = [x ** 2 for x in x_data]

# Maak een trace, wat bij Plotly een serie datapunten is 
trace = go.Scatter(
x = x_data,
y = y_data,
mode = 'lines',
name = 'kwadratisch'
)

# Groepeer de trace in een lijst - handig voor later als je meer traces wilt toevoegen
data = [trace]

# Definieer de layout van onze grafiek
layout = go.Layout(
title = 'Mijn Eerste Plotly Grafiek',
)

# Combineer data en layout in een figuur
figure = go.Figure(data=data, layout=layout)

# Toon de figuur
pyo.plot(figure, filename='eerste_plotly_grafiek.html')

De bovenstaande code creëert een simpele lijngrafiek waarbij x_data wordt uitgezet tegen y kwadraat. We maken een trace-object dat de punten vertegenwoordigt die we willen plotten. Na het definiëren van de trace, groeperen we deze in een lijst. Dit wordt nuttig wanneer je meerdere datasets in één grafiek wilt weergeven.

Om de figuur te zien, combineren we het met een layout in go.Figure, en dan roepen we pyo.plot() aan om de figuur in je webbrowser te tonen.

Hier is nog een snel voorbeeld - dit keer een staafdiagram. De opzet lijkt veel op de lijngrafiek, maar we gebruiken go.Bar in plaats daarvan.

# Voorbeelddata voor ons staafdiagram
categorieën = ['Appels', 'Sinaasappels', 'Peren', 'Druiven']
waarden = [5, 10, 3, 7]

# Maak een trace voor het staafdiagram
trace = go.Bar(
x = categorieën,
y = waarden
)

# Weer groeperen we de trace in een lijst
data = [trace]

# We gebruiken dezelfde layout als de lijngrafiek voor consistentie
layout = go.Layout(
title = 'Mijn Eerste Plotly Staafdiagram',
)

# Maak een figuur en toon deze
figure = go.Figure(data=data, layout=layout)
pyo.plot(figure, filename='eerste_plotly_staafdiagram.html')

In het bovenstaande voorbeeld zie je een staafdiagram dat de hoeveelheden van verschillende fruitcategorieën toont. Het proces van het maken en tonen van de figuur blijft hetzelfde; het enige wat verandert is het type trace dat je gebruikt.

Oefening is belangrijk, dus ik raad aan om wat te spelen met verschillende trace types (go.Scatter, go.Bar, go.Pie, etc.) en vertrouwd te raken met de ideeën van traces en layouts, omdat deze concepten fundamenteel zijn bij het gebruik van Plotly.

Er zijn veel bronnen beschikbaar. Als je vastloopt, zijn de Plotly community forums een geweldige plek om vragen te stellen. De Plotly Python documentatie is ook een uitstekende referentie met veel voorbeelden.

Dat is het zo'n beetje voor je eerste Plotly-grafiek. In de volgende secties leer je hoe je deze grafieken kunt aanpassen om ze informatiever en visueel aantrekkelijker te maken, en hoe je interactiviteit aan je Plotly-plots kunt toevoegen. Veel plezier met plotten!

Het aanpassen van Plotly-grafieken voegt een extra laag van professionaliteit en een persoonlijke touch toe aan datavisualisaties. Toen ik voor het eerst begon met Plotly, vond ik de vele aanpassingsmogelijkheden overweldigend, maar het beheersen van deze stappen heeft de presentatie van mijn data aanzienlijk verbeterd. Hier is hoe jij dat ook kunt doen.

import plotly.graph_objs as go

# Maak een basis scatter plot
fig = go.Figure(data=[go.Scatter(
x=[1, 2, 3],
y=[4, 1, 2],
mode='markers'
)])

# Pas de layout aan
fig.update_layout(
title='Aangepaste Scatter Plot',
xaxis_title='X-as Titel',
yaxis_title='Y-as Titel',
font=dict(family='Courier New, monospace', size=18, color='RebeccaPurple')
)

# Pas het uiterlijk van de markers aan
fig.update_traces(
marker=dict(size=12, color='LightSkyBlue', symbol='circle', line=dict(color='MediumPurple', width=2))
)

fig.show()

In het voorbeeld hierboven heb ik de opmaak en stijl van de markers van de scatter plot aangepast. Door de title, xaxis_title en yaxis_title bij te werken, communiceert de grafiek de informatie duidelijker. Het font dict verandert de tekststijl, waardoor het een opvallende uitstraling krijgt. Bovendien worden met de update_traces-methode markers aangepast voor een betere visuele aantrekkingskracht. Voor meer informatie over het maken van effectieve datavisualisaties in Python, zie onze Korte tutorial: data visualiseren in Python met Altair.

Kleurenschema's zijn van groot belang voor het aantrekkelijk maken van grafieken. Plotly ondersteunt verschillende kleurenpaletten die eenvoudig kunnen worden toegepast op staafdiagrammen.

import plotly.express as px

# Maak een basis staafdiagram
df = px.data.gapminder().query("country=='Canada'")
fig = px.bar(df, x='year', y='pop')

# Kleuren aanpassen
fig.update_traces(marker_color='rgba(135, 206, 250, 0.6)',
marker_line_color='rgba(0, 191, 255, 1.0)',
marker_line_width=1.5,
opacity=0.6)
fig.update_layout(title_text='Bevolking door de jaren heen in Canada')
fig.show()

De code past een semi-transparante blauwe kleur op de staven toe en geeft ze een stevige blauwe contour, wat diepte toevoegt en het aantrekkelijker maakt.

Bij het weergeven van meerdere datareeksen is het nuttig om de legenda aan te passen om de leesbaarheid te verbeteren. De legenda in Plotly kan worden geplaatst en gestyled om beter bij de context van je gegevens te passen.

import plotly.graph_objs as go

# Maak een lijndiagram met drie lijnen
fig = go.Figure()
fig.add_trace(go.Scatter(x=[1, 2, 3], y=[4, 5, 6],
mode='lines+markers',
name='Serie 1'))
fig.add_trace(go.Scatter(x=[1, 2, 3], y=[1, 6, 3],
mode='lines+markers',
name='Serie 2'))
fig.add_trace(go.Scatter(x=[1, 2, 3], y=[6, 5, 4],
mode='lines+markers',
name='Serie 3'))

# Legenda aanpassen
fig.update_layout(legend=dict(
yanchor="top",
y=0.99,
xanchor="left",
x=0.01
))

fig.show()

Deze code plaatst de legenda netjes in de linkerbovenhoek, zonder dat het de grafiek stoort, waardoor het gemakkelijk te interpreteren is.

Tot slot zijn thema’s een handige manier om snel aanpassingen door te voeren. Plotly biedt verschillende ingebouwde thema's die onmiddellijk de esthetiek van de grafiek wijzigen.

import plotly.io as pio

# Pas een ingebouwd thema toe
pio.templates.default = "plotly_dark"

fig.show()

Dit fragment stelt het standaardthema in op "plotly_dark," wat een donkere achtergrond en kleurenpalet biedt, geschikt voor presentaties in donkere omgevingen.

Onthoud, hoewel aanpassingen de uitstraling van je grafieken sterk kunnen verbeteren, is het belangrijk een balans te houden tussen stijl en leesbaarheid. Data is de ster; de visuele elementen ondersteunen het verhaal.

Voor uitgebreide documentatie over aanpassingen, is de officiële documentatie voor grafische bibliotheken van Plotly een waardevolle bron. De Plotly-community op GitHub en forums zoals Stack Overflow bieden ook steun bij het oplossen van specifieke problemen.

Door deze aanpassingen in je Plotly-grafieken te integreren, maak je je visuele dataverhalen net zo impactvol als de inzichten zelf. Blijf experimenteren met verschillende stijlen en lay-outs; soms kunnen kleine aanpassingen een wereld van verschil maken.

Interactiviteit en delen zijn de twee pijlers die Plotly verheffen van een eenvoudige visualisatietool tot een dynamisch platform voor data-exploratie en verspreiding. Ik heb gemerkt dat de bruikbare inzichten die ik uit Plotly-grafieken haal, het best tot hun recht komen wanneer ze kunnen worden onderzocht, aangepast en ontleed door nieuwsgierige belanghebbenden die het verhaal achter de cijfers willen zien.

Laten we eens kijken hoe je interactieve functies kunt implementeren en je Plotly-creaties kunt delen.

Interactieve elementen in Plotly draaien vaak om hover-tools, schuifregelaars en knoppen. Het toevoegen van een hover-tool is net zo eenvoudig als het instellen van hover_data in je grafiekobject. Hier is een snel voorbeeld met een Scatter plot:

import plotly.express as px

df = px.data.iris()  # Gebruik de Iris dataset
fig = px.scatter(df, x='sepal_width', y='sepal_length', color='species',
hover_data=['petal_length', 'petal_width'])
fig.show()

Schuifregelaars en knoppen verhogen de interactiviteit door kijkers in staat te stellen de data die ze zien aan te passen. Stel je voor dat je tijdreeksdata hebt en je gebruikers de mogelijkheid wilt geven om door de jaren te bladeren:

from plotly.subplots import make_subplots
import plotly.graph_objects as go

# Stel dat df een DataFrame is met de kolommen 'Year', 'Value', en 'Category'
fig = make_subplots()

buttons = []

for year in df['Year'].unique():
    year_data = df[df['Year'] == year]
    for category in year_data['Category'].unique():
        category_data = year_data[year_data['Category'] == category]
        fig.add_trace(go.Scatter(x=category_data['Date'], y=category_data['Value'], name=category))

    buttons.append(dict(method='update',
                        label=str(year),
                        args=[{'visible': [year == y for y in df['Year']]}]))

fig.update_layout(showlegend=True, updatemenus=[{"buttons": buttons, "direction": "down", "showactive": True}])
fig.show()

Nu, laten we naar het delen gaan. Interactieve grafieken zijn geweldig, maar ze zijn nog beter wanneer ze gedeeld worden. Je kunt je Plotly-grafieken exporteren naar HTML-bestanden of afbeeldingen direct vanuit de bibliotheek:

fig.write_html('my_interactive_chart.html')
fig.write_image('my_chart.png')

Echter, het hosten van deze op het web brengt ze tot leven. Met Dash van Plotly kun je een webapp bouwen om je grafieken te presenteren. Hier is hoe je een heel eenvoudige Dash-app start:

# Zorg ervoor dat je dash geïnstalleerd hebt: pip install dash
import dash
import dash_core_components as dcc
import dash_html_components as html

app = dash.Dash()

# Hergebruik onze 'fig' uit het vorige voorbeeld
app.layout = html.Div([
    dcc.Graph(figure=fig)
])

if __name__ == '__main__':
    app.run_server(debug=True)

Met dit soort opzet, kan iedereen met de URL van je Dash-app toegang krijgen tot, interageren met, en leren van je grafieken. Uit mijn ervaring blijkt dat deze directe toegang data-analyse verandert van iets af en toe saai en gesloten naar een levendige dialoog.

Als je dit doet in een professionele of academische context waar je bronnen moet citeren, is de traceerbaarheid van Plotly een krachtige functie. Je kunt tekstannotaties toevoegen om terug te linken naar bronnen of zelfs metadata binnen je plots coderen die programmatically toegankelijk is.

Samenwerking is een ander aspect dat wordt benadrukt door de deelopties van Plotly. Met Plotly's online Chart Studio kunnen grafieken door meerdere gebruikers worden bewerkt, waardoor een team hun visuele verhaal iteratief kan verfijnen.

Voor degenen die meer geïnteresseerd zijn in de code en verder willen bijdragen of verkennen, is de GitHub-repository van Plotly een goudmijn aan informatie en wordt actief onderhouden: https://github.com/plotly/plotly.py.

In mijn reis met datavisualisatie heb ik ontdekt dat de combinatie van interactiviteit en het gemak van delen met Plotly niet alleen boeiend is, maar ook een essentieel onderdeel vormt in het vertalen van complexe dataverhalen naar begrijpelijke verhalen. Terwijl je deze functies in je grafieken integreert, ben ik ervan overtuigd dat je dezelfde intrinsieke waarde zult onderscheiden en hopelijk die opwinding met anderen zult delen terwijl je je inzichten verspreidt.