Python 时间处理：datetime 与 time 模块

在 Python 编程中，时间处理是几乎每个项目都会遇到的需求。记录日志需要时间戳，计算程序耗时需要计时，计算用户活跃度需要日期差——这些场景都离不开时间模块的支持。Python 提供了 time 和 datetime 两个核心模块来处理时间相关问题，它们各有侧重，适用于不同的场景。

time 模块：Unix 时间戳与底层时间操作

time 模块是 Python 中最基础的时间处理模块，它直接与操作系统的时间服务交互，提供 Unix 时间戳（自 1970 年 1 月 1 日 00:00:00 UTC 以来的秒数）相关的功能。这个模块适合需要精确计时、性能分析等底层操作的场景。

获取当前时间戳

import time

# 获取当前时间戳（浮点数，精确到毫秒）
timestamp = time.time()
print(timestamp)  # 例如：1699804800.123456

time.time() 返回的是自 Unix 纪元以来的秒数，这是一个浮点数，可以精确到微秒级别。这个值适合进行时间差计算，但直接阅读可读性较差。

时间戳与本地时间转换

import time

# 获取当前时间戳
timestamp = time.time()

# 将时间戳转换为本地时间元组
local_time = time.localtime(timestamp)
print(f"年份: {local_time.tm_year}")
print(f"月份: {local_time.tm_mon}")
print(f"日期: {local_time.tm_mday}")
print(f"时: {local_time.tm_hour}")
print(f"分: {local_time.tm_min}")
print(f"秒: {local_time.tm_sec}")

time.localtime() 接收一个时间戳，返回一个命名元组（struct_time），包含年、月、日、时、分、秒等属性。这种结构化的表示方式方便程序逐个提取时间分量。

格式化时间字符串

import time

# 获取当前时间戳
timestamp = time.time()

# 转换为可读的时间字符串
time_str = time.ctime(timestamp)
print(time_str)  # 例如：Thu Nov 23 10:30:45 2023

time.ctime() 是最简单的时间格式化方法，直接将时间戳转换为人类可读的字符串，格式为 "Thu Nov 23 10:30:45 2023"。如果你需要自定义格式，可以使用 time.strftime()：

import time

# 自定义格式：年-月-日 时:分:秒
formatted_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())
print(formatted_time)  # 例如：2023-11-23 10:30:45

strftime 的格式符号非常丰富，常用的包括 %Y（四位年份）、%m（两位月份）、%d（两位日期）、%H（24小时制小时）、%M（分钟）、%S（秒）等。

程序计时与性能分析

import time

# 记录开始时间
start_time = time.time()

# 执行需要计时的操作
result = sum(range(1000000))

# 记录结束时间
end_time = time.time()

# 计算耗时
elapsed = end_time - start_time
print(f"计算完成，耗时: {elapsed:.4f} 秒")

time.time() 是性能分析的首选工具。通过在代码段前后分别记录时间戳并计算差值，可以精确测量程序的执行时间。测量睡眠时间则推荐使用 time.sleep()：

import time

print("开始等待...")
time.sleep(3)  # 暂停 3 秒
print("等待结束")

datetime 模块：面向对象的时间处理

datetime 模块提供了更高级、更直观的时间处理方式。与 time 模块专注于 Unix 时间戳不同，datetime 模块实现了多个面向对象的类，包括 date（日期）、time（时间）、datetime（日期时间组合）和 timedelta（时间间隔）。这些类的方法设计符合直觉，让时间操作变得更加简单。

获取当前日期和时间

from datetime import datetime, date, time

# 获取当前日期时间对象
now = datetime.now()
print(f"当前日期时间: {now}")
print(f"年份: {now.year}")
print(f"月份: {now.month}")
print(f"日期: {now.day}")
print(f"小时: {now.hour}")
print(f"分钟: {now.minute}")
print(f"秒: {now.second}")

# 分别获取日期对象和时间对象
today = date.today()
print(f"当前日期: {today}")

current_time = time(12, 30, 45)
print(f"指定时间: {current_time}")

datetime.now() 返回当前本地日期时间的 datetime 对象，这个对象包含了日期和时间的全部信息，并且可以直接访问年、月、日、时、分、秒等属性。

创建指定日期时间

from datetime import datetime

# 使用构造函数创建 datetime 对象
dt1 = datetime(2023, 12, 25, 15, 30, 0)
print(f"指定日期时间: {dt1}")

# 从时间戳创建 datetime 对象
timestamp = 1702888200  # 示例时间戳
dt2 = datetime.fromtimestamp(timestamp)
print(f"从时间戳创建: {dt2}")

# 从字符串解析日期时间
dt3 = datetime.strptime("2023-12-25 15:30:00", "%Y-%m-%d %H:%M:%S")
print(f"从字符串解析: {dt3}")

datetime.strptime() 是处理日期时间字符串的神器，它可以根据指定的格式将字符串解析为 datetime 对象。这在处理用户输入、日志文件中的时间戳时非常有用。

日期时间格式化输出

from datetime import datetime

now = datetime.now()

# 格式化为字符串
formatted1 = now.strftime("%Y年%m月%d日 %H:%M:%S")
print(f"中文格式: {formatted1}")

formatted2 = now.strftime("%Y/%m/%d %H:%M")
print(f"简洁格式: {formatted2}")

formatted3 = now.strftime("%Y-%m-%d")
print(f"仅日期: {formatted3}")

formatted4 = now.strftime("%H:%M:%S")
print(f"仅时间: {formatted4}")

# ISO 8601 格式
iso_format = now.isoformat()
print(f"ISO格式: {iso_format}")

strftime 方法提供了强大的格式化能力，可以根据需要自定义输出格式。常用的格式符号包括 %Y（四位年份）、%y（两位年份）、%B（完整月份名）、%b（缩写月份名）、%A（完整星期名）等。

时间间隔计算（timedelta）

from datetime import datetime, timedelta

now = datetime.now()

# 计算 7 天后的日期
future = now + timedelta(days=7)
print(f"7天后: {future}")

# 计算 3 小时前的时间
past = now - timedelta(hours=3)
print(f"3小时前: {past}")

# 计算两个日期的差值
dt1 = datetime(2023, 12, 25, 0, 0, 0)
dt2 = datetime(2024, 1, 1, 0, 0, 0)
delta = dt2 - dt1
print(f"相差天数: {delta.days}")
print(f"相差总秒数: {delta.seconds}")
print(f"相差天数（包含秒数）: {delta.total_days()}")

timedelta 是时间差计算的核心类，它可以表示两个日期或时间之间的差异，支持加减运算。delta.days 返回天数部分，delta.seconds 返回不足一天的部分（0-86399），delta.total_seconds() 返回总秒数（包括天数部分）。

更复杂的时间计算

from datetime import datetime, timedelta

# 下个工作日计算
def next_workday(start_date):
    days_to_add = 1
    while True:
        target = start_date + timedelta(days=days_to_add)
        # 跳过周末（5=Saturday, 6=Sunday）
        if target.weekday() < 5:
            return target
        days_to_add += 1

today = datetime.now().date()
print(f"今天: {today}")
print(f"下个工作日: {next_workday(today)}")

# 本周开始日期（周一）
def week_start(date_obj):
    # weekday(): Monday=0, Sunday=6
    days_since_monday = date_obj.weekday()
    return date_obj - timedelta(days=days_since_monday)

print(f"本周开始日期: {week_start(today)}")

# 本月最后一天
def month_last_day(date_obj):
    # 下个月第一天减一天
    if date_obj.month == 12:
        next_month = date_obj.replace(year=date_obj.year + 1, month=1, day=1)
    else:
        next_month = date_obj.replace(month=date_obj.month + 1, day=1)
    return next_month - timedelta(days=1)

print(f"本月最后一天: {month_last_day(today)}")

通过组合 timedelta 和 datetime 的方法，可以实现各种复杂的时间计算逻辑，如计算工作日、获取周起始日期、获取月份最后一天等。

时区处理

from datetime import datetime, timezone, timedelta

# 获取 UTC 时间
utc_now = datetime.now(timezone.utc)
print(f"UTC 时间: {utc_now}")

# 创建带时区的时间
tokyo_tz = timezone(timedelta(hours=9))  # 东九区
tokyo_time = datetime.now(tokyo_tz)
print(f"东京时间: {tokyo_time}")

# 时区转换
utc_time = utc_now.astimezone(tokyo_tz)
print(f"UTC 转东京时间: {utc_time}")

# 不同时区的时间差
diff = tokyo_time - utc_now
print(f"时区差: {diff}")

时区处理是全球化应用的重要需求。datetime 模块通过 timezone 类支持时区-aware（时区感知）的时间对象。使用 astimezone() 方法可以在不同时区之间转换时间。

模块选择指南

性能对比示例

import time
from datetime import datetime

# 对比两种方式获取当前时间的开销
iterations = 100000

# time.time()
start = time.time()
for _ in range(iterations):
    _ = time.time()
time_time_elapsed = time.time() - start

# datetime.now()
start = time.time()
for _ in range(iterations):
    _ = datetime.now()
datetime_now_elapsed = time.time() - start

print(f"time.time() {iterations}次调用耗时: {time_time_elapsed:.4f}秒")
print(f"datetime.now() {iterations}次调用耗时: {datetime_now_elapsed:.4f}秒")

在性能敏感的场景（如高频循环中的时间记录），time.time() 的开销通常略低于 datetime.now()。但在大多数应用场景下，这种差异可以忽略不计，选择更符合语义的方式即可。

常见问题与解决方案

时区不一致导致的时间差

from datetime import datetime

# 问题：直接比较 naive datetime（无时区信息）可能导致意外结果
dt1 = datetime(2023, 12, 25, 10, 0, 0)  # 本地时间 10:00
dt2 = datetime(2023, 12, 25, 18, 0, 0)  # 本地时间 18:00

# 解决方案：始终使用 UTC 时间进行存储和比较
utc_dt1 = dt1.replace(tzinfo=timezone.utc)
utc_dt2 = dt2.replace(tzinfo=timezone.utc)

time_diff = utc_dt2 - utc_dt1
print(f"时间差: {time_diff}")

字符串解析常见错误

from datetime import datetime

# 常见错误：格式不匹配
try:
    dt = datetime.strptime("2023/12/25", "%Y-%m-%d")
except ValueError as e:
    print(f"解析错误: {e}")

# 正确做法：确保格式字符串与输入匹配
dt = datetime.strptime("2023/12/25", "%Y/%m/%d")
print(f"正确解析: {dt}")

跨年、跨月的日期计算

from datetime import datetime, timedelta

# 问题：2023年1月31日 + 1个月 = ?
start = datetime(2023, 1, 31)
one_month = timedelta(days=31)

# 直接加天数是安全的
result1 = start + one_month
print(f"加31天: {result1}")

# 使用 relativedelta 处理月份更智能（需要 dateutil 库）
# from dateutil.relativedelta import relativedelta
# result2 = start + relativedelta(months=1)
# print(f"加1个月: {result2}")  # 会自动调整到2月28日或3月1日

最佳实践总结

存储与展示分离：在数据库中存储 UTC 时间戳，呈现给用户时再转换为本地时区。这样可以避免时区混乱，也便于不同时区的用户看到正确的时间。

优先使用 datetime：除非有特殊性能需求，否则优先使用 datetime 模块。它的 API 设计更现代，方法命名更清晰，减少了出错的可能性。

时区信息不可省略：在涉及多时区或需要精确时间比较的场景，始终使用带时区信息的 datetime 对象，避免 "magic number" 和隐式时区转换带来的 bug。

善用 timedelta 进行计算：日期时间计算优先使用 timedelta，而不是手动计算天数后再构造新对象。前者不仅代码更简洁，还能正确处理月份天数变化、夏令时等边界情况。