Fechas y series temporales con pandas

Una fecha es más útil cuando pandas sabe que es una fecha. Una serie temporal vincula observaciones con momentos o intervalos de tiempo. Las lecturas de energía por hora forman una serie regular; los pedidos que llegan a intervalos desiguales forman una irregular. Un texto como «12/31/2024» puede ordenarse después de «03/01/2025», aunque diciembre llegó primero. Las cadenas ISO completas y coherentes se ordenan correctamente, pero los valores de fecha y hora también permiten la selección por calendario y las operaciones aritméticas.

Elige el objeto temporal adecuado

Python proporciona datetime, date y timedelta. En pandas, un Timestamp contiene un momento, una columna de fechas y horas tiene el tipo de datos datetime64[unit] y un DatetimeIndex contiene etiquetas de fila de fecha y hora. NaT indica una fecha u hora faltante. Detéctala con pd.isna(); restar una fecha u hora faltante produce otra fecha u hora faltante.

La unidad de datetime64[us] es el microsegundo, la resolución de almacenamiento. Otras unidades incluyen segundos (s), milisegundos (ms) y nanosegundos (ns). pandas 3 normalmente interpreta el texto con resolución de microsegundos y usa nanosegundos cuando el texto los necesita. Una resolución más fina usa más parte del intervalo de enteros: las fechas en nanosegundos solo abarcan de 1677 a 2262.

Calcula el tiempo transcurrido

import pandas as pd
start = pd.Timestamp("2025-03-10 18:00")
end = pd.Timestamp("2025-03-14 09:30")
elapsed = end - start
hours = elapsed / pd.Timedelta(hours=1)

elapsed es 3 días, 15 horas y 30 minutos. Los tres días aportan 72 horas, así que hours es 87,5. elapsed.total_seconds() da 315 000. Su atributo .days da solo 3; es el componente de días completos, no la duración completa en días. Crea duraciones con pd.Timedelta(hours=36) o interpreta varias con pd.to_timedelta(["1h", "90min"]).

Restar una marca de tiempo a una columna completa de fechas y horas produce duraciones fila por fila. Utiliza .dt.days para los componentes de días completos o divide la columna de duraciones entre un Timedelta de una unidad para obtener totales fraccionarios.

Lee componentes del calendario y redondea horas

En una columna, .dt.year, .dt.month, .dt.hour y .dt.quarter extraen componentes del calendario. .dt.day_of_week numera el lunes como 0 hasta el domingo como 6; .dt.day_name() da un nombre. El 14 de marzo de 2025 es viernes, con el número 4. Un índice utiliza estos atributos directamente: df.index.month. Los nombres day_of_week y day_of_year sustituyen a los nombres antiguos declarados obsoletos en pandas 3.1.

Un día de la semana puede convertirse en una clave de agrupación: df.groupby(df["timestamp"].dt.day_name())["kwh"].mean(). Agrupar por número de mes combina ese mes de distintos años; un período mensual mantiene cada año separado.

Para 09:37, .dt.floor("h") da 09:00, .dt.ceil("h") da 10:00 y .dt.round("15min") da 09:30. .dt.normalize() establece las horas a medianoche y conserva los valores de fecha y hora. En cambio, .dt.date produce objetos de fecha de Python y pierde las funciones de las columnas de fechas y horas.

Mantén explícitas las unidades numéricas

astype("int64") devuelve recuentos en la unidad propia de la columna. Un recuento en microsegundos es 1000 veces menor que el recuento en nanosegundos del mismo momento. Si un cálculo externo necesita nanosegundos, utiliza s.dt.as_unit("ns").astype("int64"); un Timestamp o un índice utiliza .as_unit("ns") directamente. Para el tiempo transcurrido, las operaciones con Timedelta evitan esa confusión de unidades.

La interpretación da al texto un significado de calendario. Antes de convertir una columna de fechas, establece su formato y comprueba si contiene desfases, entradas no válidas o valores faltantes. ISO 8601 escribe primero el año, como en «2025-03-14T09:30:00», y evita la ambigüedad entre día y mes.

Indica el formato de origen

«03/04/2025» puede significar el 4 de marzo o el 3 de abril. pd.to_datetime("03/04/2025") lee primero el mes; dayfirst=True lee primero el día. Un formato conocido es más claro:

raw = pd.Series(["14/03/2025 18:45", "15/03/2025 09:00"])
parsed = pd.to_datetime(raw, format="%d/%m/%Y %H:%M")

%Y es un año de cuatro dígitos, %m un mes y %d un día. %H es una hora de reloj de 24 horas, %M un minuto y %S un segundo. Utiliza %I con %p para un reloj de 12 horas y AM/PM. %b y %B leen nombres de mes abreviados y completos. %M en mayúscula significa minutos, así que no puede sustituir a %m en minúscula para los meses.

Sin format, pandas infiere un formato a partir de la primera entrada presente y lo aplica a la columna. Con «03/04/2025» primero, un «13/04/2025» posterior falla al inferirse que el mes va primero. Cambiar el orden de las filas puede cambiar el formato inferido. format="ISO8601" gestiona variantes de ISO. format="mixed" interpreta las entradas individualmente, pero no puede resolver una convención de origen ambigua; limpia o comprueba primero esa convención.

Inspecciona las conversiones fallidas

raw = pd.Series(["2025-01-15", "not a date", None])
parsed = pd.to_datetime(raw, format="%Y-%m-%d", errors="coerce")
failed = parsed.isna() & raw.notna()

El resultado contiene el 15 de enero y dos valores NaT. parsed.isna().sum() es 2 porque incluye la entrada que ya faltaba. failed.sum() es 1 porque solo «not a date» estaba presente y no se pudo interpretar. Inspecciona raw[failed] antes de decidir si lo corriges o eliminas. La coerción permite que la carga continúe, pero también oculta errores de escritura como un mes imposible. La opción predeterminada errors="raise" se detiene ante entradas no válidas; pandas 3 eliminó errors="ignore".

Interpreta archivos y marcas de tiempo numéricas

pd.read_csv("meter.csv", parse_dates=["timestamp"], index_col="timestamp") solicita la interpretación de fechas y horas y un índice temporal. Comprueba los tipos de datos resultantes después de la carga. Las columnas de texto en pandas 3 usan el tipo de datos str; las versiones anteriores suelen mostrar object.

Une las cadenas de fecha y hora separadas con un espacio antes de interpretarlas. Las columnas llamadas year, month y day se pueden reunir directamente con pd.to_datetime(df[["year", "month", "day"]]).

Para los recuentos Unix, especifica la unidad. pd.to_datetime(1735689600, unit="s", utc=True) da la medianoche UTC del 1 de enero de 2025. El recuento en milisegundos es 1735689600000 con unit="ms". Usar la unidad equivocada cambia el momento interpretado.

Da formato solo para la presentación

parsed.dt.strftime("%d %b %Y") escribe texto como «15 Jan 2025». El método .isoformat() de un Timestamp escribe una cadena ISO. Los nombres de meses y días de la semana siguen la configuración regional del sistema; los ejemplos mostrados usan inglés. Conserva las fechas y horas durante el análisis y dales formato al exportar, porque las cadenas dejan de permitir operaciones aritméticas con fechas.

Un índice temporal útil está interpretado, ordenado y comprobado. Una tabla puede contener varios eventos en un mismo momento, días ausentes o lotes desordenados. Cada situación cambia el significado de los cálculos posteriores.

Crea etiquetas de fila de fecha y hora

df["timestamp"] = pd.to_datetime(df["timestamp"], format="%Y-%m-%d %H:%M")
df = df.set_index("timestamp").sort_index()

set_index() desplaza la columna a las etiquetas de fila; no interpreta texto. Inspecciona df.index.dtype para comprobar que el tipo de datos sea de fecha y hora y df.index.is_monotonic_increasing para comprobar el orden cronológico. Un índice creciente permite horas consecutivas iguales, así que esta comprobación no establece la unicidad.

Un DatetimeIndex permite seleccionar fechas y remuestrear. Las etiquetas de texto no se convierten en un índice temporal solo porque parezcan fechas. También puedes dejar las marcas de tiempo en una columna: df.resample("D", on="timestamp") utiliza esa columna sin cambiar el índice. Un PeriodIndex es otra representación de serie temporal cuando las filas describen intervalos como meses.

Decide qué significan las horas repetidas

df.index.is_unique indica si todas las etiquetas son distintas. df.index.duplicated() marca las etiquetas repetidas después de la primera. Supón que dos lecturas, 3 y 5, comparten el 1 de enero y una lectura de 4 corresponde al 2 de enero. Promediar las lecturas duplicadas con df.groupby(level=0).mean() produce 4,0 en ambas fechas.

Esa operación es una decisión sobre los datos. Si las filas son compras separadas, sumarlas puede ser adecuado. Si una importación duplicó un registro, puede ser adecuado conservar la última copia con df[~df.index.duplicated(keep="last")]. No elimines transacciones válidas solo para que un índice sea único. Las operaciones que sitúan un valor en cada etiqueta de destino, incluidas reindex() y asfreq(), requieren etiquetas de origen únicas.

Distingue la frecuencia almacenada de la inferida

Un índice creado con pd.date_range() normalmente lleva .freq. Las marcas de tiempo interpretadas suelen tener .freq igual a None, incluso cuando corresponden a días consecutivos. pd.infer_freq(df.index) examina al menos tres marcas de tiempo y devuelve un alias como «D» o «ME» si encuentra un patrón regular. Un espaciado irregular devuelve None.

Los metadatos de frecuencia no son una comprobación de integridad. Para buscar filas diarias ausentes, crea el calendario que esperas:

calendar = pd.date_range(df.index.min(), df.index.max(), freq="D")
missing = calendar.difference(df.index)

Un día ausente no tiene fila. Se diferencia de una fila presente que contiene NaN. Un calendario limitado por el mínimo y el máximo observados no puede revelar fechas ausentes fuera de ese intervalo; utiliza el inicio y el final previstos del período de informe cuando los conozcas.

Prepárate para operaciones posteriores

La ordenación hace que los segmentos sean predecibles y es necesaria para las ventanas móviles basadas en el tiempo. Las filas ausentes importan incluso cuando un cálculo se ejecuta correctamente: shift(1) significa una fila hacia atrás y rolling(7) significa siete filas. Ninguno comprueba que cada fila represente un día. En una tabla larga, conserva también la clave de la serie, como el sensor o la tienda, para que las operaciones posteriores puedan ejecutarse por separado para cada serie.

Una vez que el índice contiene fechas y horas ordenadas, las cadenas de fecha se convierten en selectores útiles. Su precisión determina cuánto tiempo representan: un año, un mes, un día o un minuto concreto.

Selecciona un período completo del calendario

Para datos diarios de enero a marzo de 2025, ts.loc["2025"] selecciona los 90 días. ts.loc["2025-02"] selecciona los 28 días de febrero. En datos por hora, una cadena de día selecciona todo ese día, no solo la medianoche.

Utiliza también .loc en un DataFrame:

february = df.loc["2025-02", "kwh"]
spring_onward = df.loc["2025-03-01":]

En cambio, df["2025-02"] solicita una columna con ese nombre. La presencia de un índice temporal no convierte la selección de columnas con corchetes en una selección de filas.

Interpreta el extremo con precisión

Un segmento por etiquetas incluye ambos extremos. ts.loc["2025-01-30":"2025-02-02"] incluye el 30 y 31 de enero y el 1 y 2 de febrero. Un segmento por posiciones como ts.iloc[0:4] termina antes de la posición 4.

El final de un segmento con cadena parcial incluye todo el período indicado. En datos por hora, df.loc[:"2025-06-01"] incluye todo el 1 de junio. df.loc[:"2025-06-01 00:00"] termina a medianoche. Del mismo modo, un segmento que termina en «2025-02» incluye todo febrero. Elegir una cadena más precisa cambia el límite, así que escribe el punto de corte de acuerdo con la pregunta.

ts.truncate(before="2025-03-01") conserva desde el 1 de marzo en adelante. Su argumento after= recorta el otro extremo. Ordenar primero evita fallos que pueden ocurrir cuando los segmentos con cadenas de fecha se encuentran con etiquetas desordenadas.

Selecciona condiciones recurrentes del calendario

Los atributos del calendario producen máscaras booleanas:

weekends = df[df.index.day_of_week >= 5]
evening_march = df[(df.index.month == 3) & (df.index.hour >= 18)]

El lunes es 0, así que el sábado y el domingo son 5 y 6. Cada condición necesita paréntesis cuando se combina con & o |. Con una columna de fechas y horas, utiliza df["timestamp"].dt.day_of_week en lugar de un atributo del índice. La máscara de días de la semana selecciona un patrón recurrente del calendario; es diferente de seleccionar un intervalo continuo de fechas.

Selecciona una franja horaria en cada fecha

df.between_time("09:00", "17:00") selecciona esas horas cada día. Ambos extremos se incluyen por defecto, lo que da nueve filas en un día completo con datos por hora. inclusive="left" incluye las 09:00 y excluye las 17:00, lo que da ocho. df.at_time("12:00") selecciona exactamente el mediodía de cada día.

Una franja horaria puede cruzar la medianoche. between_time("22:00", "06:00") selecciona filas de las últimas horas de la noche y las primeras de la mañana a lo largo del índice. No selecciona un intervalo ininterrumpido entre dos fechas concretas. En un índice con zona horaria, la selección con cadenas de fecha usa la zona local del índice; convierte el índice antes de seleccionar un día de informe en otra zona.

Una variación necesita un punto de comparación claro. «Anterior» puede significar la fila observada anterior, el día natural anterior o el mismo mes de hace un año. Elige ese significado antes de calcular un rezago o una tasa de crecimiento.

Sitúa los valores anteriores junto a los actuales

Para los recuentos de visitantes 200, 210 y 189 del 3 al 5 de marzo, s.shift(1) da NaN, 200 y 210. Desplaza los valores una fila hacia abajo y conserva las etiquetas. La nueva primera posición está vacía porque no existe una observación anterior. shift(-1) da 210, 189 y NaN: un adelanto que lleva el valor siguiente a la fila actual.

df["previous"] = df["visitors"].shift(1)
df["change"] = df["visitors"].diff()
df["growth"] = df["visitors"].pct_change()

diff() resta el valor anterior, lo que da NaN, 10 y −21. pct_change() divide el valor actual entre el anterior y resta 1, lo que da NaN, 0,05 y −0,10. Son fracciones: 0,05 significa 5 %, no 0,05 %. La salida de coma flotante puede tener pequeños dígitos adicionales; redondea para mostrarla después de calcular.

Elige el rezago en filas o en tiempo

pct_change(7) compara con siete filas antes. Solo corresponde al mismo día de la semana anterior cuando hay exactamente una fila por día sin fechas ausentes. En una serie mensual completa, pct_change(12) da la variación interanual.

shift(1, freq="D") desplaza las marcas de tiempo un día hacia adelante y deja los valores asociados a esas etiquetas desplazadas. Conserva todos los valores. Las operaciones aritméticas con el original se alinean entonces por fecha:

previous_day = s.shift(1, freq="D")
daily_change = s - previous_day

Si el origen solo tiene observaciones el lunes y el jueves, shift(1) sin frecuencia compara el jueves con el lunes. Un desplazamiento de fecha ofrece una comparación con el miércoles; si falta el miércoles, la variación diaria del jueves es un valor faltante. Rellenar esa ausencia es una decisión aparte sobre los datos.

Ten en cuenta que las operaciones aritméticas alinean etiquetas

Dos Series se combinan por marca de tiempo, no por posición de fila. Suma los valores 200, 210 y 189 del 3, 4 y 5 de marzo a los valores 1 y 1 del 4 y 7 de marzo. Solo el 4 de marzo tiene dos observaciones, así que su suma es 211. La unión de fechas es el 3, 4, 5 y 7 de marzo; los demás resultados son faltantes.

Utiliza s.add(other, fill_value=0) cuando una observación ausente signifique realmente cero, como en un recuento de eventos verificado. No es una solución general para las lecturas faltantes de sensores.

Reinicia las comparaciones por serie

Ordena una tabla larga por su clave de serie y fecha, y después calcula dentro de los grupos. df.groupby("store")["sales"].pct_change() compara cada tienda solo consigo misma. Para la tienda A que vende 100 y luego 110 y la tienda B que vende 50 y luego 40, las tasas de crecimiento son un valor faltante, 0,10, un valor faltante y −0,20. Un cálculo sin agrupar para toda la columna compararía la primera venta de B con la última venta de A. Ese resultado numérico describiría un cambio de tienda, no un crecimiento a lo largo del tiempo.

Una secuencia regular de fechas es un calendario que puedes generar en lugar de escribir cada etiqueta. Puede etiquetar datos de prueba, definir una cuadrícula de informe esperada o revelar observaciones ausentes después de reindexar.

Especifica un inicio y una regla

ends = pd.date_range("2025-01-01", periods=4, freq="ME")

Las cuatro marcas de tiempo son el 31 de enero, el 28 de febrero, el 31 de marzo y el 30 de abril. «ME» significa fin de mes, así que la primera fecha es el primer fin de mes igual o posterior al inicio. Una frecuencia regular puede seguir una regla de calendario aunque los intervalos de tiempo transcurrido tengan distinta duración.

Normalmente, proporciona dos de start, end y periods, además de freq. Sin una frecuencia explícita, se utiliza por defecto un día natural. periods es un recuento de marcas de tiempo, no de intervalos entre ellas: cuatro marcas de tiempo por hora contienen tres intervalos.

Interpreta los alias habituales

Los múltiplos expresan intervalos más amplios: «15min», «2h» y «90min». Empezar a las 08:00 con cuatro períodos de «90min» da 08:00, 09:30, 11:00 y 12:30. «1h30min» expresa el mismo espaciado.

Las frecuencias de marcas de tiempo de pandas 3 usan «ME», «QE», «YE», «BME», «h», «min», «s», «ms» y «us». Los alias antiguos «M», «Q», «Y» o «A», «BM», «H», «T», «S», «L» y «U» ya no funcionan en estas operaciones con marcas de tiempo. Los períodos mensuales siguen usando «M» porque un período describe un intervalo.

Sigue los puntos de anclaje y los días hábiles

Una secuencia anclada no fuerza la inclusión de la fecha de inicio proporcionada en la salida. Empezar el 15 de enero de 2025 con freq="MS" da primero el 1 de febrero. En enero de 2025, «W-MON» da el 6, 13, 20 y 27 de enero; «W» sin más da los domingos. «WOM-3FRI» significa el tercer viernes de cada mes.

«B» omite los fines de semana, pero no conoce los días festivos locales. Marzo de 2025 contiene 21 fechas de lunes a viernes. Un calendario personalizado puede excluir un festivo proporcionado:

pd.bdate_range("2025-03-01", "2025-03-31",
               freq="C", holidays=["2025-03-17"])

Esa secuencia contiene 20 fechas. La lista de festivos es explícita; no se infiere un país a partir de una zona horaria o un idioma.

Cuenta los extremos con cuidado

Los puntos de inicio y fin que corresponden a la frecuencia se incluyen por defecto. Por horas, desde la medianoche del 1 de enero hasta la medianoche del 2 de enero se obtienen 25 marcas de tiempo. Utiliza periods=24 para obtener exactamente 24 lecturas por hora, o inclusive="left" para excluir el final. normalize=True establece las horas de inicio y fin a medianoche. Añade tz="Asia/Tokyo" cuando las etiquetas generadas deban llevar una zona.

«Un mes después» es una instrucción de calendario. «Treinta días después» es tiempo transcurrido. Los resultados pueden diferir porque no todos los meses y años contienen el mismo número de días.

Distingue la duración del desplazamiento por calendario

Un Timedelta añade una cantidad fija de tiempo transcurrido. Un DateOffset sigue los campos del calendario. Desde el 31 de enero de 2025:

t = pd.Timestamp("2025-01-31")
t + pd.DateOffset(months=1)   # February 28
t + pd.Timedelta(days=30)    # March 2

Para el DateOffset, primero se pasa a febrero y después se conserva el día 31 si existe. No existe, así que pandas ajusta la fecha al último día válido de febrero. Desde el 31 de enero de 2024, el resultado es el 29 de febrero porque es un año bisiesto. pd.Timedelta(months=1) no es válido: un mes no tiene una única duración fija.

La misma distinción se aplica a los años. Desde el 1 de enero de 2024, 365 días transcurridos terminan el 31 de diciembre de 2024. pd.DateOffset(years=1) termina el 1 de enero de 2025. Utiliza la unidad indicada por la pregunta real en lugar de sustituirla por un número conveniente de días.

Desplázate a un punto de anclaje del calendario

pd.offsets.MonthEnd(1) desplaza al siguiente fin de mes. Empezar el 15 de enero de 2025 da el 31 de enero. Empezar el 31 de enero da el 28 de febrero. El recuento de uno significa avanzar hasta un punto de anclaje, así que una fecha que ya cumple la regla también se desplaza.

MonthEnd(0) desplaza una fecha hacia adelante hasta el fin de su mes actual, pero deja sin cambios una fecha que ya es fin de mes. Es útil para etiquetar cada observación con el final de su mes:

month_labels = df.index + pd.offsets.MonthEnd(0)

Un desplazamiento también tiene rollforward() y rollback(). Para el 15 de enero, el punto de anclaje de MonthEnd más cercano hacia adelante es el 31 de enero y el más cercano hacia atrás es el 31 de diciembre de 2024. Estas operaciones seleccionan el punto de anclaje válido más cercano en una dirección.

Desplázate por días hábiles

El 14 de marzo de 2025 es viernes. Añadir pd.offsets.BDay(1) da el lunes 17 de marzo. Añadir un día de tiempo transcurrido da el sábado 15 de marzo. Una regla estándar de días hábiles omite los fines de semana; para los festivos se necesita un calendario personalizado proporcionado explícitamente.

Las cadenas de frecuencia son nombres cortos de objetos de desplazamiento: «ME» corresponde a MonthEnd, «B» a BusinessDay y «W-MON» a una semana anclada en lunes. Esto permite que el mismo significado de calendario rija una secuencia, una regla de remuestreo o un desplazamiento de fecha.

Conserva la hora deseada durante el horario de verano

En pandas 3, pd.offsets.Day(1) significa un día natural y conserva la hora local del reloj. pd.Timedelta(days=1) añade exactamente 24 horas. Desde el mediodía del 29 de marzo de 2025 en Ámsterdam, el desplazamiento de calendario termina al mediodía del 30 de marzo, después de solo 23 horas transcurridas. El Timedelta termina a las 13:00. Por tanto, una cita local recurrente y el tiempo de funcionamiento medido de un equipo necesitan operaciones distintas.

Un total de ventas mensuales pertenece a un mes completo. Es posible etiquetarlo con una marca de tiempo, pero un Period indica directamente su intervalo. Un período combina un valor con una frecuencia, así que «2025-03» con frecuencia «M» significa todo marzo de 2025.

Representa y desplaza intervalos

march = pd.Period("2025-03", freq="M")
months = pd.period_range("2025-01", "2025-04", freq="M")

months es un PeriodIndex de cuatro elementos con tipo de datos period[M]. El start_time de marzo es el 1 de marzo a medianoche; su end_time es el 31 de marzo a las 23:59:59,999999 con resolución de microsegundos. El final es el último momento, no la medianoche al comienzo del último día.

Las operaciones aritméticas con períodos avanzan en la unidad propia del período. march + 1 es abril de 2025. Junio menos marzo con frecuencia mensual da un desplazamiento de tres fines de mes, cuyo .n es 3. Un período mensual también conoce .days_in_month: febrero de 2025 tiene 28 días.

Convierte momentos en intervalos y viceversa

monthly_labels = df.index.to_period("M")
column_labels = df["date"].dt.to_period("M")
start_labels = monthly_labels.to_timestamp()
end_labels = monthly_labels.to_timestamp(how="end")

Cada marca de tiempo de marzo corresponde al mismo período mensual. Volver a convertir ese período da su inicio por defecto o su final cuando se solicita. Esto no recupera el día y la hora originales de una observación: la conversión a período descartó ese detalle.

Mantén separadas las familias de alias. Un intervalo mensual usa «M» en Period y period_range. Una marca de tiempo de fin de mes usa «ME» en date_range y en el remuestreo de fechas y horas. Los dos nombres describen distintos tipos de etiquetas.

Cambia la frecuencia de un período

.asfreq() de un período selecciona un período que lo contiene o está contenido en él con una frecuencia distinta. march.asfreq("D", how="start") da el 1 de marzo como período diario; how="end" da el 31 de marzo. Un período anual convertido a «M» con how="start" da enero.

Esto selecciona un período de límite; no distribuye un total mensual entre los días. Para una serie con PeriodIndex, el remuestreo puede agregar intervalos mensuales en intervalos trimestrales. Los recuentos de días de cada mes de 2025 suman los totales trimestrales 90, 91, 92 y 92.

Interpreta las etiquetas de trimestres fiscales

Un trimestre fiscal se nombra dentro de un ejercicio fiscal cuyo mes de cierre es explícito. Con «Q-JUN», el ejercicio fiscal 2025 termina en junio de 2025. Por tanto, su primer trimestre va de julio a septiembre de 2024:

q = pd.Period("2025Q1", freq="Q-JUN")

Con «Q-MAR», el 10 de mayo de 2025 corresponde a 2026Q1 porque ese ejercicio fiscal termina en marzo de 2026. El año de una etiqueta fiscal no tiene por qué coincidir con el año natural de su primer día. Para filtrar marcas de tiempo, seleccionar los momentos anteriores al inicio del siguiente período suele ser más claro que construir la última fracción de segundo del período actual.

El remuestreo responde a preguntas como «¿Cuánta energía se consumió cada día?» o «¿Cuál fue la temperatura media de cada mes?». Agrupa las observaciones en intervalos de tiempo y después aplica una agregación.

Elige un estadístico adecuado para la cantidad

daily = df.resample("D").agg({"kwh": "sum", "temp_c": "mean"})

La energía en kWh y la precipitación en mm se acumulan con el tiempo. La temperatura es un nivel, así que una media la describe de forma más útil que una suma. last() es adecuado para un saldo de cierre, mientras que max() encuentra un máximo. Las ventas diarias se pueden sumar para obtener las ventas totales mensuales o promediar para obtener las ventas medias por día observado; la pregunta decide.

resample() devuelve un Resampler hasta que llamas a una agregación como sum(), mean(), count() o agg(). Utiliza on="date" cuando las fechas y horas estén en una columna en lugar del índice.

Interpreta los intervalos de calendario y la cobertura parcial

Una serie diaria de unos del 1 de enero al 30 de abril de 2025 da los totales mensuales 31, 28, 31 y 30 con resample("ME").sum(). «MS» da los mismos totales mensuales con etiquetas de inicio. El remuestreo a fin de trimestre da 90 para enero–marzo y 30 para un segundo trimestre que solo contiene abril. Una etiqueta del 30 de junio no demuestra que se hayan observado mayo y junio.

Los intervalos semanales «W» terminan en domingo. Los valores diarios del 1 al 14 desde el lunes 3 de marzo suman 28 para la semana etiquetada con el 9 de marzo y 77 para la semana etiquetada con el 16 de marzo. «W-MON» termina en lunes; entonces el primer intervalo contiene solo el 3 de marzo. Comprueba el día de anclaje antes de interpretar una etiqueta como el inicio de una semana.

Distingue la pertenencia de la etiqueta

closed controla qué límite pertenece a un intervalo. label controla la marca de tiempo mostrada en el resultado. Para la mayoría de las reglas, incluidas «5min», «h», «D» y «MS», ambos son «left» por defecto.

Los valores del 0 al 9, uno por minuto desde las 00:00, producen dos sumas predeterminadas de cinco minutos: 10 con la etiqueta 00:00 y 35 con la etiqueta 00:05. El primer intervalo contiene desde las 00:00 hasta las 00:04. Con closed="right", label="right", los resultados son 0 a las 00:00, 15 a las 00:05 y 30 a las 00:10. El intervalo central contiene desde las 00:01 hasta las 00:05. Cambiar solo la etiqueta no cambiaría la pertenencia.

Las reglas de fin como «ME», «QE», «YE», «W» y «BME» usan por defecto el cierre por la derecha y las etiquetas a la derecha. Los intervalos de duración fija normalmente se alinean desde la medianoche del primer día, así que los límites de 15 minutos son 00:00, 00:15 y así sucesivamente.

Distingue los intervalos vacíos de los ceros reales

El sum() de un día vacío es 0, count() es 0 y mean() es NaN. Utiliza sum(min_count=1) para conservar la ausencia de datos cuando no haya ninguna lectura disponible. Así se pueden distinguir un cero registrado y una lectura ausente.

Para varios resúmenes de una serie, .ohlc() da apertura, máximo, mínimo y cierre: el primer valor observado, el máximo, el mínimo y el último de cada intervalo. Las lecturas 10, 12 y 11 dan apertura 10, máximo 12, mínimo 10 y cierre 11. La apertura y el cierre dependen del orden temporal, no del tamaño numérico.

Una cuadrícula más fina crea posiciones, no mediciones. Antes de rellenarlas, decide si cada valor representa un estado, un recuento, una medición que cambia de forma gradual o un total durante un intervalo.

Muestra las nuevas posiciones

s = pd.Series([10.0, 16.0],
              index=pd.to_datetime(["2025-06-01", "2025-06-04"]))
daily = s.asfreq("D")

El resultado diario es 10, NaN, NaN, 16. Aquí s.resample("D").asfreq() da la misma cuadrícula. Los valores se conservan en las marcas de tiempo coincidentes; las nuevas fechas no contienen ninguna observación original.

Rellena según el significado

El ajuste de un termostato se mantiene hasta que alguien lo cambia, así que el relleno hacia adelante es útil. Un nivel de agua que cambia gradualmente puede justificar la interpolación. El cero solo es adecuado para un recuento de eventos cuando el registro ausente significa que no hubo ningún evento. Una interrupción del sensor no demuestra que la medición sea cero.

El ejemplo de interpolación usa una cuadrícula diaria regular. El cambio total es 6 a lo largo de tres pasos de un día, así que cada paso añade 2. Los dos valores interiores son estimaciones, no mediciones recuperadas.

El relleno hacia atrás utiliza información futura. No puede describir lo que un observador sabía en cada momento anterior. El relleno hacia adelante respeta esa dirección temporal, pero los intervalos largos sin datos pueden hacer que un estado trasladado quede desactualizado. daily.ffill(limit=1) rellena una posición después de una lectura, lo que da 10, 10, NaN, 16 en este ejemplo.

Utiliza límites explícitos para el informe

asfreq("D") abarca desde la primera hasta la última marca de tiempo de origen. Reindexa cuando el calendario deba extenderse más:

calendar = pd.date_range("2025-06-01", "2025-06-05", freq="D")
complete = s.reindex(calendar)

Ahora también se ve el 5 de junio. fill_value=0 al reindexar rellena las etiquetas recién creadas, lo que es útil para días en los que se ha comprobado que no hubo eventos. No sustituye los valores faltantes que ya existían en el origen. Tanto la reindexación como asfreq() necesitan etiquetas de origen únicas.

Distingue el muestreo de la agregación

asfreq() selecciona valores en las marcas de tiempo de destino. No resume las observaciones que hay entre ellas. Para 48 valores por hora numerados del 0 al 47, asfreq("D") selecciona las lecturas de medianoche 0 y 24. En cambio, resample("D").sum() da 276 y 852 al sumar todos los valores por hora de cada día.

Un total mensual no se puede rellenar hacia adelante en cada día y después sumar: eso contaría el mismo total repetidamente. Un reparto diario uniforme requiere dividir entre el número de días del mes. Es una suposición de reparto, distinta de trasladar un estado o estimar una medición que cambia gradualmente.

Una tabla larga puede contener muchas series en una sola columna de valores. Una clave de tienda distingue las tiendas y una clave de sensor distingue los sensores. Agrupa por esa identidad y por tiempo cuando la pregunta requiera un historial separado para cada serie.

Combina una clave de serie con una regla temporal

monthly = df.groupby([
    "store", pd.Grouper(key="date", freq="ME")
])["sales"].sum()

pd.Grouper sitúa una regla de intervalos temporales dentro de groupby. key= indica una columna de fechas y horas; level= puede indicar un nivel de índice de fechas y horas. El resultado tiene un nivel de índice para la tienda y otro para el fin de mes. Seleccionar la columna numérica centra la agregación en las ventas.

Supón que la tienda A vende 100 el 5 de enero, 150 el 20 de enero y 120 el 3 de febrero. La tienda B vende 80 el 11 de enero, 90 el 14 de febrero y 60 el 25 de febrero. El resultado agrupado es A: enero 250, febrero 120; B: enero 80, febrero 150. Remuestrear toda la tabla sin la clave de tienda combinaría las tiendas en enero 330 y febrero 270.

Remuestrea dentro de cada grupo

Una segunda forma establece primero la fecha como índice:

monthly = (df.set_index("date")
             .groupby("store")["sales"]
             .resample("ME").sum())

Produce los mismos totales para las combinaciones de tienda y mes observadas. Las dos formas difieren cuando una tienda no tiene filas en un mes intermedio. Si A aparece solo en enero y marzo, el remuestreo por grupos crea un intervalo de febrero entre la primera y la última fecha de A; sum() sin más da cero ahí. Agrupar por tienda y un Grouper conserva las combinaciones que contienen filas, así que la combinación de A y febrero está ausente.

Una combinación ausente, un intervalo vacío resumido como cero y una medición faltante son estados de datos distintos. Decide cuál debe mostrar el informe. Utiliza una reindexación explícita cuando todas las tiendas deban compartir un calendario más amplio que su intervalo observado. Utiliza min_count=1 con una suma cuando un intervalo vacío deba seguir siendo un valor faltante.

Reestructura para comparar

monthly.unstack("store") desplaza el nivel de tienda a las columnas y deja los meses en las filas. En el ejemplo, enero tiene A = 250 y B = 80; febrero tiene A = 120 y B = 150. Una combinación faltante de tienda y mes se convierte en NaN; unstack("store", fill_value=0) sustituye las combinaciones faltantes por cero cuando ese significado es adecuado.

Mantén separados los años cuando sea necesario

Un agrupador temporal con «ME» mantiene separados enero de 2024 y enero de 2025. Agrupar por df["date"].dt.month conserva solo los números de mes y combina ambos eneros. La primera forma responde a «¿Qué ocurrió cada mes?». La segunda permite una comparación estacional, como las ventas medias de enero a lo largo de varios años. La elección depende de la identidad temporal que necesites conservar.

Una ventana móvil resume repetidamente un grupo de filas que se desplaza. En cada fila nueva, la ventana incorpora el valor actual y acaba descartando el más antiguo. La longitud de la ventana controla cuánto se suaviza la variación a corto plazo.

Trabaja con una ventana cada vez

Para los valores 4, 8, 6, 10 y 12:

s = pd.Series([4, 8, 6, 10, 12])
s.rolling(3).mean()

La primera ventana completa es [4, 8, 6], con un total de 18 y una media de 6. La siguiente es [8, 6, 10], con una media de 8. La última es [6, 10, 12], con una media aproximada de 9,333. Los resultados predeterminados son NaN, NaN, 6, 8 y 9,333 porque las dos primeras filas aún no tienen tres observaciones.

Controla los requisitos de datos y la ubicación

min_periods establece el número requerido de valores presentes. Para una ventana definida por número de filas, por defecto es el tamaño completo de la ventana. Con min_periods=1, las primeras medias usan un valor y después dos: 4 y 6. Sus muestras más pequeñas las hacen menos estables que las medias posteriores de tres valores.

Los valores faltantes siguen ocupando posiciones de fila. En [4, NaN, 6, 10, 12], una ventana de tres filas que contiene el valor faltante solo tiene dos observaciones válidas. min_periods=2 permite calcular la media de [4, NaN, 6], que es 5; la opción predeterminada no lo permite.

Los resultados normalmente corresponden a la última fila de la ventana. Con center=True, las mismas tres medias de ventanas completas aparecen en las filas centrales, lo que da NaN, 6, 8, 9,333, NaN. Un valor centrado utiliza observaciones posteriores a su etiqueta. Utiliza ventanas retrospectivas para describir lo que se conocía en cada momento.

Resume más que la media

Las mismas ventanas admiten sum(), max(), min() y std(). pandas usa por defecto la desviación estándar muestral: [4, 8, 6] tiene una desviación estándar de 2. Una función personalizada puede calcular un rango:

s.rolling(3).apply(lambda v: v.max() - v.min(), raw=True)

Los rangos de las ventanas completas son 4, 4 y 6. raw=True pasa los valores del arreglo a la función. Dos series alineadas también pueden compartir una ventana: a.rolling(3).corr(b) mide la correlación entre las últimas tres observaciones emparejadas, de modo que la relación puede variar con el tiempo.

Elige una longitud y una agrupación significativas

Con una fila diaria completa por día, una media de siete filas contiene una vez cada día de la semana y promedia un componente semanal fijo y repetitivo hasta eliminarlo. Una media de doce filas hace lo mismo con un componente anual fijo en datos mensuales completos. Las ventanas más largas suavizan más, pero responden más tarde a los cambios de dirección; una media retrospectiva de n filas tiene aproximadamente media ventana de retraso, unas (n − 1) / 2 filas.

Las filas no son días. Siete lecturas con fechas ausentes pueden abarcar más de una semana. Utiliza una ventana temporal cuando la pregunta indique tiempo transcurrido. En una tabla larga, ordena cada serie por tiempo y ejecuta las ventanas dentro de su grupo: df.groupby("store")["sales"].rolling(2).sum(). Esto evita que una ventana pase de los datos de una tienda a los de otra.

Los eventos irregulares requieren ventanas definidas por tiempo. «Pedidos de los últimos tres días» debe conservar la misma duración aunque haya muchos pedidos un día y ninguno al siguiente.

Define una ventana de tiempo transcurrido

s = pd.Series([5, 3, 4, 6], index=pd.to_datetime([
    "2025-05-01", "2025-05-02", "2025-05-05", "2025-05-06"
]))
s.rolling("3D").sum()

Los resultados son 5, 8, 4 y 10. A diferencia de rolling(3), la cadena «3D» define un intervalo de tres días. El número de filas dentro de ese intervalo puede variar. Ordena primero el DatetimeIndex; las ventanas temporales requieren tiempos monótonos. Un DataFrame puede usar una columna de fechas y horas ordenada con on="date".

Comprueba el límite antes de sumar

Por defecto, la ventana incluye el momento actual y excluye el instante de exactamente tres días antes. A medianoche del 5 de mayo, el intervalo va desde justo después de la medianoche del 2 de mayo hasta la medianoche del 5 de mayo. La lectura del 2 de mayo está exactamente en el límite excluido, así que solo contribuye el valor 4 del 5 de mayo.

El 6 de mayo, la ventana comienza justo después del 3 de mayo e incluye los valores 4 y 6, que suman 10. Con closed="both", la ventana del 5 de mayo también incluye el 2 de mayo y suma 7. La elección del límite puede cambiar un resultado aunque los datos y la duración sigan siendo los mismos.

Una ventana de dos filas en esta serie da NaN, 8, 7 y 10. El 5 de mayo incluye la fila anterior del 2 de mayo. Eso responde a «las dos últimas lecturas», una pregunta distinta de «los últimos tres días».

Establece un requisito de datos

El min_periods de una ventana temporal es 1 por defecto. Por tanto, la primera observación puede producir un resultado de inmediato. s.rolling("3D").count() da 1, 2, 1 y 2 lecturas, lo que muestra cómo cambia la cantidad de datos que sustenta el resultado. Una media basada en una lectura y una media basada en muchas son cálculos válidos, pero tienen distinto respaldo de datos.

Con min_periods=2, las sumas son NaN, 8, NaN, 10. La duración no ha cambiado; ahora el cálculo requiere al menos dos observaciones presentes dentro de esa duración. Un intervalo temporal más amplio no garantiza por sí mismo más observaciones.

Utiliza duraciones fijas y separa las series

Una ventana móvil basada en el tiempo requiere una duración fija como «30min», «24h» o «7D». Una regla de fin de mes como «1ME» tiene una duración variable y no puede definir este tipo de ventana móvil. Utiliza una duración fija indicada, como «30D», si esa es la regla deseada, o agrega primero en intervalos mensuales cuando la pregunta se refiera a meses del calendario.

Para historiales separados de clientes, df.groupby("customer").rolling("30D", on="date")["amount"].sum() mantiene juntas las transacciones de cada cliente. Las horas deben estar ordenadas dentro de cada cliente. El resultado añade la clave de grupo como nivel del índice y conserva qué serie describe cada ventana.

Algunas preguntas necesitan todo el historial: «¿Cuánto se ha acumulado?» o «¿Cuál es el valor más alto hasta ahora?». Otras deben favorecer las observaciones recientes sin descartar bruscamente el pasado. Los cálculos expansivos y ponderados exponencialmente sirven para estos fines distintos.

Amplía el historial una fila cada vez

Para los valores 4, 8, 6, 10 y 12, s.expanding().mean() da 4, 6, 6, 7 y 8. El cuarto resultado usa los cuatro valores: su total es 28 y su media es 7. expanding().sum() da 4, 12, 18, 28 y 40, igual que cumsum() en esta serie completa. expanding().max() da 4, 8, 8, 10 y 12, igual que cummax().

Las ventanas expansivas requieren por defecto una observación. Conservan todas las observaciones anteriores con el mismo peso. En las últimas etapas de una serie larga, un valor nuevo solo aporta una pequeña parte de todo ese historial, por lo que una media acumulada reacciona lentamente.

Las sumas acumuladas pueden reiniciarse en un límite:

ytd = df.groupby(df.index.year)["sales"].cumsum()
by_store = df.groupby("store")["sales"].cumsum()

Ordena dentro del historial correspondiente antes de acumular. Una suma acumulada sin agrupar sobre tiendas intercaladas las mezcla.

Mide la distancia por debajo de un máximo acumulado

Para 100, 120, 90, 110 y 130, cummax() da 100, 120, 120, 120 y 130. Calcula la caída relativa desde el máximo acumulado con s / s.cummax() - 1. En 90 la referencia es el máximo anterior de 120, así que la caída es −0,25, o un 25 % por debajo del máximo. Comparar 90 con el primer valor de 100 respondería a otra pregunta. Un nuevo máximo tiene una caída relativa de cero.

Da más peso a los valores recientes

Una media móvil ponderada exponencialmente, o EWMA, reduce el peso de los valores más antiguos por un factor constante. El factor de suavizado sigue $\alpha =2\mathrm{/}(\text{span}+1)$, así que span=3 da 0,5. Para adjust=False, la actualización es:

Aquí, $x_t$ es la nueva observación, $y_{t-1}$ es el valor suavizado anterior y $y_t$ es el resultado actualizado. El primer valor suavizado es igual a la primera observación. Después, cada valor nuevo recibe un peso de 0,5 y el valor suavizado anterior recibe un peso de 0,5:

s.ewm(span=3, adjust=False).mean()

Para 4, 8, 6, 10 y 12, los resultados son 4, 6, 6, 8 y 10. La última actualización promedia la nueva observación 12 y el valor suavizado anterior 8. No promedia solo las dos observaciones en bruto más recientes.

Interpreta el ajuste

La opción predeterminada adjust=True normaliza mediante la suma de los pesos disponibles. Para los mismos datos, los primeros resultados son 4, aproximadamente 6,667, 6,286, 8,267 y 10,194. Es un cálculo inicial distinto del de la forma recursiva; la diferencia disminuye a medida que hay más historial disponible.

Elige un argumento de decaimiento: span, alpha, com o halflife. Una EWMA no tiene un corte abrupto en el que una fila antigua desaparezca de repente. Una media móvil tiene ese corte, mientras que una media expansiva conserva todos los valores anteriores con el mismo peso. Elige según la influencia que deban tener los cambios recientes.

Una lectura del reloj necesita una ubicación para identificar un momento. «2025-07-01 09:00» es una marca de tiempo sin zona horaria. Añadir «Europe/Amsterdam» la convierte en una marca con zona horaria: en julio tiene un desfase de +02:00 y representa las 07:00 UTC. UTC es la referencia horaria compartida y no tiene cambios de reloj por horario de verano.

Asigna la zona de registro

local = pd.Timestamp("2025-07-01 09:00")
aware = local.tz_localize("Europe/Amsterdam")

tz_localize() conserva las 09:00 y les asigna el significado de su zona. Utiliza la ubicación donde se registró la lectura del reloj. Llamar UTC a esa misma lectura describiría un momento distinto, dos horas después en este ejemplo.

Utiliza nombres de IANA como «Europe/Amsterdam», «America/New_York» y «Asia/Kolkata». Las zonas regionales con nombre conservan el historial de desfases y las reglas de horario de verano. Un desfase fijo de +01:00 no lo hace. Los nombres cortos son inconsistentes: «EST» es fijo en −05:00, mientras que «CET» sigue los cambios estacionales. pandas 3 utiliza la representación zoneinfo de Python.

Convierte un momento ya identificado

aware.tz_convert("UTC") da 07:00 UTC. Convertir ese mismo instante a Nueva York da las 03:00, a Calcuta las 12:30, a Tokio las 16:00 y a Sídney las 17:00 el 1 de julio. La hora del reloj cambia, pero el momento real sigue siendo el mismo.

Convertir un valor sin zona horaria genera un error porque no se conoce la zona de partida. Asignar una zona a un valor que ya la tiene también genera un error; utiliza la conversión para esa operación. En columnas, utiliza .dt.tz_localize() y .dt.tz_convert(). En índices, utiliza los métodos directamente o los métodos del DataFrame que actúan sobre el índice.

Interpreta texto con desfases y combina zonas

Una «Z» al final de un texto ISO significa UTC. Para texto con distintos desfases, interpreta con utc=True:

raw = pd.Series(["2025-03-01 10:00+01:00",
                 "2025-04-01 10:00+02:00"])
common = pd.to_datetime(raw, utc=True)

Estos valores se convierten en 09:00 y 08:00 UTC. Después conviértelos a una zona regional para los informes locales. Interpretar desfases mixtos sin utc=True genera un error en pandas 3.

Dos series con zona horaria se alinean por momentos reales aunque sus etiquetas de zona difieran. Las lecturas de Ámsterdam a las 09:00 y 10:00 y las de Londres a las 08:00 y 09:00 en julio se refieren a instantes coincidentes. Su resultado aritmético usa etiquetas UTC. Las comparaciones de orden entre marcas de tiempo sin y con zona horaria fallan; la igualdad devuelve falso.

Elimina una zona de forma deliberada

tz_convert(None) expresa primero un valor con zona horaria en UTC y después elimina la zona. Las 09:00 de Ámsterdam se convierten en las 07:00 sin zona horaria en julio. tz_localize(None) elimina la zona y conserva las 09:00 sin zona horaria. Son resultados distintos. Mantén los datos de cálculo con zona horaria en UTC y después conviértelos antes de elaborar informes o agrupar por día local.

Los relojes locales pueden omitir o repetir una hora. Esos cambios afectan a la interpretación, las duraciones transcurridas y los totales diarios. Las zonas horarias con nombre permiten a pandas distinguir los momentos reales detrás de las lecturas de los relojes locales.

Reconoce una hora local omitida

Ámsterdam adelantó el reloj de las 02:00 a las 03:00 el 30 de marzo de 2025. La lectura de las 02:30 nunca ocurrió. Asignarle una zona sin un criterio genera un error:

pd.Timestamp("2025-03-30 02:30").tz_localize(
    "Europe/Amsterdam", nonexistent="shift_forward"
)

El resultado es 03:00+02:00, la primera hora válida después del intervalo omitido. nonexistent="NaT" conserva el problema como un valor faltante. "shift_backward" desplaza al último momento válido anterior al intervalo omitido. Desplazar un registro cambia su marca de tiempo, así que conserva la entrada original y documenta el criterio elegido en el análisis.

Distingue dos lecturas repetidas

El 26 de octubre de 2025, Ámsterdam atrasó el reloj de las 03:00 a las 02:00. La lectura local de las 02:30 ocurrió una vez con el desfase +02:00 y otra con +01:00. Están separadas por una hora en UTC.

ambiguous=True selecciona la ocurrencia en horario de verano; ambiguous=False selecciona la de horario estándar. ambiguous="NaT" marca una lectura no resuelta como faltante. Una lista booleana puede elegir para cada fila. ambiguous="infer" puede usar una secuencia ordenada que contenga la hora repetida, como 01:30, 02:00, 02:30, 02:00, 02:30, 03:00. Una sola lectura repetida del reloj no proporciona suficiente información de orden para inferir a cuál de las dos ocurrencias se refiere.

Cuenta las horas del día local

El día de transición de primavera tiene 23 horas y el día de transición de otoño tiene 25. Por tanto, una serie completa de datos por hora remuestreada a días locales tiene recuentos variables. Para informar de la energía media por hora, divide una suma diaria entre el número real de lecturas válidas por hora o calcula su media. Dividir todos los totales entre 24 representa incorrectamente los días de transición.

Un conjunto de datos incompleto también puede crear intervalos cortos. Una serie UTC que comienza el 29 de marzo a las 00:00 comienza en Ámsterdam a las 01:00, así que a su primer día local le falta la medianoche incluso antes del día de transición. Comprueba los límites del informe además de las reglas de la zona.

Distingue la misma hora del reloj de un tiempo transcurrido igual

t = pd.Timestamp("2025-03-29 12:00", tz="Europe/Amsterdam")
t + pd.offsets.Day(1)       # March 30 at 12:00
t + pd.Timedelta(days=1)    # March 30 at 13:00

El desplazamiento de calendario conserva el mediodía y solo atraviesa 23 horas transcurridas. El Timedelta añade 24 horas. En otoño, un día natural local puede contener, en cambio, 25 horas transcurridas.

Elige la zona del informe antes de agrupar

El remuestreo sigue la zona del índice. Para calcular el consumo total según la fecha local de Ámsterdam, convierte primero un índice UTC con zona horaria a «Europe/Amsterdam» y después remuestrea a «D». Remuestrear primero en UTC crea límites diarios distintos que no se pueden corregir simplemente cambiando las etiquetas del resultado.

Las fechas de transición difieren según la región: Nueva York cambió el 9 de marzo y el 2 de noviembre de 2025; Sídney terminó el horario de verano el 6 de abril y lo comenzó el 5 de octubre. Tokio y Calcuta no tienen cambios de horario de verano. Conserva los momentos en bruto en UTC y utiliza la zona local con nombre para los informes de calendario.