Step 1: Create Your First Bar Chart

Hospital systems often rely on satisfaction surveys to assess how patients feel about the care they received. These scores can influence funding, reputation, and improvement strategies.

In this Code Lab, you'll start by creating simple bar charts to visualize satisfaction scores from multiple hospitals. You’ll learn how to use both:

• Matplotlib’s plt.bar() function (imperative style)
• Seaborn's sns.barplot() function (declarative style)

Both tool helps you visualize data, but they differ in how much you control versus how much is automated.

What You’ll Learn in This Step

• Build a basic vertical bar chart using Matplotlib
• Recreate it using Seaborn’s barplot() function
• Understand how both libraries render bar charts differently

You'll complete all tasks in a Jupyter notebook rather than in standalone .py files.

Open the Notebook

• Navigate to the workspace in the right panel.
• Open the file: step-one.ipynb.

For this lab, you’ll use the dataset located at data/medicalPatients.csv. It contains demographic and diagnostic information for hospital patients.

To visualize categorical data using Matplotlib, use the plt.bar() function to generate vertical bar graphs.

import matplotlib.pyplot as plt

plt.bar(x=['A', 'B', 'C'], height=[10, 20, 15])
plt.show()

While matplotlib.pyplot gives you full control over how charts are constructed, it can be more manual. For cleaner, faster visualizations, many analysts use Seaborn—a library that automates chart layout and statistical aggregation.

The sns.barplot() function builds bar charts directly from a DataFrame. You specify which columns should represent the x-axis (categories) and y-axis (values), and it does the rest.

import seaborn as sns
import matplotlib.pyplot as plt

sns.barplot(x="category_column", y="numeric_column", data=table_name, estimator=function)
plt.show()

You’ll use this approach to recreate the same diagnosis chart—showing how Seaborn can handle counting and plotting in fewer lines of code.

Step 2: Add Labels and Titles

Charts without titles, axis labels, or tick formatting can confuse or mislead your audience—even when the data itself is accurate. This step helps you transform basic bar charts into clear, presentation-ready visuals by:

• Adding axis labels to clarify units and categories
• Applying chart titles to summarize the message
• Rotating long tick labels for better legibility

These finishing touches ensure your visualizations are interpretable and professional—both essentials for any reporting or stakeholder deliverables.

What You’ll Learn in This Step

• Use plt.xlabel() and plt.ylabel() to define axis labels
• Use plt.title() to summarize your chart’s purpose
• Rotate tick labels using plt.xticks(rotation=...) for clarity

You'll complete all tasks in a Jupyter notebook rather than in standalone .py files.

Open the Notebook

• Open the file: step-two.ipynb in the workspace.

When building data visualizations, chart readability is just as important as the data itself. That’s where axis labels, titles, and tick formatting come in.

Matplotlib gives you a few essential tools for this:

plt.xlabel("X-axis label")
plt.ylabel("Y-axis label")
plt.title("Chart Title")
plt.xticks(rotation=45)

You’ll now take the basic bar chart you created earlier and refine it for clarity and presentation. Across the next few tasks, you’ll focus on key improvements like adding labels, applying a title, and adjusting tick readability. ---

Add a Title Using plt.title()

A chart title is often the first thing a viewer sees—it helps them understand what the data represents without needing to decode axis labels or dive into the chart structure.

Matplotlib allows you add a title using a simple, single function:

plt.title("Descriptive Chart Title")

The title should summarize the chart’s key insight clearly and succinctly. It typically appears at the top and is added after you've built your plot.

Adjust Tick Labels for Readability

Tick labels help your audience understand what each bar or point in a chart represents. But when labels are long—like diagnosis names—they can overlap or become unreadable.

Matplotlib and Seaborn both provide ways to fix this.

plt.xticks(rotation=45)

import seaborn as sns
sns.set(style="whitegrid", context="talk")

Step 3: Customize Bar Colors and Styles

Styling a chart is more than just aesthetics—color and layout can guide attention, reinforce categories, and make data easier to interpret.

In this step, you’ll learn how to control the look and feel of your bar charts.

You’ll apply:

• Custom fill colors to individual bars
• Seaborn palettes for categorical data
• Consistent visual themes using sns.set_style()

This is where your chart starts looking like something you’d show in a presentation or dashboard.

What You’ll Learn in This Step

• Change bar colors in matplotlib using the color and edgecolor parameters
• Use Seaborn’s built-in color palettes for automatic styling
• Apply global chart styles using sns.set_style()

You'll complete all tasks in a Jupyter notebook rather than in standalone .py files.

Open the Notebook

• Open the file: step-three.ipynb in the workspace.

Apply Custom Bar Colors in Matplotlib

By default, matplotlib assigns a single color to all bars. But in many cases, adjusting the fill and border colors can improve visual clarity—especially when comparing categories or highlighting specific data.

You can customize colors by passing color names or hex values to the color and edgecolor parameters:

plt.bar(x_values, y_values, color='skyblue', edgecolor='black')

color="steelblue"         # Named color
color="#1f77b4"           # Hex code
color=["skyblue", "orange", "salmon"]  # List of colors for each bar
edgecolor="black"         # Adds a border around bars

When working with categorical values (like diagnosis), you can generate a list of colors that matches the number of categories, then pass that list to the color parameters. ---

Use Seaborn Color Palettes

When working with categorical data like diagnoses, using a distinct color for each category can make the chart easier to scan and compare.

Seaborn provides built-in color palettes that automatically assign consistent colors to categories. These palettes work seamlessly with Seaborn’s sns.barplot() function.

import seaborn as sns
sns.barplot(
    x="diagnosis", 
    y="count", 
    hue="diagnosis",          # Required to assign colors per category
    data=table, 
    palette="pastel", 
    legend=False              # Optional: hides the redundant color legend
)

sns.color_palette("pastel")

In addition to setting bar colors, you can style the entire chart environment using Seaborn’s set_style() function. This controls things like background gridlines, axis borders, and overall visual tone.

This helps maintain visual consistency across multiple plots—especially in presentations or reports.

sns.set_style("whitegrid")  # Recommended for bar charts

You typically call sns.set_style() once before plotting and it will persist for all following charts unless explicitly changed.

Step 4: Experiment with Layout Variations in Matplotlib

Matplotlib supports more than just vertical bar charts. You can rotate axes, stack values, or even create grouped comparisons. In this step, you’ll explore layout variations that help communicate different types of relationships in your data.

What You’ll Learn in This Step

• Create a horizontal bar chart using plt.barh()
• Build a stacked bar chart using the bottom parameter

You'll complete all tasks in a Jupyter notebook rather than in standalone .py files.

Open the Notebook

• Open the file: step-four.ipynb in the workspace.

A horizontal bar chart can be more effective than a vertical one—especially when category names are long or when you want to emphasize ranking over raw counts.

Matplotlib makes this easy by using plt.barh() instead of plt.bar().

plt.barh(y=categories, width=values)

This layout flips the usual orientation:

• Category names are listed top-to-bottom
• Values are measured left-to-right

Create a Stacked Bar Chart Using the bottom Parameter

A stacked bar chart allows you show multiple values for the same category—layered visually to display sub-totals and totals at once.

Matplotlib’s plt.bar() supports stacking by setting the bottom parameter. This tells Python where to start each bar, allowing you to stack new values on top of existing ones.

plt.bar(x=labels, height=group1)
plt.bar(x=labels, height=group2, bottom=group1)

To use this pattern:

• Group the dataset by two dimensions (e.g., diagnosis and gender)
• Plot one group first (e.g., Male)
• Stack the other on top (e.g., Female) using the bottom argument to align the bars vertically

Step 5: Final Touches and Exporting in Matplotlib

Polished charts are just as important as accurate ones. After analyzing and visualizing your data, you should be able to:

• Communicate uncertainty using error bars
• Eliminate chart clutter like excess spines or borders
• Export your final chart using plt.savefig() for sharing or documentation

This step equips you with the tools to finalize your visualization with clarity, precision, and portability.

What You’ll Learn in This Step

• Add vertical and horizontal error bars using yerr and xerr
• Clean up unnecessary chart spines
• Export your chart using plt.savefig()

You'll complete all tasks in a Jupyter notebook rather than in standalone .py files.

Open the Notebook

• Open the file: step-five.ipynb in the workspace.

Error bars are used to show variability or uncertainty in your data—such as survey margin of error or confidence intervals.

In Matplotlib, you can add error bars to bar charts using:

• yerr= → for vertical bar charts
• xerr= → for horizontal bar charts

These parameters accept a single number (same error for all bars) or a list/array of values (custom error for each bar).

# Vertical bar chart with constant error
plt.bar(x=["A", "B", "C"], height=[10, 15, 8], yerr=2)

# Horizontal bar chart with different errors per bar
plt.barh(y=["X", "Y", "Z"], width=[5, 7, 4], xerr=[1, 2, 1])

Chart spines are the border lines surrounding the plot area. By default, Matplotlib includes all four spines: top, right, left, and bottom.

In most modern chart designs, the top and right spines are removed to reduce visual clutter and shift the focus toward the data.

# Access the current Axes
ax = plt.gca()

# Hide the top and right spines
ax.spines["top"].set_visible(False)
ax.spines["right"].set_visible(False)

Once your chart is complete, you may want to share it in reports, presentations, or emails. Matplotlib allows you to export your chart as an image using the savefig() function.

This ensures that your visualization can be reused outside of the notebook—and that its formatting is preserved exactly as rendered.

plt.savefig("output_chart.png")

Step 6: Get Started with Seaborn for Declarative Plotting

Declarative plotting tools like Seaborn let you build expressive charts with less code. Instead of manually calculating values and drawing each component, you describe what you want to show and Seaborn takes care of the rendering logic.

In this step, you'll use sns.barplot() to quickly generate charts that summarize key patient metrics.

What You’ll Learn in This Step

• Create bar charts using Seaborn’s sns.barplot() function
• Use the estimator parameter to count or summarize automatically
• Apply Seaborn’s built-in themes for clean, presentation-ready visuals

You'll complete all tasks in a Jupyter notebook rather than in standalone .py files.

Open the Notebook

• Open the file: step-six.ipynb in the workspace.

Seaborn’s sns.barplot() is designed to be declarative: you provide a dataset and column names, and it automatically computes the necessary summaries and draws the chart.

Unlike plt.bar(), you don’t need to manually count or aggregate values. Just pass a categorical column for the x-axis and a numeric column for the y-axis—Seaborn handles the rest.

import seaborn as sns
import matplotlib.pyplot as plt

sns.barplot(x="diagnosis", y="patient_id", data=df, estimator=len)
plt.show()

In this task, you'll improve the readability of your Seaborn bar chart by adding axis labels and a title using matplotlib.pyplot.

Even though Seaborn handles much of the chart layout, labeling remains your responsibility. You’ll use standard plt functions to make the chart self-explanatory and presentation-ready.

plt.xlabel("Diagnosis")
plt.ylabel("Patient Count")
plt.title("Number of Patients by Diagnosis")

plt.xlabel("Diagnosis")
plt.ylabel("Number of Patients")
plt.title("Number of Patients by Diagnosis")
 ### Apply a Colorblind-Friendly Palette with Seaborn

Color plays a crucial role in how your charts are interpreted. Using accessible palettes—such as Seaborn’s `"colorblind"` palette—ensures your visualizations are inclusive and easy to understand for all audiences.

In this task, you’ll apply a high-contrast, colorblind-safe palette to your chart using`sns.color_palette("colorblind")` 

---

<details>
<summary><strong>Using a Colorblind-Safe Palette</strong></summary>

```python
import seaborn as sns
sns.set_palette("colorblind")

Step 7: Advanced Seaborn Features and Export

Grouped bar charts are an effective way to compare multiple categories side by side. Seaborn makes this easy using the hue parameter, which segments each bar group visually without manual layout logic.

In this step, you’ll build grouped bar charts using Seaborn’s high-level plotting tools and explore how to control orientation and spacing.

What You’ll Learn in This Step

• Use the hue parameter in sns.barplot() to segment bars by category
• Convert grouped bars to horizontal layout using orient="h"
• Control spacing between grouped bars using dodge=False

You'll complete all tasks in a Jupyter notebook rather than in standalone .py files.

Open the Notebook

• Open the file: step-seven.ipynb in the workspace.

When you want to compare subgroups within a main category—for example, comparing male and female satisfaction scores within each hospital—Seaborn’s hue parameter handles this automatically.

Instead of reshaping your data manually (as you would in Matplotlib), you simply specify an additional categorical column. Seaborn will segment the bars and generate a grouped layout by default.

import seaborn as sns
import matplotlib.pyplot as plt

sns.barplot(x="hospital", y="satisfaction", hue="gender", data=df)
plt.title("Satisfaction by Hospital and Gender")
plt.xticks(rotation=45)
plt.show()

Sometimes, horizontal bar charts offer better readability—especially when category labels are long or when comparing smaller differences in values.

Seaborn supports horizontal grouped bars by setting the orient="h" parameter in sns.barplot(). This flips the chart so categories appear on the y-axis and values extend along the x-axis.

sns.barplot(
    y="hospital",
    x="satisfaction",
    hue="gender",
    data=df,
    orient="h"
)

By default, Seaborn spaces grouped bars side by side to clearly show distinctions between subgroups. But sometimes, especially with many categories, tighter spacing is more readable.

The dodge parameter controls this behavior:

• dodge=True (default): Separates each subgroup into distinct bars.
• dodge=False: Overlays the bars for each group—useful for a more compact look or when the subgroups are closely related.

This is especially effective when you're comparing relative totals rather than exact subgroup differences.

sns.barplot(
    x="hospital",
    y="satisfaction",
    hue="gender",
    data=df,
    dodge=False
)

Customize or Remove the Legend for Grouped Bar Charts

Grouped bar charts include a legend by default to indicate the meaning of colors assigned via hue. In some contexts, however, the legend may be redundant or better placed elsewhere.

Seaborn and Matplotlib give you full control over the legend’s visibility, position, and appearance using plt.legend() or ax.legend().

You can:

• Remove the legend completely with plt.legend().remove().
• Move it to the top, bottom, or side using loc parameter.
• Add a title to clarify what’s being grouped.

sns.barplot(x="hospital", y="satisfaction", hue="gender", data=df)
plt.title("Satisfaction by Gender")
plt.legend(title="Gender", loc="upper right")

plt.legend().remove()

Managing the legend helps focus the chart on what matters most, especially when the visual grouping is self-explanatory or already labeled elsewhere.

Step 8: Finalize and Export Seaborn Charts

As you wrap up your grouped bar chart, it's time to polish and export your work.

In this step, you'll:

• Remove unnecessary chart borders (called spines) for a cleaner look
• Save your final Seaborn chart as a static image using plt.savefig()

These steps help ensure your chart is presentation-ready for reports, slides, or dashboards.

What You’ll Learn in This Step

• Remove visual clutter using sns.despine()
• Export your chart to a .png file with plt.savefig()

You'll complete all tasks in a Jupyter notebook rather than in standalone .py files.

Open the Notebook

• Open the file: step-eight.ipynb in the workspace.

By default, Seaborn charts include all four spines (outer borders). However, the top and right edges often don’t add value. Removing them can make your chart feel cleaner and more modern—especially when preparing visuals for stakeholders or reports.

The sns.despine() function removes unnecessary spines with a single line of code.

import seaborn as sns
import matplotlib.pyplot as plt

sns.barplot(x="hospital", y="satisfaction", hue="gender", data=df)
plt.title("Cleaned-Up Grouped Chart")
sns.despine()
plt.show()

Once you’ve created a polished chart, the final step is to export it for use outside the notebook. Matplotlib’s plt.savefig() function saves the current figure as an image file—perfect for reports, presentations, or emails.

You can specify the file format, size, resolution, and export location.

plt.savefig("satisfaction_by_hospital.png", dpi=300, bbox_inches="tight")

Great job! You’ve now built a complete, presentation-ready grouped bar chart using Seaborn.

Here’s what you accomplished:

• Used the hue parameter to group data visually
• Switched between vertical and horizontal layouts for better readability
• Controlled spacing with dodge=False and cleaned up visuals using sns.despine()
• Customized and removed legends to improve clarity
• Exported your final chart as a high-quality .png file using plt.savefig()

These techniques are essential for creating insightful, professional-grade visualizations that communicate data clearly and effectively.