Jak zmaksymalizować okno plt.show () za pomocą Pythona

Z ciekawości chciałbym wiedzieć, jak to zrobić w poniższym kodzie. Szukałem odpowiedzi, ale jest bezużyteczna.

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

Zwykle używam

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

przed wywołaniem plt.show()i otrzymuję zmaksymalizowane okno. Działa to tylko dla zaplecza „wx”.

EDYTOWAĆ:

dla zaplecza Qt4Agg, zobacz odpowiedź kwerendy .

Korzystam z systemu Windows (WIN7), używam Pythona 2.7.5 i Matplotlib 1.3.1.

Udało mi się zmaksymalizować okna rysunków dla TkAgg, QT4Agg i wxAgg, używając następujących linii:

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

Mam nadzieję, że to podsumowanie poprzednich odpowiedzi (i niektórych uzupełnień) połączone w roboczym przykładzie (przynajmniej dla Windows) pomoże. Twoje zdrowie

W przypadku zaplecza Qt (FigureManagerQT) właściwe polecenie to:

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

To sprawia, że ​​okno zajmuje dla mnie pełny ekran, pod Ubuntu 12.04 z zapleczem TkAgg:

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

Dla mnie nic z powyższego nie działało. Używam zaplecza Tk na Ubuntu 14.04, który zawiera matplotlib 1.3.1.

Poniższy kod tworzy pełnoekranowe okno wykresu, które nie jest tym samym, co maksymalizacja, ale dobrze służy mojemu celowi:

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

To powinno działać ( przynajmniej z TkAgg):

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

(przyjęty z powyższego i używając Tkinter, czy istnieje sposób na uzyskanie użytecznego rozmiaru ekranu bez widocznego powiększania okna? )

Jest to trochę hacky i prawdopodobnie nie jest przenośny, używaj go tylko, jeśli szukasz szybkiego i brudnego. Jeśli ustawię liczbę znacznie większą niż ekran, zajmie to dokładnie cały ekran.

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

W rzeczywistości w Ubuntu 16.04 z Qt4Agg maksymalizuje okno (nie pełnoekranowe), jeśli jest większe niż ekran. (Jeśli masz dwa monitory, po prostu maksymalizuje to na jednym z nich).

Znalazłem to dla trybu pełnoekranowego na Ubuntu

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

Ja mng.frame.Maximize(True) AttributeError: FigureManagerTkAgg instance has no attribute 'frame'też.

Następnie przejrzałem atrybuty mngi znalazłem to:

mng.window.showMaximized()

To zadziałało dla mnie.

Więc dla ludzi, którzy mają te same problemy, możesz spróbować tego.

Nawiasem mówiąc, moja wersja Matplotlib to 1.3.1.

Jedyne rozwiązanie, które działało bezbłędnie w 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()

Mój najlepszy dotychczasowy wysiłek, wspieranie różnych backendów:

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)

Naciśnięcie fklawisza (lub ctrl+fw 1.2rc1), gdy jest skupiony na wykresie, spowoduje wyświetlenie pełnego ekranu okna wykresu. Niezupełnie maksymalizujące, ale być może lepsze.

Poza tym, aby faktycznie zmaksymalizować, będziesz musiał użyć specyficznych poleceń GUI Toolkit (jeśli istnieją dla twojego konkretnego zaplecza).

HTH

W moich wersjach (Python 3.6, Eclipse, Windows 7) podane powyżej fragmenty nie działały, ale z podpowiedziami podanymi przez Eclipse / pydev (po wpisaniu: mng.) Znalazłem:

mng.full_screen_toggle()

Wygląda na to, że używanie poleceń mng jest w porządku tylko do lokalnego programowania ...

Spróbuj użyć metody „Figure.set_size_inches” z dodatkowym argumentem słowa kluczowego forward=True. Zgodnie z dokumentacją powinno to zmienić rozmiar okna rysunku.

To, czy tak się stanie, będzie zależeć od używanego systemu operacyjnego.

Oto funkcja oparta na odpowiedzi @ Pythonio. Hermetyzuję to w funkcji, która automatycznie wykrywa, z którego zaplecza korzysta i wykonuje odpowiednie czynności.

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

Spróbuj plt.figure(figsize=(6*3.13,4*3.13))powiększyć fabułę.

Ok, więc to działa dla mnie. Zrobiłem całą opcję showMaximize () i zmienia rozmiar okna proporcjonalnie do rozmiaru figury, ale nie rozszerza się i nie „dopasowuje” do płótna. Rozwiązałem to przez:

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

plt.show()

W przypadku backendu opartego na Tk (TkAgg) te dwie opcje maksymalizują & pełnoekranowe okno:

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

Podczas drukowania w wielu oknach musisz napisać to dla każdego okna:

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

Tutaj obie „figury” są kreślone w osobnych oknach. Korzystanie ze zmiennej, takiej jak

figure_manager = plt.get_current_fig_manager()

może nie maksymalizować drugiego okna, ponieważ zmienna nadal odnosi się do pierwszego okna.

To niekoniecznie maksymalizuje okno, ale zmienia rozmiar okna proporcjonalnie do rozmiaru figury:

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

Może to również pomóc: http://matplotlib.1069221.n5.nabble.com/Resizing-figure-windows-td11424.html

Poniższe mogą działać ze wszystkimi backendami, ale testowałem to tylko na 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()

Następnie wywołaj funkcję maximize()wcześniejplt.show()

W przypadku backendu GTK3Agg użyj maximize()- szczególnie z małymi literami m :

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

Testowane w Ubuntu 20.04 z Pythonem 3.8.