Visualización de Series Temporales con Python: Matplotlib y Pandas
Resumen
Representar datos que cambian con el tiempo es una de las tareas más valiosas en el análisis de datos. Cuando trabajas con tablas extensas, detectar patrones resulta complicado, pero al transformar esa información en un gráfico de líneas, las tendencias estacionales, los picos de actividad y las anomalías se vuelven evidentes de inmediato. Aquí se aborda paso a paso cómo construir visualizaciones de series temporales usando Python, Pandas y Matplotlib.
¿Qué es una serie temporal y por qué importa visualizarla?
Una serie temporal es un conjunto de datos ordenados cronológicamente. En el ejemplo presentado, un analista financiero de una empresa de energía renovable necesita monitorear la producción diaria de energía solar [0:03]. Al graficar esa producción a lo largo del tiempo, puede identificar rápidamente que en verano la generación aumenta y en invierno disminuye.
Esta técnica no se limita a las finanzas. Se aplica en:
Meteorología: seguimiento de temperaturas y precipitaciones.
Economía: evolución de indicadores macroeconómicos.
Tráfico web: análisis de visitas por periodo.
Salud: monitoreo de variables clínicas en el tiempo.
Poder representar visualmente estos datos ayuda a anticipar cambios futuros y a tomar decisiones proactivas.
¿Cómo crear un gráfico de líneas con fechas en Python?
El primer paso consiste en importar las librerías necesarias. Se utilizan NumPy para generar datos numéricos, Pandas para construir el dataframe y Matplotlib para graficar. Además, se importa el módulo matplotlib.dates con su función de formato, conocida como DateFormatter, que permite personalizar la forma en que se muestran las fechas en el eje X [0:28].
¿Cómo generar un dataset de fechas y valores?
Con pd.date_range() se crea un rango de fechas. Se especifica la fecha de inicio en formato string (por ejemplo, 2023-01-01) y la cantidad de periodos con el parámetro periods [1:02]. Para los valores, se usa np.random.randn() combinado con cumsum(), que calcula la suma acumulada y genera una serie que crece progresivamente, simulando el comportamiento real de datos temporales [1:22].
Ambos arreglos se integran en un dataframe de Pandas mediante un diccionario con las llaves fecha y valor [1:35].
¿Cómo configurar la figura y personalizar el gráfico?
Se crea la figura llamando a plt.subplots() —con la s al final, detalle importante que se menciona tras un error común al usar subplot en singular [2:42]— y se define el tamaño con figsize=(12, 6). Luego se invoca ax.plot() pasando las fechas y los valores, junto con el color deseado [2:05].
Un aspecto práctico es la rotación de etiquetas. Cuando las fechas son textos largos, se superponen unas sobre otras. Para evitarlo se usa plt.xticks(rotation=45), lo que inclina las etiquetas cuarenta y cinco grados y mejora la legibilidad [2:16].
¿Cómo aplicar series temporales a un caso de ventas mensuales?
El segundo ejemplo simula un análisis de ventas mensuales durante un año completo [3:20]. Se genera un rango de doce fechas usando el parámetro freq='M', que indica frecuencia mensual [3:50]. Las ventas se crean con np.random.randint() especificando un rango entre mil y cinco mil, con doce datos en total [4:06].
¿Cómo añadir marcadores, leyendas y formato de fecha escrito?
Al graficar, se añade el parámetro marker='o' para colocar un círculo en cada intersección de X con Y, y linestyle='-' para líneas continuas [4:38]. También se incluye un label='Ventas Mensuales' que luego se muestra con plt.legend() [4:55].
Para que los meses aparezcan con nombre en lugar de número, se configura el formateador de fechas. Usando ax.xaxis.set_major_formatter(DateFormatter('%b %Y')), la %b minúscula representa el mes abreviado de forma escrita y %Y el año completo [6:06]. El resultado transforma etiquetas numéricas como "2023-07" en "Jul 2023", facilitando la lectura del gráfico.
Finalmente, se ajusta el diseño con plt.tight_layout() para evitar que los elementos se recorten, y se llama a plt.show() para renderizar la visualización [5:40].
Si has seguido estos pasos, intenta crear tu propia serie temporal con datos reales o simulados y comparte el resultado en los comentarios.
Las anotaciones en gráficos ayudan a guiar al lector y a destacar información relevante. Mientras que algunas visualizaciones pueden comunicar la información de manera efectiva solo con elementos visuales, en otros casos es necesario agregar textos y etiquetas para aclarar el mensaje.
Agregar Textos y Etiquetas: Para agregar textos en un gráfico, se puede usar axes.text que permite posicionar el texto en coordenadas específicas.
Flechas y Anotaciones Avanzadas: Para agregar flechas y anotaciones más detalladas, se usa plt.annotate, que permite personalizar el estilo de las flechas.
Por ejemplo, en la imagen, a una serie de tiempo agreguemos un texto "Hallowen". Sin embargo, como observarás, puede que falte contexto específico, de esta manera agregamos flechas y anotaciones como las demás fechas.
Te dejo la implementación de código de un tipo para cada uno. Advertencia, se utiliza subplots.
fig, ax = plt.subplots(figsize=(12,4))dataFrameBirths.plot(ax=ax)## Etiqueta de tipo textoax.text('2012-10-31',4600,"Halloween", ha='right',**style)## Anotaciones y flechasax.annotate("Día de la independencia", xy=('2012-7-4',4250), xycoords='data', bbox=dict(boxstyle="round", fc="none", ec="gray"), xytext=(10,-40), textcoords='offset points', ha='center', arrowprops=dict(arrowstyle="->"))
Muchas gracias por el aporte. En la clase, ponen las opciones u ordenes, y no explican para qué, o de dónde salen. Tu aporte, es muy bueno.
La función cumsum() en el primer ejemplo se utiliza para calcular la suma acumulativa de los valores generados aleatoriamente. Esto significa que cada valor en la serie se suma al anterior, lo que permite visualizar cómo incrementa la producción de energía a lo largo del tiempo. Al graficar esta suma acumulada, puedes observar tendencias y patrones más fácilmente en la serie de tiempo, como el aumento de la producción en ciertos períodos.
SERIES DE TIEMPO
Qué son: Son datos recolectados o registrados en secuencias cronológicas, donde cada punto de datos tiene una marca temporal. Ejemplos incluyen temperaturas diarias, precios de acciones o registros de ventas.
Para qué sirven: Se utilizan para analizar y prever tendencias, patrones estacionales y ciclos a lo largo del tiempo. Son esenciales para el análisis predictivo, el monitoreo de eventos y la toma de decisiones basadas en datos históricos.
Me puse creativo:
import matplotlib.pyplot as pltimport pandas as pdimport numpy as npfrom matplotlib.dates import DateFormatterdates = pd.date_range(start='2023-01-01', periods=100)np.random.seed(42)values = np.random.randn(100).cumsum() + 100 df = pd.DataFrame({'Fecha': dates, 'Valor': values})df.set_index('Fecha', inplace=True)plt.figure(figsize=(10, 6))plt.plot(df.index, df['Valor'], color='blue', linestyle='-', marker='o', label='Valor diario')plt.fill_between(df.index, df['Valor'], color='skyblue', alpha=0.4) plt.title('Visualización de Serie de Tiempo')plt.xlabel('Fecha')plt.ylabel('Valor')plt.grid(True)plt.xticks(rotation=45) plt.legend()date_form = DateFormatter("%b-%d")plt.gca().xaxis.set_major_formatter(date_form)plt.tight_layout()plt.show()
Trabajar con **series de tiempo** y **fechas** en Matplotlib implica no solo graficar datos en función del tiempo, sino también manejar correctamente el formato de las fechas y aplicar personalizaciones. A continuación, te muestro cómo hacerlo paso a paso.
### 1. **Creación de una serie de tiempo**:
Primero, necesitas generar o tener acceso a datos que incluyan una columna de fechas y valores correspondientes.
#### Ejemplo de datos generados con Pandas:
import pandas as pd
import numpy as np
\# Crear un rango de fechas
dates = pd.date\_range(start="2024-01-01", periods=100, freq="D")
\# Crear datos aleatorios
values = np.random.randn(100).cumsum()
\# Crear DataFrame con fechas y valores
time\_series = pd.DataFrame({"Fecha": dates,"Valor": values})
### 2. **Graficar una serie de tiempo con Matplotlib**:
Para graficar los datos de una serie de tiempo, puedes usar plot\_date o simplemente plot si ya tienes los datos correctamente formateados.
#### Ejemplo de gráfico simple de serie de tiempo:
import matplotlib.pyplot as plt
\# Crear el gráfico
plt.figure(figsize=(10,6))plt.plot(time\_series\['Fecha'], time\_series\['Valor'], color='blue', marker='o', linestyle='-', label='Valores')
\# Añadir etiquetas y título
plt.title("Serie de Tiempo")plt.xlabel("Fecha")plt.ylabel("Valor")plt.grid(True)
\# Mostrar leyenda y gráfico
plt.legend()plt.show()
### 3. **Formato de fechas**:
Para mejorar la legibilidad del eje x (fechas), puedes usar el módulo dates de Matplotlib para personalizar el formato de las fechas.
#### Ejemplo de formato de fechas:
import matplotlib.dates as mdates
\# Crear el gráfico
plt.figure(figsize=(10,6))plt.plot(time\_series\['Fecha'], time\_series\['Valor'], color='green')
\# Formatear las fechas en el eje x
plt.gca().xaxis.set\_major\_formatter(mdates.DateFormatter('%Y-%m-%d'))plt.gca().xaxis.set\_major\_locator(mdates.MonthLocator())
\# Rotar las etiquetas de las fechas
plt.gcf().autofmt\_xdate()
\# Añadir etiquetas y título
plt.title("Serie de Tiempo con Formato de Fechas")plt.xlabel("Fecha")plt.ylabel("Valor")plt.grid(True)plt.show()
### 4. **Manejo de intervalos de fechas**:
A veces es necesario ajustar el rango de fechas mostrado en el gráfico. Esto se puede hacer utilizando plt.xlim() o configurando manualmente el rango de fechas.
#### Ejemplo de ajuste del rango de fechas:
\# Crear el gráfico
plt.figure(figsize=(10,6))plt.plot(time\_series\['Fecha'], time\_series\['Valor'], color='red')
\# Limitar las fechas mostradas
plt.xlim(pd.Timestamp("2024-01-01"), pd.Timestamp("2024-03-31"))
\# Añadir etiquetas y título
plt.title("Serie de Tiempo con Rango de Fechas Ajustado")plt.xlabel("Fecha")plt.ylabel("Valor")plt.grid(True)plt.show()
### 5. **Gráfico de barras para series de tiempo**:
También puedes representar una serie de tiempo con un gráfico de barras para resaltar los valores individuales.
#### Ejemplo de gráfico de barras:
plt.figure(figsize=(10,6))plt.bar(time\_series\['Fecha'], time\_series\['Valor'], color='purple')
\# Formatear las fechas en el eje x
plt.gca().xaxis.set\_major\_formatter(mdates.DateFormatter('%Y-%m-%d'))plt.gca().xaxis.set\_major\_locator(mdates.WeekdayLocator())
\# Rotar las etiquetas de las fechas
plt.gcf().autofmt\_xdate()
\# Añadir etiquetas y título
plt.title("Serie de Tiempo - Gráfico de Barras")plt.xlabel("Fecha")plt.ylabel("Valor")plt.grid(True)plt.show()
### Resumen de puntos importantes:
- **Fechas**: Usa pd.date\_range() para generar rangos de fechas y manipula columnas de fechas en Pandas.
- **Formateo de Fechas**: Usa mdates.DateFormatter para ajustar el formato de fechas en el eje x.
- **Intervalos**: Limita el rango de fechas con plt.xlim() o ajustando el índice de las fechas.
- **Rotación de Fechas**: Usa plt.gcf().autofmt\_xdate() para rotar etiquetas si hay superposición.
Estas herramientas te permitirán manejar y visualizar series de tiempo de manera efectiva en Matplotlib.
No entiendo porque pone el igual despues del pd.DataFrame.
Lo que pasa es que estamos sobrescribiendo pd.DataFrame
por lo cual, si intentamos seguir la correcta sintaxis (que es sin el =) va a generar error.
TypeError: 'dict' object is not callable
Recomendaciones:
Encapsular en Funciones:
Verificar el Tipo de Variables: Antes de crear un DataFrame, puedes verificar si pd.DataFrame es una función.
print(type(pd.DataFrame)) # Debería ser <class 'type'>
si te sale el error TypeError: 'dict' object is not callable es porque ya habias ejecutado el comando antes y ya se habia sobreescrito. simplemente fue un error poner un = en esa linea pero de alguna forma siguió funcionando
Qué es: Matplotlib es una biblioteca de visualización en Python que permite graficar datos, incluyendo series de tiempo. Para manejar fechas, se integra con librerías como datetime y pandas, que facilitan la manipulación de fechas y tiempos.
Para qué sirve: Permite crear gráficos que representan datos a lo largo del tiempo, como líneas de tiempo, gráficos de dispersión con fechas, y más. Esto ayuda a visualizar cómo cambian los datos en función del tiempo y facilita el análisis de tendencias y patrones.
MOdelo coworcountry o modelo coworculture con muchas actividades para pausas activas y acompañamiento de tu rol profesional Recuerda que Estamos enfocados en atender y brindar espacios para nomadas digitales, teletrabajo y coworking space en Agrolenials Paradise Ecohostel Country Inns contacto directo whatsapp +573206299333 y Faccebook
#Primero se crea la informacion #Fechas de ventas aleatorias dates = pd.date_range(start="2024-01-01", periods=12, freq="M")#Valores de ventas aleatorias sales = np.random.randint(1000,5000, size=12)#Crear el data Frame con la informaciondata = pd.DataFrame({"Dates":dates,"Sales":sales})#Segundo crear el graficofig, ax1= plt.subplots(figsize=(12,8))plt.grid(True, linestyle=":", alpha=0.6)ax1.plot(data["Dates"], data["Sales"], color="blue", marker="s", label="ventas mensuales")plt.gca().xaxis.set_major_formatter(DateFormatter("%b %Y"))plt.xticks(rotation=45)plt.title("Serie de tiempo con formato de ventas")plt.xlabel("Dates")plt.ylabel("Sales")plt.legend()plt.show()
#Mi código del caso práctico
import matplotlib.pyplot as plt
import pandas as pd
import numpy as np
from matplotlib.dates import DateFormatter
date = pd.date_range(start='2023-01-01', periods=100)
values = np.random.rand(100).cumsum()
data = pd.DataFrame({'Date': date, 'Value': values})
## Establecer y configurar los parámetros del gráfico
date = pd.date_range(start='2023-01-30', periods=12, freq='M') # M = último día del mes, MS = primer día del mes.
venta = np.random.randint(2000,5000, size=12)
## Pasar los parámetros establecidos a un DataFrame
dates = pd.date_range(start='2025-01-01', periods=12, freq='MS')temperatures = np.random.uniform(15,30, size=12)temperature_data = pd.DataFrame({'Date': dates,'Temperature': temperatures})plt.plot(temperature_data['Date'], temperature_data['Temperature'], marker='o', linestyle='-', label='Temperatura promedio mensual')plt.gca().xaxis.set_major_formatter(DateFormatter('%b %Y'))plt.xticks(rotation=45)plt.xlabel('Fecha')plt.ylabel('Temperatura (°C)')plt.title('Evolución de la temperatura promedio mensual')```
dates = pd.date_range(start='2025-01-01', periods=12, freq='MS')temperatures = np.random.uniform(15,30, size=12)temperature_data = pd.DataFrame({'Date': dates,'Temperature': temperatures})plt.plot(temperature_data['Date'], temperature_data['Temperature'], marker='o', linestyle='-', label='Temperatura promedio mensual')plt.gca().xaxis.set_major_formatter(DateFormatter('%b %Y'))plt.xticks(rotation=45)plt.xlabel('Fecha')plt.ylabel('Temperatura (°C)')plt.title('Evolución de la temperatura promedio mensual')```
La línea de código plt.gca().xaxis.set_major_formatter(DateFormatter('%b %Y')) se utiliza en Matplotlib para formatear las etiquetas del eje X en un gráfico. En este caso, %b %Y indica que las fechas se mostrarán en el formato de mes abreviado seguido del año (por ejemplo, "Jan 2023"). Esto mejora la legibilidad de las fechas en gráficos de series temporales al presentar la información de manera más clara y concisa.
Recuerda que para que esto funcione adecuadamente, debes asegurarte de que el eje X contenga datos de tipo fecha y que hayas importado DateFormatter desde matplotlib.dates.
Grafico creado utilizando la data online_retail.csv
Si quisieramos hacer el ejercicio usando la data definida principalemente