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

`PairGrid` er et subplot-rutenett for å visualisere parvise relasjoner i et datasett.

Det lager en matrise av akser der hver variabel i datasettet deles på tvers av rader og kolonner.

* **Diagonal:** viser den **univariate** fordelingen til én enkelt variabel (siden x=y);
* **Utenfor diagonal:** viser den **bivariate** relasjonen mellom to ulike variabler.



## Kontrollere rutenettet

I motsetning til `pairplot` (som er helt automatisk), krever `PairGrid` at du eksplisitt tilordner plott til bestemte seksjoner.

* **`g.map_diag(func)`**: plott på diagonalen (f.eks. `sns.histplot`);
* **`g.map_offdiag(func)`**: plott i alle ikke-diagonale celler (f.eks. `sns.scatterplot`);
* `g.map_upper(func)` / `g.map_lower(func)`: plott spesifikt i øvre eller nedre trekant av rutenettet.



## Eksempel

Her lager vi et rutenett der diagonalen viser histogrammer og den nedre trekanten viser tetthetskonturer.

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

Utforsk kraften i statistisk datavisualisering utviklet for å avdekke mønstre og sammenhenger. Bruk Seaborn til å lage informative fordelingsdiagrammer, varmekart og kategoriske diagrammer med minimal kode. Lær å anvende estetiske temaer og fargepaletter som gjør kompleks statistisk data tilgjengelig og lett å tolke.

Visualisering av Parvise Relasjoner

Kontrollere rutenettet

Eksempel

Løsning