Tamaño de figura, DPI y aspect ratio

Tamaño de la figura

El control del tamaño, la resolución y las proporciones de una figura es esencial para obtener resultados profesionales. Un gráfico destinado a una presentación necesita dimensiones y DPI distintos de uno que irá en una publicación impresa o en un panel web. Matplotlib permite ajustar estos parámetros de forma precisa.

Configurar el tamaño con figsize

El parámetro figsize define el tamaño de la figura en pulgadas como una tupla (ancho, alto). El tamaño real en píxeles se calcula multiplicando las pulgadas por el valor de dpi (puntos por pulgada). El valor por defecto de Matplotlib es (6.4, 4.8) pulgadas con 100 dpi, lo que produce una imagen de 640 x 480 píxeles.

import matplotlib.pyplot as plt
import numpy as np

# Tamaños comunes:
# (6.4, 4.8) — valor por defecto de Matplotlib
# (10, 6)    — formato apaisado estándar para presentaciones
# (8, 8)     — formato cuadrado
# (14, 5)    — muy apaisado para dashboards horizontales
# (6, 10)    — formato vertical para informes

tamaños = [(4, 3), (8, 4), (6, 6), (12, 4)]
titulos = ['4×3 (pequeño)', '8×4 (apaisado)', '6×6 (cuadrado)', '12×4 (panorámico)']

x = np.linspace(0, 10, 100)

for size, titulo in zip(tamaños, titulos):
    fig, ax = plt.subplots(figsize=size)
    ax.plot(x, np.sin(x), 'royalblue', linewidth=2)
    ax.set_title(f'figsize={size} — {titulo}', fontsize=11)
    ax.grid(True, alpha=0.3)
    plt.tight_layout()
    plt.show()
    plt.close(fig)

Como regla práctica: para pantalla usa figsize=(10, 6), para impresión A4 usa figsize=(7, 4.5) y para dashboards horizontales usa figsize=(14, 5).

Resolución y DPI

La resolución en píxeles = figsize x dpi

El DPI (dots per inch, puntos por pulgada) determina la densidad de píxeles de la imagen exportada. Una figura de (10, 6) pulgadas a 72 dpi genera una imagen de 720 x 432 píxeles, mientras que a 300 dpi produce 3000 x 1800 píxeles. El DPI no afecta al tamaño visual en pantalla (que depende de figsize), sino a la calidad del archivo exportado con savefig().

import matplotlib.pyplot as plt

# Calcular el tamaño en píxeles
figsize = (10, 6)
dpi_values = [72, 100, 150, 300]

for dpi in dpi_values:
    px_ancho = int(figsize[0] * dpi)
    px_alto = int(figsize[1] * dpi)
    print(f"dpi={dpi:3d}: {px_ancho} × {px_alto} píxeles")
# dpi= 72:  720 × 432 píxeles
# dpi=100: 1000 × 600 píxeles
# dpi=150: 1500 × 900 píxeles
# dpi=300: 3000 × 1800 píxeles

Proporción de los ejes

set_aspect(): proporción de los ejes

El método set_aspect() controla la relación de aspecto entre las unidades del eje X y el eje Y. Cuando se dibuja un círculo con datos cuyas coordenadas tienen la misma escala, sin set_aspect('equal') el círculo aparece como una elipse porque Matplotlib ajusta los ejes al espacio disponible de la figura. Fijar el aspecto a 'equal' garantiza que una unidad en X mide lo mismo que una unidad en Y:

import matplotlib.pyplot as plt
import numpy as np

theta = np.linspace(0, 2 * np.pi, 200)
x = np.cos(theta)
y = np.sin(theta)

fig, axes = plt.subplots(1, 3, figsize=(15, 5))

# Sin set_aspect: el círculo aparece como elipse
axes[0].plot(x, y, 'royalblue', linewidth=2)
axes[0].set_title('Sin set_aspect — parece elipse')
axes[0].grid(True, alpha=0.3)

# set_aspect('equal'): 1 unidad en X = 1 unidad en Y
axes[1].plot(x, y, 'coral', linewidth=2)
axes[1].set_aspect('equal')
axes[1].set_title("set_aspect('equal') — círculo real")
axes[1].grid(True, alpha=0.3)

# set_aspect(ratio numérico): X/Y = 0.5 (cada 1 en X = 2 en Y)
axes[2].plot(x, y, 'seagreen', linewidth=2)
axes[2].set_aspect(0.5)
axes[2].set_title("set_aspect(0.5) — proporción 2:1")
axes[2].grid(True, alpha=0.3)

plt.tight_layout()
plt.show()

El valor set_aspect('equal') es imprescindible en visualizaciones geográficas, planos arquitectónicos y cualquier gráfico donde la proporción espacial tenga significado real.

Márgenes y espaciado

Ajuste de márgenes con subplots_adjust()

Cuando una figura contiene múltiples subplots, las etiquetas y los títulos pueden solaparse. El método subplots_adjust() permite controlar manualmente los márgenes exteriores (left, right, top, bottom) y el espaciado entre subplots (hspace para el vertical, wspace para el horizontal):

import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 10, 100)

fig, axes = plt.subplots(2, 2, figsize=(12, 8))

for i, ax in enumerate(axes.flat):
    ax.plot(x, np.sin(x + i))
    ax.set_title(f'Subplot {i+1}')
    ax.set_xlabel('Eje X con etiqueta larga')
    ax.set_ylabel('Eje Y')

# Ajuste manual de márgenes y espaciado
fig.subplots_adjust(
    left=0.08,     # margen izquierdo
    right=0.97,    # margen derecho
    top=0.93,      # margen superior
    bottom=0.1,    # margen inferior
    hspace=0.5,    # espacio vertical entre filas
    wspace=0.3     # espacio horizontal entre columnas
)

fig.suptitle('Márgenes ajustados con subplots_adjust()', fontsize=13)
plt.show()

Tamaños recomendados por formato de salida

Comparación de tamaños para distintos formatos de salida

La elección correcta de figsize y dpi depende del destino final del gráfico. A continuación se muestran los valores recomendados para los dos escenarios más habituales: visualización en pantalla y exportación para impresión en formato A4:

import matplotlib.pyplot as plt
import numpy as np

x = np.linspace(0, 10, 100)
y = np.sin(x) + np.random.normal(0, 0.1, 100)

# Tamaño para pantalla (72-100 dpi)
fig_pantalla, ax = plt.subplots(figsize=(10, 6))
ax.plot(x, y)
ax.set_title('Para pantalla: 10×6 pulgadas @ 100dpi = 1000×600 px')
ax.grid(True, alpha=0.3)
plt.tight_layout()
fig_pantalla.savefig('para_pantalla.png', dpi=100, bbox_inches='tight')
plt.close(fig_pantalla)

# Tamaño para impresión A4 (ancho ≈ 8.27", alto ≈ 11.69")
fig_a4, ax = plt.subplots(figsize=(7, 4.5))   # mitad de página A4 aprox.
ax.plot(x, y)
ax.set_title('Para impresión A4: 7×4.5 pulgadas @ 300dpi')
ax.grid(True, alpha=0.3)
plt.tight_layout()
fig_a4.savefig('para_impresion.png', dpi=300, bbox_inches='tight')
plt.close(fig_a4)

print("Figuras guardadas en los dos tamaños.")