How to Easily Create Stacked Bar Plots with Seaborn

A stacked bar plot is a type of chart that uses bars divided into a number of sub-bars to visualize the values of multiple variables at once.

Setting up the Environment and Data Creation

The initial and most critical phase of any data visualization project involves setting up the development environment and preparing the source data. We rely heavily on the Python ecosystem, specifically the Pandas DataFrame for data manipulation and storage. Ensuring that these libraries are correctly imported under their conventional aliases (pd for Pandas) streamlines the coding process and adheres to established community standards. This foundational step guarantees that all subsequent data operations and function calls are correctly executed.

For this demonstration, we will construct a simple dataset illustrating daily customer traffic metrics for a hypothetical restaurant. This dataset tracks the total customer count during two distinct periods—Morning and Evening—across the five main weekdays. Structuring the data this way, with categories (Day) and quantitative measures (Morning, Evening) defined as separate columns, is ideal for plotting comparative data where the components sum up to a daily total.

The code snippet below defines our primary data structure. We initialize a Pandas DataFrame, assigning explicit values for each day and corresponding time slot. Reviewing the resulting table immediately after creation is an essential practice to verify data integrity and ensure that the dimensions match expectations before moving on to the visualization phase.

import pandas as pd

#create DataFrame
df = pd.DataFrame({'Day': ['Mon', 'Tue', 'Wed', 'Thur', 'Fri'],
                   'Morning': [44, 46, 49, 59, 54],
                   'Evening': [33, 46, 50, 49, 60]})

#view DataFrame
df

	Day	Morning	Evening
0	Mon	44	33
1	Tue	46	46
2	Wed	49	50
3	Thur	59	49
4	Fri	54	60

Understanding the Data Structure for Stacking

While Seaborn excels at plotting data structured in a “long” format (where categories are grouped into a single variable column), the standard Matplotlib plotting API, which is often leveraged when customizing charts built on DataFrames, handles the “wide” format used here quite effectively for stacking. In our wide format, each metric we wish to stack (Morning and Evening) occupies its own column. The key to successful stacking in this scenario is utilizing the index of the DataFrame to define the horizontal axis.

The core requirement for creating a stacked bar chart using the direct plotting method on a Pandas DataFrame is that the categorical variable intended for the X-axis must be set as the index. In the next step, we will call the set_index('Day') method directly before invoking the .plot() function. This ensures that the days (Mon-Fri) become the unique identifiers along the X-axis, and the remaining numeric columns (Morning, Evening) are treated as the variables to be stacked vertically for each index value.

Understanding this structural requirement is critical because plotting without setting the index would typically result in separate, non-stacked bars for each numerical column across a default numeric index (0, 1, 2, 3, 4). By explicitly setting ‘Day’ as the index, we signal to the plotting function that the aggregation and stacking should occur based on these daily categories, preparing the visualization for the specific structure of a stacked bar plot.

Generating the Basic Stacked Bar Chart

With the data correctly structured in our Pandas DataFrame, the next logical step is to import the necessary visualization libraries—specifically Matplotlib for plotting functionality and Seaborn for enhanced statistical graphics and aesthetic controls. Although we are using the Pandas plotting wrapper (which relies fundamentally on Matplotlib), importing Seaborn allows us to leverage its sophisticated aesthetic controls, such as the sns.set() function, to immediately improve the visual appeal and readability of the chart elements.

The actual generation of the stacked bar plot is accomplished with a single, highly efficient line of code applied to the DataFrame. This line chains three operations: setting the index to ‘Day’, calling the .plot() method, and passing specific keyword arguments. Crucially, we specify kind='bar' to select the bar chart type and stacked=True, which instructs the plotting engine to stack the ‘Morning’ and ‘Evening’ values vertically rather than placing them side-by-side. We also pass a simple list of colors to enhance differentiation between the two components.

This initial visualization provides a raw view of the data distribution, clearly showing the daily totals and the proportional contribution of the morning and evening customer counts. While functional, this chart typically lacks key context such as a descriptive title and clearly labeled axes, making the customization steps that follow absolutely necessary for a professional presentation.

import matplotlib.pyplot as plt
import seaborn as sns

#set seaborn plotting aesthetics
sns.set(style='white')

#create stacked bar chart
df.set_index('Day').plot(kind='bar', stacked=True, color=['steelblue', 'red'])

The result of this code block is the basic stacked chart shown below, which effectively visualizes the customer counts aggregated by day.

As visible in this initial output, the x-axis correctly displays the day of the week, and the vertical bars represent the combined total number of customers, segmented visually by the morning and evening sessions. This foundational visualization confirms that the data mapping and stacking logic were correctly applied.

Enhancing Aesthetics with Matplotlib and Seaborn

A raw visualization, while technically accurate, often lacks the polish and clarity required for professional reporting. The fourth step involves leveraging the extensive customization capabilities provided by the underlying Matplotlib framework to add critical contextual elements. Enhancing the chart involves setting a descriptive title, labeling the axes clearly, and adjusting elements like tick rotation to improve readability, especially when dealing with long categorical labels.

We begin by setting the overall chart title using plt.title(), which immediately informs the viewer of the chart’s purpose. Following this, plt.xlabel() and plt.ylabel() are essential for providing specific context to the horizontal and vertical measurements. In our case, labeling the X-axis as ‘Day of Week’ and the Y-axis as ‘Number of Customers’ eliminates ambiguity regarding the plotted dimensions.

A crucial aesthetic enhancement for bar charts involves handling the orientation of X-axis labels. When categories are long or numerous, horizontal labels can overlap, making the chart illegible. By applying plt.xticks(rotation=45), we rotate the day labels by 45 degrees. This simple adjustment dramatically improves the spacing and ensures that all categorical labels are distinct and easy to read, finalizing the chart’s readiness for analysis and distribution.

import matplotlib.pyplot as plt
import seaborn as sns

#set seaborn plotting aesthetics
sns.set(style='white')

#create stacked bar chart
df.set_index('Day').plot(kind='bar', stacked=True, color=['steelblue', 'red'])

#add overall title
plt.title('Customers by Time & Day of Week', fontsize=16)

#add axis titles
plt.xlabel('Day of Week')
plt.ylabel('Number of Customers')

#rotate x-axis labels
plt.xticks(rotation=45)

Interpreting the Final Visualization

The final stacked bar plot is now fully customized and ready for interpretation. A stacked chart offers two primary layers of analysis simultaneously: the height of the entire bar represents the aggregate total (e.g., total customers for a given day), and the segments within the bar represent the proportional contribution of each subcategory (e.g., the breakdown between morning and evening traffic). This dual perspective is the fundamental advantage of this chart type over simple grouped bar charts.

Analyzing the total height across the week, we can quickly identify peak traffic days. For example, comparing the bars, Friday (Fri) appears to have the highest total customer count, slightly exceeding Thursday (Thur). Conversely, Monday (Mon) has the lowest overall traffic. This insight into overall volume is invaluable for operational planning, staffing decisions, and inventory management within the restaurant setting.

When examining the composition, we observe fluctuations in session dominance. On Monday and Tuesday, the Morning traffic (represented by the steelblue color) slightly outweighs the Evening traffic (red). However, as the week progresses, especially on Friday, the Evening segment dominates the overall bar height, indicating a significant shift in customer behavior towards the end of the work week. The visual representation confirms that while morning traffic is relatively stable, evening traffic drives the weekend surge, providing actionable insights into peak service hours.

Leveraging Seaborn Aesthetics

While the primary plotting mechanism here is based on Matplotlib‘s DataFrame integration, the initial inclusion of Seaborn allows us to establish a superior visual context through its control over plotting aesthetics. Seaborn is built upon Matplotlib and offers high-level interfaces for drawing attractive and informative statistical graphics. By calling sns.set(style='white'), we immediately apply a refined default visual style that enhances clarity compared to Matplotlib’s default settings.

Seaborn provides several built-in themes or “contexts” that adjust the plot’s appearance, including background color, grid lines, and font scaling. The 'white' style, for instance, removes the default gray background and horizontal grid lines typically associated with other styles, focusing the viewer’s attention purely on the data bars and axes. Other popular styles include 'darkgrid', 'whitegrid', 'dark', and 'ticks', each offering a different combination of visual cues to suit various reporting environments.

It is important to recognize that choosing the right aesthetic style is part of effective data storytelling. For dense, scientific plots, a grid might be essential for reading exact values. For a cleaner, report-style visualization like the one we created, the simpler 'white' aesthetic minimizes visual clutter. Analysts should be aware of the full range of options available in the Seaborn library to optimize their visualizations for their intended audience and purpose.

Note: We set the seaborn style to ‘white’ for this plot, but you can find a complete list of seaborn plotting aesthetics on the official documentation.

Summary of the Stacked Bar Plot Workflow

Creating a professional stacked bar plot in the Python environment is a streamlined process that bridges robust data management with powerful visualization tools. We successfully demonstrated how to initialize a data structure using a Pandas DataFrame, prepare it by setting the appropriate index, and then utilize the integrated plotting capabilities of Pandas and Matplotlib, enhanced by the aesthetics of Seaborn. The resulting visualization clearly communicated both the total daily customer volume and the contribution of morning versus evening sessions, providing two layers of valuable business intelligence.

The key takeaway from this tutorial is the necessity of setting stacked=True within the .plot() method and ensuring the categorical variable is defined as the DataFrame index. Furthermore, the importance of aesthetic refinement—adding titles, axis labels, and adjusting tick rotation—cannot be overstated, as these elements transform a raw plot into a comprehensive analytical output.

By mastering this sequence of steps—data preparation, basic plotting, and detailed customization—data professionals can efficiently generate compelling stacked bar charts tailored to various comparative analytical requirements. This methodology is highly scalable and applicable across diverse datasets where understanding component contributions to an aggregate total is paramount.