Comment changer la taille des chiffres établis avec matplotlib?

Comment modifier la taille de la figure dessinée avec matplotlib?

plt.figure(figsize=(20,10))
OU fig, ax = plt.subplots(figsize=(20, 10))
Pensant que la figure est la taille en pixels, j'ai spécifié (800,600) et le programme s'est planté ! Veuillez noter que l'unité est en pouces.
est-ce dans la documentation?
fig = plt.gcf() --> fig.set_size_inches(11,8) pour éviter la confusion une fois pour toutes.

OriginalL'auteur tatwright | 2008-12-01

844

la figure vous indique l'appel de la signature:
```
from matplotlib.pyplot import figure
figure(num=None, figsize=(8, 6), dpi=80, facecolor='w', edgecolor='k')
```
figure(figsize=(1,1)) serait de créer un pouce par pouce de l'image, qui serait de 80 par 80 pixels à moins que vous aussi donner une autre dpi argument.

Si vous avez déjà la figure créé, disent que c'est " la figure 1 (c'est celui par défaut lorsque vous utilisez pyplot), vous pouvez utiliser la figure(num=1, figsize=(8, 6), ...) pour changer la taille, etc. Si vous utilisez pyplot/pylab et show() pour créer une fenêtre pop-up, vous devez appeler figure(num=1,...) avant vous tracez la courbe de quoi que ce soit - pyplot/pylab crée une figure dès que vous dessinez quelque chose, et la taille de la fenêtre pop-up apparaît pour être fixé à ce point.
J'ai l'impression que votre réponse serait mieux si vous avez supprimé les arguments par défaut. Il diminue le rapport signal sur bruit inutilement.
Est-ce à dire si vous définissez DPI à 1, puis figsize devient une unité de pixel au lieu d'un pouce? Ce serait plus utile lors de l'utilisation de matplotlib sur le web et d'interfaces GUI.
avec figsize(1,1) vous permettra d'avoir un ratio de l'image 1:1? parce que tous mes camemberts sont de forme ovale, et la seule façon que j'ai trouvée pour faire leur ronde a été par l'utilisation de la parcelle.axe("égal"). ils auraient le même effet ou ont un comportement diferently?
Cette question est à propos de la figure de la taille. Les axes sur la partie supérieure de la figure peut encore avoir une inégalité dans le rapport d'aspect, même si la figure dans son ensemble est de 1:1, et même si les axes de la boîte est de 1:1, les données peuvent être réduits de manière différente dans les directions x et y. Donc, non, la commande ne sera pas la garantie d'une égalité de rapport d'aspect.

OriginalL'auteur Jouni K. Seppänen
613

Si vous avez déjà la figure créé, vous pouvez le faire rapidement ce:
```
fig = matplotlib.pyplot.gcf()
fig.set_size_inches(18.5, 10.5)
fig.savefig('test2png.png', dpi=100)
```
Pour propager la modification de la taille de à une fenêtre gui ajouter forward=True
```
fig.set_size_inches(18.5, 10.5, forward=True)
```
Résolu moi un problème avec imshow, maintenant, je suis en utilisant ce code juste après l'élimination de l'espace autour de la zone de traçage avec plt.subplots_adjust(left=0.0, right=1.0, bottom=0.0, top=1.0).
De même, vous pouvez exécuter fig.set_dpi(100).

OriginalL'auteur Pete
303

Dépréciation note:

Comme par le officiel Matplotlib guide, l'utilisation de la pylab module n'est plus recommandé. Veuillez prendre en considération la matplotlib.pyplot module au lieu de cela, comme décrit par cette autre réponse.

La suite semble fonctionner:
```
from pylab import rcParams
rcParams['figure.figsize'] = 5, 10
```
Ce qui rend la figure de la largeur de 5 cm, et sa hauteur 10 po.

La Figure de la classe puis l'utilise comme valeur par défaut pour l'un de ses arguments.

Cela fonctionne aussi bien en haut d'un iPython notebook, qui (étant donné --pylab=inline) a rcParams déjà importé au plus haut niveau.
Cela n'a pas fonctionné sur ma machine Windows avec une interface orientée objet pour pyplot et Qt backend. fig.set_size_inches(18.5, 10.5, forward=True) travaillé.
Cette réponse est en cours de discussion sur Meta
Pour la version de Python: 3.6.4, matplotlib: 2.2.3 je pense que vous avez besoin pour passer d'une liste ou un tuple par exemple rcParams['figure.figsize'] = (5, 10)

OriginalL'auteur tatwright
205

S'il vous plaît essayez un simple code suivant:
```
from matplotlib import pyplot as plt
plt.figure(figsize=(1,1))
x = [1,2,3]
plt.plot(x, x)
plt.show()
```
Vous devez définir la figure de la taille avant de l'intrigue.

Cette réponse me dit que c'est matplotlib.pyplot.figure, et que les autres ne le disent pas aussi clairement. Je continue à essayer des choses comme matplotlib.figure et matplotlib.figure.Figure
"_tkinter.TclError: pas assez de mémoire libre pour l'image, tampon"
plt.figure(figsize=(1,1)) est le point de bouger. Je vous remercie.
Cela ne fonctionne pas pour moi, dans un jupyter portable

OriginalL'auteur iPAS
204

À l'AIDE de plt.rcParams

Il y a aussi cette solution de contournement dans le cas où vous souhaitez modifier la taille sans l'aide de la figure de l'environnement. Ainsi, dans le cas où vous utilisez plt.plot() par exemple, vous pouvez définir un tuple avec la largeur et la hauteur.
```
import matplotlib.pyplot as plt
plt.rcParams["figure.figsize"] = (20,3)
```
Ceci est très utile lorsque vous tracez en ligne (par exemple avec IPython Notebook). @Asamaier vous avez remarqué est préférable de ne pas mettre cette instruction dans la même cellule des importations des états.

Conversion en cm

La figsize tuple accepte po donc, si vous voulez la mettre en centimètres que vous avez à les diviser par 2.54 ont un look à cette question.

Excellent! Également utile pour la création d'une fois et le tracé plusieurs fois.
Pour une raison quelconque, il semble que cela ne fonctionne plus dans Jupyter pour ordinateur portable (mais).
Pouvez-vous écrire la version de votre Jupyter ordinateur portable et le comportement pour moi ça fonctionne
la dernière fois que j'ai testé, c'était Jupyter version 4.3.0 et Python 3.6.2 de l'Anaconda, sur Windows 10 et Google Chrome 63.0.3239.84.
Pour le faire fonctionner, je dois appeler plt.rcParams["figure.figsize"] = (20,3) dans une cellule supplémentaire. Quand je l'appelle dans la même cellule que l'instruction d'importation, elle est ignorée.

OriginalL'auteur G M

Le premier lien dans Google pour 'matplotlib figure size' est AdjustingImageSize (Google cache de la page).

Voici un script de test à partir de la page mentionnée ci-dessus. Il crée test[1-3].png fichiers de tailles différentes de la même image:

#!/usr/bin/env python
"""
This is a small demo file that helps teach how to adjust figure sizes
for matplotlib

"""

import matplotlib
print "using MPL version:", matplotlib.__version__
matplotlib.use("WXAgg") # do this before pylab so you don'tget the default back end.

import pylab
import numpy as np

# Generate and plot some simple data:
x = np.arange(0, 2*np.pi, 0.1)
y = np.sin(x)

pylab.plot(x,y)
F = pylab.gcf()

# Now check everything with the defaults:
DPI = F.get_dpi()
print "DPI:", DPI
DefaultSize = F.get_size_inches()
print "Default size in Inches", DefaultSize
print "Which should result in a %i x %i Image"%(DPI*DefaultSize[0], DPI*DefaultSize[1])
# the default is 100dpi for savefig:
F.savefig("test1.png")
# this gives me a 797 x 566 pixel image, which is about 100 DPI

# Now make the image twice as big, while keeping the fonts and all the
# same size
F.set_size_inches( (DefaultSize[0]*2, DefaultSize[1]*2) )
Size = F.get_size_inches()
print "Size in Inches", Size
F.savefig("test2.png")
# this results in a 1595x1132 image

# Now make the image twice as big, making all the fonts and lines
# bigger too.

F.set_size_inches( DefaultSize )# resetthe size
Size = F.get_size_inches()
print "Size in Inches", Size
F.savefig("test3.png", dpi = (200)) # change the dpi
# this also results in a 1595x1132 image, but the fonts are larger.

De sortie:

using MPL version: 0.98.1
DPI: 80
Default size in Inches [ 8.  6.]
Which should result in a 640 x 480 Image
Size in Inches [ 16.  12.]
Size in Inches [ 16.  12.]

Deux remarques:

Le module de commentaires et la sortie réelle diffèrent.
Cette réponse permet de facilement combiner tous les trois images dans un seul fichier image pour voir la différence dans les tailles.

Chaque fois que je suis en essayant de se rappeler comment le faire, je me retrouve dans ce post. Donc, c'est le code que j'ai fais habituellement à la recherche: fig = plt.figure() default_size = fig.get_size_inches() fig.set_size_inches( (default_size[0]*2, default_size[1]*2) )

OriginalL'auteur jfs

52

Dans le cas où vous êtes à la recherche d'un moyen de changer la figure de la taille dans les Pandas, vous pourriez le faire par exemple:
```
df['some_column'].plot(figsize=(10, 5))
```
où df est une Pandas dataframe. Si vous souhaitez modifier les paramètres par défaut, vous pouvez effectuer les opérations suivantes:
```
import matplotlib

matplotlib.rc('figure', figsize=(10, 5))
```
OriginalL'auteur Kris
33

Vous pouvez simplement utiliser (à partir de matplotlib.figure.La Figure):
```
fig.set_size_inches(width,height)
```
De Matplotlib 2.0.0, des changements à votre toile sera visible immédiatement, comme le forward mot-clé par défaut est True.

Si vous voulez juste modifier la largeur ou hauteur au lieu de deux, vous pouvez utiliser

fig.set_figwidth(val) ou fig.set_figheight(val)

Ces est également directement mettre à jour votre toile, mais seulement dans Matplotlib 2.2.0 et les plus récents.

Pour Les Versions Plus Anciennes

Vous devez spécifier forward=True explicitement dans le but de vivre-mise à jour de votre toile dans les versions plus anciennes que ce qui est spécifié ci-dessus. Notez que le set_figwidth et set_figheight fonctions ne prennent pas en charge la forward paramètre dans les versions plus anciennes que Matplotlib 1.5.0.

OriginalL'auteur River

Essayer de commenter le fig = ... ligne

%matplotlib inline
import numpy as np
import matplotlib.pyplot as plt

N = 50
x = np.random.rand(N)
y = np.random.rand(N)
area = np.pi * (15 * np.random.rand(N))**2

fig = plt.figure(figsize=(18, 18))
plt.scatter(x, y, s=area, alpha=0.5)
plt.show()

OriginalL'auteur Renaud

14

Pour augmenter la taille de votre figure N fois, vous devez insérer juste avant votre pl.show():
```
N = 2
params = pl.gcf()
plSize = params.get_size_inches()
params.set_size_inches( (plSize[0]*N, plSize[1]*N) )
```
Il fonctionne aussi bien avec ipython notebook.

OriginalL'auteur psihodelia

Cela fonctionne bien pour moi:

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

OriginalL'auteur Blairg23

8

Depuis Matplotlib n'est pas en mesure à utiliser le système métrique en natif, si vous souhaitez spécifier la taille de votre figure dans un délai d'une unité de longueur comme centimètres, vous pouvez effectuer les opérations suivantes (code de gns-ank):
```
def cm2inch(*tupl):
    inch = 2.54
    if isinstance(tupl[0], tuple):
        return tuple(i/inch for i in tupl[0])
    else:
        return tuple(i/inch for i in tupl)
```
Ensuite, vous pouvez utiliser:
```
plt.figure(figsize=cm2inch(21, 29.7))
```
OriginalL'auteur Franck Dernoncourt
7

Cela permet de redimensionner la figure immédiatement, même après que le chiffre a été établi (au moins à l'aide Qt4Agg/TkAgg - mais pas MacOSX avec matplotlib 1.4.0):
```
matplotlib.pyplot.get_current_fig_manager().resize(width_px, height_px)
```
OriginalL'auteur wilywampa

Vous devez vous connecter pour publier un commentaire.

À l'AIDE de plt.rcParams

Conversion en cm

Pour Les Versions Plus Anciennes