Trabalhando com datas no Python: guia do módulo datetime

✅ Artigo atualizado em Setembro 2026: fusos horários agora com o zoneinfo da biblioteca padrão (o pytz ficou como alternativa legada), saídas de exemplo corrigidas e aviso de que timedelta não soma meses nem anos. Também ganhou tabela de códigos de formato, erros comuns com a mensagem real e 8 exercícios resolvidos.

1
2
3
4
5
6

from datetime import datetime, date, timedelta
# saídas de 27/09/2026
print(datetime.now().strftime("%d/%m/%Y %H:%M"))          # 27/09/2026 10:54
natal = datetime.strptime("25/12/2026", "%d/%m/%Y").date()  # texto -> date
print((natal - date.today()).days)                         # 89 (dias até o Natal)
print(date.today() + timedelta(days=30))                   # 2026-10-27

Salve salve Pythonista

Trabalhar com datas e horários é essencial em muitas aplicações Python.

Entender como manipular datas facilita tarefas como agendamentos, logs e análises temporais.

Neste artigo, abordaremos o módulo datetime do Python, explorando desde operações básicas até manipulações avançadas de datas e horários.

Com este conhecimento, você poderá gerenciar datas de forma eficiente em seus projetos Python.

Vá Direto ao Assunto…

• Introdução ao Módulo datetime
• Trabalhando com Datas e Horas
• Como pegar a data atual no Python
• Formatando Datas
• Convertendo Datas para Strings
• Convertendo Strings para Datas
• Códigos de formato do strftime e strptime (tabela)
• Calculando Diferença entre Datas
• Trabalhando com Timezones
• Trabalhando com timedelta
• Trabalhando com Datas em Diferentes Formatos
• Trabalhando com Datas em Diferentes Idiomas
• Qual usar: date, datetime, time, timedelta ou relativedelta?
• Casos Práticos Reais
• Erros comuns
• Exercícios resolvidos

Introdução ao Módulo datetime

O módulo datetime é a ferramenta padrão do Python para trabalhar com datas e horários.

Ele fornece classes para manipular datas, horários e intervalos de tempo.

Além disso, permite realizar operações como formatação, conversão e cálculo entre diferentes unidades de tempo.

Para começar, é necessário importar o módulo datetime:

1

import datetime

Ele tem quatro classes principais: date (data), time (horário), datetime (data e hora juntas) e timedelta (duração). A referência completa está na documentação oficial do módulo datetime.

Atenção à importação: com import datetime você escreve datetime.datetime.now() e datetime.date.today(), como nos exemplos das próximas seções. Com from datetime import datetime, date, escreve só datetime.now() e date.today(). Misturar os dois estilos é um dos erros mais comuns (veja Erros comuns).

Trabalhando com Datas e Horas

Com o módulo datetime, podemos criar objetos que representam datas e horários específicos.

Vamos criar um objeto que representa a data atual:

1
2

data_atual = datetime.date.today()
print(data_atual)

Explicação do código:

1. Importação: Importamos o módulo datetime.
2. Objeto de Data Atual: Usamos datetime.date.today() para obter a data de hoje.
3. Exibição: Imprimimos a data atual no formato YYYY-MM-DD.

A saída será:

1

2025-02-25

Criando um Objeto de Horário

Além de datas, podemos criar objetos que representam horários:

1
2

hora_atual = datetime.datetime.now().time()
print(hora_atual)

Explicação do código:

1. Método now(): datetime.datetime.now() retorna a data e hora atuais.
2. Extração de Hora: Usamos .time() para obter apenas o componente de horário.
3. Exibição: Imprimimos a hora atual no formato HH:MM:SS.microsegundos.

A saída será:

1

09:27:09.484035

Como pegar a data atual no Python

Existem quatro jeitos de pegar “agora” no Python, e a escolha depende do que você precisa:

1
2
3
4
5
6
7

from datetime import datetime, date, timezone
from zoneinfo import ZoneInfo

print(date.today())                               # só a data
print(datetime.now())                             # data e hora locais, sem fuso
print(datetime.now(ZoneInfo("America/Sao_Paulo")))  # data e hora com fuso
print(datetime.now(timezone.utc))                 # data e hora em UTC

Em 27/09/2026, às 10:54 de Brasília, a saída será algo como:

1
2
3
4

2026-09-27
2026-09-27 10:54:05.097672
2026-09-27 10:54:05.097672-03:00
2026-09-27 13:54:05.097672+00:00

Evite datetime.utcnow(): ele devolve um datetime sem fuso (que parece local, mas é UTC) e está obsoleto desde o Python 3.12. Prefira datetime.now(timezone.utc).

Com o objeto em mãos, você acessa cada parte por atributo e ainda pode formatar direto numa f-string, colocando o formato depois dos dois-pontos:

1
2
3
4
5
6
7
8
9

from datetime import datetime

agora = datetime(2026, 9, 27, 10, 54, 5)  # use datetime.now() no seu código

print(agora.day, agora.month, agora.year)
print(agora.hour, agora.minute)
print(agora.weekday())          # 0 = segunda ... 6 = domingo
print(f"{agora:%d/%m/%Y}")      # formato brasileiro
print(agora.isoformat(timespec="seconds"))

A saída será:

1
2
3
4
5

27 9 2026
10 54
6
27/09/2026
2026-09-27T10:54:05

O 6 indica domingo: 27/09/2026 cai num domingo.

Formatando Datas

Formatar datas é útil para exibir informações de maneira legível ou específica.

Usando strftime

A função strftime permite formatar objetos de data e hora:

1
2
3

data_atual = datetime.date.today()
data_formatada = data_atual.strftime("%d/%m/%Y")
print(data_formatada)

Explicação do código:

1. Formato Personalizado: %d representa o dia, %m o mês e %Y o ano.
2. Formatação: Convertendo data_atual para o formato DD/MM/AAAA.
3. Exibição: Imprimimos a data formatada.

E a saída será:

1

25/02/2025

Exemplo de Formatação Completa

1
2
3

hora_atual = datetime.datetime.now().time()
hora_formatada = hora_atual.strftime("%H:%M:%S")
print("Hora:", hora_formatada)

Explicação do código:

1. Formato de Hora: %H para horas, %M para minutos e %S para segundos.
2. Formatação: Convertendo hora_atual para o formato HH:MM:SS.
3. Exibição: Imprimimos a hora formatada.

A saída será:

1

Hora: 09:29:09

Convertendo Datas para Strings

Converter objetos de data para strings é útil para salvar ou exibir informações.

Usando str()

A função str() converte objetos de data para strings em um formato padrão:

1
2
3

data_atual = datetime.date.today()
data_str = str(data_atual)
print(data_str)

Explicação do código:

1. Conversão: Usamos str(data_atual) para converter o objeto de data em uma string.
2. Exibição: Imprimimos a string resultante no formato YYYY-MM-DD.

Sua saída será:

1

2025-02-25

Convertendo Strings para Datas

Às vezes, precisamos converter strings que representam datas em objetos de data.

Usando strptime

A função strptime permite analisar strings em objetos de data:

1
2
3

data_string = "25/12/2023"
data_convertida = datetime.datetime.strptime(data_string, "%d/%m/%Y").date()
print(data_convertida)

Explicação do código:

1. String de Data: Definimos data_string no formato DD/MM/AAAA.
2. Análise: Usamos strptime para converter a string em um objeto datetime.
3. Extração de Data: Com .date(), extraímos apenas a data.
4. Exibição: Imprimimos a data convertida no formato YYYY-MM-DD.

A saída será:

1

2023-12-25

Uma forma fácil de lembrar a diferença: strftime tem f de format (data -> texto) e strptime tem p de parse (texto -> data). No strptime, o formato precisa descrever o texto inteiro, inclusive barras, traços, espaços e a hora, se houver.

Códigos de formato do strftime e strptime (tabela)

Os mesmos códigos servem para strftime (data -> texto) e strptime (texto -> data). Os exemplos usam a data datetime(2026, 9, 7, 14, 5, 9), ou seja, 07/09/2026 às 14:05:09:

E as combinações mais pedidas:

Cuidado com duas pegadinhas: %m é mês e %M é minuto; e %w conta a semana a partir do domingo (0), enquanto o método weekday() conta a partir da segunda (0). A lista completa de códigos está na documentação oficial do strftime e strptime.

Calculando Diferença entre Datas

Calcular a diferença entre datas é útil para determinar durações ou prazos.

Usando timedelta

A classe timedelta representa uma duração ou intervalo de tempo:

1
2
3

data_futura = datetime.date(2050, 1, 1)
diferenca = data_futura - data_atual
print(diferenca.days, "dias restantes")

Explicação do código:

1. Data Futura: Criamos uma data específica para o futuro.
2. Cálculo da Diferença: Subtraímos data_atual de data_futura para obter a diferença.
3. Exibição: Imprimimos o número de dias restantes.

Considerando data_atual igual a 25/02/2025, a saída será:

1

9076 dias restantes

Trabalhando com Timezones

Gerenciar fusos horários é crucial para aplicações globais.

Usando zoneinfo (recomendado)

Desde o Python 3.9, a biblioteca padrão tem o módulo zoneinfo, que dá acesso aos fusos horários do banco de dados da IANA (como America/Sao_Paulo), incluindo regras de horário de verão.

Esse é o caminho recomendado hoje, sem instalar nada:

1
2
3
4
5
6

import datetime
from zoneinfo import ZoneInfo

fuso_horario = ZoneInfo("America/Sao_Paulo")
data_hora_local = datetime.datetime.now(fuso_horario)
print(data_hora_local)

Explicação do código:

1. Importação do ZoneInfo: Vem da biblioteca padrão, a partir do Python 3.9.
2. Definição do Fuso Horário: Criamos o fuso pelo nome da IANA.
3. Obtendo Data e Hora Local: Passamos o fuso para now(), que devolve um datetime com fuso (aware).
4. Exibição: Imprimimos a data e hora com o deslocamento em relação ao UTC.

A saída será algo como:

1

2026-09-27 10:54:05.097672-03:00

Para converter um horário de um fuso para outro, use astimezone():

1
2
3
4

reuniao = datetime.datetime(2026, 9, 27, 14, 0, tzinfo=ZoneInfo("America/Sao_Paulo"))
print(reuniao)
print(reuniao.astimezone(ZoneInfo("Europe/Lisbon")))
print(reuniao.astimezone(datetime.timezone.utc))

A saída será:

1
2
3

2026-09-27 14:00:00-03:00
2026-09-27 18:00:00+01:00
2026-09-27 17:00:00+00:00

Windows: o Windows não traz o banco de dados de fusos da IANA. Nesse caso, instale o pacote tzdata (pip install tzdata), que o zoneinfo usa automaticamente como alternativa. Sem ele, ZoneInfo(...) levanta ZoneInfoNotFoundError.

Usando pytz

O pytz é uma biblioteca externa que foi, por muitos anos, a forma padrão de trabalhar com fusos no Python. Hoje ela é considerada legada: para código novo prefira o zoneinfo acima. Você ainda vai encontrá-la em projetos antigos, então vale saber ler.

Para isso, instale o pytz utilizando o pip com pip install pytz. Em seguida:

1
2
3
4
5

import pytz

fuso_horario = pytz.timezone("America/Sao_Paulo")
data_hora_local = datetime.datetime.now(fuso_horario)
print(data_hora_local)

Explicação do código:

1. Importação do pytz: Importamos a biblioteca pytz.
2. Definição do Fuso Horário: Especificamos o fuso horário desejado.
3. Obtendo Data e Hora Local: Usamos now com o fuso horário definido.
4. Exibição: Imprimimos a data e hora local com o fuso aplicado.

A saída será:

1

2025-02-25 15:37:28.861810-03:00

A parte final da data -03:00 é o fuso de São Paulo, GMT-3!

Cuidado com uma pegadinha clássica do pytz: não passe o fuso direto em tzinfo= ao construir um datetime (por exemplo datetime.datetime(2026, 9, 27, 14, 0, tzinfo=pytz.timezone("America/Sao_Paulo"))), porque o resultado sai com o deslocamento histórico -03:06. Com pytz o certo é usar fuso_horario.localize(...). Com zoneinfo essa pegadinha não existe.

Aproveitando o tema: Estou desenvolvendo o Ebookr.ai, uma plataforma para criar ebooks profissionais com IA sobre qualquer assunto. Capa gerada por IA, infográficos automáticos e exportação em PDF. Ideal para documentar seu conhecimento. Dá uma olhada!

Trabalhando com timedelta

A classe timedelta permite realizar operações com intervalos de tempo.

Adicionando Dias a uma Data

1
2
3
4
5
6

import datetime

data_atual = datetime.date.today()
intervalo = datetime.timedelta(days=10)
nova_data = data_atual + intervalo
print(nova_data)

Explicação do código:

1. Criação do Intervalo: Definimos um intervalo de 10 dias com datetime.timedelta(days=10).
2. Adição à Data Atual: Somamos o intervalo à data atual.
3. Exibição: Imprimimos a nova data resultante.

A saída esperada é:

1

2025-03-07

Subtraindo Horas de um Horário

1
2
3
4
5
6

intervalo_horas = datetime.timedelta(hours=5)
nova_hora = datetime.datetime.now().time()
print("Hora atual:", nova_hora)

hora_ajustada = (datetime.datetime.combine(datetime.date.today(), nova_hora) - intervalo_horas).time()
print("Hora ajustada:", hora_ajustada)

Explicação do código:

1. Criação do Intervalo de Horas: Definimos um intervalo de 5 horas.
2. Combinação de Data e Hora: Combinamos a data de hoje com a hora atual.
3. Subtração do Intervalo: Subtraímos o intervalo de horas da data e hora combinadas.
4. Extração da Hora Ajustada: Obtemos apenas o componente de hora.
5. Exibição: Imprimimos a hora antes e após a subtração.

Veja a saída esperada:

1
2

Hora atual: 15:40:58.201792
Hora ajustada: 10:40:58.201792

E para somar meses ou anos?

O timedelta só aceita days, seconds, microseconds, milliseconds, minutes, hours e weeks. Ele não tem months nem years (tentar datetime.timedelta(months=1) levanta TypeError), porque meses e anos não têm duração fixa.

Para isso, a opção mais usada é o relativedelta, da biblioteca externa python-dateutil (instale com pip install python-dateutil):

1
2
3
4
5
6

import datetime
from dateutil.relativedelta import relativedelta

data = datetime.date(2025, 1, 31)
print(data + relativedelta(months=1))
print(data + relativedelta(years=1))

A saída será:

1
2

2025-02-28
2026-01-31

Repare que 31 de janeiro + 1 mês vira 28 de fevereiro: o relativedelta ajusta para o último dia válido do mês.

Trabalhando com Datas em Diferentes Formatos

Datas podem estar em diversos formatos, dependendo da aplicação.

Parsing de Múltiplos Formatos

Podemos criar funções para lidar com múltiplos formatos de data:

1
2
3
4
5
6
7
8
9
10

def parse_data(data_str):
    for fmt in ("%d/%m/%Y", "%Y-%m-%d", "%m-%d-%Y"):
        try:
            return datetime.datetime.strptime(data_str, fmt).date()
        except ValueError:
            continue
    raise ValueError("Formato de data inválido")

data_exemplo = parse_data("12-31-2023")
print(data_exemplo)

Explicação do código:

1. Função de Parsing: Tentamos diferentes formatos para analisar a string de data.
2. Laço de Tentativas: Iteramos sobre uma lista de formatos possíveis.
3. Retorno da Data: Retornamos a data convertida se o formato corresponder.
4. Exceção: Lançamos um erro se nenhum formato for válido.
5. Exibição: Imprimimos a data convertida no formato YYYY-MM-DD.

A saída será:

1

2023-12-31

O try/except ValueError é o que permite testar um formato atrás do outro sem quebrar o programa. Se quiser entender melhor esse mecanismo, veja o guia de tratamento de erros e exceções no Python.

Atenção se você acrescentar formatos parecidos à lista: uma string como "01/02/2026" é válida tanto em %d/%m/%Y (1º de fevereiro) quanto em %m/%d/%Y (2 de janeiro), e a função devolveria o primeiro que funcionar. Por isso, prefira saber de antemão o formato de cada fonte de dados.

Trabalhando com Datas em Diferentes Idiomas

Manipular datas em diferentes idiomas melhora a experiência do usuário global.

Usando locale

O módulo locale permite configurar a localização para formatação de datas:

1
2
3
4
5
6
7
8
9
10

import locale

# Seta a categoria do locale "tempo" (Locale Category: Time) para
# - Português do Brasil (pt_BR)
# - Codificação UTF-8
locale.setlocale(locale.LC_TIME, 'pt_BR.UTF-8')

data_atual = datetime.date.today()
data_formatada = data_atual.strftime("%A, %d de %B de %Y")
print(data_formatada)

Explicação do código:

1. Importação do locale: Importamos o módulo locale.
2. Configuração da Localização: Definimos a localidade para português brasileiro.
3. Formatação com locale: Usamos strftime para formatar a data com nomes de dias e meses em português.
4. Exibição: Imprimimos a data formatada, por exemplo, “segunda, 25 de dezembro de 2023”.

A saída será (em 25/02/2025, no Linux):

1

terça, 25 de fevereiro de 2025

Os nomes de dias e meses vêm do sistema operacional, então podem variar um pouco (por exemplo, “terça” ou “terça-feira”). Se o locale pt_BR.UTF-8 não estiver instalado, setlocale levanta locale.Error.

Qual usar: date, datetime, time, timedelta ou relativedelta?

Boa parte das dúvidas com datas no Python se resolve escolhendo a classe certa logo no começo:

Regra prática: se a hora não importa, use date. Comparar ou subtrair date com datetime gera TypeError, então converta com .date() antes.

Saber escolher a classe certa de data já resolve boa parte dos bugs do dia a dia - e prática assim, com projetos guiados do zero ao avançado, é o que você encontra na Jornada Python:

Domine Python: A Linguagem da Inteligência Artificial, do Desenvolvimento Web e das Carreiras do Futuro.

A mais completa formação para você se tornar um especialista em Python, pronto para construir desde aplicações web robustas com Django até projetos de Inteligência Artificial e Ciência de Dados .

Quero conhecer!

Nota 4,9 de 5 na Hotmart O curso de Python mais bem avaliado da Hotmart!

Casos Práticos Reais

1. Sistema de Agendamentos

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

from datetime import datetime, timedelta
from zoneinfo import ZoneInfo

def agendar_reuniao(data_hora_str, duracao_minutos, timezone="America/Sao_Paulo"):
    """Agenda reunião e calcula horário de fim"""
    tz = ZoneInfo(timezone)
    inicio = datetime.fromisoformat(data_hora_str).replace(tzinfo=tz)
    fim = inicio + timedelta(minutes=duracao_minutos)

    return {
        "inicio": inicio.isoformat(),
        "fim": fim.isoformat(),
        "duracao": f"{duracao_minutos} minutos",
        "dia_semana": inicio.strftime("%A"),
        "horario": inicio.strftime("%H:%M")
    }

# Uso
reuniao = agendar_reuniao("2025-02-28 14:00:00", 90)
print(reuniao)

A saída será:

1

{'inicio': '2025-02-28T14:00:00-03:00', 'fim': '2025-02-28T15:30:00-03:00', 'duracao': '90 minutos', 'dia_semana': 'Friday', 'horario': '14:00'}

Repare que dia_semana saiu em inglês: sem configurar o locale (veja a seção anterior), %A usa os nomes em inglês.

2. Cálculo de Idade e Validações

Este exemplo usa o relativedelta, da biblioteca externa python-dateutil (pip install python-dateutil):

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

from datetime import date, datetime
from dateutil.relativedelta import relativedelta

def calcular_idade_exata(data_nascimento):
    """Calcula idade exata em anos, meses e dias"""
    hoje = date.today()

    if isinstance(data_nascimento, str):
        data_nascimento = datetime.strptime(data_nascimento, "%Y-%m-%d").date()

    diff = relativedelta(hoje, data_nascimento)

    return {
        "anos": diff.years,
        "meses": diff.months,
        "dias": diff.days,
        "total_dias": (hoje - data_nascimento).days,
        "maior_idade": diff.years >= 18
    }

# Uso
idade = calcular_idade_exata("1990-05-15")
print(f"{idade['anos']} anos, {idade['meses']} meses, {idade['dias']} dias")

Como depende da data de hoje, a saída muda a cada dia. Rodando em 27/09/2026:

1

36 anos, 4 meses, 12 dias

3. Dias Úteis (excluindo fins de semana)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

from datetime import date, timedelta

def calcular_dias_uteis(data_inicio, data_fim, feriados=None):
    """Calcula número de dias úteis entre duas datas"""
    if feriados is None:
        feriados = []

    dias_uteis = 0
    data_atual = data_inicio

    while data_atual <= data_fim:
        # 0=Segunda, 6=Domingo
        if data_atual.weekday() < 5 and data_atual not in feriados:
            dias_uteis += 1
        data_atual += timedelta(days=1)

    return dias_uteis

# Uso
inicio = date(2025, 3, 1)
fim = date(2025, 3, 31)
feriados = [date(2025, 3, 3), date(2025, 3, 4)]  # Carnaval 2025
uteis = calcular_dias_uteis(inicio, fim, feriados)
print(f"Dias úteis: {uteis}")

A saída será:

1

Dias úteis: 19

4. Lembretes e Notificações

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

from datetime import datetime, timedelta

def calcular_lembretes(data_evento, lembretes=(7, 3, 1)):
    """Calcula datas para enviar lembretes antes do evento"""
    if isinstance(data_evento, str):
        data_evento = datetime.fromisoformat(data_evento)

    alertas = []
    for dias in lembretes:
        data_lembrete = data_evento - timedelta(days=dias)
        alertas.append({
            "dias_antes": dias,
            "data": data_lembrete.strftime("%d/%m/%Y"),
            "horario": data_lembrete.strftime("%H:%M"),
            "mensagem": f"Lembrete: evento em {dias} dia(s)"
        })

    return alertas

# Uso
event_date = "2025-03-15 10:00:00"
alertas = calcular_lembretes(event_date)
for alerta in alertas:
    print(f"{alerta['data']} - {alerta['mensagem']}")

A saída será:

1
2
3

08/03/2025 - Lembrete: evento em 7 dia(s)
12/03/2025 - Lembrete: evento em 3 dia(s)
14/03/2025 - Lembrete: evento em 1 dia(s)

5. Prazo de Vencimento em Dias Úteis

Uma dúvida frequente (e comum em provas) é qual função pronta do Python calcula um prazo “em N dias úteis”. Não existe função built-in para isso. A solução com a biblioteca padrão é avançar um dia por vez com timedelta e contar só os dias de segunda a sexta que não são feriados:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

from datetime import date, timedelta

def somar_dias_uteis(inicio, dias_uteis, feriados=()):
    """Retorna a data que fica N dias úteis depois de inicio"""
    data = inicio
    while dias_uteis > 0:
        data += timedelta(days=1)
        if data.weekday() < 5 and data not in feriados:
            dias_uteis -= 1
    return data

# Pedido feito na sexta, 25/09/2026, com prazo de 5 dias úteis
print(somar_dias_uteis(date(2026, 9, 25), 5))

# Pedido na sexta, 09/10/2026, 3 dias úteis, com o feriado de 12/10
print(somar_dias_uteis(date(2026, 10, 9), 3, feriados=[date(2026, 10, 12)]))

A saída será:

1
2

2026-10-02
2026-10-15

No segundo caso, o sábado, o domingo e o feriado de segunda (12/10) são pulados, então os 3 dias úteis são 13, 14 e 15 de outubro. Se o seu projeto já usa NumPy, numpy.busday_offset faz o mesmo cálculo.

Erros comuns

Estes são os erros com datas que mais aparecem em código de iniciante. As mensagens abaixo são as reais do Python 3.10.

1. ValueError: time data ... does not match format

1
2
3

from datetime import datetime

datetime.strptime("2026-09-27", "%d/%m/%Y")

1

ValueError: time data '2026-09-27' does not match format '%d/%m/%Y'

O formato precisa descrever o texto exatamente. Aqui o texto está em ano-mês-dia com traços, então o formato certo é "%Y-%m-%d". Uma variação do mesmo problema é o texto ter mais coisa que o formato:

1

datetime.strptime("27/09/2026 14:30", "%d/%m/%Y")

1

ValueError: unconverted data remains:  14:30

Correção: inclua a hora no formato, datetime.strptime("27/09/2026 14:30", "%d/%m/%Y %H:%M").

2. AttributeError por misturar os estilos de importação

1
2
3

from datetime import datetime

agora = datetime.datetime.now()

1

AttributeError: type object 'datetime.datetime' has no attribute 'datetime'

O módulo e a classe se chamam datetime. Depois de from datetime import datetime, o nome datetime já é a classe, então basta datetime.now(). Se você fez import datetime, aí sim é datetime.datetime.now().

3. TypeError ao comparar ou subtrair datetime com e sem fuso

1
2
3
4
5

from datetime import datetime, timezone

prazo = datetime(2026, 9, 27, 14, 0)   # sem fuso (naive)
agora = datetime.now(timezone.utc)     # com fuso (aware)
print(agora > prazo)

1

TypeError: can't compare offset-naive and offset-aware datetimes

Na subtração, a mensagem é TypeError: can't subtract offset-naive and offset-aware datetimes. Correção: deixe os dois do mesmo tipo, de preferência ambos com fuso, por exemplo datetime(2026, 9, 27, 14, 0, tzinfo=ZoneInfo("America/Sao_Paulo")). O mesmo vale para date e datetime: date(2026, 9, 27) < datetime(2026, 9, 28) gera TypeError: can't compare datetime.datetime to datetime.date.

4. Tentar somar meses com timedelta

1
2
3

from datetime import date, timedelta

proximo_mes = date(2026, 1, 31) + timedelta(months=1)

1

TypeError: 'months' is an invalid keyword argument for __new__()

O timedelta não tem months nem years. E trocar por timedelta(days=30) não resolve: date(2026, 1, 31) + timedelta(days=30) dá 2026-03-02, pulando fevereiro inteiro. Para meses e anos, use o relativedelta mostrado em E para somar meses ou anos?.

5. strftime com nomes em inglês (e o locale.Error)

1
2
3

from datetime import date

print(date(2026, 9, 27).strftime("%A, %d de %B de %Y"))

1

Sunday, 27 de September de 2026

Não é erro de sintaxe, mas é o resultado que ninguém quer: sem configurar o locale, %A e %B saem em inglês. A correção é locale.setlocale(locale.LC_TIME, "pt_BR.UTF-8") antes do strftime. Se esse locale não estiver instalado no sistema (comum em containers Docker e em alguns Windows), a chamada falha com:

1

locale.Error: unsupported locale setting

Nesse caso, instale o locale no sistema ou use a alternativa sem locale do Exercício 2 abaixo (uma lista com os nomes em português indexada por weekday()).

Exercícios resolvidos

Tente resolver antes de abrir a solução. Para deixar as saídas reproduzíveis, os exercícios usam datas fixas no lugar de date.today(). Se quiser praticar datas, arquivos e APIs em projetos guiados, o curso de Python completo da Jornada Python tem exercícios assim do começo ao fim.

Exercício 1. Dada a data date(2026, 9, 7), mostre-a no formato brasileiro dd/mm/aaaa, de duas formas: com strftime e com f-string.

1
2
3
4
5

from datetime import date

d = date(2026, 9, 7)
print(d.strftime("%d/%m/%Y"))
print(f"{d:%d/%m/%Y}")

Exercício 2. Descubra em que dia da semana caiu o Natal de 2025 e mostre o nome em português, sem depender do locale.

1
2
3
4
5
6
7

from datetime import date

DIAS = ["segunda-feira", "terça-feira", "quarta-feira", "quinta-feira",
        "sexta-feira", "sábado", "domingo"]

natal = date(2025, 12, 25)
print(DIAS[natal.weekday()])

Exercício 3. O usuário digita a data de um evento no formato dd/mm/aaaa. Considerando que hoje é 27/09/2026 e que ele digitou 25/12/2026, mostre quantos dias faltam.

1
2
3
4
5
6
7

from datetime import date, datetime

hoje = date(2026, 9, 27)        # no seu código: date.today()
texto = "25/12/2026"            # no seu código: input("Data do evento: ")

alvo = datetime.strptime(texto, "%d/%m/%Y").date()
print(f"Faltam {(alvo - hoje).days} dias")

Exercício 4. Escreva uma função calcular_idade(nascimento, hoje) que devolve a idade em anos completos, sem bibliotecas externas. Teste com nascimentos em 15/05/1990 e 10/10/2000, considerando hoje = 27/09/2026.

1
2
3
4
5
6
7
8
9

from datetime import date

def calcular_idade(nascimento, hoje):
    ja_fez = (hoje.month, hoje.day) >= (nascimento.month, nascimento.day)
    return hoje.year - nascimento.year - (0 if ja_fez else 1)

hoje = date(2026, 9, 27)
print(calcular_idade(date(1990, 5, 15), hoje))
print(calcular_idade(date(2000, 10, 10), hoje))

Exercício 5 (estilo prova). Qual é a saída do código abaixo?

1
2
3

from datetime import datetime

print(datetime.strptime("07/09/2026", "%d/%m/%Y").strftime("%Y-%m-%d"))

a) 07/09/2026
b) 2026-09-07
c) 2026-07-09
d) ValueError

Exercício 6 (estilo prova). Qual é o resultado de date(2026, 1, 31) + timedelta(days=30)?

a) 2026-02-28
b) 2026-03-02
c) 2026-02-31
d) TypeError

1
2
3

from datetime import date, timedelta

print(date(2026, 1, 31) + timedelta(days=30))

Exercício 7. Um boleto vence 30 dias após a emissão, mas, se o vencimento cair num sábado ou domingo, passa para a segunda-feira seguinte. Calcule o vencimento para emissões em 01/10/2026 e 27/09/2026.

1
2
3
4
5
6
7
8
9
10

from datetime import date, timedelta

def vencimento(emissao, prazo_dias=30):
    venc = emissao + timedelta(days=prazo_dias)
    while venc.weekday() >= 5:      # 5 = sábado, 6 = domingo
        venc += timedelta(days=1)
    return venc

print(vencimento(date(2026, 10, 1)))
print(vencimento(date(2026, 9, 27)))

Exercício 8. Um funcionário entrou às 08:30 e saiu às 17:45. Calcule o tempo trabalhado como timedelta e em horas decimais.

1
2
3
4
5
6
7
8

from datetime import datetime

entrada = datetime.strptime("08:30", "%H:%M")
saida = datetime.strptime("17:45", "%H:%M")

jornada = saida - entrada
print(jornada)
print(jornada.total_seconds() / 3600)

Antes de continuar… Está curtindo esse conteúdo?

Que tal receber 30 dias de conteúdo direto na sua Caixa de Entrada?

Sua assinatura não pôde ser validada.

Você fez sua assinatura com sucesso.

Assine as PyDicas e receba 30 dias do melhor conteúdo Python na sua Caixa de Entrada: direto e sem enrolação!

Seu nome

Seu e-mail

ASSINAR PYDICAS

Conclusão

Neste artigo, exploramos como trabalhar com datas no Python utilizando o módulo datetime.

Aprendemos a criar e formatar datas e horários, converter entre strings e objetos de data, calcular diferenças e manipular fusos horários com o zoneinfo.

Além disso, abordamos operações com timedelta (e o relativedelta para meses e anos), manipulações de datas futuras e passadas e formatação de datas em diferentes idiomas.

Com esses conhecimentos, você está preparado para gerenciar datas de forma eficaz em suas aplicações Python!

Quer mais exemplos? Veja também nosso post sobre manipulação de datas e horas no Python.

Por Vinícius Ramos em 25/02/2025

Engenheiro de Computação pela UnB com especialização em Inteligência Artificial. Sr. Software Engineer com 10+ anos de experiência desenvolvendo sistemas críticos em Python e Django. Atuei no Banco do Brasil liderando equipes para monitoramento de mainframe, trabalhei como desenvolvedor sênior em projetos forenses para a Polícia Federal, e atualmente sou engenheiro de software na Labcorp (Estados Unidos), desenvolvendo soluções escaláveis para testes genéticos. Fundador da Python Academy, compartilhando conhecimento técnico com a comunidade brasileira desde 2018.

Bora se conectar no LinkedIn! vinicius-aramos

Minhas redes:

• 
• 
•