Como maximizar uma janela plt.show () usando Python

Só por curiosidade gostaria de saber como fazer isso no código abaixo. Tenho procurado uma resposta, mas é 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()

Eu costumo usar

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

antes da chamada para plt.show()e eu obtenho uma janela maximizada. Isso funciona apenas para o back-end 'wx'.

EDITAR:

para backend Qt4Agg, veja a resposta de kwerenda .

Estou em um Windows (WIN7), executando Python 2.7.5 e Matplotlib 1.3.1.

Consegui maximizar as janelas de figura para TkAgg, QT4Agg e wxAgg usando as seguintes linhas:

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 resumo das respostas anteriores (e algumas adições) combinado em um exemplo de trabalho (pelo menos para Windows) ajude. Felicidades

Com o backend Qt (FigureManagerQT), o comando adequado é:

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

Isso faz com que a janela ocupe a tela inteira para mim, no Ubuntu 12.04 com o back-end TkAgg:

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

Para mim, nada do acima funcionou. Eu uso o back-end Tk no Ubuntu 14.04 que contém matplotlib 1.3.1.

O código a seguir cria uma janela de plotagem em tela cheia que não é o mesmo que maximizar, mas atende perfeitamente ao meu propósito:

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

Isso deve funcionar (pelo menos com TkAgg):

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

(adotado acima e usando o Tkinter, há uma maneira de obter o tamanho de tela utilizável sem aumentar visivelmente uma janela? )

Isso é meio hacky e provavelmente não portátil, use-o apenas se estiver procurando algo rápido e sujo. Se eu apenas definir a figura muito maior do que a tela, ele ocupa exatamente a tela inteira.

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

Na verdade, no Ubuntu 16.04 com Qt4Agg, ele maximiza a janela (não em tela inteira) se for maior que a tela. (Se você tiver dois monitores, ele apenas maximiza em um deles).

Encontrei isso para o modo de tela inteira no Ubuntu

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

Eu também entendo mng.frame.Maximize(True) AttributeError: FigureManagerTkAgg instance has no attribute 'frame'.

Então eu olhei através dos atributos mnge encontrei o seguinte:

mng.window.showMaximized()

Isso funcionou para mim.

Portanto, para pessoas que têm o mesmo problema, você pode tentar isso.

A propósito, minha versão do Matplotlib é 1.3.1.

A única solução que funcionou perfeitamente no 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()

Meu melhor esforço até agora, suportando back-ends diferentes:

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)

Pressionar a ftecla (ou ctrl+fem 1.2rc1) quando focado em um gráfico irá exibir uma janela de gráfico em tela cheia. Não totalmente maximizado, mas talvez melhor.

Além disso, para realmente maximizar, você precisará usar comandos específicos do GUI Toolkit (se eles existirem para o seu backend específico).

HTH

Em minhas versões (Python 3.6, Eclipse, Windows 7), os snippets fornecidos acima não funcionaram, mas com dicas fornecidas por Eclipse / pydev (após digitar: mng.), Descobri:

mng.full_screen_toggle()

Parece que usar comandos mng é bom apenas para desenvolvimento local ...

Tente usar o método 'Figure.set_size_inches', com o argumento de palavra-chave extra forward=True. De acordo com a documentação , isso deve redimensionar a janela da figura.

Se isso realmente acontecer, dependerá do sistema operacional que você está usando.

Aqui está uma função baseada na resposta de @Pythonio. Eu o encapsulo em uma função que detecta automaticamente qual backend ele está usando e faço as ações correspondentes.

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

Tente plt.figure(figsize=(6*3.13,4*3.13))tornar o enredo maior.

Ok, então isso é o que funcionou para mim. Eu fiz toda a opção showMaximize () e ela redimensiona sua janela em proporção ao tamanho da figura, mas não expande e 'cabe' na tela. Eu resolvi isso por:

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

plt.show()

Para back-end baseado em Tk (TkAgg), essas duas opções maximizam e exibem em tela inteira a janela:

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

Ao plotar em várias janelas, você precisa escrever isso para cada janela:

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

Aqui, ambas as 'figuras' são plotadas em janelas separadas. Usando uma variável como

figure_manager = plt.get_current_fig_manager()

pode não maximizar a segunda janela, uma vez que a variável ainda se refere à primeira janela.

Isso não maximiza necessariamente sua janela, mas a redimensiona proporcionalmente ao tamanho da 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

Isso também pode ajudar: http://matplotlib.1069221.n5.nabble.com/Resizing-figure-windows-td11424.html

O seguinte pode funcionar com todos os back-ends, mas testei apenas no 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()

Então chame a função maximize()antesplt.show()

Para backend GTK3Agg , use maximize()- principalmente com m minúsculo :

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

Testado no Ubuntu 20.04 com Python 3.8.