Choosing Chart Types

The Grammar of Graphics and Why Chart Choice Matters

Every chart encodes data through visual channels: position, length, angle, area, color, and shape. The grammar of graphics, formalized by Leland Wilkinson and implemented in tools like ggplot2 and Vega-Lite, treats every visualization as a mapping from data variables to these visual channels. Understanding this mapping is the foundation of choosing the right chart.

The critical insight is that not all visual channels are equally precise. Cleveland and McGill's experiments in the 1980s established a hierarchy of perceptual accuracy: position along a common scale is the most accurate way to judge magnitude, followed by length, then angle and slope, then area, then volume, then color saturation. This means a bar chart, which encodes value through length, will almost always be read more accurately than a pie chart, which encodes value through angle.

When you choose a chart type, you are making a claim about the relationship in your data. A bar chart claims that categories are distinct and their values are comparable. A line chart claims that the x-axis represents a continuous progression, usually time. A scatter plot claims that you want to explore the relationship between two continuous variables. Choosing the wrong chart does not just make the visualization harder to read—it actively misleads the viewer about the nature of the data.

Consider a simple example: you have monthly sales figures for three product categories over two years. If you use a pie chart, you force the viewer to compare angles across twelve separate pies, which is perceptually difficult and obscures the temporal trend. If you use a line chart with three lines, the temporal progression becomes immediately visible, and the relative performance of each category can be tracked over time. The data is identical; the chart choice determines what the viewer sees.

The decision process starts with a question: what relationship are you trying to reveal? Categorical comparison? Temporal trend? Distribution? Correlation? Part-to-whole? Each question maps to a family of chart types, and within that family, you select the specific encoding that matches your data's structure.

Bar Charts for Categorical Comparison

Bar charts encode values through the length of rectangular bars. Because length is the second-most accurate visual channel after position, bar charts are the default choice for comparing values across discrete categories. The human visual system can judge relative lengths with high precision, which is why bar charts dominate business reporting.

The key design principle for bar charts is that the y-axis must start at zero. Truncating the axis exaggerates differences between bars and misleads the viewer about the magnitude of change. A bar that is twice as tall as another should represent a value that is twice as large. If the axis starts at 90 instead of 0, a value of 100 looks dramatically larger than 95, even though the difference is only 5%.

import matplotlib.pyplot as plt
import numpy as np

categories = ['Product A', 'Product B', 'Product C', 'Product D']
values = [342, 287, 198, 156]

fig, ax = plt.subplots(figsize=(8, 5))
bars = ax.bar(categories, values, color='#2563eb', edgecolor='white', linewidth=0.5)
ax.set_ylabel('Revenue (thousands USD)')
ax.set_title('Quarterly Revenue by Product')
ax.set_ylim(0, max(values) * 1.15)
ax.spines['top'].set_visible(False)
ax.spines['right'].set_visible(False)

for bar, val in zip(bars, values):
    ax.text(bar.get_x() + bar.get_width()/2, bar.get_height() + 8,
            f'${val}K', ha='center', va='bottom', fontsize=10)

plt.tight_layout()
plt.show()

Horizontal bar charts are preferable when category labels are long. Reading a rotated label requires more cognitive effort than reading a horizontal one, and the horizontal layout gives each label the full width of the figure. When you have more than about seven categories, consider sorting bars by value rather than alphabetically—sorted bars make ranking immediately visible.

Stacked bar charts introduce a tradeoff. They show both the total and the composition of each category, but only the bottom segment is positioned against a common baseline. Comparing segments that sit on top of other segments requires the viewer to mentally subtract the baseline, which is perceptually demanding. If composition is the primary message, a stacked bar works. If comparison of individual segments matters, use grouped bars instead.

Line Charts for Temporal Trends

Line charts encode values through position along a continuous axis, making them the most accurate chart type for showing how a variable changes over time. The connecting line implies continuity and progression, which is exactly what temporal data represents. When the x-axis is time, a line chart is almost always the right choice.

The power of a line chart lies in its ability to show trend, seasonality, and change points simultaneously. A single line can reveal that sales are growing, that they peak every December, and that there was an anomalous dip in March. No other chart type communicates all three patterns as efficiently.

import matplotlib.pyplot as plt
import pandas as pd
import numpy as np

dates = pd.date_range('2024-01-01', periods=365, freq='D')
np.random.seed(42)
trend = np.linspace(100, 150, 365)
seasonal = 20 * np.sin(2 * np.pi * np.arange(365) / 365 * 4)
noise = np.random.normal(0, 5, 365)
values = trend + seasonal + noise

fig, ax = plt.subplots(figsize=(12, 5))
ax.plot(dates, values, color='#2563eb', linewidth=1.2, alpha=0.8)
ax.fill_between(dates, values, alpha=0.1, color='#2563eb')
ax.set_ylabel('Daily Active Users')
ax.set_title('User Growth Over 2024')
ax.spines['top'].set_visible(False)
ax.spines['right'].set_visible(False)
ax.xaxis.set_major_locator(plt.MaxNLocator(12))
plt.xticks(rotation=45)
plt.tight_layout()
plt.show()

When plotting multiple lines, limit the number to four or five. Beyond that, the chart becomes a tangled mess where individual lines cannot be distinguished. If you need to show more series, use a small multiples approach: create a grid of smaller charts, each showing one series with the same axis scales. This preserves comparability while keeping each chart readable.

A common mistake is using a line chart for categorical data. If the x-axis represents product categories, not time, the connecting line implies a progression that does not exist. The viewer's brain will try to interpret the slope between categories as meaningful, which it is not. Use a bar chart for categories, a line chart for time.

The y-axis for line charts does not need to start at zero because the position encoding is precise enough to show small changes. However, you should still be deliberate: if the axis range is too wide, real variation becomes invisible. If it is too narrow, noise looks like signal. Choose the range that makes the pattern you care about visible.

Scatter Plots and Histograms for Relationships and Distributions

Scatter plots encode two continuous variables as x and y positions, revealing correlation, clusters, and outliers. Because position is the most accurate visual channel, scatter plots are the best tool for exploring relationships between numeric variables. Each point is an independent observation, and the overall pattern of points tells you whether the variables are related, how strongly, and whether the relationship is linear or nonlinear.

import matplotlib.pyplot as plt
import numpy as np

np.random.seed(42)
ad_spend = np.random.uniform(1000, 5000, 200)
revenue = 2.5 * ad_spend + np.random.normal(0, 800, 200)

fig, ax = plt.subplots(figsize=(8, 6))
ax.scatter(ad_spend, revenue, alpha=0.5, s=30, color='#2563eb', edgecolors='none')

z = np.polyfit(ad_spend, revenue, 1)
p = np.poly1d(z)
ax.plot(ad_spend, p(ad_spend), color='#dc2626', linewidth=2, linestyle='--',
        label=f'Trend: y = {z[0]:.1f}x + {z[1]:.0f}')

ax.set_xlabel('Ad Spend (USD)')
ax.set_ylabel('Revenue (USD)')
ax.set_title('Ad Spend vs. Revenue')
ax.legend()
ax.spines['top'].set_visible(False)
ax.spines['right'].set_visible(False)
plt.tight_layout()
plt.show()

Histograms encode the distribution of a single continuous variable by binning values into intervals and showing the frequency of each bin as a bar height. The choice of bin width is the most important design decision. Too few bins and you lose the shape of the distribution. Too many bins and the histogram becomes noisy, with random spikes that obscure the underlying pattern.

import matplotlib.pyplot as plt
import numpy as np

np.random.seed(42)
data = np.concatenate([np.random.normal(50, 10, 800), np.random.normal(80, 5, 200)])

fig, axes = plt.subplots(1, 3, figsize=(15, 4))
for ax, bins in zip(axes, [5, 20, 50]):
    ax.hist(data, bins=bins, color='#2563eb', edgecolor='white', alpha=0.8)
    ax.set_title(f'{bins} bins')
    ax.set_xlabel('Value')
    ax.set_ylabel('Frequency')
plt.tight_layout()
plt.show()

The three-bin histogram shows a single blob. The fifty-bin histogram shows noise. The twenty-bin histogram reveals the bimodal structure: two distinct groups within the data. This is the level of detail you need—enough to see the true shape, not so much that you see artifacts of random sampling.

Use a scatter plot when both variables are continuous and you want to see their joint behavior. Use a histogram when one variable is continuous and you want to see its marginal distribution. Use a heatmap when you need to show the density of points in a two-dimensional space where individual points would overlap into an unreadable mass.

Heatmaps for Matrix Data and Density

Heatmaps encode values through color intensity in a two-dimensional grid. Each cell represents the intersection of two categorical or binned variables, and the color of the cell encodes the magnitude of a third variable. Heatmaps excel at revealing patterns in matrix data: correlation matrices, confusion matrices, time-by-category grids, and geographic density maps.

The critical design decision for heatmaps is the color scale. A sequential scale (light to dark) works for data that ranges from low to high with a meaningful zero point. A diverging scale (e.g., blue-white-red) works for data that has a meaningful center point, such as deviations from a mean or correlation coefficients ranging from -1 to +1.

import matplotlib.pyplot as plt
import numpy as np
import pandas as pd

np.random.seed(42)
corr_data = np.random.randn(100, 5)
columns = ['Revenue', 'Profit', 'Expenses', 'Customers', 'Retention']
df = pd.DataFrame(corr_data, columns=columns)
corr_matrix = df.corr()

fig, ax = plt.subplots(figsize=(8, 6))
im = ax.imshow(corr_matrix, cmap='RdBu_r', vmin=-1, vmax=1, aspect='auto')

ax.set_xticks(range(len(columns)))
ax.set_yticks(range(len(columns)))
ax.set_xticklabels(columns, rotation=45, ha='right')
ax.set_yticklabels(columns)

for i in range(len(columns)):
    for j in range(len(columns)):
        ax.text(j, i, f'{corr_matrix.iloc[i, j]:.2f}',
                ha='center', va='center', fontsize=9,
                color='white' if abs(corr_matrix.iloc[i, j]) > 0.5 else 'black')

fig.colorbar(im, ax=ax, label='Correlation Coefficient')
ax.set_title('Correlation Matrix')
plt.tight_layout()
plt.show()

Heatmaps are particularly powerful for time-series data across multiple categories. Imagine a grid where rows are hours of the day, columns are days of the week, and cell color represents website traffic. The heatmap immediately reveals that weekday evenings have high traffic, weekend mornings have moderate traffic, and Tuesday at 3 AM has almost none. This pattern would require dozens of individual line charts to communicate.

The main limitation of heatmaps is that color intensity is the least precise visual channel. Viewers can see that one cell is darker than another, but they cannot judge the exact difference. Always annotate cells with their numeric values when precision matters, or provide a colorbar with clear tick marks so viewers can estimate values.

Choose a heatmap when you have a matrix of values and want to reveal spatial patterns, clusters, or gradients. Choose a scatter plot when you need to see individual data points. Choose a line chart when one dimension is time and you want to show progression. The chart type should match the structure of your data and the question you are asking.