Cómo maximizar una ventana plt.show () usando Python

Solo por curiosidad, me gustaría saber cómo hacer esto en el siguiente código. He estado buscando una respuesta pero es inútil.

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

Yo suelo usar

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

antes de la llamada a plt.show(), y obtengo una ventana maximizada. Esto funciona solo para el backend 'wx'.

EDITAR:

para el backend de Qt4Agg, consulte la respuesta de kwerenda .

Estoy en Windows (WIN7), ejecutando Python 2.7.5 y Matplotlib 1.3.1.

Pude maximizar las ventanas de Figura para TkAgg, QT4Agg y wxAgg usando las siguientes líneas:

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

Espero que este resumen de las respuestas anteriores (y algunas adiciones) combinado en un ejemplo funcional (al menos para Windows) ayude. Salud

Con Qt backend (FigureManagerQT), el comando adecuado es:

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

Esto hace que la ventana ocupe la pantalla completa para mí, en Ubuntu 12.04 con el backend de TkAgg:

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

Para mí, nada de lo anterior funcionó. Utilizo el backend de Tk en Ubuntu 14.04 que contiene matplotlib 1.3.1.

El siguiente código crea una ventana de gráfico de pantalla completa que no es lo mismo que maximizar, pero sirve muy bien para mi propósito:

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

Esto debería funcionar (al menos con TkAgg):

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

(adoptado de lo anterior y usando Tkinter, ¿hay alguna manera de obtener el tamaño de pantalla utilizable sin hacer zoom visible en una ventana? )

Esto es un poco hacky y probablemente no sea portátil, solo utilícelo si lo que busca es rápido y sucio. Si configuro la figura mucho más grande que la pantalla, ocupa exactamente toda la pantalla.

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

De hecho, en Ubuntu 16.04 con Qt4Agg, maximiza la ventana (no la pantalla completa) si es más grande que la pantalla. (Si tiene dos monitores, simplemente lo maximiza en uno de ellos).

Encontré esto para el modo de pantalla completa en Ubuntu

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

Yo mng.frame.Maximize(True) AttributeError: FigureManagerTkAgg instance has no attribute 'frame'también.

Luego miré a través de los atributos mngtiene y encontré esto:

mng.window.showMaximized()

Eso funcionó para mí.

Entonces, para las personas que tienen el mismo problema, pueden probar esto.

Por cierto, mi versión de Matplotlib es 1.3.1.

La única solución que funcionó perfectamente en 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()

Mi mejor esfuerzo hasta ahora, apoyando diferentes backends:

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)

Al presionar la ftecla (o ctrl+fen 1.2rc1) cuando se enfoca en un gráfico, aparecerá una ventana de gráfico en pantalla completa. No maximizando, pero quizás mejor.

Aparte de eso, para maximizar realmente, necesitará usar comandos específicos de GUI Toolkit (si existen para su backend específico).

HTH

En mis versiones (Python 3.6, Eclipse, Windows 7), los fragmentos dados anteriormente no funcionaron, pero con las sugerencias dadas por Eclipse / pydev (después de escribir: mng.), Encontré:

mng.full_screen_toggle()

Parece que usar mng-commands está bien solo para el desarrollo local ...

Intente usar el método 'Figure.set_size_inches', con el argumento de palabra clave adicional forward=True. Según la documentación , esto debería cambiar el tamaño de la ventana de la figura.

Que eso suceda realmente dependerá del sistema operativo que esté utilizando.

Aquí hay una función basada en la respuesta de @ Pythonio. Lo encapsulo en una función que detecta automáticamente qué backend está usando y realiza las acciones correspondientes.

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

Intenta plt.figure(figsize=(6*3.13,4*3.13))hacer la trama más grande.

Ok, esto es lo que funcionó para mí. Hice toda la opción showMaximize () y cambia el tamaño de la ventana en proporción al tamaño de la figura, pero no se expande ni se "ajusta" al lienzo. Resolví esto por:

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

plt.show()

Esto no maximiza necesariamente su ventana, pero cambia el tamaño de su ventana en proporción al tamaño de la 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

Esto también podría ayudar: http://matplotlib.1069221.n5.nabble.com/Resizing-figure-windows-td11424.html

Lo siguiente puede funcionar con todos los backends, pero lo probé solo en 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()

Luego llame a la función maximize()antesplt.show()

Para el backend GTK3Agg , use maximize(), especialmente con una m minúscula :

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

Probado en Ubuntu 20.04 con Python 3.8.

Para el backend basado en Tk (TkAgg), estas dos opciones maximizan y pantalla completa la ventana:

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

Al trazar en varias ventanas, debe escribir esto para cada ventana:

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

Aquí, ambas 'figuras' están trazadas en ventanas separadas. Usando una variable como

figure_manager = plt.get_current_fig_manager()

es posible que no maximice la segunda ventana, ya que la variable aún se refiere a la primera ventana.