Enge Layout-Anleitung

So verwenden Sie ein enges Layout, um Plots sauber in Ihre Figur einzupassen.

tight_layout passt Subplot-Parameter automatisch so an, dass die Subplots in den Figurenbereich passen. Dies ist eine experimentelle Funktion und funktioniert in einigen Fällen möglicherweise nicht. Es überprüft nur die Ausmaße von Ticklabels, Achsenbeschriftungen und Titeln.

Eine Alternative zu tight_layout ist constrained_layout .

Einfaches Beispiel

In Matplotlib wird die Position von Achsen (einschließlich Subplots) in normalisierten Figurenkoordinaten angegeben. Es kann vorkommen, dass Ihre Achsenbeschriftungen oder -titel (oder manchmal sogar Teilstrichbeschriftungen) außerhalb des Abbildungsbereichs liegen und daher abgeschnitten werden.

import matplotlib.pyplot as plt
import numpy as np

plt.rcParams['savefig.facecolor'] = "0.8"


def example_plot(ax, fontsize=12):
    ax.plot([1, 2])

    ax.locator_params(nbins=3)
    ax.set_xlabel('x-label', fontsize=fontsize)
    ax.set_ylabel('y-label', fontsize=fontsize)
    ax.set_title('Title', fontsize=fontsize)

plt.close('all')
fig, ax = plt.subplots()
example_plot(ax, fontsize=24)

Um dies zu verhindern, muss die Position der Achsen angepasst werden. Bei Nebenhandlungen kann dies manuell erfolgen, indem Sie die Nebenhandlungsparameter mit anpassen Figure.subplots_adjust. Figure.tight_layoutmacht das automatisch.

fig, ax = plt.subplots()
example_plot(ax, fontsize=24)
plt.tight_layout()

Beachten Sie, dass matplotlib.pyplot.tight_layout()die Subplot-Parameter nur angepasst werden, wenn es aufgerufen wird. Um diese Anpassung jedes Mal durchzuführen, wenn die Figur neu gezeichnet wird, können Sie aufrufen fig.set_tight_layout(True)oder entsprechend set rcParams["figure.autolayout"](Standard: False) to True.

Wenn Sie mehrere Subplots haben, sehen Sie oft Beschriftungen verschiedener Achsen, die sich überlappen.

plt.close('all')

fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(nrows=2, ncols=2)
example_plot(ax1)
example_plot(ax2)
example_plot(ax3)
example_plot(ax4)

tight_layout()wird auch den Abstand zwischen den Teilparzellen anpassen, um die Überschneidungen zu minimieren.

fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(nrows=2, ncols=2)
example_plot(ax1)
example_plot(ax2)
example_plot(ax3)
example_plot(ax4)
plt.tight_layout()

tight_layout()kann Schlüsselwortargumente von pad , w_pad und h_pad annehmen . Diese steuern die zusätzliche Polsterung um den Abbildungsrand und zwischen Subplots. Die Pads werden in Bruchteilen der Schriftgröße angegeben.

fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(nrows=2, ncols=2)
example_plot(ax1)
example_plot(ax2)
example_plot(ax3)
example_plot(ax4)
plt.tight_layout(pad=0.4, w_pad=0.5, h_pad=1.0)

tight_layout()funktioniert auch dann, wenn die Größe der Teilparzellen unterschiedlich ist, sofern ihre Rasterspezifikation kompatibel ist. Im Beispiel unten sind ax1 und ax2 Subplots eines 2x2-Rasters, während ax3 ein 1x2-Raster ist.

plt.close('all')
fig = plt.figure()

ax1 = plt.subplot(221)
ax2 = plt.subplot(223)
ax3 = plt.subplot(122)

example_plot(ax1)
example_plot(ax2)
example_plot(ax3)

plt.tight_layout()

Es funktioniert mit Subplots, die mit erstellt wurden subplot2grid(). Im Allgemeinen funktionieren Subplots, die aus der Gridspec ( Arranging multiple Axes in a Figure ) erstellt wurden.

plt.close('all')
fig = plt.figure()

ax1 = plt.subplot2grid((3, 3), (0, 0))
ax2 = plt.subplot2grid((3, 3), (0, 1), colspan=2)
ax3 = plt.subplot2grid((3, 3), (1, 0), colspan=2, rowspan=2)
ax4 = plt.subplot2grid((3, 3), (1, 2), rowspan=2)

example_plot(ax1)
example_plot(ax2)
example_plot(ax3)
example_plot(ax4)

plt.tight_layout()

Obwohl es nicht gründlich getestet wurde, scheint es für Subplots mit Aspekt != "auto" zu funktionieren (zB Achsen mit Bildern).

arr = np.arange(100).reshape((10, 10))

plt.close('all')
fig = plt.figure(figsize=(5, 4))

ax = plt.subplot()
im = ax.imshow(arr, interpolation="none")

plt.tight_layout()

Vorbehalte

• tight_layoutberücksichtigt standardmäßig alle Künstler auf den Achsen. Um einen Künstler aus der Layoutberechnung zu entfernen, können Sie anrufen Artist.set_in_layout.

• tight_layoutgeht davon aus, dass der für Künstler benötigte zusätzliche Platz unabhängig von der ursprünglichen Position der Achsen ist. Dies ist oft der Fall, aber es gibt seltene Fälle, in denen dies nicht der Fall ist.

• pad=0kann einige Texte um ein paar Pixel beschneiden. Dies kann ein Fehler oder eine Einschränkung des aktuellen Algorithmus sein, und es ist nicht klar, warum dies geschieht. In der Zwischenzeit wird die Verwendung eines Pads größer als 0,3 empfohlen.

Mit GridSpec

GridSpec hat seine eigene GridSpec.tight_layoutMethode (die Pyplot-API pyplot.tight_layoutfunktioniert auch).

import matplotlib.gridspec as gridspec

plt.close('all')
fig = plt.figure()

gs1 = gridspec.GridSpec(2, 1)
ax1 = fig.add_subplot(gs1[0])
ax2 = fig.add_subplot(gs1[1])

example_plot(ax1)
example_plot(ax2)

gs1.tight_layout(fig)

Sie können einen optionalen rect - Parameter angeben, der den Begrenzungsrahmen angibt, in den die Teilplots passen. Die Koordinaten müssen in normalisierten Figurenkoordinaten angegeben werden und der Standardwert ist (0, 0, 1, 1).

fig = plt.figure()

gs1 = gridspec.GridSpec(2, 1)
ax1 = fig.add_subplot(gs1[0])
ax2 = fig.add_subplot(gs1[1])

example_plot(ax1)
example_plot(ax2)

gs1.tight_layout(fig, rect=[0, 0, 0.5, 1.0])

Wir empfehlen jedoch nicht, dies zu verwenden, um kompliziertere Layouts manuell zu erstellen, z. B. mit einer GridSpec auf der linken und einer auf der rechten Seite der Abbildung. Für diese Anwendungsfälle sollte man stattdessen Nested Gridspecs oder die Figure subfigures nutzen .

Legenden und Anmerkungen

Vor Matplotlib 2.2 wurden Legenden und Anmerkungen von den Begrenzungsrahmenberechnungen ausgeschlossen, die das Layout bestimmen. Anschließend wurden diese Künstler in die Berechnung aufgenommen, aber manchmal ist es unerwünscht, sie einzubeziehen. In diesem Fall könnte es beispielsweise gut sein, die Achsen etwas zu verkleinern, um Platz für die Legende zu schaffen:

fig, ax = plt.subplots(figsize=(4, 3))
lines = ax.plot(range(10), label='A simple plot')
ax.legend(bbox_to_anchor=(0.7, 0.5), loc='center left',)
fig.tight_layout()
plt.show()

Manchmal ist dies jedoch nicht erwünscht (ziemlich häufig bei der Verwendung von ). Um die Legende aus der Bounding-Box-Berechnung zu entfernen, setzen wir einfach ihre Begrenzung und die Legende wird ignoriert.fig.savefig('outname.png', bbox_inches='tight')leg.set_in_layout(False)

fig, ax = plt.subplots(figsize=(4, 3))
lines = ax.plot(range(10), label='B simple plot')
leg = ax.legend(bbox_to_anchor=(0.7, 0.5), loc='center left',)
leg.set_in_layout(False)
fig.tight_layout()
plt.show()

Mit AxesGrid1 verwenden

Obwohl begrenzt, mpl_toolkits.axes_grid1wird auch unterstützt.

from mpl_toolkits.axes_grid1 import Grid

plt.close('all')
fig = plt.figure()
grid = Grid(fig, rect=111, nrows_ncols=(2, 2),
            axes_pad=0.25, label_mode='L',
            )

for ax in grid:
    example_plot(ax)
ax.title.set_visible(False)

plt.tight_layout()

Farbbalken

Wenn Sie einen Farbbalken mit erstellen Figure.colorbar, wird der erstellte Farbbalken in einem Subplot gezeichnet, solange die übergeordnete Achse ebenfalls ein Subplot ist, also Figure.tight_layoutfunktioniert es.

plt.close('all')
arr = np.arange(100).reshape((10, 10))
fig = plt.figure(figsize=(4, 4))
im = plt.imshow(arr, interpolation="none")

plt.colorbar(im)

plt.tight_layout()

Eine andere Möglichkeit besteht darin, das AxesGrid1-Toolkit zu verwenden, um explizit eine Achse für den Farbbalken zu erstellen.

from mpl_toolkits.axes_grid1 import make_axes_locatable

plt.close('all')
arr = np.arange(100).reshape((10, 10))
fig = plt.figure(figsize=(4, 4))
im = plt.imshow(arr, interpolation="none")

divider = make_axes_locatable(plt.gca())
cax = divider.append_axes("right", "5%", pad="3%")
plt.colorbar(im, cax=cax)

plt.tight_layout()