Analisando datas corretamente
Converta textos de datas em datetime64 com pd.to_datetime, trate vários formatos e defina um DatetimeIndex.
Analisando datas corretamente é uma aula grátis de Pandas & NumPy Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Pandas & NumPy Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Pandas & NumPy Academy inclui 4 aulas no total.
Por que a análise de datas é importante
Dados de data e hora estão presentes em todos os lugares nos conjuntos de dados do mundo real — registros de transações, datas de nascimento, registros de eventos e períodos financeiros. Quando as datas são armazenadas como strings (o tipo de dados object), você não pode calcular durações, reamostrar por mês nem ordenar cronologicamente. Converter strings para o tipo datetime64 do Pandas libera toda a API de séries temporais e possibilita a análise temporal.
import pandas as pd
df = pd.DataFrame({'date': ['2024-01-15', '2024-03-20', '2024-07-04']})
print(df['date'].dtype) # object
# You cannot do arithmetic on string dates
# df['date'] + pd.Timedelta('1 day') # TypeError!
# After parsing:
df['date'] = pd.to_datetime(df['date'])
print(df['date'].dtype) # datetime64[ns]
print(df['date'] + pd.Timedelta('1 day'))Noções básicas de pd.to_datetime()
pd.to_datetime(series) é a principal função para converter colunas de strings em datetime64. Ela consegue reconhecer automaticamente a maioria dos formatos comuns de data (ISO 8601, data dos US e data europeia), sem exigir uma string de formato. O resultado é uma Series com o tipo datetime64[ns] — precisão de nanossegundos, capaz de armazenar registros de data e hora de 1677 a 2262.
import pandas as pd
dates = pd.Series([
'2024-01-15',
'15/01/2024',
'January 15, 2024',
'2024-01-15 08:30:00'
])
parsed = pd.to_datetime(dates)
print(parsed)
# 0 2024-01-15 00:00:00
# 1 2024-01-15 00:00:00
# 2 2024-01-15 00:00:00
# 3 2024-01-15 08:30:00
print(parsed.dtype) # datetime64[ns]Especificando o argumento format=
Quando a inferência automática é lenta demais ou ambígua (por exemplo, '01-02-03' pode significar 2 de janeiro de 2003, 1 de fevereiro de 2003 ou 3 de fevereiro de 2001), forneça a string de formato exata usando os códigos strftime do Python. Isso também é significativamente mais rápido: em conjuntos de dados grandes, a análise com formato explícito pode ser 10 vezes mais rápida que a inferência automática, porque o Pandas não precisa testar vários padrões.
import pandas as pd
dates = pd.Series(['15/01/2024', '20/03/2024', '04/07/2024'])
# Explicit format: day/month/year
parsed = pd.to_datetime(dates, format='%d/%m/%Y')
print(parsed)
# 0 2024-01-15
# 1 2024-03-20
# 2 2024-07-04
# Common format codes:
# %Y = 4-digit year, %y = 2-digit year
# %m = month (01-12), %d = day (01-31)
# %H = hour (0-23), %M = minute, %S = seconderrors='coerce' para datas inválidas
Conjuntos de dados reais frequentemente contêm erros de digitação ou strings usadas como marcadores, como 'TBD', 'N/A' ou '99/99/9999', em colunas de datas. Passar errors='coerce' instrui pd.to_datetime() a converter valores que não podem ser analisados em NaT (Not a Time — o equivalente, para data e hora, de NaN), em vez de gerar uma exceção. Isso permite identificar e tratar as datas inválidas separadamente.
import pandas as pd
dates = pd.Series(['2024-01-15', 'TBD', '2024-07-04', 'N/A'])
parsed = pd.to_datetime(dates, errors='coerce')
print(parsed)
# 0 2024-01-15
# 1 NaT
# 2 2024-07-04
# 3 NaT
# Detect bad dates
print('Bad date rows:', parsed.isna().sum()) # 2parse_dates em read_csv()
O momento mais eficiente para analisar datas é durante o carregamento, usando o parâmetro parse_dates de pd.read_csv(). Passe uma lista de nomes ou índices de colunas que devem ser analisadas como datas. Isso evita uma etapa separada de pós-processamento e costuma ser mais rápido, pois o Pandas faz a operação durante a análise do CSV no nível C.
import pandas as pd
import io
csv_data = '''order_id,order_date,ship_date
1,2024-01-15,2024-01-18
2,2024-02-20,2024-02-22
'''
df = pd.read_csv(
io.StringIO(csv_data),
parse_dates=['order_date', 'ship_date']
)
print(df.dtypes)
# order_id int64
# order_date datetime64[ns]
# ship_date datetime64[ns]O acessador .dt para componentes de data
Depois que uma coluna passa a ter o tipo datetime64, o acessador .dt libera dezenas de propriedades e métodos. Você pode extrair .dt.year, .dt.month, .dt.day, .dt.hour, .dt.dayofweek (0 = segunda-feira) e .dt.is_month_end. Esses recursos são usados na engenharia de atributos para previsão de séries temporais e para agrupar dados por período.
import pandas as pd
df = pd.DataFrame({
'event_time': pd.to_datetime([
'2024-03-15 08:30:00',
'2024-07-04 14:00:00',
'2024-12-25 09:00:00'
])
})
df['year'] = df['event_time'].dt.year
df['month'] = df['event_time'].dt.month
df['day_of_week'] = df['event_time'].dt.day_name()
df['hour'] = df['event_time'].dt.hour
print(df[['year', 'month', 'day_of_week', 'hour']])Definindo um DatetimeIndex
Na análise de séries temporais, é padrão definir a coluna de data e hora como o índice do DataFrame. Com um DatetimeIndex, você pode usar seleção baseada em tempo (df['2024'], df['2024-01':'2024-06']), reamostrar para qualquer frequência e acessar toda a API de séries temporais do Pandas. Use set_index() ou passe index_col em read_csv.
import pandas as pd
df = pd.DataFrame({
'date': pd.to_datetime(['2024-01-01', '2024-01-02', '2024-01-03']),
'temp': [22.5, 23.0, 21.8]
})
df = df.set_index('date')
print(df)
# temp
# date
# 2024-01-01 22.5
# 2024-01-02 23.0
# 2024-01-03 21.8
# Time-based slicing
print(df['2024-01-02':'2024-01-03'])Lidando com vários formatos de data
Se uma coluna de datas contiver uma mistura de formatos (por exemplo, algumas linhas tiverem datas ISO e outras, datas no padrão dos US), não será possível especificar uma única string de formato. Passe format='mixed' (Pandas 2.0 ou posterior) para permitir a detecção do formato linha a linha ou faça uma limpeza prévia da coluna com expressões regulares para normalizar todas as datas em um único formato antes de chamar pd.to_datetime().
import pandas as pd
mixed_dates = pd.Series([
'2024-01-15',
'03/20/2024',
'2024-07-04T10:30:00'
])
# format='mixed' handles different formats row-by-row (Pandas >= 2.0)
parsed = pd.to_datetime(mixed_dates, format='mixed')
print(parsed)
# 0 2024-01-15 00:00:00
# 1 2024-03-20 00:00:00
# 2 2024-07-04 10:30:00Datas e horas com fuso horário
Os registros de data e hora do mundo real frequentemente vêm acompanhados de informações de fuso horário. pd.to_datetime() pode analisar strings com deslocamento UTC (por exemplo, '2024-01-15 08:30:00+05:30') e armazená-las como datetime64 com fuso horário. Use .dt.tz_convert('UTC') para normalizar todos os registros para um fuso horário comum e permitir comparações e operações aritméticas corretas.
import pandas as pd
dates = pd.to_datetime(['2024-01-15 08:30:00+05:30', '2024-01-15 10:00:00-08:00'])
print(dates)
# DatetimeIndex(['2024-01-15 08:30:00+05:30', '2024-01-15 10:00:00-08:00'])
# Convert both to UTC for fair comparison
utc_dates = dates.tz_convert('UTC')
print(utc_dates)
# DatetimeIndex(['2024-01-15 03:00:00+00:00', '2024-01-15 18:00:00+00:00'])Calculando diferenças entre datas
A aritmética entre duas colunas datetime64 produz uma Series de Timedelta. Você pode extrair o número de dias, horas ou segundos de um Timedelta usando as propriedades .dt.days, .dt.seconds e .dt.total_seconds(). Essa é a forma padrão de calcular idade, duração ou atributos como dias desde o último evento.
import pandas as pd
df = pd.DataFrame({
'start': pd.to_datetime(['2024-01-01', '2024-03-10', '2024-06-15']),
'end': pd.to_datetime(['2024-01-20', '2024-04-05', '2024-06-30'])
})
df['duration_days'] = (df['end'] - df['start']).dt.days
print(df[['start', 'end', 'duration_days']])
# start end duration_days
# 0 2024-01-01 2024-01-20 19
# 1 2024-03-10 2024-04-05 26
# 2 2024-06-15 2024-06-30 15pd.date_range() para gerar datas
pd.date_range(start, end, freq=) gera uma sequência de datas igualmente espaçadas como um DatetimeIndex. Isso é útil para criar uma estrutura temporal completa contra a qual você pode reindexar seus dados, garantindo que cada período do calendário apareça na saída, mesmo quando não houve eventos naquele dia. Valores comuns de freq: 'D' (diário), 'ME' (fim do mês), 'h' (de hora em hora).
import pandas as pd
# Weekly dates for the first quarter of 2024
weekly = pd.date_range(start='2024-01-01', end='2024-03-31', freq='W')
print(weekly[:5])
# DatetimeIndex(['2024-01-07', '2024-01-14', '2024-01-21', '2024-01-28', '2024-02-04'])
# Monthly date spine
monthly = pd.date_range(start='2024-01', periods=12, freq='ME')
print(len(monthly), monthly[0], monthly[-1])
# 12 2024-01-31 2024-12-31Verificação rápida
Teste sua compreensão sobre a análise correta de datas no Pandas.
Recapitulação da lição
Nesta lição, você aprendeu que pd.to_datetime() converte colunas de strings em datetime64; format= especifica o padrão exato para obter velocidade e precisão; e errors='coerce' transforma datas inválidas em NaT em vez de interromper a execução. O acessador .dt extrai o ano, o mês, o dia e outros componentes, e definir um DatetimeIndex permite a seleção baseada em tempo. A seguir, vamos explorar o acessador .str para operações vetorizadas com strings.
Perguntas Frequentes
A aula “Analisando datas corretamente” é grátis?
Sim — o texto completo de “Analisando datas corretamente” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Pandas & NumPy Academy, atualize para CoddyKit PRO. O curso de Pandas & NumPy Academy inclui 4 aulas no total.
O que vou aprender em “Analisando datas corretamente”?
Converta textos de datas em datetime64 com pd.to_datetime, trate vários formatos e defina um DatetimeIndex. Você pratica Pandas & NumPy Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.
Preciso ter experiência prévia para começar Pandas & NumPy Academy?
Nenhuma experiência prévia é necessária. Pandas & NumPy Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.
Quanto tempo leva a aula “Analisando datas corretamente”?
A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.
Posso escrever e executar código nesta aula de Pandas & NumPy Academy?
Sim. Cada aula de Pandas & NumPy Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.
Todas as aulas deste curso
- Inspecionando os tipos de dados das colunas
- Conversão de tipos com astype()
- Tipo de dados categórico
- Analisando datas corretamente