Summary  
This chapter explains how to create and control a PairGrid to plot pairwise relationships by mapping univariate plots on the diagonal and bivariate plots on off-diagonal cells. It covers the use of explicit mapping functions to customize the grid’s diagonal, off-diagonal, upper, and lower sections.

General domain of usage  
Data visualization

The `PairGrid` is a subplot grid for plotting pairwise relationships in a dataset.

It creates a matrix of axes where each variable in the dataset is shared across a row and a column.

* **Diagonal:** shows the **univariate** distribution of a single variable (since x=y);
* **Off-Diagonal:** shows the **bivariate** relationship between two different variables.



## Controlling the Grid

Unlike `pairplot` (which is fully automatic), `PairGrid` requires you to map plots to specific sections explicitly.

* **`g.map_diag(func)`**: plots on the diagonal (e.g., `sns.histplot`);
* **`g.map_offdiag(func)`**: plots on all non-diagonal cells (e.g., `sns.scatterplot`);
* `g.map_upper(func)` / `g.map_lower(func)`: plots specifically in the upper or lower triangle of the grid.



## Example

Here we create a grid where the diagonal shows histograms and the lower triangle shows density contours.

import seaborn as sns
import matplotlib.pyplot as plt

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

# 1. Initialize the grid
g = sns.PairGrid(df, hue='species')

# 2. Map plots to specific regions
g.map_diag(sns.histplot)        # Diagonal: Histograms
g.map_offdiag(sns.scatterplot)  # Off-diagonal: Scatterplots

g.add_legend()
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({
            'bill_length_mm': [39.1, 39.5, 40.3],
            'bill_depth_mm': [18.7, 17.4, 18.0],
            'species': ['Adelie', 'Gentoo', 'Adelie'],
            'Unnamed: 0': [0, 1, 2] # Included so the drop call works
        })
        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.PairGrid'), 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] == 'ticks'
            
            rc_params = args[1] if len(args) > 1 else kwargs.get('rc', {})
            facecolor_correct = rc_params.get('figure.facecolor') == 'lightpink'

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

    # Test PairGrid initialization
    def test_pairgrid_init(self):
        with patch('seaborn.PairGrid') 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.PairGrid()` to be initialized.")
                return

            args, kwargs = mock_grid_class.call_args
            
            # Check data (it might be passed as a positional arg or keyword arg)
            # Note: user_code does `df = df.drop(...)`, so we check if the passed df has the right columns (no 'Unnamed: 0')
            passed_df = args[0] if args else kwargs.get('data')
            is_dataframe = isinstance(passed_df, pd.DataFrame)
            
            hue_check = kwargs.get('hue') == 'species'
            palette_check = kwargs.get('palette') == 'rocket_r'
            sharey_check = kwargs.get('diag_sharey') is False

            _dynamic_test(
                self,
                is_dataframe and hue_check and palette_check and sharey_check,
                "The `PairGrid` is initialized correctly (`hue`, `palette`, `diag_sharey`).",
                f"Expected `hue='species'`, `palette='rocket_r'`, `diag_sharey=False`. Got: {kwargs}"
            )

    # Test mapping methods
    def test_grid_mapping(self):
        with patch('seaborn.PairGrid') as mock_grid_class:
            # Create a mock instance
            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
            
            # 1. Check map_diag
            if not mock_grid_instance.map_diag.called:
                _dynamic_test(self, False, "", "Expected `g.map_diag()` to be called.")
                return

            diag_args, diag_kwargs = mock_grid_instance.map_diag.call_args
            # Ensure sns.histplot was passed
            hist_check = diag_args[0] == user_code.sns.histplot
            kde_check = diag_kwargs.get('kde') is True

            # 2. Check map_offdiag
            if not mock_grid_instance.map_offdiag.called:
                _dynamic_test(self, False, "", "Expected `g.map_offdiag()` to be called.")
                return

            offdiag_args, offdiag_kwargs = mock_grid_instance.map_offdiag.call_args
            # Ensure sns.scatterplot was passed
            scatter_check = offdiag_args[0] == user_code.sns.scatterplot
            linewidth_check = offdiag_kwargs.get('linewidth') == 0.9
            edgecolor_check = offdiag_kwargs.get('edgecolor') == 'purple'

            _dynamic_test(
                self,
                all([hist_check, kde_check, scatter_check, linewidth_check, edgecolor_check]),
                "The plotting functions are mapped correctly with required parameters.",
                f"Expected `kde=True` for diag, `linewidth=0.9` and `edgecolor='purple'` for off-diag."
            )

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

Plotting Pairwise Relationships

Controlling the Grid

Example

解答