Summary  
This chapter covers layering a rug plot onto a kernel density estimate to reveal individual data points alongside a smoothed distribution, using parameters like height and hue for customization.

General domain of usage  
Data visualization

The `rugplot` is a plot intended to complement other plots by showing the location of individual observations in an unobtrusive way.

While `kdeplot` shows a smooth probability curve, it can sometimes hide the fact that there are very few data points in a certain area. Adding a `rugplot` draws small "ticks" (like fringes on a rug) for every single data point along the x or y axis.

### Why Combine Them?

* **KDE:** shows the abstract shape (trend).
* **Rugplot:** shows the actual data density (reality).

## Key Parameters

To make the rugplot effective and compatible with other plots, you should know these parameters:

* **`height`**: controls the length of the ticks relative to the plot area. A value like `0.05` or `0.1` is usually best to keep it subtle;
* **`hue`**: groups data by color, allowing you to match the categories in your main plot;
* `x` or `y`: determines which axis the data lies on.

import seaborn as sns
import matplotlib.pyplot as plt

# Load the dataset
df = sns.load_dataset('tips')

# 1. Main plot (Abstract shape)
sns.kdeplot(data=df, x='total_bill', fill=True, alpha=0.3)

# 2. Rug plot (Real data points)
sns.rugplot(data=df, x='total_bill', height=0.1, color='black')

plt.show()

import unittest
import importlib
import sys
import pandas as pd # Don't forget to import pandas here
from unittest.mock import patch

# 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):
        # Patch read_csv to avoid network calls
        self.patcher_csv = patch('pandas.read_csv')
        self.mock_read_csv = self.patcher_csv.start()
        
        # FIX: Return a REAL DataFrame instead of MagicMock.
        # This prevents "TypeError: Data source must be a DataFrame" 
        # in unpatched Seaborn calls.
        self.mock_df = pd.DataFrame({
            'total_bill': [10.5, 20.0, 15.0, 30.0, 12.5],
            'sex': ['Male', 'Female', 'Male', 'Female', 'Male']
        })
        self.mock_read_csv.return_value = self.mock_df

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

    # Test custom style configuration
    def test_style_configuration(self):
        # We patch both plotting functions to prevent them from doing work during this test
        with patch('seaborn.kdeplot'), patch('seaborn.rugplot'): 
            with patch('seaborn.set_style') as mock_style:
                with patch('matplotlib.pyplot.show'):
                    if 'user_code' in sys.modules:
                        importlib.reload(sys.modules['user_code'])
                    else:
                        import user_code
                
                if not mock_style.called:
                     _dynamic_test(self, False, "", "Expected `sns.set_style()` to be called.")
                     return

                args, kwargs = mock_style.call_args
                
                style_name_correct = args[0] == 'darkgrid'
                
                rc_params = args[1] if len(args) > 1 else kwargs.get('rc', {})
                grid_disabled = rc_params.get('axes.grid') is False
                facecolor_correct = rc_params.get('axes.facecolor') == 'aliceblue'

                _dynamic_test(
                    self,
                    style_name_correct and grid_disabled and facecolor_correct,
                    "The style is set to 'darkgrid' with correct custom colors.",
                    "Expected `sns.set_style('darkgrid', {'axes.grid': False, 'axes.facecolor': 'aliceblue'})`."
                )

    # Test Rugplot implementation
    def test_rugplot_params(self):
        # Patch kdeplot so it doesn't consume resources, but mainly patch rugplot to inspect it
        with patch('seaborn.kdeplot'): 
            with patch('seaborn.rugplot') as mock_rug:
                with patch('matplotlib.pyplot.show'):
                    if 'user_code' in sys.modules:
                        importlib.reload(sys.modules['user_code'])
                    else:
                        import user_code
                
                if not mock_rug.called:
                    _dynamic_test(self, False, "", "Expected `sns.rugplot()` to be used.")
                    return

                args, kwargs = mock_rug.call_args
                
                # We check against the values from our mock_df or the strings
                x_check = kwargs.get('x') == 'total_bill'
                hue_check = kwargs.get('hue') == 'sex'
                height_check = kwargs.get('height') == 0.05
                palette_check = kwargs.get('palette') == 'magma'

                _dynamic_test(
                    self,
                    x_check and hue_check and height_check and palette_check,
                    "The `rugplot` parameters are configured correctly.",
                    f"Expected `height=0.05`, `x='total_bill'`, `hue='sex'`, `palette='magma'`. Got: {kwargs}"
                )

    # Test if plots are displayed
    def test_show_used(self):
        with patch('seaborn.kdeplot'), patch('seaborn.rugplot'):
            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.

Enhancing Plots with Rugs

Why Combine Them?

Key Parameters

Solution