So maximieren Sie ein plt.show () -Fenster mit Python

Nur aus Neugier möchte ich im folgenden Code wissen, wie das geht. Ich habe nach einer Antwort gesucht, bin aber nutzlos.

import numpy as np
import matplotlib.pyplot as plt
data=np.random.exponential(scale=180, size=10000)
print ('el valor medio de la distribucion exponencial es: ')
print np.average(data)
plt.hist(data,bins=len(data)**0.5,normed=True, cumulative=True, facecolor='red', label='datos tamano paqutes acumulativa', alpha=0.5)
plt.legend()
plt.xlabel('algo')
plt.ylabel('algo')
plt.grid()
plt.show()

Ich benutze normalerweise

mng = plt.get_current_fig_manager()
mng.frame.Maximize(True)

vor dem Anruf an plt.show() , und ich bekomme ein maximiertes Fenster. Dies funktioniert nur für das Backend 'wx'.

BEARBEITEN:

Informationen zum Qt4Agg-Backend finden Sie in der Antwort von kwerenda .

Ich arbeite unter Windows (WIN7) mit Python 2.7.5 und Matplotlib 1.3.1.

Ich konnte die Figurenfenster für TkAgg, QT4Agg und wxAgg mithilfe der folgenden Zeilen maximieren:

from matplotlib import pyplot as plt

### for 'TkAgg' backend
plt.figure(1)
plt.switch_backend('TkAgg') #TkAgg (instead Qt4Agg)
print '#1 Backend:',plt.get_backend()
plt.plot([1,2,6,4])
mng = plt.get_current_fig_manager()
### works on Ubuntu??? >> did NOT working on windows
# mng.resize(*mng.window.maxsize())
mng.window.state('zoomed') #works fine on Windows!
plt.show() #close the figure to run the next section

### for 'wxAgg' backend
plt.figure(2)
plt.switch_backend('wxAgg')
print '#2 Backend:',plt.get_backend()
plt.plot([1,2,6,4])
mng = plt.get_current_fig_manager()
mng.frame.Maximize(True)
plt.show() #close the figure to run the next section

### for 'Qt4Agg' backend
plt.figure(3)
plt.switch_backend('QT4Agg') #default on my system
print '#3 Backend:',plt.get_backend()
plt.plot([1,2,6,4])
figManager = plt.get_current_fig_manager()
figManager.window.showMaximized()
plt.show()

Ich hoffe, diese Zusammenfassung der vorherigen Antworten (und einiger Ergänzungen) in einem Arbeitsbeispiel (zumindest für Windows) hilft. Prost

Mit dem Qt-Backend (FigureManagerQT) lautet der richtige Befehl:

figManager = plt.get_current_fig_manager()
figManager.window.showMaximized()

Dadurch nimmt das Fenster unter Ubuntu 12.04 mit dem TkAgg-Backend für mich den Vollbildmodus ein:

    mng = plt.get_current_fig_manager()
    mng.resize(*mng.window.maxsize())

Für mich hat nichts davon funktioniert. Ich benutze das Tk-Backend unter Ubuntu 14.04, das matplotlib 1.3.1 enthält.

Der folgende Code erstellt ein Vollbild-Plotfenster, das nicht mit Maximieren identisch ist, aber meinen Zweck erfüllt:

from matplotlib import pyplot as plt
mng = plt.get_current_fig_manager()
mng.full_screen_toggle()
plt.show()

Dies sollte funktionieren ( zumindest mit TkAgg):

wm = plt.get_current_fig_manager()
wm.window.state('zoomed')

( Wie oben beschrieben und unter Verwendung von Tkinter, gibt es eine Möglichkeit, die verwendbare Bildschirmgröße zu erhalten, ohne ein Fenster sichtbar zu zoomen? )

Dies ist eine Art Hacky und wahrscheinlich nicht tragbar. Verwenden Sie es nur, wenn Sie schnell und schmutzig suchen. Wenn ich die Figur nur viel größer als den Bildschirm einstelle, nimmt sie genau den gesamten Bildschirm ein.

fig = figure(figsize=(80, 60))

In Ubuntu 16.04 mit Qt4Agg wird das Fenster maximiert (nicht im Vollbildmodus), wenn es größer als der Bildschirm ist. (Wenn Sie zwei Monitore haben, wird diese nur auf einem von ihnen maximiert.)

Ich fand dies für den Vollbildmodus unter Ubuntu

#Show full screen
mng = plt.get_current_fig_manager()
mng.full_screen_toggle()

Ich verstehe mng.frame.Maximize(True) AttributeError: FigureManagerTkAgg instance has no attribute 'frame'auch.

Dann habe ich die Attribute durchgesehen mngund dabei Folgendes gefunden:

mng.window.showMaximized()

Das hat bei mir funktioniert.

Für Leute, die die gleichen Probleme haben, können Sie dies versuchen.

Meine Matplotlib-Version ist übrigens 1.3.1.

Meine bisher besten Bemühungen, verschiedene Backends zu unterstützen:

from platform import system
def plt_maximize():
    # See discussion: /programming/12439588/how-to-maximize-a-plt-show-window-using-python
    backend = plt.get_backend()
    cfm = plt.get_current_fig_manager()
    if backend == "wxAgg":
        cfm.frame.Maximize(True)
    elif backend == "TkAgg":
        if system() == "win32":
            cfm.window.state('zoomed')  # This is windows only
        else:
            cfm.resize(*cfm.window.maxsize())
    elif backend == 'QT4Agg':
        cfm.window.showMaximized()
    elif callable(getattr(cfm, "full_screen_toggle", None)):
        if not getattr(cfm, "flag_is_max", None):
            cfm.full_screen_toggle()
            cfm.flag_is_max = True
    else:
        raise RuntimeError("plt_maximize() is not implemented for current backend:", backend)

Durch Drücken der fTaste (oder ctrl+fin 1.2rc1), wenn Sie sich auf ein Diagramm konzentrieren, wird ein Diagrammfenster im Vollbildmodus angezeigt. Nicht ganz maximierend, aber vielleicht besser.

Um dies tatsächlich zu maximieren, müssen Sie GUI Toolkit-spezifische Befehle verwenden (sofern diese für Ihr spezifisches Backend vorhanden sind).

HTH

Die einzige Lösung, die unter Win 10 einwandfrei funktioniert hat.

import matplotlib.pyplot as plt

plt.plot(x_data, y_data)

mng = plt.get_current_fig_manager()
mng.window.state("zoomed")
plt.show()

In meinen Versionen (Python 3.6, Eclipse, Windows 7) funktionierten die oben angegebenen Snippets nicht, aber mit Hinweisen von Eclipse / pydev (nach Eingabe von: mng.) Fand ich Folgendes:

mng.full_screen_toggle()

Es scheint, dass die Verwendung von mng-Befehlen nur für die lokale Entwicklung in Ordnung ist ...

Versuchen Sie es mit der Methode 'Figure.set_size_inches' mit dem zusätzlichen Schlüsselwortargument forward=True. Laut Dokumentation sollte dies so sein die Figur Fenstergröße ändern.

Ob dies tatsächlich geschieht, hängt vom verwendeten Betriebssystem ab.

Hier ist eine Funktion, die auf der Antwort von @ Pythonio basiert. Ich kapsle es in eine Funktion, die automatisch erkennt, welches Backend es verwendet, und führe die entsprechenden Aktionen aus.

def plt_set_fullscreen():
    backend = str(plt.get_backend())
    mgr = plt.get_current_fig_manager()
    if backend == 'TkAgg':
        if os.name == 'nt':
            mgr.window.state('zoomed')
        else:
            mgr.resize(*mgr.window.maxsize())
    elif backend == 'wxAgg':
        mgr.frame.Maximize(True)
    elif backend == 'Qt4Agg':
        mgr.window.showMaximized()

Versuchen Sie plt.figure(figsize=(6*3.13,4*3.13)), die Handlung größer zu machen.

Ok, das hat bei mir funktioniert. Ich habe die gesamte Option showMaximize () verwendet und die Größe Ihres Fensters wird proportional zur Größe der Figur geändert, aber die Leinwand wird nicht erweitert und "angepasst". Ich habe das gelöst durch:

mng = plt.get_current_fig_manager()                                         
mng.window.showMaximized()
plt.tight_layout()    
plt.savefig('Images/SAVES_PIC_AS_PDF.pdf') 

plt.show()

Dies maximiert nicht unbedingt Ihr Fenster, ändert jedoch die Größe Ihres Fensters proportional zur Größe der Abbildung:

from matplotlib import pyplot as plt
F = gcf()
Size = F.get_size_inches()
F.set_size_inches(Size[0]*2, Size[1]*2, forward=True)#Set forward to True to resize window along with plot in figure.
plt.show() #or plt.imshow(z_array) if using an animation, where z_array is a matrix or numpy array

Dies kann auch hilfreich sein: http://matplotlib.1069221.n5.nabble.com/Resizing-figure-windows-td11424.html

Folgendes funktioniert möglicherweise mit allen Backends, aber ich habe es nur auf QT getestet:

import numpy as np
import matplotlib.pyplot as plt
import time

plt.switch_backend('QT4Agg') #default on my system
print('Backend: {}'.format(plt.get_backend()))

fig = plt.figure()
ax = fig.add_axes([0,0, 1,1])
ax.axis([0,10, 0,10])
ax.plot(5, 5, 'ro')

mng = plt._pylab_helpers.Gcf.figs.get(fig.number, None)

mng.window.showMaximized() #maximize the figure
time.sleep(3)
mng.window.showMinimized() #minimize the figure
time.sleep(3)
mng.window.showNormal() #normal figure
time.sleep(3)
mng.window.hide() #hide the figure
time.sleep(3)
fig.show() #show the previously hidden figure

ax.plot(6,6, 'bo') #just to check that everything is ok
plt.show()

import matplotlib.pyplot as plt
def maximize():
    plot_backend = plt.get_backend()
    mng = plt.get_current_fig_manager()
    if plot_backend == 'TkAgg':
        mng.resize(*mng.window.maxsize())
    elif plot_backend == 'wxAgg':
        mng.frame.Maximize(True)
    elif plot_backend == 'Qt4Agg':
        mng.window.showMaximized()

Rufen Sie dann maximize()vorher die Funktion aufplt.show()