Trabajar con datos temporales es una de las tareas más frecuentes en el análisis de datos, y Pandas ofrece herramientas poderosas para hacerlo de forma eficiente. Cuando las fechas llegan como cadenas de texto desde archivos CSV u otras fuentes, es indispensable convertirlas al tipo datetime para habilitar operaciones como filtrado por rangos, resampling y análisis de tendencias.
¿Por qué convertir columnas al tipo datetime?
Al cargar un dataset, es común que columnas como Invoice Date aparezcan con tipo de dato object o string [0:40]. Esto limita cualquier operación temporal. Para solucionarlo, se utiliza la función pd.to_datetime(), que transforma la columna completa al formato adecuado.
Después de ejecutar esta conversión, al consultar df.info() se confirma que la columna ahora tiene tipo datetime64 [1:22]. Este paso es fundamental antes de cualquier análisis temporal.
También es recomendable eliminar valores nulos en la columna de fechas utilizando dropna() con el parámetro subset para especificar la columna y el parámetro inplace=True para modificar el DataFrame directamente sin generar una copia [1:40].
¿Cómo establecer fechas como índice y extraer componentes?
Una práctica muy útil es asignar la columna de fechas como índice del DataFrame mediante set_index() [2:20]. Esto permite acceder a los datos por fecha de forma directa.
python
df.set_index('Invoice Date', inplace=True)
Una vez que el índice es de tipo datetime, se pueden descomponer sus componentes en columnas independientes [3:00]:
df['año'] = df.index.year extrae el año.
df['mes'] = df.index.month extrae el mes.
df['dia'] = df.index.day extrae el día.
df['dia_semana'] = df.index.dayofweek devuelve un número del 0 al 6, donde 0 es lunes.
df['hora'] = df.index.hour extrae la hora.
El formato que se respeta en el índice es año-mes-día hora:minutos:segundos [2:50]. Es importante verificar siempre el resultado imprimiendo el DataFrame completo después de cada modificación para asegurar que todo esté correcto [4:20].
¿Qué hacer si se comete un error al crear una columna?
Si una columna se crea con un nombre incorrecto, la mejor estrategia es eliminarla con drop() y volver a crearla correctamente [4:50]. Al crear la nueva columna sin especificar posición, esta se agrega al final del DataFrame.
Esto devuelve todas las filas comprendidas entre ambas fechas, incluyendo los extremos.
¿Cómo generar rangos de fechas desde cero?
Pandas incluye la función pd.date_range() para crear secuencias de fechas personalizadas [7:50]. Se especifica una fecha de inicio, una de fin y la frecuencia deseada.
python
rango = pd.date_range(start='2024-01-01', end='2024-12-31', freq='D')
df_fechas = pd.DataFrame(rango, columns=['date'])
El parámetro freq='D' indica frecuencia diaria, generando cada día dentro del rango especificado [8:10]. Esta funcionalidad es muy útil para crear DataFrames temporales desde cero.
Dominar el tipo datetime en Pandas abre la puerta a análisis temporales robustos. Con los datos transformados y organizados, el siguiente paso natural es pensar en cómo visualizar esta información para comunicarla de forma efectiva al stakeholder. ¿Qué tipo de visualización consideras más adecuada para datos temporales? Comparte tu opinión en los comentarios.
Definitivamente la musica estorba, por favor no la pongan!!
El manejo de **series temporales** es fundamental cuando trabajamos con datos que incluyen fechas y tiempos. **Pandas** proporciona herramientas poderosas para manipular, analizar y visualizar series temporales de manera eficiente. Aquí te explico las operaciones clave que puedes realizar con **Pandas** para trabajar con datos de tipo temporal.
### 1. **Creación de Series Temporales**
#### Crear una serie de fechas:
Puedes crear una serie de fechas usando pd.date\_range().
import pandas as pd
\# Crear una serie de fechas desde el 1 de enero de 2023, con 10 días de frecuencia
fechas = pd.date\_range(start='2023-01-01', periods=10, freq='D')print(fechas)
#### Crear un DataFrame con una columna de fechas:
\# Crear un DataFrame con fechas y datos
data = pd.DataFrame({  'fecha': pd.date\_range('2023-01-01', periods=10, freq='D'),  'valor': range(10)})print(data)
### 2. **Conversión de Fechas (Datetime)**
Si tienes una columna de fechas como texto, puedes convertirla a formato **datetime** usando pd.to\_datetime().
\# Crear un DataFrame con fechas como cadenas
data = pd.DataFrame({  'fecha': \['2023-01-01', '2023-01-02', '2023-01-03'],  'valor': \[10, 20, 30]})\# Convertir la columna 'fecha' a formato datetime
data\['fecha']= pd.to\_datetime(data\['fecha'])print(data.dtypes)
### 3. **Indexación y Selección por Fechas**
Cuando trabajas con series temporales, a menudo querrás usar las fechas como índice. Esto facilita la selección de datos basados en intervalos de tiempo.
#### Establecer una columna de fechas como índice:
data.set\_index('fecha', inplace=True)print(data)
#### Selección de datos por fecha:
\# Seleccionar datos de una fecha específica
print(data.loc\['2023-01-02'])
\# Seleccionar datos por rango de fechas
print(data.loc\['2023-01-01':'2023-01-03'])
### 4. **Resampling (Re-Muestreo)**
El **resampling** permite agrupar datos por diferentes frecuencias de tiempo (como días, meses, o años). Es útil para agregar, promediar o tomar la suma de datos en diferentes intervalos de tiempo.
#### Ejemplo de re-muestreo a frecuencia mensual:
\# Crear un DataFrame con datos diarios
data = pd.DataFrame({  'fecha': pd.date\_range(start='2023-01-01', periods=100, freq='D'),  'valor': range(100)})data.set\_index('fecha', inplace=True)\# Re-muestrear a frecuencia mensual y sumar los valores
data\_mensual = data.resample('M').sum()print(data\_mensual)
#### Frecuencias comunes para resampling:
- D: Día.
- M: Mes.
- Y: Año.
- H: Hora.
- T: Minuto.
### 5. **Shifting y Lagging**
El desplazamiento (shift()) se utiliza para mover datos hacia adelante o hacia atrás en el tiempo. Esto es útil para calcular diferencias entre períodos consecutivos.
#### Ejemplo de shift():
\# Desplazar los valores hacia abajo
data\['valor\_shift']= data\['valor'].shift(1)print(data)
#### Calcular la diferencia entre períodos:
\# Calcular la diferencia entre un valor y el anterior
data\['diferencia']= data\['valor']- data\['valor'].shift(1)print(data)
### 6. **Ventanas Móviles (Rolling Windows)**
Las ventanas móviles permiten aplicar funciones (como media, suma, etc.) sobre ventanas deslizantes de datos temporales.
#### Ejemplo de media móvil:
\# Calcular la media móvil de 3 díasdata\['media\_movil']= data\['valor'].rolling(window=3).mean()print(data)
### 7. **Frecuencias de Fechas Personalizadas**
Pandas permite trabajar con diferentes frecuencias de tiempo, no solo días o meses. Puedes crear series de tiempo con frecuencias personalizadas, como días laborables (B), horas (H), semanas (W), etc.
#### Ejemplo de días laborables:
\# Crear una serie temporal solo con días laborables
fechas\_laborables = pd.date\_range(start='2023-01-01', periods=10, freq='B')print(fechas\_laborables)
#### Frecuencias comunes:
- B: Días laborables.
- W: Semanas.
- H: Horas.
- T o min: Minutos.
- S: Segundos.
### 8. **Visualización de Series Temporales**
Podemos usar **Matplotlib** para visualizar datos de series temporales.
#### Ejemplo de gráfico de línea para una serie temporal:
import matplotlib.pyplot as plt
\# Crear una serie temporal con datos aleatorios
data = pd.DataFrame({  'fecha': pd.date\_range(start='2023-01-01', periods=100, freq='D'),  'valor': np.random.randn(100).cumsum()})data.set\_index('fecha', inplace=True)
\# Graficar la serie temporal
data\['valor'].plot(title='Serie Temporal')plt.xlabel('Fecha')plt.ylabel('Valor')plt.show()
### 9. **Resampling con Agregaciones Personalizadas**
Además de sumar o promediar, puedes aplicar cualquier función personalizada al re-muestrear los datos.
#### Ejemplo de re-muestreo con agregación personalizada:
\# Re-muestrear por mes y aplicar diferentes agregaciones
data\_resample = data.resample('M').agg({  'valor': \['sum', 'mean', 'max']})print(data\_resample)
### 10. **Manipulación Avanzada de Series Temporales**
#### Descomposición estacional:
Puedes descomponer una serie temporal en sus componentes estacionales, tendencia y residuales usando statsmodels.
from statsmodels.tsa.seasonal import seasonal\_decompose
\# Descomponer la serie temporal
resultado = seasonal\_decompose(data\['valor'], model='additive', period=30)
\# Graficar los resultados de la descomposición
resultado.plot()plt.show()
#### Ajuste de zonas horarias (time zones):
Pandas permite ajustar y convertir zonas horarias de manera eficiente.
\# Convertir a zona horaria UTC
data = data.tz\_localize('UTC')
\# Convertir a una nueva zona horaria
data = data.tz\_convert('America/New\_York')print(data)
### Resumen de Operaciones Clave:
- **pd.date\_range()**: Para crear series de fechas.
- **pd.to\_datetime()**: Para convertir columnas de fechas.
- **set\_index()**: Para establecer fechas como índice.
- **resample()**: Para cambiar la frecuencia temporal.
- **shift()**: Para desplazar datos en el tiempo.
- **rolling()**: Para aplicar funciones sobre ventanas móviles.
- **tz\_localize() y tz\_convert()**: Para ajustar zonas horarias.
Con estas herramientas puedes manejar series temporales de manera eficiente en Pandas. Si tienes alguna duda o quieres profundizar en un tema específico, ¡avísame!
Para colocar una nueva columna en una posición específica en un DataFrame de Pandas, puedes usar el método insert(). Este método te permite especificar el índice donde deseas insertar la nueva columna. Aquí tienes un ejemplo:
import pandas as pd
# DataFrame de ejemplodf = pd.DataFrame({'A':[1,2,3],'B':[4,5,6]})# Insertar nueva columna 'C' en la posición 1df.insert(1,'C',[7,8,9])print(df)
Esto insertará la columna 'C' en la posición 1, desplazando las demás columnas a la derecha.
Tomando esto como ejemplo, la solución para agregar la columna Weekday en la posición 10 y no al final de la derechadf.insert(10, "Weekday", df.index.weekday)```python
Ubicando columna Weekday en la penultma columna (la última es la posición 11 que la ocupará la columna Hour)
df.insert(10, "Weekday", df.index.weekday)
Monstrar DataFrame
df
Una forma de ver que en el Q4 del 2010 (siendo vísperas navideñas, no tuvo el impacto en ventas, como en el Q4 del 2011, donde se disparó mucho!
🤯 Increíble aporte, yo hice algo parecido en la clase de reestructuración de datos con pivot table, pero como desconocía esta forma de crear trimestres a partir de datos de tiempo, así que hice una función para calcular los trimestres 😂.
Mil gracias por tu aporte 🙌🏼
El manejo de series temporales en Pandas es clave para analizar datos a lo largo del tiempo. Permite detectar tendencias, estacionalidades y fluctuaciones cíclicas en tus datos. La conversión de fechas a tipo datetime es fundamental, así como establecer la columna de tiempo como índice del DataFrame. Utilizando métodos como resample, puedes agrupar tus datos por periodos, ya sean días, meses o años, facilitando el análisis y la visualización. Para graficar, puedes usar Matplotlib, lo que ayuda a identificar patrones visualmente.
Cómo le ha hace la maestra para que los datos ocupen todo el ancho de pantalla¿?
Sería interesante que en el futuro se hagan cursos de Series de Tiempo (clásica, multivariada, con machine learning, modelos avanzados etc). Es un campo con mucha demanda y transversal a varios perfiles profesionales.
Yo te apoyo, estuve buscando información y es mucho más complejo que solo cambiar el tipo de dato y hacer filtros. Solo el tema de llenar datos faltantes con fechas es super complejo y aplicarlo a casos ufff... sería un curso completo.
🟢 Qué es un Timestamp
Un timestamp es una representación de un momento específico en el tiempo. Generalmente, se expresa como el número de segundos o milisegundos transcurridos desde una fecha y hora base, que suele ser el 1 de enero de 1970 a la medianoche UTC (Conocida como la Epoch en UNIX).
Los timestamps pueden ser representados en diferentes unidades de tiempo. Los más comunes son:* Segundos: Por ejemplo, 1609459200 representa el 1 de enero de 2021.
Milisegundos: Por ejemplo, 1609459200000 representa el mismo momento pero en milisegundos.
No confundas este concepto con formatos de fecha que generan algunos lenguajes de programación como: YYYY-MM-DDTHH:MM:SS.sssZ o datetime(2024, 9, 16, 8, 48, 2, 313465).
¡Nunca pares de aprender! 🚀🚀
Manejo de series temporales en Pandas
Se refiere a trabajar con datos indexados por fechas y tiempos. Pandas facilita esta tarea con herramientas para:
Indexación Temporal: Utiliza fechas como índices en DataFrames o Series.
Generación de Fechas: Usa pd.date_range() y pd.to_datetime() para crear o convertir datos temporales.
Resampling: Cambia la frecuencia de los datos (por ejemplo, de diaria a mensual) con resample().
Desplazamiento: Mueve datos en el tiempo con shift().
Rolling Windows: Aplica funciones estadísticas a ventanas móviles con rolling().
Estas herramientas te permiten analizar y modelar datos temporales de manera eficiente.
¿Qué tipo de visualización consideras más adecuada para datos temporales?
Yo entiendo que la visualización más adecuada es los gráficos de líneas, que nos ayudan para analizar tendencias a lo largo del tiempo.
Una observación - los subtítulos del video no se corresponden con el audio
Gracias, ya lo arreglamos :D
Con el error que presenta al nombrar la columna wekdy es necesario eliminarla y volver a crearla?. No es posible corregir donde se creo la columna y correr de nuevo el código?
Hola diego, al corregir el nombre sin eliminar la columna tendrás 2 columnas, la del error y la nueva corregida, por eso es importante eliminarla.
Es increíble lo que se puede hacer con las series temporales cuando se ponen en el índice del dataframe! Muy buena clase!
1. Cargar y Previsualizar el Dataset
file_path = 'online_retail.csv'
df = pd.read_csv(file_path)
print(df.head())
Descripción:
Carga el archivo online_retail.csv en un DataFrame de Pandas llamado df usando read_csv.
Muestra las primeras cinco filas del DataFrame utilizando head() para previsualizar su estructura.
Resultado: Las primeras cinco filas del conjunto de datos, con columnas como InvoiceNo, StockCode, Description, Quantity, InvoiceDate, UnitPrice, CustomerID y Country.
2. Comprender la Estructura del Dataset
df.info()
Descripción:
El método info() proporciona un resumen del conjunto de datos, incluyendo:
El número de filas.
Los nombres de las columnas.
Conteo de valores no nulos por columna.
Tipos de datos por columna.
Uso de memoria del DataFrame.
Resultado: Un resumen de la estructura del conjunto de datos, ayudando a comprender su tamaño y la presencia de datos faltantes.
Crea un DataFrame df_dates a partir del rango de fechas generado, con una sola columna llamada Date.
Resultado: Un DataFrame que contiene las primeras filas de la columna Date.
Una pregunta. No se supone que los indices deben ser UNICOS. Como se trabaja eso si las fechas son las mismas en muchos casos.
algo que no aclaran en la clase es el uso del formato, por defecto pd.dateTime usa 'yyyy-mm-dd'
cuidado si sus datos estan en un formato yankee o latino y quieren pasar a dateTime, deben verificar en que formato vienen sus datos para poder transformarlos bien a DateTime
📝 Mis apuntes de la clase
Las series de tiempo representan datos en un punto determinado del tiempo, esto nos permite realizar análisis de tendencias, patrones estacionales, fluctuaciones u otros comportamientos a lo largo del tiempo.
Trabajar con series de tiempo nos permite realizar operaciones complejas de forma eficiente.
Por ejemplo:
Filtrado por fechas.
Remuestreo.
Análisis de tendencias.- Acceso avanzado a los datos por medio de la funcionalidad loc, indicando solo el año, mes o rango de fechas.
Al trabajarlas con pandas debemos:
Asegurar que las columnas que contengan datos de fecha y hora tengan el formato adecuado. Se corrigen con la función pd.to\_date().
Cambiar el ídice numérico del DataFrame por el valor de la columna que contenga la fecha en el formato datetime. Se logra con la función integrada en la instancia del DF df.set\_index("columna", inplace=True)
El formato datetime de pandas habilita nuevas funcionalidades:
Extracción de partes especificas de la fecha (año, mes, día, nombre del mes, día de la semana, etc.).
Indexación por fechas.
Generar rango de tiempo con pf.date\_range().- Manejo de datos faltantes con interpolate.- Etc.
Ejemplos:
"""
Cambiamos el indice numérico del dataframe por un indice datetime a partir
de la columna InvoiceDate"""
print("Indice anterior:", df.index.dtype)df.set_index("InvoiceDate", inplace=True)print("Indice nuevo:", df.index.dtype)df.head()
Al colocar InvoiceDate como índice ésta columna ya no aparece en el DataFrame, por lo tanto para acceder a sus respectivos valores lo haremos mediante la propiedad index.
print(df.index[:5])# Extraer elementos de especificos de una fecha:print("Año", df.sample(5).index.year[:5])print("Mes", df.sample(5).index.month[:5])print("Nombre mes:", df.sample(5).index.month_name())# Filtro avanzado a partir del indice tipo datetime con .locprint("Enero 2011:")display(retail_df.loc["2011-01"].sample(5))print("Rango: desde 01/15/2011 al 15/12/2011 ")display(retail_df.loc["2011-12-01":"2011-12-15"].sample(5))
