Matplotlib Rellenar Entre

Introducción

Matplotlib es una biblioteca de visualización de datos en el lenguaje de programación Python. Se utiliza para crear visualizaciones estáticas, animadas e interactivas en Python. En este laboratorio, aprenderá a usar la función fill_between de Matplotlib para rellenar el área entre dos líneas.

Consejos sobre la VM

Una vez finalizada la inicialización de la VM, haga clic en la esquina superior izquierda para cambiar a la pestaña Cuaderno y acceder a Jupyter Notebook para practicar.

A veces, es posible que tenga que esperar unos segundos a que Jupyter Notebook termine de cargarse. La validación de operaciones no se puede automatizar debido a las limitaciones de Jupyter Notebook.

Si tiene problemas durante el aprendizaje, no dude en preguntar a Labby. Deje su retroalimentación después de la sesión y lo resolveremos rápidamente para usted.

Uso básico

La función fill_between se puede utilizar para rellenar el área entre dos líneas. Los parámetros y1 y y2 pueden ser escalares, lo que indica un límite horizontal en los valores de y dados. Si solo se da y1, y2 por defecto es 0.

x = np.arange(0.0, 2, 0.01)
y1 = np.sin(2 * np.pi * x)
y2 = 0.8 * np.sin(4 * np.pi * x)

fig, (ax1, ax2, ax3) = plt.subplots(3, 1, sharex=True, figsize=(6, 6))

ax1.fill_between(x, y1)
ax1.set_title('rellenar entre y1 y 0')

ax2.fill_between(x, y1, 1)
ax2.set_title('rellenar entre y1 y 1')

ax3.fill_between(x, y1, y2)
ax3.set_title('rellenar entre y1 y y2')
ax3.set_xlabel('x')
fig.tight_layout()

Bandas de confianza

Una aplicación común de fill_between es la indicación de bandas de confianza. fill_between utiliza los colores del ciclo de colores como color de relleno. Por lo tanto, a menudo es una buena práctica clarificar el color haciendo que el área sea semi-transparente utilizando alpha.

N = 21
x = np.linspace(0, 10, 11)
y = [3.9, 4.4, 10.8, 10.3, 11.2, 13.1, 14.1,  9.9, 13.9, 15.1, 12.5]

## ajusta una curva lineal y estima sus valores de y y su error.
a, b = np.polyfit(x, y, deg=1)
y_est = a * x + b
y_err = x.std() * np.sqrt(1/len(x) +
                          (x - x.mean())**2 / np.sum((x - x.mean())**2))

fig, ax = plt.subplots()
ax.plot(x, y_est, '-')
ax.fill_between(x, y_est - y_err, y_est + y_err, alpha=0.2)
ax.plot(x, y, 'o', color='tab:brown')

Rellenando regiones horizontales de forma selectiva

El parámetro where permite especificar los rangos de x que se deben rellenar. Es una matriz booleana del mismo tamaño que x. Solo se rellenan los rangos de x de secuencias contiguas de valores True. Como resultado, el rango entre valores True y False adyacentes nunca se rellena. Por lo tanto, se recomienda establecer interpolate=True a menos que la distancia en x de los puntos de datos sea lo suficientemente fina para que el efecto anterior no sea notable.

x = np.array([0, 1, 2, 3])
y1 = np.array([0.8, 0.8, 0.2, 0.2])
y2 = np.array([0, 0, 1, 1])

fig, (ax1, ax2) = plt.subplots(2, 1, sharex=True)

ax1.set_title('interpolación=False')
ax1.plot(x, y1, 'o--')
ax1.plot(x, y2, 'o--')
ax1.fill_between(x, y1, y2, donde=(y1 > y2), color='C0', alpha=0.3)
ax1.fill_between(x, y1, y2, donde=(y1 < y2), color='C1', alpha=0.3)

ax2.set_title('interpolación=True')
ax2.plot(x, y1, 'o--')
ax2.plot(x, y2, 'o--')
ax2.fill_between(x, y1, y2, donde=(y1 > y2), color='C0', alpha=0.3,
                 interpolación=True)
ax2.fill_between(x, y1, y2, donde=(y1 <= y2), color='C1', alpha=0.3,
                 interpolación=True)
fig.tight_layout()

Marcando selectivamente regiones horizontales en todo el eje

El mismo mecanismo de selección se puede aplicar para rellenar toda la altura vertical del eje. Para ser independiente de los límites de y, agregamos una transformación que interpreta los valores de x en coordenadas de datos y los valores de y en coordenadas de eje. El siguiente ejemplo marca las regiones en las que los datos de y están por encima de un umbral dado.

fig, ax = plt.subplots()
x = np.arange(0, 4 * np.pi, 0.01)
y = np.sin(x)
ax.plot(x, y, color='black')

threshold = 0.75
ax.axhline(threshold, color='green', lw=2, alpha=0.7)
ax.fill_between(x, 0, 1, where=y > threshold,
                color='green', alpha=0.5, transform=ax.get_xaxis_transform())

Resumen

En este laboratorio, aprendiste cómo utilizar la función fill_between de Matplotlib para rellenar el área entre dos líneas. También aprendiste cómo rellenar selectivamente regiones horizontales y marcar regiones horizontales en todo el eje.