Summary  
This chapter covers using stripplots to visualize individual data points for a numerical variable grouped by a categorical variable, and customizing point appearance (transparency, size, marker shape) and jitter to address overplotting.

General domain of usage  
Exploratory data analysis

In statistics, a **categorical variable** is a variable that can take on one of a limited number of possible values (e.g., "Day of Week", "Gender", "Country").

A `stripplot` is essentially a scatter plot where one of the axes represents a categorical variable. It visualizes the distribution of many individual one-dimensional values.

## Why Use a Stripplot?

Unlike a histogram or a density plot which aggregates data, a stripplot shows **every single observation** as a dot. This is perfect for smaller datasets where you want to see the exact spread and identify outliers.

## Key Parameters for Customization

Since dots can overlap (a problem called "overplotting"), `stripplot` offers several ways to make them distinct:

* **`alpha`**: controls transparency (0 to 1). Setting this to a low value (e.g., `0.25`) helps visualize density — darker areas mean more points;
* **`size`**: changes the radius of the dots;
* **`marker`**: changes the shape of the points (e.g., `'D'` for diamonds, `'s'` for squares);
* **`jitter`**: adds a small amount of random noise to the position of dots so they don't sit exactly on top of each other (enabled by default).

### Live Example

Here is how to create a stripplot that uses transparency to handle overlapping data.

import seaborn as sns
import matplotlib.pyplot as plt

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

# Create a customized stripplot
sns.stripplot(
    data=df,
    x='day',            # Categorical axis
    y='total_bill',     # Numerical axis
    alpha=0.5,          # Make points semi-transparent
    size=10,            # Make points larger
    jitter=True         # Spread points out slightly
)

plt.show()

import unittest
import importlib
import sys
import pandas as pd
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):
        self.patcher_csv = patch('pandas.read_csv')
        self.mock_read_csv = self.patcher_csv.start()
        
        # Provide real data structure
        self.mock_df = pd.DataFrame({
            'day': ['Sun', 'Sat', 'Sun', 'Fri'],
            'total_bill': [10.5, 20.0, 15.0, 30.0],
            'smoker': ['Yes', 'No', 'Yes', 'No']
        })
        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):
        with patch('seaborn.stripplot'), patch('matplotlib.pyplot.show'):
            with patch('seaborn.set_style') as mock_style:
                # Reload module to capture set_style call
                if 'user_code' in sys.modules:
                    importlib.reload(sys.modules['user_code'])
                import user_code # Explicit import to ensure variable availability
            
            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] == 'whitegrid'
            
            # Check dictionary configuration
            rc_params = args[1] if len(args) > 1 else kwargs.get('rc', {})
            facecolor_correct = rc_params.get('axes.facecolor') == 'aliceblue'

            _dynamic_test(
                self,
                style_name_correct and facecolor_correct,
                "The style is set to 'whitegrid' with 'aliceblue' background.",
                "Expected `sns.set_style('whitegrid', {'axes.facecolor': 'aliceblue'})`."
            )

    # Test stripplot implementation
    def test_stripplot_params(self):
        with patch('seaborn.stripplot') as mock_strip:
            with patch('matplotlib.pyplot.show'):
                # Reload module to capture stripplot call
                if 'user_code' in sys.modules:
                    importlib.reload(sys.modules['user_code'])
                import user_code # FIX: Ensures user_code is defined in local scope
            
            if not mock_strip.called:
                _dynamic_test(self, False, "", "Expected `sns.stripplot()` to be used.")
                return

            args, kwargs = mock_strip.call_args
            
            # Check data binding
            # Now user_code is guaranteed to be defined
            x_check = kwargs.get('x') == 'day'
            y_check = kwargs.get('y') == 'total_bill'
            hue_check = kwargs.get('hue') == 'smoker'
            data_check = kwargs.get('data') is user_code.df

            # Check styling parameters
            size_check = kwargs.get('size') == 20
            palette_check = kwargs.get('palette') == 'crest'
            marker_check = kwargs.get('marker') == 'D'
            alpha_check = kwargs.get('alpha') == 0.25

            _dynamic_test(
                self,
                all([x_check, y_check, hue_check, size_check, palette_check, marker_check, alpha_check]),
                "The `stripplot` parameters (`size`, `marker`, `alpha`, etc.) are configured correctly.",
                f"Expected `size=20`, `marker='D'`, `alpha=0.25`, `palette='crest'`. Got: {kwargs}"
            )

    # Test show
    def test_show_used(self):
        with patch('seaborn.stripplot'):
            with patch('matplotlib.pyplot.show') as mock_show:
                if 'user_code' in sys.modules:
                    importlib.reload(sys.modules['user_code'])
                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.

Visualizing Categorical Scatter Plots

Why Use a Stripplot?

Key Parameters for Customization

Live Example

解答