Introducción a Matplotlib
¿Qué es Matplotlib?
Matplotlib es una librería de Python utilizada para crear visualizaciones de datos en forma de gráficos 2D. Es altamente versátil y permite generar una amplia gama de gráficos, desde simples gráficos de líneas y barras hasta complejos gráficos de dispersión, histogramas, gráficos de pastel, entre otros. Matplotlib es particularmente popular en campos como ciencia de datos, estadística e ingeniería, ya que ofrece una manera fácil y flexible de representar visualmente datos de manera clara y comprensible. La librería se integra bien con otras herramientas de análisis de datos en Python, como NumPy y Pandas, lo que facilita el análisis y la visualización de grandes conjuntos de datos. Con Matplotlib, los usuarios pueden personalizar cada aspecto de un gráfico, desde los colores y estilos de línea hasta la inclusión de leyendas, títulos y anotaciones, lo que la convierte en una excelente herramienta para crear visualizaciones que representen la información de manera eficaz.
Instalación
Para comenzar a utilizar Matplotlib, necesitas instalar la librería en tu entorno de Python. Esto se hace fácilmente utilizando pip, que es el gestor de paquetes de Python. Este comando descargará e instalará la última versión de Matplotlib y sus dependencias:
pip install matplotlib
Importar Matplotlib
En Python, las librerías se importan para acceder a sus funcionalidades. Para Matplotlib, la parte que se utiliza con mayor frecuencia es pyplot, un módulo que proporciona una interfaz de alto nivel para crear gráficos. Se suele importar con el alias plt para simplificar su uso. De hecho, este alias plt es un estándar de facto y verás que la mayoría de los ejemplos y tutoriales utilizan esta convención:
import matplotlib.pyplot as plt
En entornos donde no se tiene una pantalla (como en servidores web o scripts que generan gráficos sin mostrarlos), se recomienda utilizar matplotlib.use('Agg') para configurar Matplotlib en un backend que no requiere una interfaz gráfica:
import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
Creación de gráficos básicos
Gráfico de líneas
Los gráficos de líneas son uno de los tipos de gráficos más comunes y se utilizan para mostrar la relación entre dos variables continuas. Son especialmente útiles para mostrar cómo cambia una variable en función del tiempo u otra métrica continua.
Ejemplo: Ventas a lo largo del año
import matplotlib.pyplot as plt
# Datos
meses = ['Enero', 'Febrero', 'Marzo', 'Abril', 'Mayo', 'Junio']
ventas = [150, 200, 250, 300, 350, 400]
# Crear el gráfico
plt.plot(meses, ventas)
# Añadir títulos y etiquetas
plt.title("Ventas Mensuales")
plt.xlabel("Meses")
plt.ylabel("Ventas en $")
# Mostrar el gráfico
plt.show()
Explicación:
plt.plot(meses, ventas) genera una línea que conecta los puntos definidos por las listas meses y ventas.plt.title, plt.xlabel, y plt.ylabel se usan para añadir un título y etiquetas a los ejes.plt.show() muestra el gráfico en la pantalla.
Gráfico de barras
Los gráficos de barras son ideales para comparar diferentes categorías. Cada barra representa una categoría, y su altura o longitud representa la magnitud de la variable asociada a esa categoría.
Ejemplo: Comparación de ventas por producto
productos = ['Producto A', 'Producto B', 'Producto C']
ventas = [300, 450, 150]
plt.bar(productos, ventas)
plt.title("Ventas por Producto")
plt.xlabel("Productos")
plt.ylabel("Ventas en $")
plt.show()
Explicación:
plt.bar(productos, ventas) crea un gráfico de barras donde cada barra corresponde a un producto y su altura muestra el volumen de ventas.- Este tipo de gráfico es útil para visualizar comparaciones directas entre diferentes elementos.
Gráfico de dispersión
Un gráfico de dispersión es útil cuando deseas visualizar la relación entre dos variables numéricas. Cada punto en el gráfico representa un par de valores.
Ejemplo: Relación entre publicidad y ventas
publicidad = [100, 200, 300, 400, 500]
ventas = [10, 20, 30, 40, 50]
plt.scatter(publicidad, ventas)
plt.title("Relación entre Publicidad y Ventas")
plt.xlabel("Publicidad en $")
plt.ylabel("Ventas en $")
plt.show()
Explicación:
plt.scatter(publicidad, ventas) dibuja un punto para cada par de valores en las listas publicidad y ventas.- Este gráfico es excelente para identificar patrones, tendencias o posibles correlaciones entre las variables.
Histograma
Los histogramas se utilizan para mostrar la distribución de un conjunto de datos. Dividen el rango de datos en intervalos (o «bins») y cuentan cuántos valores caen en cada intervalo.
Ejemplo: Distribución de edades en un grupo
edades = [23, 25, 26, 29, 30, 32, 35, 36, 40, 41, 42, 45, 50, 55, 60]
plt.hist(edades, bins=5) # 'bins' define el número de barras en el histograma
plt.title("Distribución de Edades")
plt.xlabel("Edades")
plt.ylabel("Número de Personas")
plt.show()
Explicación:
plt.hist(edades, bins=5) crea un histograma que divide los datos en 5 intervalos y cuenta cuántos valores caen en cada intervalo.- Los histogramas son útiles para comprender la distribución de los datos, por ejemplo, si los datos están sesgados hacia un extremo o si tienen una distribución normal.
Personalización de gráficos
Colores y estilos de líneas
Matplotlib permite personalizar el color y el estilo de las líneas en los gráficos, lo que es útil para mejorar la claridad y la estética de la visualización.
Ejemplo: Personalización de un gráfico de líneas
dias = ['Lunes', 'Martes', 'Miércoles', 'Jueves', 'Viernes']
temperaturas = [22, 24, 20, 21, 19]
plt.plot(dias, temperaturas, color='green', linestyle='--', marker='o')
plt.title("Temperaturas Diarias")
plt.xlabel("Días")
plt.ylabel("Temperatura (°C)")
plt.show()
Explicación:
color='green' cambia el color de la línea a verde.linestyle='--' convierte la línea en discontinua.marker='o' añade marcadores de círculos en cada punto de datos.
Añadir leyendas
Las leyendas identifican las distintas series de datos en un gráfico, lo que es esencial cuando se comparan varias series.
Ejemplo: Comparación de ventas de dos productos
meses = ['Enero', 'Febrero', 'Marzo', 'Abril']
ventas_producto_a = [200, 220, 250, 270]
ventas_producto_b = [180, 190, 200, 210]
plt.plot(meses, ventas_producto_a, label='Producto A')
plt.plot(meses, ventas_producto_b, label='Producto B')
plt.title("Comparación de Ventas")
plt.xlabel("Meses")
plt.ylabel("Ventas en $")
plt.legend() # Añadir leyenda
plt.show()
Explicación:
label='Producto A' y label='Producto B' especifican el nombre de cada línea en la leyenda.plt.legend() coloca la leyenda en el gráfico.
Gráficos con subtramas
Los subgráficos permiten colocar múltiples gráficos en una sola figura, organizándolos en una cuadrícula.
Ejemplo: Gráficos de ventas y beneficios
meses = ['Enero', 'Febrero', 'Marzo', 'Abril']
ventas = [250, 300, 350, 400]
beneficios = [50, 60, 70, 80]
fig, (ax1, ax2) = plt.subplots(1, 2) # Una fila y dos columnas
ax1.plot(meses, ventas)
ax1.set_title("Ventas")
ax2.plot(meses, beneficios, color='red')
ax2.set_title("Beneficios")
plt.show()
Explicación:
plt.subplots(1, 2) crea una figura con una fila y dos columnas de subgráficos.ax1.plot(...) y ax2.plot(...) permiten dibujar gráficos en los diferentes ejes.
Gráficos avanzados
Gráfico de series temporales
Los gráficos de series temporales son fundamentales para mostrar cómo cambian los datos a lo largo del tiempo.
Ejemplo: Evolución de precios de acciones
import pandas as pd
import matplotlib.pyplot as plt
# Datos de ejemplo
fechas = pd.date_range(start='2023-01-01', periods=6, freq='M')
precios = [100, 105, 102, 108, 110, 115]
plt.plot(fechas, precios, marker='o')
plt.title("Evolución de Precios de Acciones")
plt.xlabel("Fecha")
plt.ylabel("Precio ($)")
plt.xticks(rotation=45)
plt.show()
Explicación:
pd.date_range(start='2023-01-01', periods=6, freq='M') genera un rango de fechas mensuales a partir de enero de 2023.- Este gráfico es ideal para mostrar datos financieros, meteorológicos, u otras métricas que varían con el tiempo.
Gráfico de pastel
Los gráficos de pastel se utilizan para mostrar la proporción de diferentes categorías en un conjunto de datos.
Ejemplo: Distribución de ventas por región
regiones = ['Norte', 'Sur', 'Este', 'Oeste']
ventas = [400, 300, 150, 150]
plt.pie(ventas, labels=regiones, autopct='%1.1f%%')
plt.title("Distribución de Ventas por Región")
plt.show()
Explicación:
plt.pie(ventas, labels=regiones, autopct='%1.1f%%') crea un gráfico de pastel y muestra los porcentajes de cada categoría en el gráfico.- Este tipo de gráfico es útil para mostrar cómo se distribuyen los datos en diferentes categorías.
Gráfico de barras apiladas
Los gráficos de barras apiladas son útiles para mostrar cómo diferentes subcomponentes contribuyen a un total.
Ejemplo: Ventas por categoría en diferentes meses
import numpy as np
meses = ['Enero', 'Febrero', 'Marzo', 'Abril']
categoria_a = [20, 35, 30, 35]
categoria_b = [25, 32, 34, 20]
categoria_c = [30, 30, 30, 30]
ind = np.arange(len(meses)) # La posición de los grupos
ancho = 0.35 # El ancho de las barras
p1 = plt.bar(ind, categoria_a, ancho)
p2 = plt.bar(ind, categoria_b, ancho, bottom=categoria_a)
p3 = plt.bar(ind, categoria_c, ancho, bottom=np.array(categoria_a)+np.array(categoria_b))
plt.ylabel('Ventas')
plt.title('Ventas por Categoría y Mes')
plt.xticks(ind, meses)
plt.legend(('Categoría A', 'Categoría B', 'Categoría C'))
plt.show()
Explicación:
bottom=categoria_a apila las barras de categoria_b sobre las de categoria_a.- Este gráfico es útil para ver la contribución relativa de diferentes categorías a lo largo del tiempo.
Guardar y compartir gráficos
Guardar gráficos en un archivo
Matplotlib permite guardar gráficos en diferentes formatos de archivo como PNG, PDF, SVG, entre otros. Esto es especialmente útil si deseas incluir gráficos en informes o presentaciones.
Ejemplo: Guardar un gráfico como PNG
x = [1, 2, 3, 4, 5]
y = [10, 20, 25, 30, 40]
plt.plot(x, y)
plt.title("Gráfico para Guardar")
plt.xlabel("Eje X")
plt.ylabel("Eje Y")
plt.savefig('grafico_guardado.png') # Guarda el gráfico como PNG
Explicación:
plt.savefig('grafico_guardado.png') guarda el gráfico en el archivo grafico_guardado.png en el formato especificado.- Es posible cambiar el formato del archivo guardándolo con una extensión diferente, como
.pdf o .svg.
Uso de BytesIO para generar gráficos en memoria
En algunos casos, no es necesario guardar los gráficos en el disco como archivos para compartirlos o visualizarlos en otras aplicaciones. Por ejemplo, en aplicaciones web se pueden enviar los gráficos dinámicamente al navegador sin crear archivos temporales. Aquí es donde entra en juego BytesIO, una clase de la librería estándar io en Python, que actúa como un contenedor de datos en memoria que se comporta como un archivo. Puedes escribir en él, leer de él, y tratarlo como si fuera un archivo regular, pero todo ocurre en la memoria RAM en lugar de en el disco duro.
Además, BytesIO no necesita ser instalado por separado porque forma parte de la biblioteca estándar de Python, específicamente dentro del módulo io. Esto significa que BytesIO está disponible automáticamente en cualquier instalación de Python moderna (Python 3 y superior) y no requiere ninguna instalación adicional:
from io import BytesIO
Ejemplo: Generación de un gráfico y almacenamiento en BytesIO
A continuación se muestra cómo se puede crear un gráfico con Matplotlib, almacenarlo en un objeto BytesIO en lugar de guardarlo en un archivo físico, y luego usar plt.close() para liberar recursos de manera eficiente:
import matplotlib.pyplot as plt
from io import BytesIO
# Datos de ejemplo
x = [1, 2, 3, 4, 5]
y = [10, 20, 25, 30, 35]
# Crear un gráfico
plt.plot(x, y)
plt.title("Gráfico en Memoria")
plt.xlabel("Eje X")
plt.ylabel("Eje Y")
# Crear un objeto BytesIO para almacenar el gráfico
img = BytesIO()
# Guardar el gráfico en el objeto BytesIO en formato PNG
plt.savefig(img, format='png')
# Colocar el puntero del archivo en memoria al inicio
# Ahora `img` contiene el gráfico en formato PNG, listo para ser enviado o procesado
img.seek(0)
# Cerrar la figura para liberar memoria
plt.close()
Explicación:
BytesIO() crea un objeto en memoria que se comporta como un archivo.plt.savefig(img, format='png') guarda el gráfico en el objeto BytesIO en formato PNG.img.seek(0) reposiciona el puntero al inicio del archivo en memoria para poder leerlo desde el principio.plt.close() cierra la figura actual y libera los recursos de memoria asociados al gráfico. Esto es especialmente importante en aplicaciones que generan muchos gráficos, ya que evita el consumo excesivo de memoria.
Uso de BytesIO en Aplicaciones web con Flask
Una de las aplicaciones más comunes de BytesIO es en el desarrollo de aplicaciones web con frameworks como Flask. En estas aplicaciones, los gráficos se generan en respuesta a las solicitudes HTTP y se envían directamente al usuario para que los pueda visualizar en el navegador:
from flask import Flask, send_file
import matplotlib.pyplot as plt
from io import BytesIO
app = Flask(__name__)
@app.route('/grafico')
def generar_grafico():
# Datos de ejemplo
x = [1, 2, 3, 4, 5]
y = [10, 20, 25, 30, 35]
# Crear un gráfico
plt.plot(x, y)
plt.title("Gráfico Generado en Flask")
plt.xlabel("Eje X")
plt.ylabel("Eje Y")
# Crear un objeto BytesIO
img = BytesIO()
# Guardar el gráfico en el objeto BytesIO en formato PNG
plt.savefig(img, format='png')
img.seek(0) # Reposicionar el puntero al inicio del archivo en memoria
# Cerrar la figura para liberar memoria
plt.close()
# Enviar el gráfico como respuesta HTTP
return send_file(img, mimetype='image/png')
if __name__ == '__main__':
app.run(debug=True)
Explicación:
send_file(img, mimetype='image/png') envía el contenido del BytesIO al cliente web como una imagen PNG.plt.close() cierra la figura una vez que el gráfico ha sido guardado en memoria, asegurando que no queden gráficos abiertos que puedan consumir memoria innecesariamente.- Esta configuración permite que cada vez que un usuario acceda a la ruta
/grafico, se genere un gráfico dinámicamente en memoria y se envíe al navegador.
Ventajas del uso de BytesIO y plt.close()
- Eficiencia: No se necesita escribir archivos temporales en disco, lo que reduce el I/O del disco y mejora el rendimiento. Además,
plt.close() asegura que la memoria se libere inmediatamente después de generar el gráfico.
- Seguridad: Al no crear archivos temporales, se minimiza el riesgo de dejar datos sensibles en el disco.
- Flexibilidad: Este enfoque se puede utilizar con aplicaciones que requieren gráficos dinámicos, como servicios web o scripts automatizados, sin preocuparse por el manejo de archivos en el sistema.
Ejemplos reales
Análisis de datos meteorológicos
Este ejemplo muestra cómo crear un gráfico con la evolución de la temperatura a lo largo de un día. Es común en aplicaciones de monitoreo del clima o en la presentación de datos meteorológicos:
import matplotlib.pyplot as plt
horas = ['6 AM', '9 AM', '12 PM', '3 PM', '6 PM', '9 PM']
temperaturas = [15, 18, 22, 26, 23, 20]
plt.plot(horas, temperaturas, marker='o', linestyle='-', color='blue')
plt.title("Evolución de la Temperatura")
plt.xlabel("Hora del Día")
plt.ylabel("Temperatura (°C)")
plt.grid(True)
plt.show()
Explicación:
marker='o', linestyle='-', color='b' personaliza la línea del gráfico.plt.grid(True) añade una cuadrícula al gráfico para mejorar la legibilidad.
Análisis de datos financieros
Con el siguiente código creamos un gráfico que muestra la evolución del precio de cierre de las acciones de una empresa durante una semana. Este tipo de gráfico es fundamental en finanzas para analizar el rendimiento de acciones, bonos, etc.:
import matplotlib.pyplot as plt
dias = ['Lunes', 'Martes', 'Miércoles', 'Jueves', 'Viernes']
precios = [150, 152, 148, 155, 160]
plt.plot(dias, precios, marker='o', linestyle='-', color='green')
plt.title("Evolución del precio de las acciones")
plt.xlabel("Días de la Semana")
plt.ylabel("Precio de la Acción ($)")
plt.grid(True)
plt.show()
Explicación:
plt.grid(True) añade una cuadrícula al gráfico para facilitar la comparación entre los días.
Análisis de resultados de exámenes
Este ejemplo muestra cómo comparar los resultados de dos clases en un examen. Puede resultar últil para analizar el rendimiento de los estudiantes de grupos diferentes:
import matplotlib.pyplot as plt
clases = ['Clase A', 'Clase B']
promedio_matematicas = [78, 85]
promedio_lenguaje = [82, 88]
x = range(len(clases))
plt.bar(x, promedio_matematicas, width=0.4, label='Matemáticas', align='center')
plt.bar(x, promedio_lenguaje, width=0.4, label='Lenguaje', align='edge')
plt.xlabel('Clases')
plt.ylabel('Promedio de Examen')
plt.title('Comparación de Resultados de Exámenes por Clase')
plt.xticks(x, clases)
plt.legend()
plt.show()
Explicación:
plt.bar(x, promedio_matematicas, width=0.4, label='Matemáticas', align='center') dibuja barras para Matemáticas.plt.bar(x, promedio_lenguaje, width=0.4, label='Lenguaje', align='edge') dibuja barras para Lenguaje justo al lado de las de Matemáticas.plt.legend() añade una leyenda que identifica qué barras corresponden a cada materia.
Recursos adicionales para aprender Matplotlib
Aprender a utilizar Matplotlib a fondo requiere tiempo y práctica, pero afortunadamente, la documentación oficial está muy bien redactada y organizada, y se actualiza con frecuencia. Además, dispone de una extensa galería de ejemplos donde puedes consultar muchos fragmentos de código, y observar el resultado generado.
Documentación oficial
La documentación oficial de Matplotlib es el recurso más completo y fiable. Este es el lugar al que debes recurrir cuando necesites información específica sobre cómo hacer algo con Matplotlib. Aquí encontrarás información detallada sobre todas las funciones y características. La documentación incluye:
- Tutoriales: Introducciones paso a paso para principiantes que cubren desde los gráficos más básicos hasta técnicas avanzadas.
- Guías de Uso: Explicaciones detalladas sobre cómo usar diversas partes de la API de Matplotlib.
- Referencia de API: Una lista exhaustiva de todas las funciones, métodos y clases disponibles en Matplotlib, junto con ejemplos de cómo usarlos.
- Ejemplos de Código: Pequeños fragmentos de código que ilustran cómo lograr resultados específicos con Matplotlib.
Galería de ejemplos
La galería de ejemplos de Matplotlib te proporciona un excelente recurso visual que muestra una gran cantidad de gráficos que puedes crear con Matplotlib. Cada ejemplo en la galería está acompañado del código fuente, lo que te permite ver exactamente cómo se generó el gráfico y experimentar por ti mismo. Esta sección de la documentación oficial incluye:
- Cientos de ejemplos: La galería es ideal para obtener ideas sobre cómo visualizar tus propios datos de manera efectiva.
- Código listo para usar: Puedes copiar y pegar el código directamente en tu propio proyecto y ajustarlo según tus necesidades.
- Tipos de gráficos muy diversos: Desde gráficos de líneas y barras hasta gráficos más complejos como gráficos de violín, mapas de calor, y gráficos 3D.
