Python怎样处理日期时间？datetime模块技巧

python处理日期时间的核心是datetime模块，1. 使用datetime.datetime.now()获取当前本地时间，datetime.date.today()获取当前日期；2. 通过strptime()将格式匹配的字符串解析为datetime对象，fromtimestamp()将时间戳转为datetime；3. 利用timedelta进行日期加减计算，并支持两个datetime对象相减得到时间差；4. 区分naive（无时区）和aware（有时区）对象，推荐使用timezone.utc处理utc时间，并通过astimezone()实现时区转换，复杂时区建议用zoneinfo或pytz库；所有内部存储应采用utc时间，展示时再转为本地时区，以确保准确性。

Python处理日期时间，核心就是利用内置的

datetime

模块。它提供了一套非常完整且强大的工具集，能让你轻松地创建、操作、格式化和解析日期与时间，无论是精确到微秒的本地时间，还是复杂的跨时区转换，都能找到对应的解决方案。

解决方案

要说Python里玩转日期时间，

datetime

模块绝对是绕不开的基石。它不像一些语言那样，把日期和时间分得太开，而是很优雅地把它们融合在一起，形成了一个个易于操作的对象。

通常，你会用到这几个核心类：

• datetime.datetime

  : 最常用的，包含了日期和时间信息。

• datetime.date

  : 只有日期（年、月、日）。

• datetime.time

  : 只有时间（时、分、秒、微秒）。

• datetime.timedelta

  : 表示两个日期或时间点之间的时间差，用于日期时间计算。

• datetime.timezone

  : 用于处理时区信息，尤其是在Python 3.2+版本中，提供了一个更原生的时区处理方式。

实际操作中，获取当前时间是起点：

import datetime

# 获取当前日期和时间
now = datetime.datetime.now()
print(f"当前日期时间: {now}")

# 获取当前日期
today = datetime.date.today()
print(f"今天日期: {today}")

# 创建一个特定的日期时间
specific_dt = datetime.datetime(2023, 10, 27, 14, 30, 0)
print(f"特定日期时间: {specific_dt}")

# 格式化输出：将datetime对象转成字符串
formatted_dt = now.strftime("%Y-%m-%d %H:%M:%S")
print(f"格式化输出: {formatted_dt}")

# 从字符串解析：将字符串转成datetime对象
dt_string = "2024-01-01 10:00:00"
parsed_dt = datetime.datetime.strptime(dt_string, "%Y-%m-%d %H:%M:%S")
print(f"解析后的日期时间: {parsed_dt}")

# 日期时间计算：使用timedelta
one_day_later = now + datetime.timedelta(days=1)
print(f"明天: {one_day_later}")

five_hours_ago = now - datetime.timedelta(hours=5)
print(f"五小时前: {five_hours_ago}")

这些基础操作构成了我们日常处理日期时间的主体。理解了它们，基本上就能应对大部分场景了。

日期时间对象创建与转换：如何从字符串、时间戳构建datetime？

在实际开发里，我们很少能直接拿到一个

datetime

对象，更多时候数据是以字符串或者时间戳的形式存在。这就引出了

strptime()

和

fromtimestamp()

这两个非常实用的方法。

strptime()

，顾名思思义，“string parse time”，就是把字符串解析成时间。这里最关键的是格式化字符串，它就像一个秘密口令，告诉Python你的日期字符串长什么样。比如

"%Y-%m-%d %H:%M:%S"

，就是指年-月-日 时:分:秒。如果你的字符串格式和这个口令对不上，那就会直接报错，这是新手常遇到的坑。比如，如果你字符串里是

2023/10/27

，但你用了

%Y-%m-%d

，那肯定不行。

import datetime

# 从字符串创建 datetime 对象
date_str_1 = "2023-10-27 15:30:00"
dt_obj_1 = datetime.datetime.strptime(date_str_1, "%Y-%m-%d %H:%M:%S")
print(f"从'YYYY-MM-DD HH:MM:SS'解析: {dt_obj_1}")

date_str_2 = "Oct 27, 2023, 3:30 PM"
# 注意这里格式代码的变化，需要对应英文缩写和PM/AM
dt_obj_2 = datetime.datetime.strptime(date_str_2, "%b %d, %Y, %I:%M %p")
print(f"从'Mon DD, YYYY, HH:MM PM/AM'解析: {dt_obj_2}")

# 常见错误：格式不匹配
try:
    datetime.datetime.strptime("2023/10/27", "%Y-%m-%d")
except ValueError as e:
    print(f"解析错误示例: {e}") # 会报错：time data '2023/10/27' does not match format '%Y-%m-%d'

# 从时间戳创建 datetime 对象
# 时间戳通常是自1970年1月1日UTC午夜（Unix纪元）以来的秒数
timestamp_seconds = 1678886400 # 2023-03-15 00:00:00 UTC
dt_from_ts = datetime.datetime.fromtimestamp(timestamp_seconds)
print(f"从本地时间戳解析: {dt_from_ts}")

# 如果是UTC时间戳，可以使用utcfromtimestamp (Python 3.3+ 推荐 timezone.utc)
dt_from_utc_ts = datetime.datetime.fromtimestamp(timestamp_seconds, tz=datetime.timezone.utc)
print(f"从UTC时间戳解析: {dt_from_utc_ts}")

# 获取时间戳
current_dt = datetime.datetime.now()
current_timestamp = current_dt.timestamp()
print(f"当前时间的时间戳: {current_timestamp}")

理解这些格式代码是关键，它们决定了你能不能正确地把字符串“翻译”成Python能理解的日期时间对象。

日期时间计算与比较：timedelta的魔法与实用场景

datetime

对象之所以强大，很大一部分原因在于它能进行直观的日期时间计算。这里的主角就是

timedelta

。你可以把它想象成一个“时间段”或者“时间差”，比如“3天”、“5小时”、“1周零2天”。

有了

timedelta

，你就可以对

datetime

对象进行加减运算，轻松实现“明天是哪天”、“上周二是什么时候”、“某个事件发生后30分钟”这类需求。

import datetime

# 创建一个timedelta对象
# 可以指定天、秒、微秒、毫秒、分、时、周
one_day = datetime.timedelta(days=1)
three_hours = datetime.timedelta(hours=3)
half_minute = datetime.timedelta(seconds=30)
two_weeks_and_a_day = datetime.timedelta(weeks=2, days=1)

now = datetime.datetime.now()
print(f"当前时间: {now}")

# 加法运算
tomorrow = now + one_day
print(f"明天: {tomorrow}")

future_time = now + three_hours + half_minute
print(f"未来时间: {future_time}")

# 减法运算
yesterday = now - one_day
print(f"昨天: {yesterday}")

past_time = now - two_weeks_and_a_day
print(f"两周一天前: {past_time}")

# 计算两个datetime对象之间的时间差，结果是timedelta
event_start = datetime.datetime(2023, 10, 20, 9, 0, 0)
event_end = datetime.datetime(2023, 10, 27, 17, 0, 0)
duration = event_end - event_start
print(f"事件持续时间: {duration}")
print(f"事件持续天数: {duration.days}天")
print(f"事件持续总秒数: {duration.total_seconds()}秒")

# 日期时间比较
dt1 = datetime.datetime(2023, 1, 1)
dt2 = datetime.datetime(2023, 1, 2)
dt3 = datetime.datetime(2023, 1, 1)

print(f"dt1  dt1: {dt2 > dt1}") # True

# 实用场景：计算年龄
birth_date = datetime.date(1990, 5, 15)
today_date = datetime.date.today()
age_delta = today_date - birth_date
age_years = age_delta.days // 365 # 简单粗暴的年龄计算，不考虑闰年
print(f"年龄（约）: {age_years}岁")

# 实用场景：任务截止日期提醒
task_deadline = datetime.datetime(2024, 1, 1, 23, 59, 59)
time_left = task_deadline - now
if time_left.total_seconds() > 0:
    print(f"距离任务截止还有: {time_left.days}天 {time_left.seconds // 3600}小时")
else:
    print("任务已过期！")

timedelta

的灵活组合，让日期时间的操作变得非常直观和强大。这是我个人觉得

datetime

模块里最“解压”的功能之一，因为它把很多原本需要手动计算的逻辑，都封装得很好。

时区处理：理解本地时间、UTC与时区转换的挑战

时区，这玩意儿在处理全球化应用时，简直是个噩梦。Python的

datetime

模块虽然提供了时区处理的能力，但它本身对于时区数据库的支持是有限的。你可能会听到“naive”和“aware”两种

datetime

对象：

• Naive (天真/无知) datetime: 没有关联任何时区信息。当你直接

  datetime.datetime.now()

  时，得到的就是一个naive对象，它代表的是你系统当前设置的时区时间，但它不知道自己是什么时区。
• Aware (有意识) datetime: 包含时区信息。它知道自己属于哪个时区，因此可以进行正确的时区转换。

处理时区，最推荐的做法是：所有内部存储和计算都使用UTC时间。只有在需要向用户展示或者与外部系统交互时，才转换为特定的本地时区。

datetime

模块提供了一个

timezone

类来表示固定偏移量的时区（比如UTC+8），但对于复杂的、包含夏令时规则的时区（如“America/New_York”），你需要借助第三方库，比如

pytz

或者Python 3.9+自带的

zoneinfo

模块。

import datetime

# 1. Naive datetime (默认是本地时间，但不知道自己是哪个时区)
naive_dt = datetime.datetime.now()
print(f"Naive datetime: {naive_dt} (没有时区信息)")

# 2. Aware datetime with fixed offset (比如UTC)
utc_now = datetime.datetime.now(datetime.timezone.utc)
print(f"Aware datetime (UTC): {utc_now} (有UTC时区信息)")

# 创建一个表示东八区的时区对象
# datetime.timedelta(hours=8) 表示 UTC+8
beijing_tz = datetime.timezone(datetime.timedelta(hours=8), name='Asia/Shanghai')
london_tz = datetime.timezone(datetime.timedelta(hours=0), name='Europe/London') # 简化，实际伦敦有夏令时

# 3. 将Naive datetime 转换为 Aware datetime (假定它是某个时区的时间)
# 假设 naive_dt 就是北京时间
beijing_dt = naive_dt.replace(tzinfo=beijing_tz)
print(f"Naive转Aware (北京时间): {beijing_dt}")

# 4. 时区转换：使用 .astimezone()
# 将北京时间转换为伦敦时间
london_dt = beijing_dt.astimezone(london_tz)
print(f"北京时间转伦敦时间: {london_dt}")

# 将北京时间转换为UTC时间
beijing_to_utc = beijing_dt.astimezone(datetime.timezone.utc)
print(f"北京时间转UTC: {beijing_to_utc}")

# 5. 从UTC时间创建Aware datetime并转换为本地时区（系统时区）
# 这通常是推荐的做法：内部用UTC，显示时转本地
utc_specific_dt = datetime.datetime(2023, 10, 27, 10, 0, 0, tzinfo=datetime.timezone.utc)
print(f"UTC特定时间: {utc_specific_dt}")

# 转换为本地系统时区
local_specific_dt = utc_specific_dt.astimezone() # 不传入参数默认转为本地系统时区
print(f"UTC转本地系统时间: {local_specific_dt}")

# 注意：datetime.timezone 只能处理固定偏移量，对于夏令时等复杂规则，
# 建议使用第三方库如 'pytz' 或 Python 3.9+ 的 'zoneinfo'。
# 例如，使用 zoneinfo (Python 3.9+)
# from zoneinfo import ZoneInfo
# ny_tz = ZoneInfo("America/New_York")
# ny_time = utc_specific_dt.astimezone(ny_tz)
# print(f"UTC转纽约时间 (使用zoneinfo): {ny_time}")

时区处理确实是日期时间操作中比较复杂的一部分，因为它涉及到地理、政治、以及时间调整的规则。我的建议是，如果你的应用需要处理全球用户，那么从一开始就应该把时区问题考虑进去，并坚持使用UTC作为内部标准。这能省掉很多后续的麻烦。

Python免费学习笔记（深入）：立即学习
在学习笔记中，你将探索 Python 的核心概念和高级技巧！