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` er det underliggende figur-nivå-objektet som brukes til å lage bivariate plott med marginale univariate plott.

Når du bruker `sns.jointplot()`, opprettes en `JointGrid` automatisk for deg. Ved å bruke `JointGrid` direkte får du imidlertid et tomt lerret. Du kan eksplisitt bestemme hva som skal tegnes i midten og hva som skal tegnes på sidene.



## Arbeidsflyt

1. **Initialisering:** opprett rutenettet med dine data og variabler. På dette tidspunktet er det tomt;
2. **`g.plot_joint()`**: tegner det bivariate plottet i midten (for eksempel spredningsplott);
3. **`g.plot_marginals()`**: tegner de univariate plottene på øvre og høyre akse (for eksempel histogram eller KDE).



## Eksempel

Her oppretter vi et tilpasset rutenett med et regresjonsplott i midten og KDE-kurver på sidene.


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

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.

Oppretting av Fellesfordelingsdiagrammer

Arbeidsflyt

Eksempel

Løsning