How Can Plt Subplots Figsize Preserve Aspect Ratio?

Oh, this plotting little puzzle is one of my favorites to tinker with! If you want plt.subplots(figsize=...) to preserve an aspect ratio, the trick is knowing that figsize controls the overall figure inches, while axes have their own box and data aspect settings. For simple cases I like to set the axes box aspect so the axes themselves keep the width:height ratio I want: ax.set_box_aspect(h/w) (requires Matplotlib 3.3+). That makes the axes rectangle scale correctly no matter how the figure is resized.

A practical pattern I use a lot: compute the total figure size from the number of columns and rows and your desired per-axis aspect. For example, if each subplot should be 4:3 (width:height) and you have 3 cols and 2 rows, pick a base width (say 3 inches per subplot) and set figsize=(3*3, 3*3*(3/4)) or more simply derive height = width * (rows/cols) * (desired_height/desired_width). Then set constrained_layout=True or tight_layout() so Matplotlib honors margins and suptitles without clipping. Example sketch:

fig, axes = plt.subplots(2, 3, figsize=(9, 6), constrained_layout=True)
for ax in axes.flat:
ax.set_box_aspect(3/4) # keeps each axis box at 3:4 (h/w) so the images look right

If you must preserve data units (one x unit equals one y unit), use ax.set_aspect('equal', adjustable='box') instead. For images, imshow(..., aspect='equal') or set extent so axes scaling is consistent. Also watch out: colorbars, legends, and titles change free space, so either reserve space with GridSpec or use set_box_aspect so the axes ignore figure decorations when keeping shape. I like this approach because it’s deterministic — you get square-ish or fixed-ratio panels without manual fiddling.

I like to think of figsize as the paper size and axes aspect as the stamp you glue on it. If you want proportions preserved, you can approach it two ways: keep the data aspect equal (ax.set_aspect('equal')) or fix the axes’ box aspect (ax.set_box_aspect(yratio/xratio)). The former makes one data unit equal in x and y; the latter forces the axes rectangle to a fixed shape regardless of the data range.

A simple recipe that works for me is: pick the per-subplot aspect you want, calculate total figsize = (per_subplot_width * ncols, per_subplot_height * nrows), enable constrained_layout or tight_layout, then call set_box_aspect on each axis. For older Matplotlib where set_box_aspect isn’t available, you can instead use ax.set_aspect('equal', adjustable='box') and carefully compute figsize and subplot spacing. Also keep in mind colorbars and labels; they’ll steal space and can distort the final look unless you reserve space with GridSpec or pad the figure.

Try a tiny test script with one subplot first — it’s much faster to iterate that way and you’ll quickly see how figsize and the various aspect settings interact.

Lately I’ve been doing a lot of tiled plots, so here’s a neat little workflow that always saves me time. figsize sets the outer inches of the figure, but preserving aspect is really about controlling the axes box and the data aspect separately. If you want each subplot to have the same on-screen shape regardless of data span, use ax.set_box_aspect(ratio). That tells Matplotlib to keep the axes patch itself at a fixed height/width ratio.

When making multi-panel figures I often use GridSpec to control relative widths and heights and then combine that with set_box_aspect. For instance, use fig.add_gridspec(nrows, ncols, height_ratios=[...], width_ratios=[...]) so you can allocate more space for a wide plot. Compute figsize so that fig.get_figwidth()/fig.get_figheight() matches the overall ratio you need. If you need the data units to be equal (e.g., maps or scatter with equal scales) do ax.set_aspect('equal', adjustable='box') or specify aspect='auto' for flexible behavior.

Remember that things like colorbars, suptitles, and legend boxes can shrink the axes area; constrained_layout=True or fig.tight_layout() helps mitigate that. If you’re stuck on an exact pixel result for publications, calculate figure size precisely: desired_axis_width_in_inches = Ncols * axis_width, desired_axis_height_in_inches = Nrows * axis_width * (desired_height/desired_width), and pass that to figsize. That way the visual proportions are reproducible between runs.