4.2 Statistical Data Visualization with Seaborn

4.2 Statistical Data Visualization with Seaborn

Seaborn is a Python data visualization library built on top of Matplotlib. It provides a high-level interface for creating attractive and statistically informative visualizations.

While Matplotlib gives detailed control over individual plot elements, Seaborn makes many statistical visualizations easier to create with less code.

1. What Is Seaborn?

Seaborn is a Python library designed specifically for statistical data visualization.

It works particularly well with:

• pandas DataFrames
• NumPy arrays
• Statistical datasets
• Exploratory Data Analysis (EDA)
• Machine Learning datasets

Seaborn provides convenient functions for exploring relationships, distributions, categories, and statistical patterns.

2. Seaborn vs Matplotlib

3. Installing Seaborn

Install Seaborn using pip:

pip install seaborn

With Conda:

conda install seaborn

In a Jupyter Notebook:

%pip install seaborn

4. Importing Seaborn

import seaborn as sns

sns is the conventional alias used for Seaborn.

Matplotlib is commonly imported alongside Seaborn:

import seaborn as sns
import matplotlib.pyplot as plt

5. Your First Seaborn Visualization

import seaborn as sns
import matplotlib.pyplot as plt

data = [12, 15, 18, 20, 22, 25, 28, 30]

sns.histplot(data=data)

plt.show()

Seaborn creates the visualization while Matplotlib can be used to display and further customize the figure.

6. Working with a pandas DataFrame

Seaborn becomes especially powerful when working with pandas DataFrames.

import pandas as pd

df = pd.DataFrame({
    "Hours": [
        2, 3, 4, 5, 6,
        7, 8, 9, 10, 11
    ],

    "Score": [
        48, 52, 58, 64, 69,
        74, 80, 84, 89, 94
    ],

    "Class": [
        "A", "A", "B", "B", "A",
        "B", "A", "B", "A", "B"
    ]
})

print(df)

Once the data is stored in a DataFrame, Seaborn functions can reference columns directly.

7. Long-Form Data

Seaborn works particularly well with long-form data, where each observation is represented by a row and variables are stored in columns.

This structure makes it easy for Seaborn to map variables to visual properties.

8. The hue Parameter

One of Seaborn's most useful features is the hue parameter.

It allows observations to be visually separated according to a categorical variable.

sns.scatterplot(
    data=df,
    x="Hours",
    y="Score",
    hue="Class"
)

plt.show()

Here, the Class column determines the visual grouping of observations.

9. Distribution Visualization

Distribution visualizations help us understand how numerical observations are spread across their possible values.

They can help identify:

• Central tendency
• Spread
• Skewness
• Clusters
• Potential outliers
• General shape of the data

10. Histograms with Seaborn

Use sns.histplot() to create a histogram.

scores = [
    45, 52, 56, 61, 64,
    67, 70, 72, 75, 78,
    81, 84, 87, 90, 94,
    98
]

sns.histplot(
    data=scores
)

plt.title("Score Distribution")
plt.xlabel("Score")
plt.ylabel("Frequency")

plt.show()

11. Controlling Histogram Bins

The bins parameter controls the number or structure of histogram intervals.

sns.histplot(
    data=scores,
    bins=5
)

plt.show()

Choosing an appropriate number of bins is important because too few bins can hide patterns while too many can make a distribution appear unnecessarily noisy.

12. Kernel Density Estimation (KDE)

KDE provides a smooth estimate of the probability density of numerical data.

A KDE curve can help visualize the overall shape of a distribution.

sns.kdeplot(
    data=scores
)

plt.title("Score Density")
plt.xlabel("Score")

plt.show()

13. Histogram with KDE

Seaborn can display a histogram together with a KDE curve.

sns.histplot(
    data=scores,
    bins=6,
    kde=True
)

plt.title(
    "Score Distribution with Density"
)

plt.xlabel("Score")
plt.ylabel("Frequency")

plt.show()

14. Box Plots

A box plot summarizes the distribution of numerical data using quartiles and can help identify potential outliers.

A standard box plot represents:

• Median
• First quartile (Q1)
• Third quartile (Q3)
• Interquartile range (IQR)
• Potential outliers

sns.boxplot(
    data=df,
    y="Score"
)

plt.title("Score Distribution")

plt.show()

15. Understanding the Box Plot

16. Comparing Distributions with Box Plots

Box plots become particularly useful when comparing numerical distributions across categories.

sns.boxplot(
    data=df,
    x="Class",
    y="Score"
)

plt.title(
    "Score Distribution by Class"
)

plt.show()

This allows you to compare the center, spread, and potential outliers of different groups.

17. Violin Plots

A violin plot combines aspects of a box plot with a density representation.

sns.violinplot(
    data=df,
    x="Class",
    y="Score"
)

plt.title(
    "Score Distribution by Class"
)

plt.show()

18. Count Plots

A count plot displays the number of observations in each category.

sns.countplot(
    data=df,
    x="Class"
)

plt.title(
    "Number of Students by Class"
)

plt.xlabel("Class")
plt.ylabel("Count")

plt.show()

Count plots are useful for examining categorical frequencies.

19. Statistical Bar Plots

Seaborn's barplot() is different from a basic Matplotlib bar chart because it is designed around statistical aggregation.

sns.barplot(
    data=df,
    x="Class",
    y="Score"
)

plt.title(
    "Average Score by Class"
)

plt.show()

The exact estimator and error representation can be controlled through Seaborn's parameters.

20. Strip Plots

A strip plot displays individual observations for categorical groups.

sns.stripplot(
    data=df,
    x="Class",
    y="Score"
)

plt.title(
    "Individual Scores by Class"
)

plt.show()

Strip plots are useful when the individual observations themselves are important.

21. Swarm Plots

A swarm plot arranges individual observations so that overlapping points are easier to distinguish.

sns.swarmplot(
    data=df,
    x="Class",
    y="Score"
)

plt.title(
    "Individual Scores by Class"
)

plt.show()

22. Pair Plots

A pair plot provides a matrix of pairwise relationships between numerical variables in a dataset.

It is particularly useful during EDA when you want to quickly inspect relationships across several variables.

import seaborn as sns
import matplotlib.pyplot as plt

df = sns.load_dataset("iris")

sns.pairplot(
    df
)

plt.show()

23. Pair Plot with Categories

A categorical variable can be supplied using hue.

sns.pairplot(
    df,
    hue="species"
)

plt.show()

This helps identify whether different groups occupy different regions of the feature space.

24. When Should You Use a Pair Plot?

Pair plots are useful when:

• The dataset contains several numerical features.
• You are performing initial EDA.
• You want to inspect possible correlations.
• You want to identify clusters.
• You want to compare distributions by category.

25. Correlation and Heatmaps

A correlation matrix summarizes pairwise relationships between numerical variables.

Pandas can calculate the correlation matrix:

correlation = df.corr(
    numeric_only=True
)

print(correlation)

The resulting matrix can be visualized with a Seaborn heatmap.

26. Heatmaps

A heatmap represents numerical values using visual intensity, making patterns in a matrix easier to identify.

correlation = df.corr(
    numeric_only=True
)

sns.heatmap(
    correlation
)

plt.title(
    "Correlation Matrix"
)

plt.show()

27. Displaying Values in a Heatmap

Use annot=True to display numerical values inside the heatmap cells.

sns.heatmap(
    correlation,
    annot=True
)

plt.title(
    "Correlation Matrix"
)

plt.show()

28. Formatting Heatmap Values

The fmt parameter can control how annotated values are displayed.

sns.heatmap(
    correlation,
    annot=True,
    fmt=".2f"
)

plt.show()

Here, values are displayed with two decimal places.

29. Square Heatmaps

For correlation matrices, square cells can make the matrix easier to inspect.

sns.heatmap(
    correlation,
    annot=True,
    fmt=".2f",
    square=True
)

plt.show()

30. Regression Visualization

Seaborn can visualize a relationship between two numerical variables together with a fitted regression model.

sns.regplot(
    data=df,
    x="Hours",
    y="Score"
)

plt.title(
    "Study Hours vs Score"
)

plt.show()

Regression visualization is useful when investigating whether a relationship between variables can be approximated by a statistical model.

31. Relationship Plots with relplot()

sns.relplot() provides a figure-level interface for relational plots.

sns.relplot(
    data=df,
    x="Hours",
    y="Score",
    hue="Class"
)

plt.show()

Relational plots are useful for examining how numerical variables relate to each other.

32. Seaborn Themes and Styles

Seaborn provides built-in styling options that can change the overall appearance of plots.

sns.set_theme()

sns.histplot(
    data=scores
)

plt.show()

You can also select a theme explicitly.

sns.set_theme(
    style="whitegrid"
)

Common styles include:

• darkgrid
• whitegrid
• dark
• white
• ticks

33. Color Palettes

Seaborn provides color palettes designed for categorical and numerical data.

sns.set_palette(
    "deep"
)

A palette can also be supplied to an individual plot:

sns.boxplot(
    data=df,
    x="Class",
    y="Score",
    palette="Set2"
)

34. Faceting with col and row

Seaborn figure-level functions can create separate panels for different categories.

sns.relplot(
    data=df,
    x="Hours",
    y="Score",
    col="Class"
)

plt.show()

Faceting is useful when a single visualization becomes crowded and separate panels make group comparisons clearer.

35. Categorical Visualization with catplot()

catplot() provides a figure-level interface for categorical plots.

sns.catplot(
    data=df,
    x="Class",
    y="Score",
    kind="box"
)

plt.show()

The kind parameter determines the type of categorical visualization.

36. Common Categorical Plot Types

37. Comparing Distributions by Category

A useful EDA technique is to compare the distribution of a numerical variable across categories.

sns.histplot(
    data=df,
    x="Score",
    hue="Class",
    kde=True
)

plt.title(
    "Score Distribution by Class"
)

plt.show()

This can reveal whether different groups have different distributions.

38. KDE by Category

sns.kdeplot(
    data=df,
    x="Score",
    hue="Class",
    fill=True
)

plt.title(
    "Score Density by Class"
)

plt.show()

This allows the density shapes of multiple categories to be compared.

39. Visualizing Discrete Numerical Values

Some numerical variables represent counts or other discrete values. Seaborn provides parameters that can help communicate this structure appropriately.

sns.histplot(
    data=df,
    x="Score",
    discrete=True
)

plt.show()

40. Data Preparation Before Seaborn

Visualization should generally be performed after checking the quality of the data.

print(df.info())
print(df.isnull().sum())
print(df.describe())

If necessary, handle missing or invalid values before plotting.

clean_df = df.dropna()

sns.boxplot(
    data=clean_df,
    x="Class",
    y="Score"
)

plt.show()

41. Complete EDA Example Using the Iris Dataset

Seaborn includes several example datasets that are useful for learning visualization techniques.

import seaborn as sns
import matplotlib.pyplot as plt

df = sns.load_dataset(
    "iris"
)

print(df.head())

print(df.describe())

The Iris dataset contains measurements such as sepal and petal dimensions along with the species category.

42. Iris Distribution Visualization

sns.histplot(
    data=df,
    x="petal_length",
    hue="species",
    kde=True
)

plt.title(
    "Petal Length Distribution by Species"
)

plt.show()

43. Iris Box Plot

sns.boxplot(
    data=df,
    x="species",
    y="petal_length"
)

plt.title(
    "Petal Length by Species"
)

plt.show()

44. Iris Pair Plot

sns.pairplot(
    df,
    hue="species"
)

plt.show()

This is a powerful example of how several numerical relationships can be explored simultaneously.

45. Iris Correlation Heatmap

correlation = df.corr(
    numeric_only=True
)

sns.heatmap(
    correlation,
    annot=True,
    fmt=".2f",
    square=True
)

plt.title(
    "Feature Correlation"
)

plt.show()

46. Controlling Figure Size

Seaborn works with Matplotlib's Figure system, so Matplotlib functions can be used to control the figure.

plt.figure(
    figsize=(10, 6)
)

sns.boxplot(
    data=df,
    x="species",
    y="petal_length"
)

plt.tight_layout()
plt.show()

Figure-level Seaborn functions such as pairplot(), relplot(), and catplot() have their own sizing parameters and return Seaborn objects that can be further configured.

47. Saving Seaborn Visualizations

Since Seaborn uses Matplotlib, standard Matplotlib saving functionality can be used.

sns.histplot(
    data=df,
    x="petal_length"
)

plt.title(
    "Petal Length Distribution"
)

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

plt.show()

48. Axes-Level vs Figure-Level Functions

Seaborn functions can broadly be understood as either axes-level or figure-level.

49. Important Distribution Functions

50. Important Relational Functions

51. Important Categorical Functions

52. Matrix and Relationship Visualization

53. Choosing the Right Seaborn Visualization

54. Seaborn EDA Workflow

A practical EDA workflow can follow this sequence:

1. Load the dataset.
2. Inspect its structure.
3. Check data types.
4. Check missing values.
5. Calculate descriptive statistics.
6. Examine distributions.
7. Compare categories.
8. Explore relationships.
9. Inspect correlations.
10. Investigate potential outliers.
11. Form hypotheses for further analysis.

import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt

df = pd.read_csv(
    "students.csv"
)

print(df.info())
print(df.describe())
print(df.isnull().sum())

sns.histplot(
    data=df,
    x="Score",
    kde=True
)

plt.show()

sns.boxplot(
    data=df,
    x="Class",
    y="Score"
)

plt.show()

sns.pairplot(
    df,
    hue="Class"
)

plt.show()

55. Seaborn Best Practices

56. Common Seaborn Mistakes

57. Seaborn Interview Questions

import seaborn as sns

58. Examination Questions — MCQs

59. Practical Examination Questions

import seaborn as sns
import matplotlib.pyplot as plt

scores = [
    45, 52, 58, 61,
    65, 68, 72, 75,
    78, 81, 84, 88,
    91, 95
]

sns.histplot(
    data=scores,
    bins=6,
    kde=True
)

plt.title(
    "Examination Score Distribution"
)

plt.xlabel("Score")
plt.ylabel("Frequency")

plt.show()

sns.boxplot(
    data=df,
    x="Class",
    y="Score"
)

plt.title(
    "Score Distribution by Class"
)

plt.show()

sns.pairplot(
    df,
    hue="Class"
)

plt.show()

correlation = df.corr(
    numeric_only=True
)

sns.heatmap(
    correlation,
    annot=True,
    fmt=".2f"
)

plt.title(
    "Correlation Matrix"
)

plt.show()

sns.countplot(
    data=df,
    x="Class"
)

plt.title(
    "Number of Students by Class"
)

plt.show()

60. Scenario-Based Questions

61. Quick-Fire Interview Revision

63. Key Takeaways

• Seaborn is a high-level statistical visualization library built on Matplotlib.
• It integrates naturally with pandas DataFrames.
• histplot() and kdeplot() help analyze distributions.
• boxplot() helps analyze spread, quartiles, and potential outliers.
• violinplot() combines distribution shape with categorical comparison.
• pairplot() provides a broad view of pairwise relationships.
• heatmap() is particularly useful for correlation matrices and other numerical matrices.
• countplot() is useful for categorical frequencies.
• hue is one of the most important Seaborn parameters for grouping observations.
• Good visualization begins with understanding the data and the analytical question.