Summary  
This chapter covers how to construct a grid of plots by initializing a FacetGrid with categorical row/column variables and then mapping a plotting function onto each cell to render multiple subplots at once.  

General domain of usage  
Data visualization

A `FacetGrid` is the fundamental structure that allows you to create a matrix of plots defined by categorical variables.

Think of it as a two-step process:

1. **Build the grid:** you define the "skeleton" (rows and columns) based on your data. At this stage, the plots are empty;
2. **Map the data:** you use the `.map()` method to "paint" a specific type of plot (histogram, scatter, etc.) onto every cell in that grid.



## The Workflow

```python
# Step 1: Initialize the grid
# This creates empty subplots: one for each 'time' (Lunch/Dinner)
g = sns.FacetGrid(data=df, col='time')

# Step 2: Map a plot onto the grid
# This draws a histogram of 'total_bill' in every empty subplot
g.map(sns.histplot, 'total_bill')
```



## Key Parameters

* `col` / `row`: the variables that define the grid structure;
* **`height`**: height (in inches) of each individual facet (subplot);
* **`.map(func, *args, **kwargs)`**:
  * `func`: the plotting function to use (e.g., `sns.histplot`, `plt.scatter`);
  * `*args`: the column names to plot (e.g., `'total_bill'`);
  * `**kwargs`: styling arguments (e.g., `color='red'`).

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({
            'total_bill': [16.99, 10.34, 21.01, 23.68],
            'day': ['Sun', 'Sun', 'Sun', 'Sun'],
            'smoker': ['No', '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.FacetGrid'), 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
            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') == 'cornsilk'

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

    # Test FacetGrid initialization
    def test_facetgrid_init(self):
        with patch('seaborn.FacetGrid') as mock_grid_class:
            with patch('matplotlib.pyplot.show'):
                if 'user_code' in sys.modules:
                    importlib.reload(sys.modules['user_code'])
                import user_code
            
            if not mock_grid_class.called:
                _dynamic_test(self, False, "", "Expected `sns.FacetGrid()` to be initialized.")
                return

            args, kwargs = mock_grid_class.call_args
            
            # Check data (first positional argument)
            # Since user_code passes `df`, which is our mock_df
            data_passed = args[0] if args else kwargs.get('data')
            data_check = data_passed is user_code.df

            # Check logic parameters
            col_check = kwargs.get('col') == 'day'
            row_check = kwargs.get('row') == 'smoker'
            height_check = kwargs.get('height') == 3

            _dynamic_test(
                self,
                all([data_check, col_check, row_check, height_check]),
                "The `FacetGrid` is initialized correctly (`col`, `row`, `height`).",
                f"Expected `col='day'`, `row='smoker'`, `height=3`. Got: {kwargs}"
            )

    # Test .map() call
    def test_map_call(self):
        with patch('seaborn.FacetGrid') as mock_grid_class:
            # Create a mock instance for the grid
            mock_grid_instance = MagicMock()
            mock_grid_class.return_value = mock_grid_instance
            
            with patch('matplotlib.pyplot.show'):
                if 'user_code' in sys.modules:
                    importlib.reload(sys.modules['user_code'])
                import user_code
            
            # Check if .map was called
            if not mock_grid_instance.map.called:
                _dynamic_test(self, False, "", "Expected `g.map()` to be called.")
                return

            # Check arguments passed to .map()
            args, kwargs = mock_grid_instance.map.call_args
            
            # args[0] should be the plotting function (sns.histplot)
            # args[1] should be the variable name ('total_bill')
            
            func_check = args[0] == user_code.sns.histplot
            var_check = args[1] == 'total_bill'
            
            # Check kwargs for styling
            color_check = kwargs.get('color') == 'olive'
            kde_check = kwargs.get('kde') is True
            fill_check = kwargs.get('fill') is False
            binwidth_check = kwargs.get('binwidth') == 4

            _dynamic_test(
                self,
                all([func_check, var_check, color_check, kde_check, fill_check, binwidth_check]),
                "The `g.map()` function is used with `sns.histplot` and correct parameters.",
                f"Expected `sns.histplot`, `color='olive'`, `fill=False`. Got: {kwargs}"
            )

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

Building Multi-Plot Grids

The Workflow

Key Parameters

解答