Cursus
Exploratory Data Analysis in Python
4 uur
119.3K
Veelvoorkomende soorten datagrafieken in Python
Laten we beginnen met de meest gangbare grafieken die in veel vakgebieden worden gebruikt en in de meeste Python-visualisatielibraries kunnen worden gebouwd (op enkele zeer specialistische na).
Staafdiagram
Een staafdiagram is de meest gebruikte visualisatie om numerieke waarden van categorische data te tonen en categorieën met elkaar te vergelijken. De categorieën worden weergegeven door rechthoekige balken van gelijke breedte, waarvan de hoogte (bij verticale diagrammen) of lengte (bij horizontale) evenredig is aan de bijbehorende waarde.
Om een basisstaafdiagram in matplotlib te maken, gebruiken we de functie matplotlib.pyplot.bar() als volgt:
# Data preparation
penguins_grouped = penguins[['species', 'bill_length_mm']].groupby('species').mean().reset_index()
# Creating a bar chart
plt.bar(penguins_grouped['species'], penguins_grouped['bill_length_mm'])
plt.title('Average penguin bill length by species')
plt.show()
We kunnen de balkbreedte en -kleur aanpassen, de randbreedte en -kleur, ticklabels toevoegen, balken met patronen vullen, enz.
Lijndiagram
Een lijndiagram laat de voortgang van een variabele van links naar rechts langs de x-as zien via datapunten die met rechte lijnsegmenten zijn verbonden. Meestal wordt de verandering van een variabele over de tijd uitgezet. Lijndiagrammen worden dan ook vaak gebruikt voor tijdreeksen, zoals besproken in de tutorial over Matplotlib time series line plots.
We kunnen een basislijndiagram in matplotlib maken met de functie matplotlib.pyplot.plot() als volgt:
# Data preparation
flights_grouped = flights[['year', 'passengers']].astype({'year': 'string'}).groupby('year').sum().reset_index()
# Creating a line plot
plt.plot(flights_grouped['year'], flights_grouped['passengers'])
plt.title('Total number of passengers by year')
plt.show()
Je kunt de lijndikte, -stijl, kleur en transparantie aanpassen, markers toevoegen en aanpassen, enz.
De tutorial Line Plots in MatplotLib with Python geeft meer uitleg en voorbeelden voor matplotlib. Wil je een lijndiagram in seaborn maken en aanpassen? Lees dan Python Seaborn Line Plot Tutorial: Create Data Visualizations.
Spreidingsdiagram
Een spreidingsdiagram toont de relatie tussen twee variabelen als punten in het coördinatenvlak. Je gebruikt dit type om te controleren of er correlatie is tussen twee variabelen, hoe sterk die is en of er duidelijke clusters zijn.
De onderstaande code illustreert hoe je een basisspreidingsdiagram in matplotlib maakt met de functie matplotlib.pyplot.scatter():
# Creating a scatter plot
plt.scatter(penguins['bill_length_mm'], penguins['bill_depth_mm'])
plt.title('Penguin bill length vs. bill depth')
plt.show()
We kunnen de puntsize, stijl, kleur, transparantie, randbreedte, randkleur, enz. aanpassen.
Lees meer over spreidingsdiagrammen (en meer!) in deze tutorial: Data Demystified: Data Visualizations that Capture Relationships.
Histogram
Een histogram geeft de frequentieverdeling van de waarden van een numerieke variabele weer. Onder de motorkap splitst het de data in waardebereiken (bins), telt het aantal punten per bin en toont elke bin als een verticale balk met een hoogte evenredig aan de frequentie. Je kunt een histogram zien als een speciaal type staafdiagram, maar dan met aaneengesloten balken vanwege de continue aard van de bins.
We bouwen eenvoudig een basishistogram in matplotlib met de functie matplotlib.pyplot.hist():
# Creating a histogram
plt.hist(penguins['bill_length_mm'])
plt.title('Penguin bill length distribution')
plt.show()
Je kunt veel aanpassen: de kleur en stijl, het aantal bins, de binedges, het onder- en bovengrensbereik, of het histogram regulier of cumulatief is, enz.
Voor meer histogramvoorbeelden, bekijk Histograms in Matplotlib en How to Create a Histogram with Plotly.
Boxplot
Een boxplot toont vijf beschrijvende statistieken van de data: minimum en maximum (exclusief uitbijters), de mediaan en het eerste en derde kwartiel. Optioneel kan het ook het gemiddelde tonen. Kies een boxplot als je alleen in deze statistieken geïnteresseerd bent, zonder in te gaan op de onderliggende verdeling.
In de tutorial 11 Data Visualization Techniques for Every Use-Case with Examples vind je onder andere meer uitleg over welke statistische informatie je uit een boxplot kunt halen.
We kunnen een basisboxplot in matplotlib maken met de functie matplotlib.pyplot.boxplot() zoals hieronder:
# Data preparation
penguins_cleaned = penguins.dropna()
# Creating a box plot
plt.boxplot(penguins_cleaned['bill_length_mm'])
plt.title('Penguin bill length distribution')
plt.show()
Er is veel te customizen: de breedte en oriëntatie, de positie van box en snorharen, de zichtbaarheid en stijl van elementen, enz.
Let op: om met deze functie een boxplot te maken, moet de data geen missende waarden bevatten. In het voorbeeld hierboven verwijderen we die waarden dus vooraf. Ter vergelijking: de Seaborn-library heeft deze beperking niet en verwerkt missende waarden op de achtergrond, zoals hieronder:
# Creating a box plot
sns.boxplot(data=penguins, y='bill_length_mm')
plt.title('Penguin bill length distribution')
plt.show()
Taartdiagram
Een taartdiagram is een visualisatie in de vorm van een cirkel die in sectoren is verdeeld. Elke sector staat voor een categorie van de categorische data en de hoek van elke sector weerspiegelt de proportie van die categorie als deel van het geheel. Anders dan staafdiagrammen zijn taartdiagrammen bedoeld om categorieën te tonen die samen het geheel vormen, zoals passagiers van een schip.
Taartdiagrammen hebben enkele nadelen:
- Hoeken zijn voor het menselijk oog lastiger te interpreteren dan lengtes en kunnen misleidend zijn.
- Ze zijn minder efficiënt bij vijf of meer categorieën.
- Ze kunnen niet meer dan één set categorische data tonen; groeperen zoals bij staafdiagrammen kan niet.
- Ze onthullen niet gemakkelijk de exacte waarden.
- Ze zijn niet informatief wanneer categorieën weinig van elkaar verschillen.
Gebruik taartdiagrammen daarom spaarzaam en met beleid.
Een basistaartdiagram in matplotlib maak je met de functie matplotlib.pyplot.pie() als volgt:
# Data preparation
titanic_grouped = titanic.groupby('class')['pclass'].count().reset_index()
# Creating a pie chart
plt.pie(titanic_grouped['pclass'], labels=titanic_grouped['class'])
plt.title('Number of passengers by class')
plt.show()
Indien nodig kun je de kleuren van de sectoren wijzigen, een offset toevoegen (meestal bij erg kleine sectoren), de straal aanpassen, het label-formaat customizen, sectoren met patronen vullen, enz.
Voor een diepere duik in taartdiagrammen, inclusief percentages en exploded slices, lees Python Pie Chart: Build and Style with Pandas and Matplotlib.
Geavanceerde soorten datagrafieken in Python
In deze sectie verkennen we diverse geavanceerde grafieken. Sommige zijn een fraaie variant op de veelvoorkomende types uit de vorige sectie, andere staan op zichzelf.
Gegroepeerd staafdiagram
Waar een gewoon staafdiagram de waarden van één categorische variabele per categorie toont, doet een gegroepeerd staafdiagram dat over twee categorische variabelen. Grafisch krijg je groepen balken: elke groep hoort bij een categorie van de eerste variabele en elke balk binnen zo'n groep bij een categorie van de tweede variabele. Deze grafiek werkt het best als de tweede variabele maximaal drie categorieën heeft; anders wordt het te vol en minder bruikbaar.
Net als een gewoon staafdiagram kun je dit met matplotlib maken. Maar Seaborn biedt met seaborn.barplot() handigere functionaliteit. Hieronder een basisvoorbeeld voor snavellengte van pinguïns over twee categorische variabelen: soort en geslacht.
# Creating a grouped bar chart
sns.barplot(data=penguins, x='species', y='bill_length_mm', hue='sex')
plt.title('Penguin bill length by species and sex')
plt.show()
De tweede categorische variabele voeg je toe via de parameter hue. Andere optionele parameters veranderen de oriëntatie, breedte en kleur van de balken, de categorievolgorde, de statistische schatter, enz.
Wil je dieper in Seaborn duiken? Bekijk dan deze cursus: Intermediate Data Visualization with Seaborn.
Gestapelde gebiedenkaart
Een gestapelde gebiedenkaart is een uitbreiding op een gewone gebiedenkaart (een lijndiagram met gekleurde/gevulde onderzijde) met meerdere gebieden, elk voor een aparte variabele, op elkaar gestapeld. Handig om zowel de totale ontwikkeling als de individuele bijdrage van variabelen te volgen. Net als lijndiagrammen tonen ze meestal verandering over tijd.
Belangrijk om te onthouden: gestapelde gebiedengrafieken vangen vooral de algemene trend, niet de exacte waarden van de individuele lagen.
Een basisvoorbeeld in matplotlib maak je met matplotlib.pyplot.stackplot() als volgt:
# Data preparation
flights_grouped = flights.groupby(['year', 'month']).mean().reset_index()
flights_49_50 = pd.DataFrame(list(zip(flights_grouped.loc[:11, 'month'].tolist(), flights_grouped.loc[:11, 'passengers'].tolist(), flights_grouped.loc[12:23, 'passengers'].tolist())), columns=['month', '1949', '1950'])
# Creating a stacked area chart
plt.stackplot(flights_49_50['month'], flights_49_50['1949'], flights_49_50['1950'], labels=['1949', '1950'])
plt.title('Number of passengers in 1949 and 1950 by month')
plt.legend()
plt.show()
Aanpasbaar zijn o.a. de kleuren, transparantie, vulpatronen en de lijnbreedte, -stijl, -kleur, -transparantie, enz.
Meervoudige boxplot
Eerder definieerden we een boxplot als een visualisatie van vijf beschrijvende statistieken. Soms wil je die statistieken per categorie van een categorische variabele tonen en vergelijken. Dan plot je meerdere boxen in hetzelfde vlak, wat eenvoudig kan met seaborn.boxplot() als volgt:
# Creating multiple box plots
sns.boxplot(data=penguins, x='bill_length_mm', y='species')
plt.title('Penguin bill length distribution by species')
plt.show()
Je kunt de volgorde en oriëntatie veranderen, kleur, transparantie, breedte, eigenschappen van elementen, een extra categorische variabele toevoegen, enz.
Vioolplot
Een vioolplot lijkt op een boxplot en toont dezelfde samenvattende statistieken, maar laat óók de vorm van de verdeling zien. Net als bij boxplots kun je één viool of, vaker, meerdere violen per categorie tonen.
Seaborn biedt meer mogelijkheden voor het maken en aanpassen van vioolplots dan matplotlib. Een basisvioolplot in seaborn maak je met seaborn.violinplot() als volgt:
# Creating a violin plot
sns.violinplot(data=penguins, x='bill_length_mm', y='species')
plt.title('Penguin bill length distribution by species')
plt.show()
Je kunt de volgorde en oriëntatie aanpassen, kleur, transparantie, breedte, eigenschappen van elementen, de verdeling voorbij de uiterste punten laten doorlopen, een extra categorische variabele toevoegen, kiezen hoe punten binnenin worden weergegeven, enz.
Heatmap
Een heatmap is een tabelachtige visualisatie waarbij elk numeriek datapunt wordt weergegeven op basis van een gekozen kleurschaal en zijn grootte binnen de dataset. Het idee is om potentiële hot en cold spots te illustreren die extra aandacht verdienen.
Vaak is wat preprocessing nodig voor je een heatmap maakt, zoals datacleaning en normalisatie.
Onderstaande code laat zien hoe je een basisheatmap maakt (na de benodigde preprocessing) met seaborn.heatmap():
# Data preparation
from sklearn import preprocessing
car_crashes_cleaned = car_crashes.drop(labels='abbrev', axis=1).iloc[0:10]
min_max_scaler = preprocessing.MinMaxScaler()
car_crashes_normalized = pd.DataFrame(min_max_scaler.fit_transform(car_crashes_cleaned.values), columns=car_crashes_cleaned.columns)
# Creating a heatmap
sns.heatmap(car_crashes_normalized, annot=True)
plt.title('Car crash heatmap for the first 10 car crashes')
plt.show()
Mogelijke aanpassingen zijn o.a. de colormap kiezen, ankerwaarden definiëren, annotaties formatteren, scheidslijnen aanpassen, een masker toepassen, enz.
Voor een uitgebreidere gids, inclusief custom colormaps en annotaties, lees Seaborn Heatmaps: A Guide to Data Visualization.
Onconventionele soorten datagrafieken in Python
Tot slot bekijken we enkele zelden gebruikte of minder bekende visualisaties. Veel ervan hebben een tegenhanger onder populairdere grafieken. Toch kunnen deze onconventionele visualisaties in specifieke gevallen efficiënter zijn dan de gebruikelijke.
Stamdiagram
Een stamdiagram is in feite een alternatief voor een staafdiagram: in plaats van balken zie je dunne lijnen met (optionele) markers bovenop. Hoewel het wellicht overbodig lijkt, is het juist een beter alternatief bij veel categorieën. Het voordeel is een hogere data-ink-ratio en dus betere leesbaarheid.
Een basisstamdiagram in matplotlib maak je met matplotlib.pyplot.stem() als volgt:
# Data preparation
fmri_grouped = fmri.groupby('subject')[['subject', 'signal']].max()
# Creating a stem plot
plt.stem(fmri_grouped['subject'], fmri_grouped['signal'])
plt.title('FMRI maximum signal by subject')
plt.show()
Met de optionele parameters kun je de oriëntatie wijzigen en de eigenschappen van stam, basislijn en markers aanpassen.
Strip- en swarmplots
Deze twee vergelijkbare visualisaties kun je zien als een scatterimplementatie voor een categorische variabele: zowel strip- als swarmplots tonen de binnenkant van de verdeling, inclusief steekproefgrootte en de posities van individuele punten, maar zonder samenvattende statistieken. Het verschil: in een stripplot kunnen punten overlappen, in een swarmplot niet; daar worden punten langs de categorische as uitgelijnd.
Houd er rekening mee dat beide alleen nuttig zijn voor relatief kleine datasets.
Zo maak je een stripplot met seaborn.stripplot():
# Creating a strip plot
sns.stripplot(data=penguins, x='bill_length_mm', y='species')
plt.title('Penguin bill length distribution by species')
plt.show()
Nu maken we een swarmplot met seaborn.swarmplot() voor dezelfde data en bekijken we het verschil:
# Creating a swarm plot
sns.swarmplot(data=penguins, x='bill_length_mm', y='species')
plt.title('Penguin bill length distribution by species')
plt.show()
De functies seaborn.stripplot() en seaborn.swarmplot() hebben een vergelijkbare syntax. Je kunt o.a. de volgorde en oriëntatie instellen en marker-eigenschappen aanpassen, zoals stijl, grootte, kleur, transparantie, enz. Door transparantie te regelen kun je overlap in een stripplot beperken.
Treemap
Een treemap visualiseert de numerieke waarden van categorische data per categorie als rechthoeken binnen een groter rechthoekig kader, waarbij het oppervlak evenredig is aan de waarde. Qua doel is een treemap gelijk aan staaf- en taartdiagrammen. Net als taartdiagrammen tonen ze vooral onderdelen van een geheel. Treemaps werken goed bij tot ongeveer tien categorieën met duidelijke waardeverschillen.
De nadelen lijken sterk op die van taartdiagrammen:
- Oppervlakken zijn lastiger te interpreteren dan lengtes en kunnen misleiden.
- Minder efficiënt bij meer dan tien categorieën.
- Ze kunnen niet meer dan één set categorische data tonen; groeperen kan niet, in tegenstelling tot staafdiagrammen.
- Moeilijker om exacte waarden af te lezen.
- Weinig informatief bij kleine waardeverschillen tussen categorieën.
Houd deze punten in gedachten en gebruik treemaps spaarzaam en alleen wanneer ze het best werken.
Om een treemap in Python te bouwen, installeer en importeer je eerst de squarify-library: pip install squarify, daarna import squarify. De onderstaande code maakt een basistreemap:
import squarify
# Data preparation
diamonds_grouped = diamonds[['cut', 'price']].groupby('cut').mean().reset_index()
# Creating a treemap
squarify.plot(sizes=diamonds_grouped['price'], label=diamonds_grouped['cut'])
plt.title('Average diamond price by cut')
plt.show()
Je kunt kleuren en transparantie aanpassen, met patronen vullen, de randeigenschappen wijzigen, kleine tussenruimtes toevoegen en de labeltekst afstellen.
Er is ook een aanpak met de plotly-library. Lees meer in de tutorial What is Data Visualization? A Guide for Data Scientists.
Word cloud
Een word cloud is een tekstvisualisatie waarbij de lettergrootte van elk woord overeenkomt met de frequentie waarmee het in een tekst voorkomt. Hiermee vind je snel de belangrijkste woorden.
Hoewel word clouds altijd in het oog springen en intuïtief zijn, kennen ze enkele beperkingen:
- Het maken vereist vaak tijdrovende datavoorbereiding.
- Net als veel textmining-tools missen ze context en zijn ze vatbaar voor misinterpretaties (bijv. sarcasme, ontkenning of figuurlijk taalgebruik).
- Ze bieden geen duidelijke ranking: je ziet makkelijk het meest frequente woord, de tweede, derde, misschien vierde; daarna wordt het lastig.
- Ze tonen geen exacte frequentiewaarden.
- Langere woorden lijken groter dan kortere met dezelfde frequentie.
- Veel verticale woorden of een masker verminderen de leesbaarheid.
Een interessante, minder bekende toepassing: je kunt een word cloud baseren op een andere attribuutwaarde dan frequentie. Maak bijvoorbeeld een woordenboek van landen met hun bevolkingsaantallen en visualiseer dat.
Voor een word cloud in Python gebruik je de gespecialiseerde wordcloud-library. Installeer die eerst (pip install wordcloud), importeer dan de klasse WordCloud en stopwords: from wordcloud import WordCloud, STOPWORDS. De volgende code genereert een basis-word cloud:
from wordcloud import WordCloud, STOPWORDS
text = 'cat cat cat cat cat cat dog dog dog dog dog panda panda panda panda koala koala koala rabbit rabbit fox'
# Creating a word cloud
wordcloud = WordCloud().generate(text)
plt.imshow(wordcloud)
plt.title('Words by their frequency in the text')
plt.axis('off')
plt.show()
Je kunt de afmetingen aanpassen, de achtergrondkleur wijzigen, een colormap kiezen, voorkeur geven aan horizontale woorden, het maximum aantal woorden limiteren, de stopwords-lijst uitbreiden, lettergroottes begrenzen, collocaties meenemen, reproduceerbaarheid waarborgen, enz.
Wil je meer leren over word clouds in Python? Lees dan: Generating WordClouds in Python Tutorial.
Onderwerpen
