Histograms and Kernel Density Estimates (histplot, kdeplot)

Understanding the shape of your data is a fundamental step in analysis. Histograms and Kernel Density Estimates (KDEs) are two powerful tools provided by Seaborn to visualize the distribution of a single numerical variable. They help answer questions like: Where is the data concentrated? Is the distribution symmetric or skewed? Are there multiple peaks?

Histograms with histplot

A histogram is perhaps the most familiar way to visualize a distribution. It works by dividing the range of the data into a series of intervals, called bins, and then counting how many data points fall into each bin. The height of the bars in a histogram represents the frequency (or count) of data points within each bin.

Seaborn's histplot function makes creating histograms straightforward. It builds upon Matplotlib's hist function but integrates better with Pandas DataFrames and offers more sophisticated options, including the ability to automatically determine a reasonable number of bins.

Let's generate some sample data and create a basic histogram:

import seaborn as sns
import numpy as np
import matplotlib.pyplot as plt

# Generate some normally distributed data
np.random.seed(0) # for reproducibility
data = np.random.randn(200)

# Create a histogram using Seaborn's histplot
sns.histplot(data=data)
plt.title('Histogram of Sample Data')
plt.xlabel('Value')
plt.ylabel('Frequency')
plt.show()

This code generates 200 random numbers from a standard normal distribution and then plots them using histplot. Seaborn automatically chooses a suitable number of bins to represent the data's structure.

A basic histogram showing the frequency distribution of the sample data.

Controlling the Bins

The number and width of bins can significantly impact how a histogram looks and the insights you draw from it. Too few bins might oversimplify the distribution, hiding important features. Too many bins might create a noisy plot, emphasizing random fluctuations.

The histplot function provides the bins parameter to control this. You can specify an integer for the number of bins or provide a list or array defining the bin edges. By default, histplot uses an automatic algorithm (often Freedman-Diaconis or Sturges) to estimate a good number of bins.

Let's see how changing the number of bins affects the plot:

# Histogram with fewer bins (e.g., 5)
sns.histplot(data=data, bins=5)
plt.title('Histogram with 5 Bins')
plt.xlabel('Value')
plt.ylabel('Frequency')
plt.show()

# Histogram with more bins (e.g., 30)
sns.histplot(data=data, bins=30)
plt.title('Histogram with 30 Bins')
plt.xlabel('Value')
plt.ylabel('Frequency')
plt.show()

Histogram with only 5 bins. The overall shape is visible, but finer details are lost.

Histogram with 30 bins. This shows more detail but might appear slightly more jagged.

Experimenting with the bins parameter is often necessary to find the best representation for your specific dataset.

Kernel Density Estimates with kdeplot

While histograms group data into discrete bins, a Kernel Density Estimate (KDE) provides a smoothed, continuous representation of the underlying distribution. Imagine placing a small "kernel" (a smooth bump, often Gaussian) on top of each data point and then summing these kernels to get a smooth curve. The height of the KDE curve at a given point represents an estimate of the probability density at that point.

Seaborn's kdeplot function creates these smoothed estimates:

# Create a KDE plot using Seaborn's kdeplot
sns.kdeplot(data=data)
plt.title('KDE Plot of Sample Data')
plt.xlabel('Value')
plt.ylabel('Density')
plt.show()

A smooth Kernel Density Estimate plot representing the distribution of the sample data.

Understanding Bandwidth

The smoothness of the KDE plot is controlled by a parameter called the bandwidth. A larger bandwidth results in a smoother curve, potentially obscuring finer details. A smaller bandwidth leads to a less smooth, more "wiggly" curve that might fit the sample data too closely. Seaborn's kdeplot uses the bw_adjust parameter to modify the automatically calculated bandwidth (a value of 1 uses the default, < 1 makes it less smooth, > 1 makes it smoother).

# KDE plot with smaller bandwidth (less smooth)
sns.kdeplot(data=data, bw_adjust=0.5)
plt.title('KDE Plot (bw_adjust = 0.5)')
plt.xlabel('Value')
plt.ylabel('Density')
plt.show()

# KDE plot with larger bandwidth (smoother)
sns.kdeplot(data=data, bw_adjust=2)
plt.title('KDE Plot (bw_adjust = 2)')
plt.xlabel('Value')
plt.ylabel('Density')
plt.show()

Choosing an appropriate bandwidth is analogous to choosing the number of bins in a histogram. Seaborn's default usually works well, but adjustment might be needed depending on the data and the analysis goal.

Combining Histograms and KDEs

Sometimes, it's useful to see both the binned representation and the smoothed estimate on the same plot. The histplot function makes this easy with the kde parameter:

# Create a histogram with an overlaid KDE
sns.histplot(data=data, kde=True)
plt.title('Histogram with KDE Overlay')
plt.xlabel('Value')
plt.ylabel('Frequency / Density') # Note Y-axis now represents both
plt.show()

Histogram overlaid with a Kernel Density Estimate. The histogram bars are scaled to represent density to match the KDE curve.

When kde=True, histplot automatically scales the histogram bars so their area sums to 1 (representing density rather than raw frequency), allowing for a meaningful comparison with the KDE curve, which also represents density.

Histograms and KDE plots are fundamental tools for exploring the distribution of your data. histplot provides a binned view sensitive to bin width choice, while kdeplot offers a smoothed perspective sensitive to bandwidth selection. Often, using them together provides the most comprehensive understanding.