Summary  
This chapter demonstrates how to construct custom joint distribution plots by initializing a JointGrid and then using plot_joint and plot_marginals to render bivariate relationships alongside their marginal distributions.

General domain of usage  
Exploratory data analysis and visualization

`JointGrid` is the underlying figure-level object used to create bivariate plots with marginal univariate plots.

When you use `sns.jointplot()`, it creates a `JointGrid` for you automatically. However, using `JointGrid` directly gives you a blank canvas. You can explicitly decide what to draw in the center and what to draw on the sides.



## The Workflow

1. **Initialize:** create the grid with your data and variables. At this point, it is empty;
2. **`g.plot_joint()`**: draws the bivariate plot in the center (e.g., scatter plot);
3. **`g.plot_marginals()`**: draws the univariate plots on the top and right axes (e.g., histogram or KDE).



## Example

Here we create a custom grid with a regression plot in the center and KDE curves on the sides.


import seaborn as sns
import matplotlib.pyplot as plt

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

# 1. Initialize the grid
g = sns.JointGrid(data=df, x='bill_length_mm', y='bill_depth_mm')

# 2. Draw the plots
g.plot_joint(sns.regplot, scatter_kws={'alpha': 0.5})  # Center: Regression
g.plot_marginals(sns.kdeplot, fill=True)               # Sides: KDE

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']
        })
        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.JointGrid'), 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') == 'lightcyan'

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

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

            args, kwargs = mock_grid_class.call_args
            
            x_check = kwargs.get('x') == 'bill_length_mm'
            y_check = kwargs.get('y') == 'bill_depth_mm'
            hue_check = kwargs.get('hue') == 'species'
            palette_check = kwargs.get('palette') == 'viridis'
            data_check = kwargs.get('data') is user_code.df

            _dynamic_test(
                self,
                all([x_check, y_check, hue_check, palette_check, data_check]),
                "The `JointGrid` is initialized correctly (`x`, `y`, `hue`, `palette`).",
                f"Expected `x='bill_length_mm'`, `y='bill_depth_mm'`, `palette='viridis'`. Got: {kwargs}"
            )

    # Test plotting methods (joint and marginals)
    def test_grid_plotting(self):
        with patch('seaborn.JointGrid') as mock_grid_class:
            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 plot_joint
            if not mock_grid_instance.plot_joint.called:
                _dynamic_test(self, False, "", "Expected `g.plot_joint()` to be called.")
                return

            joint_args, joint_kwargs = mock_grid_instance.plot_joint.call_args
            scatter_check = joint_args[0] == user_code.sns.scatterplot
            alpha_check = joint_kwargs.get('alpha') == 0.5
            edgecolor_check = joint_kwargs.get('edgecolor') == 'pink'
            linewidth_check = joint_kwargs.get('linewidth') == 1

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

            marg_args, marg_kwargs = mock_grid_instance.plot_marginals.call_args
            hist_check = marg_args[0] == user_code.sns.histplot
            kde_check = marg_kwargs.get('kde') is True

            _dynamic_test(
                self,
                all([scatter_check, alpha_check, edgecolor_check, linewidth_check, hist_check, kde_check]),
                "The plots are configured correctly (Scatterplot center, Histplot+KDE sides).",
                f"Expected `alpha=0.5`, `linewidth=1` for joint, `kde=True` for marginals."
            )

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

Creating Joint Distribution Plots

The Workflow

Example

解答