Introduction

In Matplotlib, each subplot has its own Axes object, and axis limits should normally be set on that object directly. The key is to use the object-oriented API such as ax.set_xlim(...) and ax.set_ylim(...), especially when you have several subplots in one figure and only want to change one of them.

Set Limits on a Single Subplot

When you create subplots, Matplotlib returns both the figure and one or more axes. To adjust one subplot, call methods on that specific axis.

1import matplotlib.pyplot as plt
2import numpy as np
3
4x = np.linspace(0, 10, 100)
5y = np.sin(x)
6
7fig, ax = plt.subplots()
8ax.plot(x, y)
9ax.set_xlim(2, 8)
10ax.set_ylim(-0.5, 0.5)
11
12plt.show()

This is clearer than using plt.xlim(...) because the axis you are modifying is explicit. That matters more once a figure contains multiple panels.

Work with Multiple Subplots Safely

If the figure has several subplots, index into the axes array and set limits only where needed.

1import matplotlib.pyplot as plt
2import numpy as np
3
4x = np.linspace(0, 10, 100)
5
6fig, axes = plt.subplots(1, 2, figsize=(10, 4))
7
8axes[0].plot(x, np.sin(x))
9axes[0].set_title("Sine")
10axes[0].set_xlim(0, 5)
11axes[0].set_ylim(-1, 1)
12
13axes[1].plot(x, np.cos(x))
14axes[1].set_title("Cosine")
15axes[1].set_xlim(5, 10)
16axes[1].set_ylim(-0.25, 1.1)
17
18plt.tight_layout()
19plt.show()

Each subplot now has its own limits. This is the standard answer when different panels should emphasize different regions of the data.

Apply Common Limits Across Several Axes

Sometimes the goal is the opposite: all panels should share the same range to make visual comparison fair. In that case, loop through the axes and set identical limits.

1fig, axes = plt.subplots(2, 2, figsize=(8, 6))
2
3for ax in axes.flat:
4    ax.plot(x, np.sin(x))
5    ax.set_xlim(0, 10)
6    ax.set_ylim(-1.2, 1.2)
7
8plt.tight_layout()
9plt.show()

This is especially useful for dashboards, model comparison plots, or before-and-after figures where differing scales could mislead the reader.

Understand Shared Axes and Autoscaling

Matplotlib also supports sharex=True and sharey=True when creating subplots.

fig, axes = plt.subplots(2, 1, sharex=True, sharey=True)

With shared axes, changing limits on one subplot can affect the others. That is often desirable, but it can surprise people who expect each axis to stay independent.

Also remember that autoscaling may reset or override expectations if you set limits before plotting additional data. In practice, a reliable order is:

1. plot the data
2. set titles, labels, and legends
3. set final limits

That makes the resulting figure easier to reason about.

Alternative Syntax

Matplotlib offers a compact axis method too:

ax.axis([2, 8, -0.5, 0.5])

The order is xmin, xmax, ymin, ymax. It works, but set_xlim and set_ylim are often easier to read and less error-prone in review.

Use Limits Intentionally with Log Scales and Comparisons

Axis limits also matter when plots use log scaling or when one subplot is meant to highlight a narrow region of interest. If you switch to ax.set_yscale("log"), make sure the chosen limits are valid for the scale and still show the data you care about.

In comparison-heavy figures, explicitly setting the same x or y range across panels is often more important than the plotting code itself. Readers will compare heights and slopes visually, so inconsistent axis limits can create misleading differences even when the underlying data is similar.

Common Pitfalls

• Calling plt.xlim(...) in a multi-subplot figure and accidentally affecting the wrong current axis.
• Setting limits before plotting, then being surprised when later plotting changes autoscaling behavior.
• Forgetting that sharex and sharey can couple several subplots together.
• Applying different axis ranges across panels when the real goal is fair visual comparison.
• Using axis([...]) without remembering the required ordering of the four values.

Summary

• Set subplot limits on the specific Axes object with set_xlim and set_ylim.
• Index the right axis when a figure contains multiple subplots.
• Loop over axes when several panels should share the same limits.
• Be careful with shared axes and autoscaling.
• Prefer the object-oriented API because it scales better than pyplot globals.