Summary  
This chapter covers kernel density estimation for visualizing continuous data distributions and shows how to customize overlapping category densities by stacking and filling curves in Seaborn.

General domain of usage  
Exploratory data analysis

A `kdeplot` (kernel density estimation) is a method for visualizing the distribution of observations in a dataset. It is analogous to a histogram, but instead of using discrete bins, KDE represents the data using a continuous probability density curve.

This makes it excellent for seeing the "shape" of data and identifying peaks without the jaggedness of a histogram.

## Visualizing Overlapping Distributions

When you have multiple categories (using `hue`), simple lines can become hard to distinguish. Seaborn offers parameters to fix this:

* **Stacking (`multiple='stack'`):** instead of plotting lines over each other, this stacks them. It shows how different categories contribute to the total distribution;
* **Filling (`fill=True`):** fills the area under the curve with color, making the visual weight of each category more apparent.

**Example:**


import seaborn as sns
import matplotlib.pyplot as plt

# Load built-in dataset
df = sns.load_dataset('penguins')

# Create the stacked KDE plot
sns.kdeplot(
    data=df,
    x='flipper_length_mm',
    hue='species',
    multiple='stack', # Stack categories vertically
    fill=True         # Fill area with color
)

plt.show()

import unittest
import importlib
import sys
from unittest.mock import patch, MagicMock

# Helper function to dynamically generate test names and assertions
def _dynamic_test(test_case, condition, success_message, failure_message):
    if condition:
        test_case._testMethodName = success_message
        test_case.assertTrue(True, success_message)
    else:
        test_case._testMethodName = failure_message
        test_case.fail(failure_message)

class TestUserCode(unittest.TestCase):

    def setUp(self):
        # Mock pandas read_csv
        self.patcher_csv = patch('pandas.read_csv')
        self.mock_read_csv = self.patcher_csv.start()
        self.mock_df = MagicMock()
        self.mock_read_csv.return_value = self.mock_df

    def tearDown(self):
        self.patcher_csv.stop()

    # Test imports
    def test_imports(self):
        import user_code
        _dynamic_test(
            self,
            hasattr(user_code, 'sns') and hasattr(user_code, 'plt'),
            "Libraries `seaborn` and `matplotlib.pyplot` are imported.",
            "Expected `seaborn` to be imported as `sns` and `matplotlib` as `plt`."
        )

    # Test if kdeplot is used
    def test_kdeplot_called(self):
        with patch('seaborn.kdeplot') as mock_kdeplot:
            with patch('matplotlib.pyplot.show'):
                if 'user_code' in sys.modules:
                    importlib.reload(sys.modules['user_code'])
                else:
                    import user_code
            
            _dynamic_test(
                self,
                mock_kdeplot.called,
                "The `sns.kdeplot()` function is used.",
                "Expected `sns.kdeplot()` to be used."
            )

    # Test data and basic axis
    def test_data_and_axes(self):
        with patch('seaborn.kdeplot') as mock_kdeplot:
            with patch('matplotlib.pyplot.show'):
                if 'user_code' in sys.modules:
                    importlib.reload(sys.modules['user_code'])
                else:
                    import user_code
            
            if not mock_kdeplot.called:
                _dynamic_test(self, False, "", "Expected `sns.kdeplot()` to be used.")
                return

            args, kwargs = mock_kdeplot.call_args
            
            data_correct = kwargs.get('data') == user_code.df
            x_correct = kwargs.get('x') == 'max_temp'
            hue_correct = kwargs.get('hue') == 'month'

            _dynamic_test(
                self,
                data_correct and x_correct and hue_correct,
                "The `x`, `hue`, and `data` parameters are set correctly.",
                "Expected `x='max_temp'`, `hue='month'`, and `data=df`."
            )

    # Test specific visualization parameters (multiple, fill, legend)
    def test_viz_params(self):
        with patch('seaborn.kdeplot') as mock_kdeplot:
            with patch('matplotlib.pyplot.show'):
                if 'user_code' in sys.modules:
                    importlib.reload(sys.modules['user_code'])
                else:
                    import user_code
            
            if not mock_kdeplot.called:
                return

            args, kwargs = mock_kdeplot.call_args
            
            # Check for multiple='stack'
            stack_check = kwargs.get('multiple') == 'stack'
            # Check for fill=True
            fill_check = kwargs.get('fill') is True
            # Check for legend=False
            legend_check = kwargs.get('legend') is False

            _dynamic_test(
                self,
                stack_check and fill_check and legend_check,
                "The plot uses `stack`, `fill=True`, and `legend=False`.",
                f"Expected `multiple='stack'`, `fill=True`, `legend=False`. Got: {kwargs}"
            )

    # Test if plt.show() is used
    def test_show_used(self):
        with patch('seaborn.kdeplot'):
            with patch('matplotlib.pyplot.show') as mock_show:
                if 'user_code' in sys.modules:
                    importlib.reload(sys.modules['user_code'])
                else:
                    import user_code

                _dynamic_test(
                    self,
                    mock_show.called,
                    "The `plt.show()` function is used.",
                    "Expected `plt.show()` to be used to display the plot."
                )

if __name__ == '__main__':
    unittest.main()

test_code.py

Explore the power of statistical data visualization designed to reveal patterns and relationships. Use Seaborn to create informative distribution plots, heatmaps, and categorical charts with minimal code. Learn to apply aesthetic themes and color palettes that make complex statistical data accessible and easy to interpret.

Estimating Density with KDE

Visualizing Overlapping Distributions

Solution