Summary  
This chapter explains how to generate violin plots to visualize full data distributions and how to customize them using parameters such as split (for comparing two categories), inner (to show quartiles, points, or box), and bandwidth.

General domain of usage  
Exploratory data analysis

A `violinplot` is a hybrid of a box plot and a kernel density plot (KDE).

While a boxplot only shows summary statistics (median, quartiles), a violinplot reveals the **full distribution** of the data. The "width" of the violin at any given point represents the density (how many data points are there).



## Key Parameters

* **`split=True`**: if you have a `hue` variable with exactly two categories (e.g., "Male"/"Female"), this parameter draws one category on the left half of the violin and the other on the right. This makes comparing them incredibly easy;
* **`inner`**: controls what is drawn inside the violin;
* `'box'` (default): draws a mini boxplot;
* `'point'`: draws individual data points;
* `'quartile'`: draws lines for the 25th, 50th, and 75th percentiles;
* **`bw` (bandwidth)**: controls the smoothness of the curve (just like in KDE). A smaller number reveals more detail (and noise); a larger number makes it smoother.


## Example

Here is a violinplot showing the `total_bill` distribution. Notice how `split=True` allows us to compare "Smokers" vs "Non-Smokers" inside the same violin.


import seaborn as sns
import matplotlib.pyplot as plt

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

# Create a split violinplot
sns.violinplot(
    data=df,
    x='day',
    y='total_bill',
    hue='smoker',
    split=True,    # Compare sides directly
    inner='quartile', # Show quartile lines
    palette='muted'
)

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 violinplot creation and parameters
    def test_violinplot_params(self):
        # We need to mock the return value of violinplot to check if .set_title() is called on it
        with patch('seaborn.violinplot') as mock_violin:
            # Create a mock Axes object that violinplot will return
            mock_axes = MagicMock()
            mock_violin.return_value = mock_axes
            
            with patch('matplotlib.pyplot.show'):
                if 'user_code' in sys.modules:
                    importlib.reload(sys.modules['user_code'])
                import user_code

            # 1. Check if violinplot was called
            if not mock_violin.called:
                _dynamic_test(self, False, "", "Expected `sns.violinplot()` to be used.")
                return

            # 2. Check parameters
            args, kwargs = mock_violin.call_args
            
            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
            
            split_check = kwargs.get('split') is True
            inner_check = kwargs.get('inner') == 'point'
            bw_check = kwargs.get('bw') == 0.2
            palette_check = kwargs.get('palette') == 'rocket'

            _dynamic_test(
                self,
                all([x_check, y_check, hue_check, split_check, inner_check, bw_check, palette_check]),
                "The `violinplot` parameters (`split`, `inner`, `bw`, etc.) are configured correctly.",
                f"Expected `split=True`, `inner='point'`, `bw=0.2`. Got: {kwargs}"
            )

    # Test if title was set
    def test_title_set(self):
        with patch('seaborn.violinplot') as mock_violin:
            mock_axes = MagicMock()
            mock_violin.return_value = mock_axes
            
            with patch('matplotlib.pyplot.show'):
                if 'user_code' in sys.modules:
                    importlib.reload(sys.modules['user_code'])
                import user_code
            
            # Check if set_title was called on the mock object returned by violinplot
            # We look for the call g.set_title('Tips violinplot')
            
            title_called = False
            if mock_axes.set_title.called:
                # Check arguments of set_title
                args, _ = mock_axes.set_title.call_args
                if args and args[0] == 'Tips violinplot':
                    title_called = True
            
            _dynamic_test(
                self,
                title_called,
                "The plot title is set to 'Tips violinplot'.",
                "Expected `g.set_title('Tips violinplot')` to be called."
            )

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

Drawing Violin Plots

Key Parameters

Example

解答