it-swarm.com.de

Wie man die Legende aus der Handlung entfernt

Ich habe eine Reihe von 20 Plots (keine Unterplots) in einer einzigen Figur. Ich möchte, dass die Legende über den Tellerrand hinausgeht. Gleichzeitig möchte ich die Achsen nicht ändern, da sich die Größe der Figur verringert. Bitte helfen Sie mir bei folgenden Fragen:

  1. Ich möchte das Legendenfeld außerhalb des Grundstücks behalten. (Ich möchte, dass sich die Legende draußen auf der rechten Seite des Grundstücks befindet.).
  2. Gibt es sowieso, dass ich die Schriftgröße des Textes innerhalb des Legendenfeldes verkleinere, so dass die Größe des Legendenfeldes klein wird.
813
pottigopi

Sie können den Legendentext verkleinern, indem Sie Schrifteigenschaften erstellen:

from matplotlib.font_manager import FontProperties

fontP = FontProperties()
fontP.set_size('small')
legend([plot1], "title", prop=fontP) 
# or add prop=fontP to whatever legend() call you already have
84
Navi

Es gibt verschiedene Möglichkeiten, um das zu tun, was Sie wollen. Um zu dem, was @inalis und @Navi bereits gesagt haben, hinzuzufügen, können Sie das Schlüsselwortargument bbox_to_anchor verwenden, um die Legende teilweise außerhalb der Achsen zu platzieren und/oder die Schriftgröße zu verringern.

Versuchen Sie, die Legende an verschiedenen Stellen zu platzieren, bevor Sie die Schriftgröße verringern (was die Lesbarkeit erheblich beeinträchtigen kann):

Beginnen wir also mit einem allgemeinen Beispiel:

import matplotlib.pyplot as plt
import numpy as np

x = np.arange(10)

fig = plt.figure()
ax = plt.subplot(111)

for i in xrange(5):
    ax.plot(x, i * x, label='$y = %ix$' % i)

ax.legend()

plt.show()

alt text

Wenn wir dasselbe tun, aber das Schlüsselwortargument bbox_to_anchor verwenden, können wir die Legende geringfügig außerhalb der Achsengrenzen verschieben:

import matplotlib.pyplot as plt
import numpy as np

x = np.arange(10)

fig = plt.figure()
ax = plt.subplot(111)

for i in xrange(5):
    ax.plot(x, i * x, label='$y = %ix$' % i)

ax.legend(bbox_to_anchor=(1.1, 1.05))

plt.show()

alt text

Ebenso können Sie die Legende horizontaler gestalten und/oder oben in die Figur einfügen (ich drehe auch abgerundete Ecken und einen einfachen Schlagschatten):

import matplotlib.pyplot as plt
import numpy as np

x = np.arange(10)

fig = plt.figure()
ax = plt.subplot(111)

for i in xrange(5):
    line, = ax.plot(x, i * x, label='$y = %ix$'%i)

ax.legend(loc='upper center', bbox_to_anchor=(0.5, 1.05),
          ncol=3, fancybox=True, shadow=True)
plt.show()

alt text

Alternativ können Sie die Breite des aktuellen Diagramms verkleinern und die Legende vollständig außerhalb der Achse der Figur platzieren:

import matplotlib.pyplot as plt
import numpy as np

x = np.arange(10)

fig = plt.figure()
ax = plt.subplot(111)

for i in xrange(5):
    ax.plot(x, i * x, label='$y = %ix$'%i)

# Shrink current axis by 20%
box = ax.get_position()
ax.set_position([box.x0, box.y0, box.width * 0.8, box.height])

# Put a legend to the right of the current axis
ax.legend(loc='center left', bbox_to_anchor=(1, 0.5))

plt.show()

alt text

Auf ähnliche Weise können Sie den Plot vertikal verkleinern und die horizontale Legende unten einfügen:

import matplotlib.pyplot as plt
import numpy as np

x = np.arange(10)

fig = plt.figure()
ax = plt.subplot(111)

for i in xrange(5):
    line, = ax.plot(x, i * x, label='$y = %ix$'%i)

# Shrink current axis's height by 10% on the bottom
box = ax.get_position()
ax.set_position([box.x0, box.y0 + box.height * 0.1,
                 box.width, box.height * 0.9])

# Put a legend below current axis
ax.legend(loc='upper center', bbox_to_anchor=(0.5, -0.05),
          fancybox=True, shadow=True, ncol=5)

plt.show()

alt text

Schauen Sie sich die Legendenanleitung für Matplotlib an . Sie können sich auch plt.figlegend() ansehen. Hoffe das hilft sowieso ein bisschen!

1575
Joe Kington

Legende platzieren (_bbox_to_anchor_)

Eine Legende wird im Begrenzungsrahmen der Achsen mit dem Argument loc zu plt.legend positioniert.
Z.B. _loc="upper right"_ platziert die Legende in der oberen rechten Ecke des Begrenzungsrahmens, der standardmäßig von _(0,0)_ bis _(1,1)_ in Achsenkoordinaten (oder in Begrenzungsrahmennotation _(x0,y0, width, height)=(0,0,1,1)_) reicht.

Um die Legende außerhalb des Achsenbegrenzungsrahmens zu platzieren, kann ein Tupel _(x0,y0)_ der Achsenkoordinaten der unteren linken Ecke der Legende angegeben werden.

_plt.legend(loc=(1.04,0))
_

Vielseitiger wäre es jedoch, den Begrenzungsrahmen, in den die Legende eingefügt werden soll, mit dem Argument bbox_to_anchor manuell anzugeben. Man kann sich darauf beschränken, nur den Teil _(x0,y0)_ der bbox zu liefern. Dadurch wird ein Feld mit einer Spanne von Null erstellt, aus dem die Legende in die durch das Argument loc angegebene Richtung erweitert wird. Z.B.

 plt.legend (bbox_to_anchor = (1.04.1), loc = "upper left") 

platziert die Legende außerhalb der Achsen, sodass sich die obere linke Ecke der Legende an der Position _(1.04,1)_ in Achsenkoordinaten befindet.

Weitere Beispiele finden Sie weiter unten, wo zusätzlich das Zusammenspiel verschiedener Argumente wie mode und ncols gezeigt wird.

enter image description here

_l1 = plt.legend(bbox_to_anchor=(1.04,1), borderaxespad=0)
l2 = plt.legend(bbox_to_anchor=(1.04,0), loc="lower left", borderaxespad=0)
l3 = plt.legend(bbox_to_anchor=(1.04,0.5), loc="center left", borderaxespad=0)
l4 = plt.legend(bbox_to_anchor=(0,1.02,1,0.2), loc="lower left",
                mode="expand", borderaxespad=0, ncol=3)
l5 = plt.legend(bbox_to_anchor=(1,0), loc="lower right", 
                bbox_transform=fig.transFigure, ncol=3)
l6 = plt.legend(bbox_to_anchor=(0.4,0.8), loc="upper right")
_

Details zur Interpretation des 4-Tuple-Arguments für _bbox_to_anchor_ wie in _l4_ finden Sie in diese Frage . Der _mode="expand"_ erweitert die Legende horizontal innerhalb des durch das 4-Tupel vorgegebenen Begrenzungsrahmens. Eine vertikal erweiterte Legende finden Sie unter diese Frage .

Manchmal kann es nützlich sein, den Begrenzungsrahmen in Figurkoordinaten anstelle von Achsenkoordinaten anzugeben. Dies wird in dem Beispiel _l5_ von oben gezeigt, in dem das Argument _bbox_transform_ verwendet wird, um die Legende in die untere linke Ecke der Figur zu setzen.

Nachbearbeitung

Das Platzieren der Legende außerhalb der Achsen führt häufig zu der unerwünschten Situation, dass sie sich ganz oder teilweise außerhalb der Zeichenfläche befindet.

Lösungen für dieses Problem sind:

  • Passen Sie die Subplot-Parameter an
    Mit plt.subplots_adjust kann man die Subplot-Parameter so einstellen, dass die Achsen weniger Platz in der Figur beanspruchen (und damit der Legende mehr Platz lassen). Z.B.

    _plt.subplots_adjust(right=0.7)
    _

    lässt 30% Platz auf der rechten Seite der Figur, wo man die Legende platzieren könnte.

  • Enges Layout
    Verwenden von plt.tight_layout Ermöglicht die automatische Anpassung der Subplot-Parameter, sodass die Elemente in der Figur eng an den Figurenrändern anliegen. Leider wird die Legende in diesem Automatismus nicht berücksichtigt, aber wir können ein Rechteckfeld bereitstellen, in das der gesamte Bereich der Unterzeichnungen (einschließlich Beschriftungen) passt.

    _plt.tight_layout(rect=[0,0,0.75,1])
    _
  • Speichern der Figur mit _bbox_inches = "tight"_
    Mit dem Argument _bbox_inches = "tight"_ bis plt.savefig kann die Figur so gespeichert werden, dass alle Künstler auf der Leinwand (einschließlich der Legende) in den gespeicherten Bereich passen . Bei Bedarf wird die Abbildungsgröße automatisch angepasst.

    _plt.savefig("output.png", bbox_inches="tight")
    _
  • Automatische Anpassung der Untergrundparameter
    In dieser Antwort finden Sie eine Möglichkeit, die Position der Nebenzeichnung automatisch so anzupassen, dass die Legende in die Zeichenfläche passt , ohne die Größe der Figur zu ändern : Erstellen einer Figur mit exakter Größe und ohne Polsterung (und Legende außerhalb der Achsen)

Vergleich zwischen den oben diskutierten Fällen:

enter image description here

Alternativen

Eine Figurenlegende
Anstelle der Achsen kann eine Legende für die Figur verwendet werden matplotlib.figure.Figure.legend . Dies ist besonders nützlich für matplotlib-Versionen> = 2.1, bei denen keine speziellen Argumente erforderlich sind

_fig.legend(loc=7) 
_

eine Legende für alle Künstler in den verschiedenen Achsen der Figur zu erstellen. Die Legende wird mit dem Argument loc platziert, ähnlich wie es in einer Achse platziert wird, jedoch in Bezug auf die gesamte Figur - daher wird es sich etwas automatisch außerhalb der Achsen befinden. Was bleibt, ist die Anpassung der Unterzeichnungen so, dass es keine Überlappung zwischen der Legende und den Achsen gibt. Hier ist der Punkt "Passen Sie die Subplot-Parameter an" von oben hilfreich. Ein Beispiel:

_import numpy as np
import matplotlib.pyplot as plt

x = np.linspace(0,2*np.pi)
colors=["#7aa0c4","#ca82e1" ,"#8bcd50","#e18882"]
fig, axes = plt.subplots(ncols=2)
for i in range(4):
    axes[i//2].plot(x,np.sin(x+i), color=colors[i],label="y=sin(x+{})".format(i))

fig.legend(loc=7)
fig.tight_layout()
fig.subplots_adjust(right=0.75)   
plt.show()
_

enter image description here

Legende innerhalb dedizierter Teildiagrammachsen
Eine Alternative zur Verwendung von _bbox_to_anchor_ wäre das Platzieren der Legende in den zugehörigen Unterzeichenachsen (lax). Da die Legendenunterzeichnung kleiner sein sollte als die Zeichnung, können wir bei der Achsenerstellung _gridspec_kw={"width_ratios":[4,1]}_ verwenden. Wir können die Achsen lax.axis("off") verbergen, aber dennoch eine Legende einfügen. Die Legendengriffe und Beschriftungen müssen über h,l = ax.get_legend_handles_labels() aus dem realen Plot abgerufen werden und können dann in der Teilzeichnung laxlax.legend(h,l) an die Legende übergeben werden. Ein vollständiges Beispiel finden Sie weiter unten.

_import matplotlib.pyplot as plt
plt.rcParams["figure.figsize"] = 6,2

fig, (ax,lax) = plt.subplots(ncols=2, gridspec_kw={"width_ratios":[4,1]})
ax.plot(x,y, label="y=sin(x)")
....

h,l = ax.get_legend_handles_labels()
lax.legend(h,l, borderaxespad=0)
lax.axis("off")

plt.tight_layout()
plt.show()
_

Dies erzeugt eine grafische Darstellung, die der grafischen Darstellung von oben optisch ziemlich ähnlich ist:

enter image description here

Wir könnten auch die ersten Achsen verwenden, um die Legende zu platzieren, aber den _bbox_transform_ der Legendenachsen verwenden,

_ax.legend(bbox_to_anchor=(0,0,1,1), bbox_transform=lax.transAxes)
lax.axis("off")
_

Bei diesem Ansatz müssen wir die Legendenhandles nicht extern beziehen, sondern das Argument _bbox_to_anchor_ angeben.

Weitere Lektüre und Anmerkungen:

  • Betrachten Sie die matplotlib Legenden-Anleitung mit einigen Beispielen für andere Dinge, die Sie mit Legenden machen möchten.
  • Einige Beispielcodes zum Platzieren von Legenden für Kreisdiagramme finden Sie direkt in der Antwort auf diese Frage: Python - Legende überlappt mit dem Kreisdiagramm
  • Das Argument loc kann Zahlen anstelle von Zeichenfolgen annehmen, wodurch die Aufrufe kürzer werden. Sie sind jedoch nicht sehr intuitiv aufeinander abgebildet. Hier ist die Zuordnung als Referenz:

enter image description here

Rufen Sie einfach legend() nach dem plot() auf:

# matplotlib
plt.plot(...)
plt.legend(loc='center left', bbox_to_anchor=(1, 0.5))

# Pandas
df.myCol.plot().legend(loc='center left', bbox_to_anchor=(1, 0.5))

Die Ergebnisse würden ungefähr so ​​aussehen:

enter image description here

140
Shital Shah

Kurze Antwort: Sie können bbox_to_anchor + bbox_extra_artists + bbox_inches='tight' verwenden.


Längere Antwort: Sie können bbox_to_anchor verwenden, um die Position des Legendenfelds manuell festzulegen, wie einige andere Personen in den Antworten angegeben haben.

Das übliche Problem ist jedoch, dass das Legendenfeld beschnitten ist, z.

import matplotlib.pyplot as plt

# data 
all_x = [10,20,30]
all_y = [[1,3], [1.5,2.9],[3,2]]

# Plot
fig = plt.figure(1)
ax = fig.add_subplot(111)
ax.plot(all_x, all_y)

# Add legend, title and axis labels
lgd = ax.legend( [ 'Lag ' + str(lag) for lag in all_x], loc='center right', bbox_to_anchor=(1.3, 0.5))
ax.set_title('Title')
ax.set_xlabel('x label')
ax.set_ylabel('y label')

fig.savefig('image_output.png', dpi=300, format='png')

enter image description here

Um zu verhindern, dass die Legendenbox beschnitten wird, können Sie beim Speichern der Figur die Parameter bbox_extra_artists und bbox_inches verwenden, um savefig aufzufordern, beschnittene Elemente in das gespeicherte Bild aufzunehmen:

fig.savefig('image_output.png', bbox_extra_artists=(lgd,), bbox_inches='tight')

Beispiel (Ich habe nur die letzte Zeile geändert, um 2 Parameter zu fig.savefig() hinzuzufügen):

import matplotlib.pyplot as plt

# data 
all_x = [10,20,30]
all_y = [[1,3], [1.5,2.9],[3,2]]

# Plot
fig = plt.figure(1)
ax = fig.add_subplot(111)
ax.plot(all_x, all_y)

# Add legend, title and axis labels
lgd = ax.legend( [ 'Lag ' + str(lag) for lag in all_x], loc='center right', bbox_to_anchor=(1.3, 0.5))
ax.set_title('Title')
ax.set_xlabel('x label')
ax.set_ylabel('y label')    

fig.savefig('image_output.png', dpi=300, format='png', bbox_extra_artists=(lgd,), bbox_inches='tight')

enter image description here

Ich wünschte, matplotlib würde nativ einen externen Speicherort für das Legendenfeld zulassen, wie Matlab tut dies :

figure
x = 0:.2:12;
plot(x,besselj(1,x),x,besselj(2,x),x,besselj(3,x));
hleg = legend('First','Second','Third',...
              'Location','NorthEastOutside')
% Make the text of the legend italic and color it brown
set(hleg,'FontAngle','italic','TextColor',[.3,.2,.1])

enter image description here

76

Um die Legende außerhalb des Plotbereichs zu platzieren, verwenden Sie die Schlüsselwörter loc und bbox_to_anchor von legend(). Mit dem folgenden Code wird beispielsweise die Legende rechts vom Plotbereich platziert:

legend(loc="upper left", bbox_to_anchor=(1,1))

Weitere Informationen finden Sie in der Legendenanleitung

64
Christian Alis

Zusätzlich zu all den hervorragenden Antworten hier können neuere Versionen von matplotlib und pylabbestimmen automatisch, wo die Legende platziert werden soll, ohne die Darstellungen zu beeinträchtigen, wenn möglich.

pylab.legend(loc='best')

Dadurch wird die Legende nach Möglichkeit automatisch von den Daten entfernt! Compare the use of loc='best'

Wenn es jedoch keinen Ort gibt, an dem die Legende platziert werden kann, ohne die Daten zu überlappen, sollten Sie eine der anderen Antworten ausprobieren. Wenn Sie loc="best" verwenden, wird die Legende niemals außerhalb des Diagramms platziert.

58
dotancohen

Kurze Antwort: Rufen Sie Drag & Drop für die Legende auf und verschieben Sie sie interaktiv, wo immer Sie möchten:

ax.legend().draggable()

Lange Antwort: Wenn Sie die Legende lieber interaktiv/manuell als programmgesteuert platzieren möchten, können Sie den ziehbaren Modus der Legende umschalten, sodass Sie sie an eine beliebige Stelle ziehen können. Überprüfen Sie das folgende Beispiel:

import matplotlib.pylab as plt
import numpy as np
#define the figure and get an axes instance
fig = plt.figure()
ax = fig.add_subplot(111)
#plot the data
x = np.arange(-5, 6)
ax.plot(x, x*x, label='y = x^2')
ax.plot(x, x*x*x, label='y = x^3')
ax.legend().draggable()
plt.show()
55
mefathy

Nicht genau das, wonach Sie gefragt haben, aber ich fand, dass es eine Alternative für dasselbe Problem ist. Machen Sie die Legende halbtransparent: matplotlib plot with semi transparent legend and semitransparent text box

Mach das mit:

fig = pylab.figure()
ax = fig.add_subplot(111)
ax.plot(x,y,label=label,color=color)
# Make the legend transparent:
ax.legend(loc=2,fontsize=10,fancybox=True).get_frame().set_alpha(0.5)
# Make a transparent text box
ax.text(0.02,0.02,yourstring, verticalalignment='bottom',
                     horizontalalignment='left',
                     fontsize=10,
                     bbox={'facecolor':'white', 'alpha':0.6, 'pad':10},
                     transform=self.ax.transAxes)
13
Bastiaan

Wie bereits erwähnt, können Sie die Legende auch im Plot platzieren oder auch etwas außerhalb des Randes platzieren. Hier ist ein Beispiel unter Verwendung der Plotly Python API , erstellt mit einem IPython Notebook . Ich bin im Team.

Zunächst möchten Sie die erforderlichen Pakete installieren:

import plotly
import math
import random
import numpy as np

Dann installieren Sie Plotly:

un='IPython.Demo'
k='1fw3zw2o13'
py = plotly.plotly(username=un, key=k)


def sin(x,n):
sine = 0
for i in range(n):
    sign = (-1)**i
    sine = sine + ((x**(2.0*i+1))/math.factorial(2*i+1))*sign
return sine

x = np.arange(-12,12,0.1)

anno = {
'text': '$\\sum_{k=0}^{\\infty} \\frac {(-1)^k x^{1+2k}}{(1 + 2k)!}$',
'x': 0.3, 'y': 0.6,'xref': "paper", 'yref': "paper",'showarrow': False,
'font':{'size':24}
}

l = {
'annotations': [anno], 
'title': 'Taylor series of sine',
'xaxis':{'ticks':'','linecolor':'white','showgrid':False,'zeroline':False},
'yaxis':{'ticks':'','linecolor':'white','showgrid':False,'zeroline':False},
'legend':{'font':{'size':16},'bordercolor':'white','bgcolor':'#fcfcfc'}
}

py.iplot([{'x':x, 'y':sin(x,1), 'line':{'color':'#e377c2'}, 'name':'$x\\\\$'},\
      {'x':x, 'y':sin(x,2), 'line':{'color':'#7f7f7f'},'name':'$ x-\\frac{x^3}{6}$'},\
      {'x':x, 'y':sin(x,3), 'line':{'color':'#bcbd22'},'name':'$ x-\\frac{x^3}{6}+\\frac{x^5}{120}$'},\
      {'x':x, 'y':sin(x,4), 'line':{'color':'#17becf'},'name':'$ x-\\frac{x^5}{120}$'}], layout=l)

Dadurch wird Ihr Diagramm erstellt, und Sie können die Legende im Diagramm selbst beibehalten. Wenn die Legende nicht festgelegt ist, wird sie standardmäßig im Diagramm platziert, wie hier gezeigt.

enter image description here

Für eine alternative Platzierung können Sie den Rand des Diagramms und den Rand der Legende genau ausrichten und die Randlinien für eine engere Anpassung entfernen.

enter image description here

Sie können die Legende und das Diagramm mit Code oder mit der GUI verschieben und neu formatieren. Um die Legende zu verschieben, haben Sie folgende Möglichkeiten, die Legende innerhalb des Diagramms zu positionieren, indem Sie x- und y-Werte von <= 1 zuweisen. Beispiel:

  • {"x" : 0,"y" : 0} - Links unten
  • {"x" : 1, "y" : 0} - Unten rechts
  • {"x" : 1, "y" : 1} - Oben rechts
  • {"x" : 0, "y" : 1} - Oben links
  • {"x" :.5, "y" : 0} - Unten in der Mitte
  • {"x": .5, "y" : 1} - Oben Mitte

In diesem Fall wählen wir oben rechts legendstyle = {"x" : 1, "y" : 1}, ebenfalls beschrieben in die Dokumentation :

enter image description here

7
Mateo Sanchez

Etwas in diese Richtung hat für mich funktioniert. Ausgehend von einem Code, der von Joe stammt, ändert diese Methode die Fensterbreite so, dass automatisch eine Legende rechts von der Figur eingefügt wird.

import matplotlib.pyplot as plt
import numpy as np

plt.ion()

x = np.arange(10)

fig = plt.figure()
ax = plt.subplot(111)

for i in xrange(5):
    ax.plot(x, i * x, label='$y = %ix$'%i)

# Put a legend to the right of the current axis
leg = ax.legend(loc='center left', bbox_to_anchor=(1, 0.5))

plt.draw()

# Get the ax dimensions.
box = ax.get_position()
xlocs = (box.x0,box.x1)
ylocs = (box.y0,box.y1)

# Get the figure size in inches and the dpi.
w, h = fig.get_size_inches()
dpi = fig.get_dpi()

# Get the legend size, calculate new window width and change the figure size.
legWidth = leg.get_window_extent().width
winWidthNew = w*dpi+legWidth
fig.set_size_inches(winWidthNew/dpi,h)

# Adjust the window size to fit the figure.
mgr = plt.get_current_fig_manager()
mgr.window.wm_geometry("%ix%i"%(winWidthNew,mgr.window.winfo_height()))

# Rescale the ax to keep its original size.
factor = w*dpi/winWidthNew
x0 = xlocs[0]*factor
x1 = xlocs[1]*factor
width = box.width*factor
ax.set_position([x0,ylocs[0],x1-x0,ylocs[1]-ylocs[0]])

plt.draw()
3
Martin

Sie können auch figlegend versuchen. Es ist möglich, eine Legende unabhängig von einem Achsenobjekt zu erstellen. Möglicherweise müssen Sie jedoch einige "Dummy" -Pfade erstellen, um sicherzustellen, dass die Formatierung für die Objekte korrekt übergeben wird.

2
Uri Laserson

Hier ist eine andere Lösung, ähnlich wie beim Hinzufügen von bbox_extra_artists und bbox_inches, bei der Sie keine zusätzlichen Interpreten für Ihren savefig -Aufruf benötigen. Ich habe mir das ausgedacht, da ich den größten Teil meiner Handlung innerhalb von Funktionen generiere.

Anstatt alle Ihre Ergänzungen dem Begrenzungsrahmen hinzuzufügen, wenn Sie ihn ausschreiben möchten, können Sie sie den Künstlern von Figure vorab hinzufügen. Mit etwas ähnlichem wie Franck Dernoncourt Antwort oben :

import matplotlib.pyplot as plt

# data 
all_x = [10,20,30]
all_y = [[1,3], [1.5,2.9],[3,2]]

# plotting function
def gen_plot(x, y):
    fig = plt.figure(1)
    ax = fig.add_subplot(111)
    ax.plot(all_x, all_y)
    lgd = ax.legend( [ "Lag " + str(lag) for lag in all_x], loc="center right", bbox_to_anchor=(1.3, 0.5))
    fig.artists.append(lgd) # Here's the change
    ax.set_title("Title")
    ax.set_xlabel("x label")
    ax.set_ylabel("y label")
    return fig

# plotting
fig = gen_plot(all_x, all_y)

# No need for `bbox_extra_artists`
fig.savefig("image_output.png", dpi=300, format="png", bbox_inches="tight")

Hier ist das erzeugte Diagramm.

1
ivirshup

Hier ist ein Beispiel aus dem Matplotlib-Tutorial hier . Dies ist eines der einfacheren Beispiele, aber ich habe der Legende Transparenz hinzugefügt und plt.show () hinzugefügt, damit Sie dies in die interaktive Shell einfügen und ein Ergebnis erhalten können:

import matplotlib.pyplot as plt
p1, = plt.plot([1, 2, 3])
p2, = plt.plot([3, 2, 1])
p3, = plt.plot([2, 3, 1])
plt.legend([p2, p1, p3], ["line 1", "line 2", "line 3"]).get_frame().set_alpha(0.5)
plt.show()
1
radtek

Die Lösung, die für mich funktionierte, als ich eine riesige Legende hatte, bestand darin, ein zusätzliches leeres Bildlayout zu verwenden. Im folgenden Beispiel habe ich 4 Zeilen erstellt und unten habe ich das Bild mit dem Versatz für die Legende (bbox_to_anchor) geplottet. Oben wird es nicht ausgeschnitten.

f = plt.figure()
ax = f.add_subplot(414)
lgd = ax.legend(loc='upper left', bbox_to_anchor=(0, 4), mode="expand", borderaxespad=0.3)
ax.autoscale_view()
plt.savefig(fig_name, format='svg', dpi=1200, bbox_extra_artists=(lgd,), bbox_inches='tight')
1
Crystal

ich weiß nicht, ob Sie Ihr Problem bereits gelöst haben ... wahrscheinlich ja, aber ... ich habe einfach die Zeichenfolge 'outside' für die Position verwendet, wie in matlab. Ich habe Pylab aus Matplotlib importiert. siehe den Code wie folgt:

from matplotlib as plt
from matplotlib.font_manager import FontProperties
...
...
t = A[:,0]
sensors = A[:,index_lst]

for i in range(sensors.shape[1]):
    plt.plot(t,sensors[:,i])

plt.xlabel('s')
plt.ylabel('°C')
lgd = plt.legend(b,loc='center left', bbox_to_anchor=(1, 0.5),fancybox = True, shadow = True)

Klicken um die Handlung zu sehen

0
Ziuccia