Come massimizzare una finestra plt.show () usando Python

Tanto per curiosità vorrei sapere come farlo nel codice sottostante. Ho cercato una risposta ma è inutile.

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

Di solito uso

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

prima della chiamata a plt.show(), e ottengo una finestra ingrandita. Funziona solo per il backend "wx".

MODIFICARE:

per il backend Qt4Agg, vedi la risposta di kwerenda .

Sono su un Windows (WIN7), con Python 2.7.5 e Matplotlib 1.3.1.

Sono stato in grado di massimizzare le finestre delle figure per TkAgg, QT4Agg e wxAgg usando le seguenti linee:

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

Spero che questo riepilogo delle risposte precedenti (e alcune aggiunte) combinate in un esempio funzionante (almeno per Windows) aiuti. Saluti

Con il backend Qt (FigureManagerQT) il comando corretto è:

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

Questo fa sì che la finestra occupi l'intero schermo per me, sotto Ubuntu 12.04 con il backend TkAgg:

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

Per me niente di quanto sopra ha funzionato. Uso il backend Tk su Ubuntu 14.04 che contiene matplotlib 1.3.1.

Il codice seguente crea una finestra di trama a schermo intero che non è la stessa della massimizzazione ma serve bene al mio scopo:

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

Questo dovrebbe funzionare ( almeno con TkAgg):

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

(adottato da quanto sopra e utilizzando Tkinter, c'è un modo per ottenere la dimensione dello schermo utilizzabile senza ingrandire visibilmente una finestra? )

Questo è un po 'hacky e probabilmente non portatile, usalo solo se stai cercando veloce e sporco. Se imposto solo la figura molto più grande dello schermo, occupa esattamente l'intero schermo.

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

Infatti, in Ubuntu 16.04 con Qt4Agg, massimizza la finestra (non a schermo intero) se è più grande dello schermo. (Se hai due monitor, lo massimizza solo su uno di essi).

L'ho trovato per la modalità a schermo intero su Ubuntu

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

Lo capisco anche io mng.frame.Maximize(True) AttributeError: FigureManagerTkAgg instance has no attribute 'frame'.

Quindi ho esaminato gli attributi mnge ho trovato questo:

mng.window.showMaximized()

Ha funzionato per me.

Quindi, per le persone che hanno gli stessi problemi, puoi provare questo.

A proposito, la mia versione di Matplotlib è 1.3.1.

L'unica soluzione che ha funzionato perfettamente su Win 10.

import matplotlib.pyplot as plt

plt.plot(x_data, y_data)

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

Il mio miglior sforzo finora, supportando diversi backend:

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)

Premendo il ftasto (octrl+f in 1.2rc1) quando ci si concentra su un grafico, la finestra del grafico verrà visualizzata a schermo intero. Non del tutto massimizzante, ma forse migliore.

Oltre a questo, per massimizzare effettivamente, dovrai utilizzare i comandi specifici di GUI Toolkit (se esistono per il tuo backend specifico).

HTH

Nelle mie versioni (Python 3.6, Eclipse, Windows 7), gli snippet forniti sopra non funzionavano, ma con i suggerimenti forniti da Eclipse / pydev (dopo aver digitato: mng.), Ho trovato:

mng.full_screen_toggle()

Sembra che l'uso di mng-commands sia ok solo per lo sviluppo locale ...

Prova a utilizzare il metodo "Figure.set_size_inches", con l'argomento parola chiave aggiuntivo forward=True. Secondo la documentazione , questo dovrebbe ridimensionare la finestra della figura.

Se ciò accadrà effettivamente dipenderà dal sistema operativo che stai utilizzando.

Ecco una funzione basata sulla risposta di @ Pythonio. Lo incapsulano in una funzione che rileva automaticamente quale backend sta utilizzando e fa le azioni corrispondenti.

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

Prova plt.figure(figsize=(6*3.13,4*3.13))a ingrandire la trama.

Ok, quindi questo è ciò che ha funzionato per me. Ho scelto l'intera opzione showMaximize () e ridimensiona la finestra in proporzione alle dimensioni della figura, ma non si espande e "si adatta" alla tela. Ho risolto questo problema:

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

plt.show()

Questo non massimizza necessariamente la tua finestra, ma ridimensiona la tua finestra in proporzione alla dimensione della figura:

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

Questo potrebbe anche aiutare: http://matplotlib.1069221.n5.nabble.com/Resizing-figure-windows-td11424.html

Quanto segue potrebbe funzionare con tutti i backend, ma l'ho testato solo su QT:

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

Quindi chiama la funzione maximize()primaplt.show()

Per il backend GTK3Agg , usa maximize()- in particolare con una m minuscola :

manager = plt.get_current_fig_manager()
manager.window.maximize()

Testato in Ubuntu 20.04 con Python 3.8.

Per il backend basato su Tk (TkAgg), queste due opzioni massimizzano la finestra a schermo intero:

plt.get_current_fig_manager().window.state('zoomed')
plt.get_current_fig_manager().window.attributes('-fullscreen', True)

Quando si stampa in più finestre, è necessario scrivere questo per ogni finestra:

data = rasterio.open(filepath)

blue, green, red, nir = data.read()
plt.figure(1)
plt.subplot(121); plt.imshow(blue);
plt.subplot(122); plt.imshow(red);
plt.get_current_fig_manager().window.state('zoomed')

rgb = np.dstack((red, green, blue))
nrg = np.dstack((nir, red, green))
plt.figure(2)
plt.subplot(121); plt.imshow(rgb);
plt.subplot(122); plt.imshow(nrg);
plt.get_current_fig_manager().window.state('zoomed')

plt.show()

Qui, entrambe le "figure" sono tracciate in finestre separate. Utilizzando una variabile come

figure_manager = plt.get_current_fig_manager()

potrebbe non massimizzare la seconda finestra, poiché la variabile si riferisce ancora alla prima finestra.