Eric Campbell 4 min read Data Science

How to Create a Joint Plot in Seaborn

Joint plots are one of Seaborn's most powerful visualization tools for exploring relationships between two continuous variables. Unlike a simple scatter plot, a joint plot displays three...

Key Insights

  • Joint plots combine bivariate scatter plots with univariate distributions on the margins, revealing both the relationship between variables and their individual distributions in a single visualization
  • Seaborn offers six joint plot types (scatter, kde, hex, reg, resid, hist) that each serve different purposes—hex plots excel with large datasets while KDE plots work best for smooth density estimation
  • Customize joint plots through the JointGrid object for fine-grained control, or use the simpler jointplot() function for quick exploratory analysis with built-in statistical annotations

Introduction to Joint Plots

Joint plots are one of Seaborn’s most powerful visualization tools for exploring relationships between two continuous variables. Unlike a simple scatter plot, a joint plot displays three complementary views: the bivariate relationship in the center and the univariate distributions of each variable along the margins. This multi-perspective approach helps you understand not just how two variables relate to each other, but also how each variable is distributed independently.

The primary advantage of joint plots is efficiency. Instead of creating three separate plots to understand your data, you get a comprehensive view in one figure. This is particularly valuable during exploratory data analysis when you’re investigating multiple variable pairs and need to quickly assess correlations, outliers, and distribution shapes.

Basic Joint Plot Setup

Creating a joint plot in Seaborn requires minimal code. Start by importing the necessary libraries and loading your data:

import seaborn as sns
import matplotlib.pyplot as plt
import pandas as pd

# Load sample dataset
tips = sns.load_dataset('tips')

# Create a basic joint plot
sns.jointplot(data=tips, x='total_bill', y='tip')
plt.show()

This basic example creates a scatter plot in the center showing the relationship between total bill and tip amounts, with histograms on the top and right margins showing the distribution of each variable. The default settings provide a clean, publication-ready visualization with minimal effort.

You can also work with the iris dataset to explore different relationships:

iris = sns.load_dataset('iris')
sns.jointplot(data=iris, x='sepal_length', y='sepal_width')
plt.show()

Customizing Plot Types

Seaborn provides six different plot types through the kind parameter, each optimized for different scenarios and data characteristics.

Hexbin plots aggregate data points into hexagonal bins, making them ideal for large datasets where individual points would create overplotting:

# Generate larger dataset for demonstration
import numpy as np
np.random.seed(42)
large_data = pd.DataFrame({
    'x': np.random.randn(10000),
    'y': np.random.randn(10000) * 0.5 + np.random.randn(10000)
})

sns.jointplot(data=large_data, x='x', y='y', kind='hex', gridsize=25)
plt.show()

KDE (Kernel Density Estimation) plots create smooth contours representing data density, providing an elegant view of concentration patterns:

sns.jointplot(data=tips, x='total_bill', y='tip', kind='kde', fill=True)
plt.show()

Regression plots automatically fit a linear regression line with confidence intervals, making relationships immediately apparent:

sns.jointplot(data=tips, x='total_bill', y='tip', kind='reg')
plt.show()

The regression plot includes Pearson correlation coefficient and p-value by default, providing statistical context alongside the visualization.

Residual plots help assess the quality of a linear fit by plotting residuals:

sns.jointplot(data=tips, x='total_bill', y='tip', kind='resid')
plt.show()

Histogram plots use 2D histograms in the center instead of scatter points:

sns.jointplot(data=tips, x='total_bill', y='tip', kind='hist')
plt.show()

Styling and Customization

Seaborn joint plots accept numerous parameters for visual customization. You can control colors, transparency, marker styles, and the type of marginal plots independently:

# Custom styling with color palette and markers
sns.jointplot(
    data=tips, 
    x='total_bill', 
    y='tip',
    kind='scatter',
    color='darkred',
    marker='+',
    alpha=0.6,
    marginal_kws={'bins': 20, 'color': 'darkblue'}
)
plt.show()

You can mix different plot types for the center and margins:

# Scatter plot with KDE margins
sns.jointplot(
    data=tips,
    x='total_bill',
    y='tip',
    kind='scatter',
    marginal_kws={'kde': True, 'bins': 15}
)
plt.show()

For more control over the color palette and aesthetics:

# Using a custom color palette
sns.set_palette("husl")
g = sns.jointplot(
    data=iris,
    x='petal_length',
    y='petal_width',
    kind='kde',
    fill=True,
    cmap='viridis',
    thresh=0
)
plt.show()

Working with Different Data Sources

Joint plots work seamlessly with pandas DataFrames, which is the recommended approach for most use cases:

# From CSV file
df = pd.read_csv('your_data.csv')
sns.jointplot(data=df, x='column1', y='column2')
plt.show()

You can also pass numpy arrays or lists directly using the x and y parameters without the data parameter:

# From numpy arrays
x_data = np.random.normal(100, 15, 500)
y_data = x_data * 0.5 + np.random.normal(0, 10, 500)

sns.jointplot(x=x_data, y=y_data, kind='reg')
plt.show()

For filtered or transformed data:

# Using query or filtering
large_tips = tips[tips['total_bill'] > 20]
sns.jointplot(data=large_tips, x='total_bill', y='tip', kind='kde')
plt.show()

Advanced Techniques

For advanced customization, use the JointGrid class directly instead of the jointplot() function. This provides access to the underlying matplotlib axes:

# Advanced customization with JointGrid
g = sns.JointGrid(data=tips, x='total_bill', y='tip', height=8)
g.plot_joint(sns.scatterplot, alpha=0.5, s=50)
g.plot_marginals(sns.histplot, kde=True, bins=20)

# Add correlation coefficient annotation
from scipy import stats
r, p = stats.pearsonr(tips['total_bill'], tips['tip'])
g.ax_joint.annotate(
    f'r = {r:.2f}\np = {p:.3f}',
    xy=(0.05, 0.95),
    xycoords='axes fraction',
    fontsize=12,
    bbox=dict(boxstyle='round', facecolor='wheat', alpha=0.5)
)

plt.show()

You can add reference lines to highlight specific values or thresholds:

g = sns.jointplot(data=tips, x='total_bill', y='tip', kind='scatter')
g.ax_joint.axhline(y=tips['tip'].mean(), color='red', linestyle='--', label='Mean tip')
g.ax_joint.axvline(x=tips['total_bill'].mean(), color='blue', linestyle='--', label='Mean bill')
g.ax_joint.legend()
plt.show()

Control figure size and aspect ratio:

sns.jointplot(
    data=tips,
    x='total_bill',
    y='tip',
    kind='reg',
    height=10,
    ratio=4  # Ratio of joint axes height to marginal axes height
)
plt.show()

Common Use Cases and Best Practices

When to use joint plots: Joint plots excel when you need to understand both correlation and distribution simultaneously. Use them during initial data exploration, when checking for outliers, or when presenting findings that require showing both individual and joint distributions.

When to avoid joint plots: For datasets with more than two variables, consider pair plots instead. If you only care about the relationship and not the marginal distributions, a simple scatter plot is more efficient. For categorical data, use categorical plots like violin plots or box plots.

Performance considerations: For datasets exceeding 10,000 points, use hexbin or KDE plots instead of scatter plots:

# Good for large datasets
sns.jointplot(data=large_data, x='x', y='y', kind='hex')

# Avoid for large datasets (slow rendering)
# sns.jointplot(data=large_data, x='x', y='y', kind='scatter')

Interpretation tips: Look for the shape of the central plot (linear, curved, clustered), check if marginal distributions are normal or skewed, and identify outliers that appear in both views. The correlation coefficient in regression plots provides a quantitative measure of linear relationship strength.

Practical comparison:

# Appropriate: Clear bivariate relationship
fig, axes = plt.subplots(1, 2, figsize=(12, 5))
plt.subplot(1, 2, 1)
sns.jointplot(data=tips, x='total_bill', y='tip', kind='reg')
plt.title('Appropriate: Strong correlation')

# Less useful: Weak or no relationship
plt.subplot(1, 2, 2)
sns.jointplot(data=tips, x='size', y='total_bill', kind='scatter')
plt.title('Less informative: Discrete x-variable')
plt.tight_layout()
plt.show()

Joint plots are most valuable when both variables are continuous and you suspect a relationship worth investigating. They transform what would be multiple separate analyses into a single, coherent visualization that tells a complete story about your data.

Liked this? There's more.

Every week: one practical technique, explained simply, with code you can use immediately.