Jak usunąć legendę z fabuły

Istnieje wiele sposobów, aby zrobić to, co chcesz. Aby dodać do tego, co już powiedzieli @inalis i @Navi, możesz użyć argumentu słowa kluczowego bbox_to_anchor, aby umieścić legendę częściowo poza osiami i / lub zmniejszyć rozmiar czcionki.

Zanim rozważysz zmniejszenie rozmiaru czcionki (co może utrudnić czytanie), spróbuj pogrywać z umieszczaniem legendy w różnych miejscach:

Zacznijmy więc od ogólnego przykładu:

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()

Jeśli zrobimy to samo, ale używając argumentu bbox_to_anchor możemy przesunąć legendę nieco poza granice osi:

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()

Podobnie, możesz zrobić legendę bardziej poziomą i/lub umieścić ją na górze figury (włączam również zaokrąglone rogi i prosty cień):

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()

Alternatywnie można zmniejszyć szerokość aktualnego wykresu i umieścić legendę całkowicie poza osią rysunku:

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()

I w podobnym sposób, można zmniejszyć fabułę w pionie i umieścić poziomą legendę na dole:

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()

Umieszczenie legendy (bbox_to_anchor)

Legenda jest umieszczana wewnątrz obwiedni osi za pomocą argumentu loc, aby plt.legend.
Na przykład loc="upper right" umieszcza legendę w prawym górnym rogu obwiedni, która domyślnie rozciąga się od (0,0) do (1,1) we współrzędnych osi (lub w notacji obwiedni (x0,y0, width, height)=(0,0,1,1)).

Aby umieścić legendę poza obwiednią osi, można określić krotkę (x0,y0) współrzędnych osi lewego dolnego rogu legenda.

plt.legend(loc=(1.04,0))

Jednak bardziej wszechstronnym podejściem byłoby ręczne określenie obwiedni, w której powinna być umieszczona legenda, za pomocą bbox_to_anchor kłótnia. Można ograniczyć się do dostarczania tylko (x0,y0) części bbox. Tworzy to pole zerowej rozpiętości, z którego legenda rozszerzy się w kierunku podanym przez argument loc. Np.

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

Umieszcza legendę poza osiami, tak aby lewy górny róg legenda znajduje się na pozycji (1.04,1) we współrzędnych osi.

Dalsze przykłady podano poniżej, gdzie dodatkowo pokazane są wzajemne zależności między różnymi argumentami, takimi jak mode i ncols.

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")

Szczegóły jak zinterpretować argument 4-krotki na bbox_to_anchor, jak w l4, można znaleźć w to pytanie. mode="expand" rozszerza legendę poziomo wewnątrz obwiedni podanej przez 4 krotkę. W celu zapoznania się z rozszerzoną pionowo legendą zobacz to pytanie .

Czasami może być przydatne określenie obwiedni w współrzędnych rysunku zamiast współrzędnych osi. Jest to pokazane w przykładzie l5 z góry, gdzie argument bbox_transform jest używany do umieszczenia legendy w lewym dolnym rogu rysunku.

]}

Umieszczenie legendy poza osiami często prowadzi do niepożądanej sytuacji, że jest ona całkowicie lub częściowo poza płótnem postaci.

Rozwiązania do ten problem to:

• Dostosuj parametry podprogramu
  Parametry podprogramu można tak dostosować, aby osie zajmowały mniej miejsca wewnątrz figury (a tym samym pozostawiały więcej miejsca legendzie) za pomocą plt.subplots_adjust. Np.

  plt.subplots_adjust(right=0.7)
  

  Pozostawia 30% miejsca po prawej stronie figury, gdzie można umieścić legendę.

• Tight layout
  Za pomocą plt.tight_layout pozwala na automatyczną regulację parametry podprogramu takie, że elementy na rysunku przylegają do krawędzi rysunku. Niestety legenda nie jest brana pod uwagę w tym automatyzmie, ale możemy dostarczyć prostokątne pudełko, do którego zmieści się cały obszar podprogramów (w tym etykiety).

  plt.tight_layout(rect=[0,0,0.75,1])
  

• Zapisywanie figury z bbox_inches = "tight"
  Argument bbox_inches = "tight" do plt.savefig można użyć do zapisania figury tak, aby wszyscy artyści na płótnie (w tym legenda) zmieścili się w zapisanym miejsce. W razie potrzeby rozmiar figury jest automatycznie dostosowywany.

  plt.savefig("output.png", bbox_inches="tight")
  

• automatyczna regulacja podprogramów
  Sposób na automatyczne dopasowanie pozycji podpłytki tak, aby legenda zmieściła się wewnątrz płótna bez zmiany rozmiaru figury można znaleźć w tej odpowiedzi: Tworzenie figury o dokładnym rozmiarze i bez wypełnienia (i legendy poza osiami)

Porównanie przypadków omówionych powyżej:

Alternatywy

Legenda postaci
Można użyć legendy do postaci zamiast osi, matplotlib.figure.Figure.legend. Stało się to szczególnie przydatne w przypadku wersji matplotlib > = 2.1, gdzie nie są potrzebne żadne specjalne argumenty

fig.legend(loc=7) 

Stworzyć legendę dla wszystkich artystów w różnych osiach figury. Legenda jest umieszczana za pomocą argumentu loc, podobnego do tego, jak jest umieszczona wewnątrz osi, ale w odniesieniu do cała postać - stąd będzie ona poza osiami nieco automatycznie. Pozostaje tylko wyregulować podpowiedzi tak, aby nie zachodziła na siebie legenda i osie. Tutaj pomocny będzie punkt "dostosuj parametry podprogramu" z góry. Przykład:

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()

Legenda wewnątrz dedykowanych osi subplot
Alternatywą dla użycia bbox_to_anchor byłoby umieszczenie legendy w jej dedykowanych osiach podplotowych (lax). Ponieważ podrozdział legendy powinien być mniejszy od fabuły, możemy użyć gridspec_kw={"width_ratios":[4,1]} przy tworzeniu osi. Możemy ukryć osie lax.axis("off"), ale i tak umieścimy tam legendę. Legenda i etykiety muszą być pozyskane z prawdziwego wykresu przez h,l = ax.get_legend_handles_labels(), a następnie mogą być dostarczone do legendy w podrozdziale lax, lax.legend(h,l). Pełny przykład znajduje się poniżej.

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()

Możemy również użyć pierwszych osi do należy umieścić legendę, ale użyć bbox_transform toporów legendy,

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

W tym podejściu nie musimy uzyskiwać zewnętrznych uchwytów legend, ale musimy określić argument bbox_to_anchor.

Dalsze czytanie i uwagi:

• rozważ matplotlib przewodnik po legendach z przykładami innych rzeczy, które chcesz zrobić z legendami.
• przykładowy kod do umieszczania legend na wykresach kołowych można znaleźć bezpośrednio w odpowiedzi na to pytanie: Python - Legenda pokrywa się z wykresem kołowym
• argument loc może przyjmować liczby zamiast ciągów znaków, które skracają wywołania, jednak nie są one zbyt intuicyjnie odwzorowywane do siebie. Oto mapowanie dla odniesienia:

Jeśli używasz funkcji wrapper Pandas plot() i chcesz umieścić legendę Na Zewnątrz, oto bardzo prosty sposób:

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

Po prostu łączymy legend() wywołanie po plot().

Wyniki wyglądałyby mniej więcej tak:

Krótka odpowiedź: możesz użyć bbox_to_anchor + bbox_extra_artists + bbox_inches='tight'.

Dłuższa odpowiedź: Możesz użyć bbox_to_anchor, aby ręcznie określić lokalizację pola legendy, jak wskazywały inne osoby w odpowiedziach.

Jednak zwykle problem polega na tym, że pole legendy jest przycięte, np.:

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')

Aby zapobiec przycinaniu pola legendy, podczas zapisywania figury możesz użyć parametrów bbox_extra_artists i bbox_inches, aby poprosić savefig o przycinanie elementy w zapisanym obrazku:

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

Przykład (zmieniłem tylko ostatnią linijkę aby dodać 2 parametry do fig.savefig()):

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')

Chciałbym, aby matplotlib natywnie zezwalał na zewnętrzne umiejscowienie pudełka legendy, ponieważ Matlab robi :

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])

Krótka odpowiedź : wywołaj przeciąganie na legendę i interaktywnie przesuwaj ją, gdzie chcesz:

ax.legend().draggable()

Długa odpowiedź: Jeśli wolisz umieścić legendę interaktywnie / ręcznie, a nie programowo, możesz przełączać tryb przeciągania legendy, dzięki czemu możesz przeciągać ją w dowolne miejsce. Sprawdź poniższy przykład:

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()

Oprócz wszystkich doskonałych odpowiedzi tutaj, nowsze wersje matplotlib i pylab mogą automatycznie określić, gdzie umieścić legendę bez ingerowania w fabułę.

pylab.legend(loc='best')

To automatycznie umieści legendę poza fabułą!

Aby umieścić legendę poza obszarem wykresu, użyj słów kluczowych Loc i bbox_to_anchor z legend(). Na przykład następujący kod umieści legendę po prawej stronie obszaru wykresu:

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

Aby uzyskać więcej informacji, zobacz legend guide

Nie dokładnie to, o co prosiłeś, ale znalazłem alternatywę dla tego samego problemu. Uczynić legendę półprzezroczystą, w ten sposób:

Zrób to z:

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)

Jak wspomniano, można również umieścić legendę w fabule, lub nieco od niej do krawędzi, jak również. Poniżej znajduje się przykład użycia Plotly Python API, wykonanego z notebooka IPython. Jestem w drużynie.

Aby rozpocząć, należy zainstalować niezbędne pakiety:

import plotly
import math
import random
import numpy as np

Następnie zainstaluj 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)

To tworzy twój wykres i pozwala Ci zachować legendę wewnątrz samej fabuły. Domyślną wartością dla legendy, jeśli nie jest ustawiona, jest umieść go na działce, jak pokazano tutaj.

Aby uzyskać alternatywną lokalizację, możesz dokładnie wyrównać krawędź wykresu i obramowanie legendy, a także usunąć linie obramowania, aby dopasować je bliżej.

Możesz przenieść I zmienić styl legendy i wykresu za pomocą kodu lub GUI. Aby przesunąć legendę, możesz ustawić legendę wewnątrz wykresu, przypisując wartości X i y

• {"x" : 0,"y" : 0} -- Dolny Lewy
• {"x" : 1, "y" : 0} -- Prawy Dolny
• {"x" : 1, "y" : 1} -- Prawy Górny Róg
• {"x" : 0, "y" : 1} -- Lewy Górny
• {"x" :.5, "y" : 0} -- Bottom Center
• {"x": .5, "y" : 1} -- Top Center

W tym przypadku wybieramy prawy górny róg, legendstyle = {"x" : 1, "y" : 1}, również opisany w dokumentacji :

Coś w tym stylu zadziałało na mnie. Począwszy od kodu zaczerpniętego z Joe, ta metoda zmienia szerokość okna, aby automatycznie dopasować legendę po prawej stronie rysunku.

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()

Możesz również spróbować figlegend. Możliwe jest tworzenie legendy niezależnie od dowolnego obiektu osi. Może być jednak konieczne utworzenie "atrapy" ścieżek, aby upewnić się, że formatowanie obiektów jest przekazywane poprawnie.

Oto przykład z tutoriala matplotlib znalezionego tutaj . Jest to jeden z prostszych przykładów, ale dodałem przezroczystość do legendy i dodałem plt.show() więc możesz wkleić to do interaktywnej powłoki i uzyskać wynik:

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()

Rozwiązaniem, które działało dla mnie, gdy miałem ogromną legendę, było użycie dodatkowego pustego układu graficznego. W poniższym przykładzie zrobiłem 4 wiersze i na dole rysuję obraz z offsetem dla legendy (bbox_to_anchor) na górze nie dostaje cięcia.

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')

Oto inne rozwiązanie, podobne do dodawania bbox_extra_artists i bbox_inches, gdzie nie musisz mieć dodatkowych artystów w zakresie połączenia savefig. Wymyśliłem to, ponieważ generuję większość mojej fabuły wewnątrz funkcji.

Zamiast dodawać wszystkie dodatki do obwiedni, gdy chcesz je zapisać, możesz dodać je wcześniej do artystów Figure. Używając czegoś podobnego do odpowiedzi Francka Dernoncourta powyżej :

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")

Oto wygenerowany fabuła

Nie wiem, czy już rozwiązałeś swój problem...pewnie tak, ale... Po prostu użyłem ciągu "Na zewnątrz" dla lokalizacji, jak w matlab. Importowałem pylab z matplotlib. zobacz następujący kod:

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)

Kliknij aby zobaczyć wykres