Seaborn-barplot: een complete gids

Datavisualisatie zet complexe informatie om in heldere, toepasbare inzichten. Seaborn-barplots blinken uit in het presenteren van categorische data met elegante, statistische grafieken. De bibliotheek combineert de flexibiliteit van Matplotlib met de kracht van pandas, waardoor hij ideaal is voor zowel snelle analyses als publicatieklare visualisaties.

Seaborn-barplots bieden essentiële functies voor data-analyse — van basisvergelijkingen tot geavanceerde statistische weergaven. Ze pakken veelvoorkomende taken aan, zoals het vergelijken van verkoopcijfers per regio, het analyseren van enquêteresultaten en het visualiseren van experimentele uitkomsten. 

De intuïtieve syntax en ingebouwde statistische functies maken de bibliotheek waardevol voor zowel beginners als ervaren dataprofessionals.

In dit artikel bekijken we de basis van Seaborn-barplots, maken we basisplots met codevoorbeelden, verbeteren we plots via maatwerk, implementeren we geavanceerde functies en verkennen we praktische toepassingen.

Wil je meer leren over datavisualisatie met Seaborn? Bekijk dan onze Introduction to Data Visualization with Seaborn-cursus.

Seaborn-barplot: de basis

Voordat we in barplots duiken, kijken we naar enkele basisprincipes van Seaborn, de voordelen voor staafdiagrammen en hoe je de code-omgeving inricht.

Wat is Seaborn?

Seaborn is een Python-bibliotheek voor statistische datavisualisatie, gebouwd boven op Matplotlib. Hij is gespecialiseerd in het maken van informatieve en aantrekkelijke statistische grafieken met minimale code. De bibliotheek integreert naadloos met pandas DataFrames, wat haar bijzonder effectief maakt in data-analyseworkflows.

Ze biedt een high-level interface om aantrekkelijke plots te tekenen en neemt veel stijldetails automatisch uit handen.

De bibliotheek blinkt uit op drie vlakken:

• Naadloze integratie met pandas DataFrames, waardoor datamanipulatie eenvoudig is
• Ingebouwde statistische functies, zodat aparte berekeningen niet nodig zijn
• Standaard professionele thema’s en kleurenpaletten

Zo vereist Matplotlib meerdere regels code om een eenvoudige statistische visualisatie te maken, terwijl Seaborn hetzelfde met één functieaanroep kan doen. 

Voor staafdiagrammen voegt Seaborn krachtige functies toe zoals automatische gemiddelden, betrouwbaarheidsintervallen en geavanceerde verwerking van categorische variabelen — mogelijkheden die in puur Matplotlib aanzienlijk extra code vergen.

Waarom barplots gebruiken?

Barplots tonen categorische data met verticale of horizontale balken waarvan de lengte een numerieke waarde vertegenwoordigt. Ze zijn ideaal om waarden over verschillende groepen of categorieën te vergelijken. In data-analyse helpen staafdiagrammen om enquêteresultaten, marktaandelen, prestatie-indicatoren en verkoopverdelingen te visualiseren.

Belangrijke voordelen zijn onder meer:

• Heldere vergelijking van hoeveelheden tussen categorieën
• Ingebouwde statistiek (gemiddelde, mediaan, betrouwbaarheidsintervallen)
• Effectieve weergave van gegroepeerde data
• Eenvoudige maar informatieve visuele elementen
• Eenvoudige aanpassingen voor professionele presentaties

Snel aan de slag

Om barplots met Seaborn te maken, richten we eerst onze Python-omgeving in. Zo begin je:

Installeer eerst de vereiste pakketten zoals hieronder:

pip install seaborn pandas numpyMogelijk gemaakt door

Nu hebben we alle visualisatietools klaar voor gebruik. Laten we de benodigde libraries importeren, zoals hieronder:

# For creating statistical visualizations
import seaborn as sns

# For data manipulation and analysis
import pandas as pd

# For numerical operations
import numpy as npMogelijk gemaakt door

We kunnen onze plots mooier maken met enkele stijlinstellingen, als volgt:

# Clean white style
sns.set_style("white")Mogelijk gemaakt door

De white-stijl verwijdert rasterlijnen en laat de plots er op de meeste schermen goed uitzien. In de volgende secties bekijken we het maken en verbeteren van barplots.

Basis Seaborn-barplots maken

Een barplot is perfect om relaties tussen categorische en numerieke variabelen te visualiseren. Het toont puntschattingen (zoals gemiddelde of mediaan) en de onzekerheid daaromheen via foutbalken. Laten we de basis-syntax van seaborn barplot bekijken.

Syntax en parameters

De sns.barplot()-functie in Seaborn biedt een eenvoudige manier om statistische staafdiagrammen te maken. De basisstructuur van de .barplot()-functie ziet er als volgt uit:

sns.barplot(
    data=None,      # Your DataFrame
    x=None,         # Category variable
    y=None,         # Numeric variable
    estimator='mean',  # Statistical function to estimate
    errorbar=('ci', 95),  # Error bars type and level
    orient=None     # "v" for vertical, "h" for horizontal
)Mogelijk gemaakt door

Met deze parameters bepalen we welke data we tonen en hoe we die presenteren. De parameter data neemt je DataFrame, terwijl x en y aangeven welke kolommen de categorieën en waarden bevatten. Met estimator kies je de toe te passen statistische functie (standaard: gemiddelde), en errorbar bepaalt hoe onzekerheid wordt weergegeven. Met de parameter orient kun je bovendien tussen verticale en horizontale oriëntatie wisselen.

Laten we nu bekijken hoe je effectieve barplots maakt met Seaborns ingebouwde tips-dataset, die informatie bevat over restaurantrekeningen en fooien.

Voorbeeld: een eenvoudige dataset visualiseren

We onderzoeken het fooigedrag op verschillende dagen van de week met de tips-dataset. Deze dataset bevat informatie over restaurantrekeningen, waaronder de dag van de week, het totaalbedrag, het fooibedrag en andere variabelen.

# Import required libraries and load dataset
import seaborn as sns
tips = sns.load_dataset("tips")

# Create a basic barplot showing average tips by day
sns.barplot(data=tips, x="day", y="tip")Mogelijk gemaakt door

Uitvoer:

Onze code maakte de bovenstaande visualisatie waarin elke balk het gemiddelde fooibedrag voor een andere dag van de week weergeeft. De hoogte van elke balk toont de gemiddelde fooi, en de zwarte lijnen (foutbalken) geven het 95%-betrouwbaarheidsinterval aan — zo krijgen we inzicht in zowel het typische fooibedrag als de variatie daarin.

We kunnen ook het fooipatroon per maaltijdmoment bekijken:

# Create a barplot showing average tips by time of day
sns.barplot(data=tips, x="time", y="tip")Mogelijk gemaakt door

Uitvoer:

Deze plot laat het verschil in fooigedrag zien tussen lunch en diner. De hoogte van elke balk staat voor het gemiddelde fooibedrag voor dat moment van de dag, met foutbalken die de variatie tonen. Dit soort visualisatie maakt het gemakkelijk om patronen te herkennen en groepen in één oogopslag te vergelijken.

Deze basis-barplots vormen de basis voor complexere visualisaties. In de volgende sectie laten we zien hoe je deze plots kunt verrijken met kleuren, groeperingen en andere aanpassingen om informatieve en visueel aantrekkelijke visualisaties te maken.

Barplots verbeteren met aanpassingen

Visuele verbeteringen toevoegen aan onze barplots kan helpen om data aantrekkelijker en begrijpelijker te maken. Laten we de verschillende manieren bekijken om barplots te customizen met de tips-dataset.

Kleuren toevoegen aan barplots

Seaborn biedt verschillende manieren om kleur aan je barplots toe te voegen, waardoor ze visueel aantrekkelijker en informatiever worden. We kunnen één kleur voor alle balken gebruiken of kleurgecodeerde groepen maken,

De parameter color stelt één kleur in voor alle balken, terwijl palette je een kleurschema laat kiezen wanneer je data meerdere groepen bevat. Seaborn heeft veel ingebouwde kleurpaletten die goed werken voor verschillende soorten data.

We kunnen een eenvoudige barplot met één kleur maken via de parameter color, zoals hieronder:

# Load the tips dataset if you haven't already
import seaborn as sns
tips = sns.load_dataset("tips")

# Single color barplot
sns.barplot(data=tips, x="day", y="tip", color="skyblue")Mogelijk gemaakt door

Uitvoer:

We kunnen een barplot met meerdere kleuren maken met de parameter palette, zoals hieronder:

# Load the tips dataset if you haven't already
import seaborn as sns
tips = sns.load_dataset("tips")

# Using a different color palette
sns.barplot(data=tips, x="day", y="tip", palette="Set2")Mogelijk gemaakt door

Uitvoer:

Seaborn-barplot met meerdere kolommen

Een van de krachtigste functies van Seaborn-barplots is de mogelijkheid om relaties tussen meerdere variabelen te tonen met de parameter hue. Dit creëert gegroepeerde balken die vergelijken makkelijker maken.

Laten we fooien vergelijken per dag én maaltijdmoment met de parameter hue, zoals hieronder:

# Load the tips dataset if you haven't already
import seaborn as sns
tips = sns.load_dataset("tips")

# Create a grouped barplot showing tips by day and time
sns.barplot(
    data=tips,
    x="day",
    y="tip",
    hue="time"
)Mogelijk gemaakt door

Uitvoer:

De bovenstaande plot toont twee balken — één voor lunch en één voor diner. Deze groepering laat niet alleen zien hoe fooien per dag verschillen, maar ook hoe ze variëren tussen maaltijdmomenten.

Een gestapelde Seaborn-barplot maken

Gestapelde barplots zijn uitstekend om de samenstelling van verschillende categorieën te tonen. Hoewel Seaborn geen directe gestapelde barplot-functie heeft, kunnen we Seaborn met matplotlib combineren om effectieve gestapelde visualisaties te maken. 

Deze aanpak benut Seaborns statistische functionaliteit en gebruikt de stapelcapaciteiten van matplotlib. In de tips-dataset bekijken we bijvoorbeeld hoe fooien verdeeld zijn tussen rokers en niet-rokers op verschillende dagen.

Laten we beginnen met het importeren van de benodigde libraries voor onze visualisatie:

# Import required libraries
import seaborn as sns
import matplotlib.pyplot as plt
import numpy as npMogelijk gemaakt door

Nu laden we onze dataset met informatie over restaurantfooien:

# Load the tips dataset
tips = sns.load_dataset("tips")Mogelijk gemaakt door

We maken een figuur met passende afmetingen voor onze visualisatie:

# Create figure and axis
plt.figure(figsize=(10, 4))Mogelijk gemaakt door

Vervolgens berekenen we de gemiddelde fooien voor rokers en niet-rokers op verschillende dagen:

# Calculate values for stacking
# Filter smokers, group by day and get mean tips
smoker_means = tips[tips['smoker']=='Yes'].groupby('day')['tip'].mean()
 
# Filter non-smokers, group by day and get mean tips     
non_smoker_means = tips[tips['smoker']=='No'].groupby('day')['tip'].mean()Mogelijk gemaakt door

Daarna stellen we de basisparameters voor onze gestapelde balken in, zoals hieronder:

# Plot the stacked bars using matplotlib
days = smoker_means.index
width = 0.8Mogelijk gemaakt door

Nu maken we de onderste laag van onze gestapelde balken voor niet-rokers:

# Create bottom bars (non-smokers)
plt.bar(days, non_smoker_means, width, label='Non-smoker', color=sns.color_palette()[0])Mogelijk gemaakt door

We voegen de bovenste laag toe voor de fooien van rokers:

# Create top bars (smokers)
plt.bar(days, smoker_means, width, bottom=non_smoker_means, 
        label='Smoker', color=sns.color_palette()[1])Mogelijk gemaakt door

We zetten een strakke stijl zonder rasterlijnen met Seaborn-styling:

# Add Seaborn styling
sns.set_style("white")Mogelijk gemaakt door

Tot slot tonen we onze voltooide gestapelde barplot:

# Show the plot
plt.show()Mogelijk gemaakt door

Uitvoer:

De resulterende plot toont de gemiddelde fooien van rokers boven op die van niet-rokers voor elke dag, waardoor je eenvoudig zowel de totale fooien als de bijdrage van elke groep kunt vergelijken.

Met deze workaround kunnen we:

• Seaborns aantrekkelijke visuele stijl behouden
• Balken stapelen om samenstelling te tonen
• Het statistische karakter van de visualisatie behouden
• Seaborns kleurenpaletten gebruiken voor consistentie

Geavanceerde functies en tips

Nu we de basis en aanpassingen hebben behandeld, bekijken we enkele geavanceerde functies die onze barplots informatiever en professioneler maken. We blijven de tips-dataset gebruiken om deze technieken te demonstreren.

Barplots annoteren

Waarde-labels aan balken toevoegen kan je visualisaties preciezer en informatiever maken. Laten we een barplot maken die de exacte fooiwaarden boven elke balk toont.

Laten we eerst onze libraries importeren en de data klaarzetten:

# Import required libraries
import seaborn as sns
import matplotlib.pyplot as plt

# Load and prepare the tips dataset
tips = sns.load_dataset("tips")Mogelijk gemaakt door

Maak onze barplot met statistische waarden:

# Create the basic barplot
ax = sns.barplot(data=tips, x="day", y="tip”, errorbar=None)    # Create barplot and store the axes object for annotationsMogelijk gemaakt door

Vervolgens voegen we waardelabels toe boven op elke balk, zoals hieronder:

# Get the height of each bar
bars = ax.containers[0]                           # Get the bar container object
heights = [bar.get_height() for bar in bars]      # Extract height of each bar

# Add text annotations on top of each bar
for bar, height in zip(bars, heights):            # Loop through bars and heights together
    ax.text(
        bar.get_x() + bar.get_width()/2.,        # X position (center of bar)
        height,                                   # Y position (top of bar)
        f'${height:.2f}',                        # Text (format as currency)
        ha='center',                             # Horizontal alignment
        va='bottom'                              # Vertical alignment
    )Mogelijk gemaakt door

Uitvoer:

Assen en schalen beheren

Bij het maken van barplots helpt het aanpassen van de assen om je data leesbaarder en impactvoller te maken. Laten we bekijken hoe je aslimieten, labels en ticks kunt aanpassen met de functies van Seaborn.

We importeren eerst onze library en laden de dataset die we nodig hebben voor de visualisatie:

# Import required libraries
import seaborn as sns

# Load and prepare the tips dataset
tips = sns.load_dataset("tips")Mogelijk gemaakt door

We kunnen een barplot maken met aangepaste labels en volgorde van dagen. Met de parameter order bepalen we precies hoe we de dagen op de x-as willen rangschikken:

# Create barplot with axis labels
ax = sns.barplot(
    data=tips,
    x="day",
    y="tip",
    order=['Thur', 'Sat', ‘Fri', 'Sun']     # Set custom order for days
)Mogelijk gemaakt door

Om onze plot informatiever te maken, kunnen we beschrijvende labels voor beide assen toevoegen met de methode set:

# Set descriptive axis labels
ax.set(
    xlabel='Day of Week',
    ylabel='Average Tip ($)'
)Mogelijk gemaakt door

Om onze visualisatie fijn af te stellen, kunnen we specifieke limieten en tickmarks instellen. De parameter ylim bepaalt het bereik van de y-as, terwijl xticks en yticks exact aangeven waar de ticks komen:

# Customize axis limits and ticks
ax.set(
    ylim=(0, 5),                            # Set y-axis range from 0 to 5
    xticks=range(4),                        # Set x-axis tick positions
    yticks=[0, 1, 2, 3, 4, 5]              # Set specific y-axis tick values
)Mogelijk gemaakt door

Om al deze wijzigingen in de grafiek op te nemen, voeren we ze in één keer uit en niet stap voor stap. De volledige code staat hieronder:

# Import required libraries
import seaborn as sns

# Load and prepare the tips dataset
tips = sns.load_dataset("tips")

# Create barplot with axis labels
ax = sns.barplot(
   data=tips,
   x="day",
   y="tip",
   order=['Thur', 'Sat', 'Fri', 'Sun']     # Set custom order for days
)

# Set descriptive axis labels
ax.set(
   xlabel='Day of Week',
   ylabel='Average Tip ($)'
)

# Customize axis limits and ticks
ax.set(
   ylim=(0, 5),                            # Set y-axis range from 0 to 5
   xticks=range(4),                        # Set x-axis tick positions
   yticks=[0, 1, 2, 3, 4, 5]              # Set specific y-axis tick values
)Mogelijk gemaakt door

Uitvoer:

De resulterende plot toont fooien per dag met duidelijke labels, passende schalen en overzichtelijke ticks, waardoor de data makkelijk te lezen en te interpreteren is.

Foutbalken toevoegen

Foutbalken helpen de onzekerheid of variatie in je data te visualiseren. Seaborn biedt verschillende opties voor het toevoegen van foutbalken aan je barplots, waaronder betrouwbaarheidsintervallen en standaarddeviatie.

We importeren eerst onze library en laden de dataset die we nodig hebben voor onze visualisatie:

# Import required libraries
import seaborn as sns

# Load and prepare the tips dataset
tips = sns.load_dataset("tips")Mogelijk gemaakt door

Standaard toont Seaborn 95%-betrouwbaarheidsintervallen. We kunnen dit aanpassen met de parameter 'errorbar' om andere statistische schattingen te laten zien:

# Create barplot with confidence intervals
ax = sns.barplot(
    data=tips,
    x="day",
    y="tip",
    errorbar="ci",                          # Show confidence interval
    capsize=0.1                            # Add small caps to error bars
)Mogelijk gemaakt door

Uitvoer:

We kunnen ook de standaarddeviatie tonen in plaats van betrouwbaarheidsintervallen, wat helpt om de spreiding van onze data te visualiseren:

# Switch to standard deviation
ax = sns.barplot(
    data=tips,
    x="day",
    y="tip",
    errorbar="sd",                          # Show standard deviation
    capsize=0.1                            # Add small caps to error bars
)Mogelijk gemaakt door

Uitvoer:

Soms willen we foutbalken helemaal verwijderen voor een strakkere look:

# Create barplot without error bars
ax = sns.barplot(
    data=tips,
    x="day",
    y="tip",
    errorbar=None                           # Remove error bars
)Mogelijk gemaakt door

Uitvoer:

De resulterende plots laten zien hoe verschillende soorten foutbalken helpen om de variatie in onze fooidata per dag van de week te begrijpen.

Praktische toepassingen van Seaborn-barplots

Barplots zijn veelzijdige tools in datavisualisatie, vooral handig wanneer je waarden over verschillende categorieën wilt vergelijken of meerdere variabelen tegelijk wilt analyseren. Laten we twee veelvoorkomende toepassingen bekijken waarin Seaborn-barplots uitblinken.

Trends in categorische data visualiseren

Seaborn-barplots zijn sterk in het blootleggen van patronen in categorische data, vooral bij het analyseren van metrics over verschillende groepen. Door zowel de centrale tendens als de onzekerheid te tonen, helpen barplots om significante verschillen tussen categorieën te identificeren. 

Dit maakt ze ideaal voor het analyseren van klantgedrag, productprestaties of enquêtereacties waarbij je waarden over duidelijke groepen vergelijkt.

Meerdere variabelen vergelijken

Wanneer onze analyse meerdere factoren omvat, kunnen de barplots van Seaborn complexe relaties in onze data benadrukken. Met functies zoals groeperen (hue) of stapelen kun je verschillende variabelen tegelijk vergelijken, waardoor patronen en interacties tussen aspecten van je data makkelijker te zien zijn.

Conclusie 

Seaborn-barplots vinden de juiste balans tussen eenvoud en statistisch inzicht. De intuïtieve syntax gecombineerd met robuuste statistische functies maakt het een onmisbaar hulpmiddel voor datavisualisatie. Van basisvergelijkingen tussen categorieën tot geavanceerde gegroepeerde visualisaties: barplots helpen patronen effectief te ontdekken en te communiceren.

Klaar om je datavisualisatievaardigheden naar een hoger niveau te tillen? Verken dan dit als volgende stap:

• Snel een naslag nodig? Bekijk onze Python Seaborn Cheat Sheet
• Verken lijndiagrammen in onze Seaborn Line Plot Tutorial
• Leer correlaties visualiseren en lees de Seaborn Heatmaps Tutorial
• Beheers datadistributies met onze gids How to Make a Seaborn Histogram

Wil je je Seaborn-skills verder uitbouwen? Schrijf je in voor de Intermediate Data Visualization with Seaborn-cursus.