¿Cómo se cambia el tamaño de las figuras dibujadas con Matplotlib?

2617

¿Cómo se cambia el tamaño de la figura dibujada con Matplotlib?

0
1412

figure te dice la firma de la llamada:

from matplotlib.pyplot import figure

figure(figsize=(8, 6), dpi=80)

figure(figsize=(1,1)) crearía una imagen pulgada por pulgada, que sería de 80 por 80 píxeles a menos que también proporcione un argumento de ppp diferente.

6
  • 113
    Si ya ha creado la figura, digamos que es 'figura 1' (que es la predeterminada cuando está usando pyplot), puede usar figure (num = 1, figsize = (8, 6), ...) para cambiar su tamaño, etc. Si está usando pyplot / pylab y show()para crear una ventana emergente, debe llamar figure(num=1,...) antes de trazar cualquier cosa: pyplot / pylab crea una figura tan pronto como dibuja algo, y aparece el tamaño de la ventana emergente para ser arreglado en este punto. 2 de julio de 2013 a las 23:31
  • 5
    ¿Significa esto que si establece DPI en 1, el tamaño de la figura se convierte en una unidad de píxel en lugar de una unidad de pulgada? Esto sería más útil cuando se usa matplotlib en interfaces web y GUI. 17/07/2017 a las 10:48
  • 2
    con figsize (1,1) tendrá una proporción en la imagen de 1: 1? porque todos mis gráficos circulares se muestran ovalados, y la única forma que encontré para hacerlos redondos fue usando plot.axis ("equals"). tendrían el mismo efecto o se comportarían de manera diferente? 9/11/2017 a las 17:43
  • 3
    @BrenoBaiardi Esta pregunta es sobre el tamaño de la figura. Los ejes en la parte superior de la figura aún pueden tener una relación de aspecto desigual incluso si la figura en su conjunto es 1: 1, e incluso si el cuadro de ejes es 1: 1, los datos se pueden escalar de manera diferente en las direcciones x e y. Entonces, no, ese comando no garantizará una relación de aspecto igual. 13/11/2017 a las 14:43
  • 2
    Tenga en cuenta que si establece un número demasiado grande figsize, la figura solo se maximizará hasta los bordes de la pantalla. Esto abre la posibilidad de una maximización horizontal y una maximización vertical.
    Stefano
    17/04/19 a las 16:13
896

Si ya ha creado la figura, puede hacer esto rápidamente:

fig = matplotlib.pyplot.gcf()
fig.set_size_inches(18.5, 10.5)
fig.savefig('test2png.png', dpi=100)

Para propagar el cambio de tamaño a una ventana GUI existente, agregue forward=True:

fig.set_size_inches(18.5, 10.5, forward=True)
3
  • 4
    Me resolvió un problema con imshow, ahora estoy usando este código justo después de eliminar el espacio alrededor del área de trazado con plt.subplots_adjust(left=0.0, right=1.0, bottom=0.0, top=1.0). 26/11/12 a las 14:21
  • 12
    Del mismo modo, puede ejecutar fig.set_dpi(100). 27/03/15 a las 19:07
  • 1
    Estoy usando esto en OS X bajo ipython 3.7, matplotlib 3.0.3. Puedo ajustar el tamaño de la figura, pero la ventana no cambia de tamaño (el lienzo de la figura se ajusta, pero la ventana no crece ni se encoge para adaptarse al lienzo). El argumento de la palabra clave forward = True no parece tener el efecto deseado en esta plataforma. 7 ene.20 a las 20:12
499

Usando plt.rcParams

También existe esta solución en caso de que desee cambiar el tamaño sin utilizar el entorno de la figura. Entonces, en caso de que esté usando, plt.plot()por ejemplo, puede establecer una tupla con ancho y alto.

import matplotlib.pyplot as plt
plt.rcParams["figure.figsize"] = (20,3)

Esto es muy útil cuando traza en línea (por ejemplo, con IPython Notebook ). Como señaló Asmaier , es preferible no poner esta declaración en la misma celda de las declaraciones de importación.

Para restablecer el tamaño de la figura global a los valores predeterminados para los siguientes gráficos:

plt.rcParams["figure.figsize"] = plt.rcParamsDefault["figure.figsize"]

Conversión a cm

La figsizetupla acepta pulgadas, por lo que si desea establecerla en centímetros, debe dividirlos por 2,54. Eche un vistazo a esta pregunta .

11
  • 5
    ¡Excelente! También es útil para configurarlo una vez y graficar varias veces. 18/10/2017 a las 22:44
  • 1
    Por alguna razón, parece que esto ya no funciona en el cuaderno Jupyter (pero solía hacerlo).
    Ray
    13 dic 2017 a las 14:01
  • @Ray ¿Puedes escribir la versión de tu cuaderno de Jupyter y el comportamiento para mí funciona?
    G M
    13/12/2017 a las 16:41
  • 13
    Para que funcione, necesito llamar plt.rcParams["figure.figsize"] = (20,3)a un celular adicional. Cuando lo llamo en la misma celda que la declaración de importación, se ignora.
    asmaier
    11 de mayo de 2018 a las 7:33
  • 1
    Para restablecer el tamaño de la figura global para gráficos posteriores al uso predeterminado plt.rcParams['figure.figsize'] = plt.rcParamsDefault['figure.figsize']
    Eiron
    11 de mayo a las 21:46
409

Deprecation note:
As per the official Matplotlib guide, usage of the pylab module is no longer recommended. Please consider using the matplotlib.pyplot module instead, as described by this other answer.

Lo siguiente parece funcionar:

from pylab import rcParams
rcParams['figure.figsize'] = 5, 10

Esto hace que el ancho de la figura sea de 5 pulgadas y su altura de 10 pulgadas .

La clase Figure luego usa esto como el valor predeterminado para uno de sus argumentos.

8
  • 3
    Esto también funciona bien en la parte superior de un cuaderno iPython, que (dado --pylab = inline) tiene rcParams ya importados en el nivel superior.
    nealmcb
    10/1213 a las 20:57
  • 4
    Esto no funcionó en mi máquina Windows con interfaz OO para pyplot y Qt backend. fig.set_size_inches(18.5, 10.5, forward=True)trabajó. 6 feb 2016 a las 19:18
  • 2
    Esta respuesta se discute actualmente en Meta
    Mischa
    10/07/2017 a las 14:17
  • Para la versión de Python: 3.6.4, matplotlib: 2.2.3 Creo que necesita pasar una lista o tupla, por ejemplo, rcParams ['figure.figsize'] = (5, 10) 13 dic 2018 a las 3:08
  • 2
    ¿Alguien sabe por qué esto no funciona la primera vez que se ejecuta la celda?
    g07kore
    27/09/19 a las 6:44
362

Pruebe con un código simple como el siguiente:

from matplotlib import pyplot as plt
plt.figure(figsize=(1,1))
x = [1,2,3]
plt.plot(x, x)
plt.show()

Debe establecer el tamaño de la figura antes de trazar.

6
  • 18
    Esta respuesta me dice que es m atplotlib.pyplot.figure, lo que los demás no dicen con tanta claridad. Sigo probando cosas como matplotlib.figureymatplotlib.figure.Figure 24 de diciembre de 2014 a las 5:29
  • "_tkinter.TclError: no hay suficiente memoria libre para el búfer de imágenes"
    Cerin
    30 de marzo de 2017 a las 0:16
  • 8
    plt.figure(figsize=(1,1))es el movimiento crucial. Gracias.
    ximiki
    15/11/2017 a las 16:24
  • 2
    En el cuaderno jupyter, esto funcionó para mí: plt.figure (figsize = (20,10)) 25 de mayo de 2019 a las 12:38
  • 1
    Para aquellos que usan el cuaderno jupyter, asegúrese de estar usando plt.figure (figsize = (15, 10)) antes que otros comandos plt. 19/11/19 a las 8:43
147

En caso de que esté buscando una forma de cambiar el tamaño de la figura en Pandas , podría, por ejemplo, hacer:

df['some_column'].plot(figsize=(10, 5))

donde dfes un marco de datos de Pandas. O, para usar una figura o ejes existentes:

fig, ax = plt.subplots(figsize=(10, 5))
df['some_column'].plot(ax=ax)

Si desea cambiar la configuración predeterminada, puede hacer lo siguiente:

import matplotlib

matplotlib.rc('figure', figsize=(10, 5))
80

El primer enlace en Google para 'matplotlib figure size'es AdjustingImageSize ( caché de Google de la página ).

Aquí hay un guión de prueba de la página anterior. Crea test[1-3].pngarchivos de diferentes tamaños de la misma imagen:

#!/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.

Producción:

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.]

Dos notas:

  1. Los comentarios del módulo y la salida real difieren.

  2. Esta respuesta permite combinar fácilmente las tres imágenes en un archivo de imagen para ver la diferencia de tamaños.

1
  • 9
    Cada vez que intento recordar cómo hacerlo, termino en este post. Entonces, este es el código que normalmente estoy buscando:fig = plt.figure() default_size = fig.get_size_inches() fig.set_size_inches( (default_size[0]*2, default_size[1]*2) ) 12/10/2016 a las 11:58
75
import matplotlib.pyplot as plt
plt.figure(figsize=(20,10))
plt.plot(x,y) ## This is your plot
plt.show()

También puedes usar:

fig, ax = plt.subplots(figsize=(20, 10))
56

Simplemente puede usar (de matplotlib.figure.Figure ):

fig.set_size_inches(width,height)

A partir de Matplotlib 2.0.0, los cambios en su lienzo serán visibles de inmediato, ya que la forwardpalabra clave predeterminada esTrue .

Si solo desea cambiar el ancho o el alto en lugar de ambos, puede usar

fig.set_figwidth(val) o fig.set_figheight(val)

Estos también actualizarán inmediatamente su lienzo, pero solo en Matplotlib 2.2.0 y versiones posteriores.

Para versiones anteriores

Debe especificar forward=Trueexplícitamente para poder actualizar en vivo su lienzo en versiones anteriores a las especificadas anteriormente. Tenga en cuenta que las funciones set_figwidthy set_figheightno admiten el forwardparámetro en versiones anteriores a Matplotlib 1.5.0.

0
45

Intenta comentar la fig = ...línea

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

Esto funciona bien para mi:

from matplotlib import pyplot as plt

F = plt.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

Esta publicación en el foro también puede ayudar: Cambiar el tamaño de las ventanas de las figuras

20

Para aumentar el tamaño de su figura N veces, debe insertar esto justo antes de su pl.show () :

N = 2
params = pl.gcf()
plSize = params.get_size_inches()
params.set_size_inches((plSize[0]*N, plSize[1]*N))

También funciona bien con un portátil IPython .

15

Generalizando y simplificando la respuesta de psihodelia :

Si desea cambiar el tamaño actual de la figura por un factor sizefactor:

import matplotlib.pyplot as plt

# Here goes your code

fig_size = plt.gcf().get_size_inches() # Get current size
sizefactor = 0.8 # Set a zoom factor
# Modify the current size by the factor
plt.gcf().set_size_inches(sizefactor * fig_size) 

Después de cambiar el tamaño actual, puede ocurrir que tenga que ajustar el diseño de la subtrama . Puede hacerlo en la GUI de la ventana de la figura, o mediante el comando subplots_adjust

Por ejemplo,

plt.subplots_adjust(left=0.16, bottom=0.19, top=0.82)
0
15

Comparación de diferentes enfoques para establecer tamaños de imagen exactos en píxeles

Esta respuesta se centrará en:

  • savefig: cómo guardar en un archivo, no solo mostrarlo en la pantalla
  • establecer el tamaño en píxeles

Aquí hay una comparación rápida de algunos de los enfoques que he probado con imágenes que muestran lo que dan.

Ejemplo de línea de base sin intentar establecer las dimensiones de la imagen

Solo para tener un punto de comparación:

base.py

#!/usr/bin/env python3

import sys

import numpy as np
import matplotlib.pyplot as plt
import matplotlib as mpl

fig, ax = plt.subplots()
print('fig.dpi = {}'.format(fig.dpi))
print('fig.get_size_inches() = ' + str(fig.get_size_inches())
t = np.arange(-10., 10., 1.)
plt.plot(t, t, '.')
plt.plot(t, t**2, '.')
ax.text(0., 60., 'Hello', fontdict=dict(size=25))
plt.savefig('base.png', format='png')

correr:

./base.py
identify base.png

salidas:

fig.dpi = 100.0
fig.get_size_inches() = [6.4 4.8]
base.png PNG 640x480 640x480+0+0 8-bit sRGB 13064B 0.000u 0:00.000

ingrese la descripción de la imagen aquí

Mi mejor enfoque hasta ahora: plt.savefig(dpi=h/fig.get_size_inches()[1]control solo de altura

Creo que esto es lo que usaré la mayor parte del tiempo, ya que es simple y escala:

get_size.py

#!/usr/bin/env python3

import sys

import numpy as np
import matplotlib.pyplot as plt
import matplotlib as mpl

height = int(sys.argv[1])
fig, ax = plt.subplots()
t = np.arange(-10., 10., 1.)
plt.plot(t, t, '.')
plt.plot(t, t**2, '.')
ax.text(0., 60., 'Hello', fontdict=dict(size=25))
plt.savefig(
    'get_size.png',
    format='png',
    dpi=height/fig.get_size_inches()[1]
)

correr:

./get_size.py 431

salidas:

get_size.png PNG 574x431 574x431+0+0 8-bit sRGB 10058B 0.000u 0:00.000

ingrese la descripción de la imagen aquí

y

./get_size.py 1293

salidas:

main.png PNG 1724x1293 1724x1293+0+0 8-bit sRGB 46709B 0.000u 0:00.000

ingrese la descripción de la imagen aquí

Tiendo a establecer solo la altura porque, por lo general, lo que más me preocupa es cuánto espacio vertical ocupará la imagen en el medio de mi texto.

plt.savefig(bbox_inches='tight' cambia el tamaño de la imagen

Siempre siento que hay demasiado espacio en blanco alrededor de las imágenes, y tendía a agregar bbox_inches='tight'desde: Eliminar el espacio en blanco alrededor de una imagen guardada en matplotlib

Sin embargo, eso funciona recortando la imagen y no obtendrá los tamaños deseados con ella.

En cambio, este otro enfoque propuesto en la misma pregunta parece funcionar bien:

plt.tight_layout(pad=1)
plt.savefig(...

que da la altura exacta deseada para la altura es igual a 431:

ingrese la descripción de la imagen aquí

Altura fija, set_aspectancho de tamaño automático y márgenes pequeños

Ermmm, set_aspectvuelve a estropear las cosas y evita que se eliminen plt.tight_layoutlos márgenes ...

Preguntado en: ¿Cómo obtener una altura fija en píxeles, una relación de aspecto x / y de datos fijos y eliminar automáticamente el margen de espacio en blanco horizontal en Matplotlib?

plt.savefig(dpi=h/fig.get_size_inches()[1] + control de ancho

Si realmente necesita un ancho específico además de la altura, esto parece funcionar bien:

width.py

#!/usr/bin/env python3

import sys

import numpy as np
import matplotlib.pyplot as plt
import matplotlib as mpl

h = int(sys.argv[1])
w = int(sys.argv[2])
fig, ax = plt.subplots()
wi, hi = fig.get_size_inches()
fig.set_size_inches(hi*(w/h), hi)
t = np.arange(-10., 10., 1.)
plt.plot(t, t, '.')
plt.plot(t, t**2, '.')
ax.text(0., 60., 'Hello', fontdict=dict(size=25))
plt.savefig(
    'width.png',
    format='png',
    dpi=h/hi
)

correr:

./width.py 431 869

producción:

width.png PNG 869x431 869x431+0+0 8-bit sRGB 10965B 0.000u 0:00.000

ingrese la descripción de la imagen aquí

y para un pequeño ancho:

./width.py 431 869

producción:

width.png PNG 211x431 211x431+0+0 8-bit sRGB 6949B 0.000u 0:00.000

ingrese la descripción de la imagen aquí

Por lo tanto, parece que las fuentes se escalan correctamente, solo tenemos algunos problemas para anchos muy pequeños con etiquetas que se cortan, por ejemplo, 100en la parte superior izquierda.

Me las arreglé para evitar aquellos con Eliminación de espacios en blanco alrededor de una imagen guardada en matplotlib

plt.tight_layout(pad=1)

lo que da:

width.png PNG 211x431 211x431+0+0 8-bit sRGB 7134B 0.000u 0:00.000

ingrese la descripción de la imagen aquí

A partir de esto, también vemos que tight_layoutelimina gran parte del espacio vacío en la parte superior de la imagen, por lo que generalmente siempre lo uso.

Altura de base mágica fija, dpiencendido fig.set_size_inchesy plt.savefig(dpi=escala

Creo que esto es equivalente al enfoque mencionado en: https://stackoverflow.com/a/13714720/895245

magic.py

#!/usr/bin/env python3

import sys

import numpy as np
import matplotlib.pyplot as plt
import matplotlib as mpl

magic_height = 300
w = int(sys.argv[1])
h = int(sys.argv[2])
dpi = 80
fig, ax = plt.subplots(dpi=dpi)
fig.set_size_inches(magic_height*w/(h*dpi), magic_height/dpi)
t = np.arange(-10., 10., 1.)
plt.plot(t, t, '.')
plt.plot(t, t**2, '.')
ax.text(0., 60., 'Hello', fontdict=dict(size=25))
plt.savefig(
    'magic.png',
    format='png',
    dpi=h/magic_height*dpi,
)

correr:

./magic.py 431 231

salidas:

magic.png PNG 431x231 431x231+0+0 8-bit sRGB 7923B 0.000u 0:00.000

ingrese la descripción de la imagen aquí

Y para ver si se escala bien:

./magic.py 1291 693

salidas:

magic.png PNG 1291x693 1291x693+0+0 8-bit sRGB 25013B 0.000u 0:00.000

ingrese la descripción de la imagen aquí

Entonces vemos que este enfoque también funciona bien. El único problema que tengo es que tienes que configurar ese magic_heightparámetro o equivalente.

DPI fijo + set_size_inches

Este enfoque dio un tamaño de píxel ligeramente incorrecto y hace que sea difícil escalar todo sin problemas.

set_size_inches.py

#!/usr/bin/env python3

import sys

import numpy as np
import matplotlib.pyplot as plt
import matplotlib as mpl

w = int(sys.argv[1])
h = int(sys.argv[2])
fig, ax = plt.subplots()
fig.set_size_inches(w/fig.dpi, h/fig.dpi)
t = np.arange(-10., 10., 1.)
plt.plot(t, t, '.')
plt.plot(t, t**2, '.')
ax.text(
    0,
    60.,
    'Hello',
    # Keep font size fixed independently of DPI.
    # https://stackoverflow.com/questions/39395616/matplotlib-change-figsize-but-keep-fontsize-constant
    fontdict=dict(size=10*h/fig.dpi),
)
plt.savefig(
    'set_size_inches.png',
    format='png',
)

correr:

./set_size_inches.py 431 231

salidas:

set_size_inches.png PNG 430x231 430x231+0+0 8-bit sRGB 8078B 0.000u 0:00.000

por lo que la altura está ligeramente desviada y la imagen:

ingrese la descripción de la imagen aquí

Los tamaños de píxeles también son correctos si lo hago 3 veces más grande:

./set_size_inches.py 1291 693

salidas:

set_size_inches.png PNG 1291x693 1291x693+0+0 8-bit sRGB 19798B 0.000u 0:00.000

ingrese la descripción de la imagen aquí

Sin embargo, entendemos por esto que para que este enfoque se escale bien, debe hacer que cada configuración dependiente de DPI sea proporcional al tamaño en pulgadas.

En el ejemplo anterior, solo hicimos que el texto "Hola" fuera proporcional, y mantuvo su altura entre 60 y 80 como era de esperar. Pero todo por lo que no hicimos eso, parece diminuto, incluyendo:

  • ancho de línea de los ejes
  • marque las etiquetas
  • marcadores de puntos

SVG

No pude encontrar cómo configurarlo para imágenes SVG, mis enfoques solo funcionaron para PNG, por ejemplo:

get_size_svg.py

#!/usr/bin/env python3

import sys

import numpy as np
import matplotlib.pyplot as plt
import matplotlib as mpl

height = int(sys.argv[1])
fig, ax = plt.subplots()
t = np.arange(-10., 10., 1.)
plt.plot(t, t, '.')
plt.plot(t, t**2, '.')
ax.text(0., 60., 'Hello', fontdict=dict(size=25))
plt.savefig(
    'get_size_svg.svg',
    format='svg',
    dpi=height/fig.get_size_inches()[1]
)

correr:

./get_size_svg.py 431

y la salida generada contiene:

<svg height="345.6pt" version="1.1" viewBox="0 0 460.8 345.6" width="460.8pt"

e identificar dice:

get_size_svg.svg SVG 614x461 614x461+0+0 8-bit sRGB 17094B 0.000u 0:00.000

y si lo abro en Chromium 86, la imagen del mouse de las herramientas de depuración del navegador confirma que la altura es de 460,79.

Pero, por supuesto, dado que SVG es un formato vectorial, todo debería escalar en teoría, por lo que puede convertir a cualquier formato de tamaño fijo sin pérdida de resolución, por ejemplo:

inkscape -h 431 get_size_svg.svg -b FFF -e get_size_svg.png

da la altura exacta:

ingrese la descripción de la imagen aquí

Yo uso Inkscape en lugar de Imagemagick convertaquí porque también necesitas jugar para obtener cambios de -densitytamaño de SVG nítidos con ImageMagick:

Y la configuración <img height=""en HTML también debería funcionar para el navegador.

Probado en matplotlib == 3.2.2.

0
14

Dado que Matplotlib no puede usar el sistema métrico de forma nativa, si desea especificar el tamaño de su figura en una unidad de longitud razonable, como centímetros, puede hacer lo siguiente (código 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)

Entonces puedes usar:

plt.figure(figsize=cm2inch(21, 29.7))
13

Utilizar esta:

plt.figure(figsize=(width,height))

El widthy heightson en pulgadas. Si no se proporciona, el valor predeterminado es rcParams["figure.figsize"] = [6.4, 4.8]. Vea más aquí .

12

Esto cambia el tamaño de la figura inmediatamente incluso después de que se ha dibujado (al menos usando Qt4Agg / TkAgg, pero no Mac OS X, con Matplotlib 1.4.0):

matplotlib.pyplot.get_current_fig_manager().resize(width_px, height_px)
12

El siguiente seguramente el trabajo, pero asegúrese de agregar la línea plt.figure(figsize=(20,10))anterior plt.plot(x,y),plt.pie() etc.

import matplotlib.pyplot as plt
plt.figure(figsize=(20,10))
plt.plot(x,y) ## This is your plot
plt.show()

El código se copia de amalik2205 .

8

Otra opción es usar la función rc () en Matplotlib (la unidad es pulgadas):

import matplotlib
matplotlib.rc('figure', figsize=[10,5])
1
  • 1
    Esto es muy útil ya que asigna el tamaño de forma global. De esa manera, no es necesario especificarlo para cada parcela. Sin embargo, podría ser más común hacer import matplotlib.pyplot as plty luego hacer plt.rc('figure', figsize=(10,5)).
    Jakob
    27 de ene a las 18:51
7

Así es como imprimí mi gráfico personalizado con tamaño personalizado

import matplotlib.pyplot as plt
from matplotlib.pyplot import figure

figure(figsize=(16, 8), dpi=80)
plt.plot(x_test, color = 'red', label = 'Predicted Price')
plt.plot(y_test, color = 'blue', label = 'Actual Price')
plt.title('Dollar to PKR Prediction')
plt.xlabel('Predicted Price')
plt.ylabel('Actual Dollar Price')
plt.legend()
plt.show()
           
5

Al crear una nueva figura , puede especificar el tamaño (en pulgadas) con el figsizeargumento:

import matplotlib.pyplot as plt
fig = plt.figure(figsize=(w,h))

Si desea modificar una figura existente , use el set_size_inches()método:

fig.set_size_inches(w,h)

Si desea cambiar el tamaño de figura predeterminado (6.4 "x 4.8"), use "ejecutar comandos" rc :

plt.rc('figure', figsize=(w,h))
1

Siempre uso el siguiente patrón:

x_inches = 150*(1/25.4)     # [mm]*constant
y_inches = x_inches*(0.8)
dpi = 96

fig = plt.figure(1, figsize = (x_inches,y_inches), dpi = dpi, constrained_layout = True)

Con este ejemplo, puede establecer las dimensiones de la figura en pulgadas o en milímetros. Cuando se establece constrained_layouten True, los gráficos llenan su figura sin bordes.