Summary  
This chapter describes how to generate bar plots to display central tendency estimates (default mean) with 95% confidence interval error bars, and how to customize their appearance (capsize, color, linewidth) and change the estimator (mean, median, sum, max).

General domain of usage  
Exploratory data analysis

A `barplot` represents an estimate of the **central tendency** (usually the mean) for a numeric variable with the height of each rectangle.

Unlike a histogram which counts how many items are in a bin, a barplot calculates a statistic (like the average bill amount) for each category.



## The Error Bars (Uncertainty)

The small black lines on top of each bar are called **error bars**. By default, they show the **95% Confidence Interval**.

To customize them, we now use the `err_kws` (error keywords) parameter. This accepts a dictionary of settings that control the look of these lines.



## Key Parameters

* **`capsize`**: adds a small horizontal line ("cap") to the ends of the error bars;
* **`err_kws`**: a dictionary to customize error bars;
* `{'color': 'black'}`: sets the color;
* `{'linewidth': 2}`: sets the thickness;
* **`estimator`**: by default, it calculates the **mean**. You can change this to `median`, `sum`, or `max` (requires importing `numpy`).


## Example

Here is a barplot showing the average total bill with customized red error bars.

import seaborn as sns
import matplotlib.pyplot as plt

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

# Create a barplot
sns.barplot(
    data=df,
    x='day',
    y='total_bill',
    hue='sex',
    capsize=0.1,
    # New way to style error bars:
    err_kws={'color': 'red', 'linewidth': 2},
    palette='pastel'
)

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.barplot'), patch('matplotlib.pyplot.show'):
            with patch('seaborn.set_style') as mock_style:
                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
            passed_style = args[0] if args else kwargs.get('style')

            _dynamic_test(
                self,
                passed_style == 'ticks',
                "The style is set to 'ticks'.",
                "Expected `sns.set_style('ticks')`."
            )

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

            args, kwargs = mock_bar.call_args
            
            # Check data binding
            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
            linewidth_check = kwargs.get('linewidth') == 2.5
            capsize_check = kwargs.get('capsize') == 0.1
            palette_check = kwargs.get('palette') == 'magma'
            
            # Check err_kws dictionary
            err_kws = kwargs.get('err_kws', {})
            err_color_check = err_kws.get('color') == 'pink'

            _dynamic_test(
                self,
                all([x_check, y_check, hue_check, linewidth_check, capsize_check, err_color_check, palette_check]),
                "The `barplot` parameters are configured correctly (including `err_kws={'color': 'pink'}`).",
                f"Expected `capsize=0.1`, `err_kws={{'color': 'pink'}}`, `linewidth=2.5`. Got: {kwargs}"
            )

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

Estimating Means with Bar Plots

The Error Bars (Uncertainty)

Key Parameters

Example

解答