Summary  
This chapter covers creating non-overlapping categorical scatter plots by algorithmically adjusting point positions, and customizing them with parameters like dodge for subgroup separation and linewidth for point styling.  

General domain of usage  
Data visualization

The `swarmplot` is very similar to the `stripplot`, but it has a major advantage: **points do not overlap**.

In a `stripplot`, we use "jitter" to randomly scatter points so they don't sit on top of each other, but overlaps can still happen. The `swarmplot` uses a specific algorithm to adjust the points along the categorical axis so that they form a clear, non-overlapping shape that resembles the distribution of the data (similar to a violin plot).

## Key Parameters

* **`dodge=True`**: when using a `hue` variable (e.g., separating smokers vs. non-smokers), this parameter separates the groups into distinct "swarms" side-by-side, rather than mixing them;
* **`linewidth`**: adds a border around each point, making them distinct even if they are small.


## Example

Here is how `dodge` changes the visualization. Notice how the blue and orange points are separated.

import seaborn as sns
import matplotlib.pyplot as plt

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

# Create a swarmplot
sns.swarmplot(
    data=df,
    x='day',
    y='total_bill',
    hue='sex',
    dodge=True,   # Separate Male/Female into side-by-side swarms
    size=4
)

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],
            'sex': ['Male', 'Female', 'Male', 'Female']
        })
        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.swarmplot'), 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 
            
            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') == 'seashell'

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

    # Test swarmplot implementation
    def test_swarmplot_params(self):
        with patch('seaborn.swarmplot') as mock_swarm:
            with patch('matplotlib.pyplot.show'):
                if 'user_code' in sys.modules:
                    importlib.reload(sys.modules['user_code'])
                import user_code
            
            if not mock_swarm.called:
                _dynamic_test(self, False, "", "Expected `sns.swarmplot()` to be used.")
                return

            args, kwargs = mock_swarm.call_args
            
            # Check data binding
            x_check = kwargs.get('x') == 'day'
            y_check = kwargs.get('y') == 'total_bill'
            hue_check = kwargs.get('hue') == 'sex'
            data_check = kwargs.get('data') is user_code.df

            # Check styling parameters
            linewidth_check = kwargs.get('linewidth') == 1
            size_check = kwargs.get('size') == 2
            dodge_check = kwargs.get('dodge') is True
            palette_check = kwargs.get('palette') == 'rocket'

            _dynamic_test(
                self,
                all([x_check, y_check, hue_check, linewidth_check, size_check, dodge_check, palette_check]),
                "The `swarmplot` parameters (`linewidth`, `size`, `dodge`, etc.) are configured correctly.",
                f"Expected `linewidth=1`, `size=2`, `dodge=True`, `palette='rocket'`. Got: {kwargs}"
            )

    # Test show
    def test_show_used(self):
        with patch('seaborn.swarmplot'):
            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.

Creating Swarm Plots

Key Parameters

Example

解答