web-dev-qa-db-fra.com

Comment maximiser une fenêtre plt.show () en utilisant Python

Juste par curiosité, je voudrais savoir comment faire cela dans le code ci-dessous. Je cherchais une réponse mais cela ne sert à rien.

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()
pythonmatplotlib
61
Santiago Lovera

J'utilise habituellement

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

avant l'appel à plt.show(), et j'obtiens une fenêtre maximisée. Cela ne fonctionne que pour le backend 'wx'.

MODIFIER:

pour le backend Qt4Agg, voir répondre de kwerenda.

26
gg349

comme je suis sur une réputation zéro, je ne peux laisser aucune autre marque qu'une nouvelle réponse Je suis sous Windows (WIN7), sous Python 2.7.5 & Matplotlib 1.3.1.

J'ai été en mesure de maximiser les fenêtres Figure pour TkAgg, QT4Agg et wxAgg en utilisant les lignes suivantes:

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

J'espère que ce résumé des réponses précédentes (et quelques ajouts) combinés dans un exemple de travail (au moins pour Windows) peut vous aider .

110
Pythonio

Avec Qt backend (FigureManagerQT), la commande appropriée est la suivante:

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

Cela me fait passer la fenêtre en plein écran, sous Ubuntu 12.04 avec le backend TkAgg:

    mng = plt.get_current_fig_manager()
    mng.resize(*mng.window.maxsize())
32
Dan Christensen

Pour moi, rien de ce qui précède n'a fonctionné. J'utilise le backend Tk sur Ubuntu 14.04 qui contient matplotlib 1.3.1.

Le code suivant crée une fenêtre de tracé en plein écran qui n’est pas identique à la maximisation, mais elle me convient parfaitement:

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

Cela devrait fonctionner (à min avec TkAgg):

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

(adopté de ce qui précède et avec Tkinter, existe-t-il un moyen d'obtenir la taille d'écran utilisable sans zoomer de manière visible sur une fenêtre? )

19
dinvlad

Je reçois aussi mng.frame.Maximize(True) AttributeError: FigureManagerTkAgg instance has no attribute 'frame'.

Puis j'ai regardé à travers les attributs que mng a et j'ai trouvé ceci: 

mng.window.showMaximized()

Cela a fonctionné pour moi.

Donc, pour les personnes qui ont le même problème, vous pouvez essayer ceci.

Au fait, ma version de Matplotlib est la 1.3.1.

4
Alan Wang

C’est une sorte de hacky et probablement pas portable, ne l’utilisez que si vous cherchez rapide et sale. Si je me contente de définir un chiffre beaucoup plus grand que l’écran, cela prend exactement tout l’écran.

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

En fait, dans Ubuntu 16.04 avec Qt4Agg, il maximise la fenêtre (pas en plein écran) si elle est plus grande que l’écran. (Si vous avez deux moniteurs, cela maximise simplement l’un d’eux).

4
Mark

Essayez plt.figure(figsize=(6*3.13,4*3.13)) pour agrandir l’intrigue.

2
Navin

Dans mes versions (Python 3.6, Eclipse, Windows 7), les extraits donnés ci-dessus ne fonctionnaient pas, mais avec des astuces données par Eclipse/pydev (après avoir tapé: mng.), J'ai trouvé:

mng.full_screen_toggle()

Il semble que l’utilisation de commandes mng n’est acceptable que pour le développement local ...

2
Antti A

J'ai trouvé cela en mode plein écran sur Ubuntu

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

Appuyez sur la touche f (ou ctrl+f dans 1.2rc1) lorsque vous vous concentrez sur un tracé pour afficher en plein écran une fenêtre de tracé. Pas tout à fait maximiser, mais peut-être mieux.

Autre que cela, pour maximiser réellement, vous devrez utiliser des commandes spécifiques à GUI Toolkit (si elles existent pour votre backend spécifique).

HTH

2
pelson

La solution qui a fonctionné parfaitement sur 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()
1
Zeds Zen

Essayez d’utiliser la méthode 'Figure.set_size_inches', avec le mot clé supplémentaire argument forward=True. Selon la documentation , devrait redimensionner la fenêtre de figure.

Que cela se produise réellement dépendra du système d'exploitation que vous utilisez.

1
Roland Smith

Ok, donc c'est ce qui a fonctionné pour moi. J'ai fait toute l'option showMaximize () et cela redimensionne votre fenêtre proportionnellement à la taille de la figure, mais cela ne se développe pas et ne correspond pas à la toile. J'ai résolu ceci par:

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

plt.show()
1
ArmandduPlessis

Ce qui suit peut fonctionner avec tous les serveurs, mais je l’ai testé uniquement sur 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()
0
MikeTeX

Cela ne maximise pas nécessairement votre fenêtre, mais le redimensionne proportionnellement à la taille de la figure:

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

Cela pourrait aussi aider: http://matplotlib.1069221.n5.nabble.com/Resizing-figure-windows-td11424.html

0
Blairg23

Mon meilleur effort jusqu'à présent, en soutenant différents backends:

from platform import system
def plt_maximize():
    # See discussion: https://stackoverflow.com/questions/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)
0
Martin R.