Python 时间处理终极指南：time 与 datetime 模块详解

玄同765

发布于 2026-01-14 13:41:07

380

在 Python 开发中，时间处理是一项无处不在的基础任务 —— 从生成日志时间戳、调度定时任务，到计算数据分析的时间跨度，时间操作的身影几乎出现在所有应用场景中。Python 标准库提供了两个核心模块来处理时间：time模块和datetime模块。本文将带你深入剖析这两个模块的用法、差异和最佳实践，助你成为 Python 时间处理大师。

一、time 模块：接近底层的时间处理

1. 核心概念

time 模块提供了与 C 语言标准库类似的时间处理接口，主要围绕时间戳和结构化时间展开：

时间戳（Timestamp）：从 1970 年 1 月 1 日 00:00:00 UTC 开始经过的秒数，是一个浮点数。
结构化时间（Struct_time）：一个包含 9 个元素的元组，用于表示年、月、日、时、分、秒等时间信息。

2. 常用函数

2.1 获取时间

import time

# 获取当前时间戳
timestamp = time.time()
print(f"当前时间戳：{timestamp}")  # 输出：当前时间戳：1635705600.123456

# 获取本地时间的结构化时间
local_time = time.localtime()
print(f"本地结构化时间：{local_time}")  # 输出：time.struct_time(tm_year=2021, tm_mon=11, tm_mday=1, tm_hour=0, tm_min=0, tm_sec=0, tm_wday=0, tm_yday=305, tm_isdst=0)

# 获取UTC时间的结构化时间
utc_time = time.gmtime()
print(f"UTC结构化时间：{utc_time}")  # 输出：time.struct_time(tm_year=2021, tm_mon=10, tm_mday=31, tm_hour=16, tm_min=0, tm_sec=0, tm_wday=6, tm_yday=304, tm_isdst=0)

2.2 时间转换

# 时间戳转结构化时间
struct_time = time.localtime(timestamp)
print(f"时间戳转结构化时间：{struct_time}")

# 结构化时间转时间戳
timestamp = time.mktime(struct_time)
print(f"结构化时间转时间戳：{timestamp}")

# 结构化时间转字符串时间
string_time = time.strftime("%Y-%m-%d %H:%M:%S", struct_time)
print(f"结构化时间转字符串时间：{string_time}")  # 输出：2021-11-01 00:00:00

# 字符串时间转结构化时间
struct_time = time.strptime(string_time, "%Y-%m-%d %H:%M:%S")
print(f"字符串时间转结构化时间：{struct_time}")

2.3 实用函数

# 程序休眠指定秒数
time.sleep(2)  # 休眠2秒

# 测量CPU时间
start_cpu = time.process_time()
sum(range(1000000))
end_cpu = time.process_time()
print(f"CPU时间：{end_cpu - start_cpu}")  # 输出：0.015625秒

# 测量墙上时间（包括休眠时间）
start_wall = time.perf_counter()
time.sleep(1)
end_wall = time.perf_counter()
print(f"墙上时间：{end_wall - start_wall}")  # 输出：1.000123秒

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

datetime 模块提供了更高级的时间处理功能，以面向对象的方式封装了时间信息，主要包括以下几个核心类：

datetime.date：处理日期（年、月、日）
datetime.time：处理时间（时、分、秒、微秒）
datetime.datetime：处理日期和时间
datetime.timedelta：处理时间差
datetime.tzinfo：处理时区（需要额外模块支持）

1. datetime.date 类

from datetime import date

# 获取当前日期
today = date.today()
print(f"当前日期：{today}")  # 输出：2021-11-01
print(f"年：{today.year}，月：{today.month}，日：{today.day}")  # 输出：年：2021，月：11，日：1

# 创建特定日期
specific_date = date(2024, 12, 25)
print(f"特定日期：{specific_date}")  # 输出：2024-12-25

# 日期转字符串
string_date = specific_date.strftime("%Y/%m/%d")
print(f"日期转字符串：{string_date}")  # 输出：2024/12/25

# 字符串转日期
specific_date = date.fromisoformat("2024-12-25")
print(f"字符串转日期：{specific_date}")  # 输出：2024-12-25

2. datetime.time 类

from datetime import time

# 创建时间
specific_time = time(14, 30, 45)
print(f"特定时间：{specific_time}")  # 输出：14:30:45
print(f"时：{specific_time.hour}，分：{specific_time.minute}，秒：{specific_time.second}")  # 输出：时：14，分：30，秒：45

# 时间转字符串
string_time = specific_time.strftime("%H:%M:%S")
print(f"时间转字符串：{string_time}")  # 输出：14:30:45

3. datetime.datetime 类

from datetime import datetime

# 获取当前日期时间
now = datetime.now()
print(f"当前日期时间：{now}")  # 输出：2021-11-01 00:00:00.123456
print(f"年：{now.year}，月：{now.month}，日：{now.day}，时：{now.hour}，分：{now.minute}，秒：{now.second}")

# 创建特定日期时间
specific_datetime = datetime(2024, 12, 25, 14, 30, 45)
print(f"特定日期时间：{specific_datetime}")  # 输出：2024-12-25 14:30:45

# 日期时间转字符串
string_datetime = specific_datetime.strftime("%Y-%m-%d %H:%M:%S")
print(f"日期时间转字符串：{string_datetime}")  # 输出：2024-12-25 14:30:45

# 字符串转日期时间
specific_datetime = datetime.strptime("2024-12-25 14:30:45", "%Y-%m-%d %H:%M:%S")
print(f"字符串转日期时间：{specific_datetime}")  # 输出：2024-12-25 14:30:45

4. datetime.timedelta 类

timedelta 类用于表示两个日期或时间之间的差异，非常适合用于时间运算：

from datetime import datetime, timedelta

# 当前日期时间
now = datetime.now()

# 计算明天的同一时间
tomorrow = now + timedelta(days=1)
print(f"明天同一时间：{tomorrow}")  # 输出：2021-11-02 00:00:00.123456

# 计算昨天的同一时间
yesterday = now - timedelta(days=1)
print(f"昨天同一时间：{yesterday}")  # 输出：2021-10-31 00:00:00.123456

# 计算1小时30分钟后的时间
later = now + timedelta(hours=1, minutes=30)
print(f"1小时30分钟后：{later}")  # 输出：2021-11-01 01:30:00.123456

# 计算两个日期之间的差异
date1 = datetime(2024, 12, 25)
date2 = datetime(2021, 11, 1)
diff = date1 - date2
print(f"日期差：{diff}")  # 输出：1150 days, 0:00:00
print(f"相差天数：{diff.days}")  # 输出：1150

5. 时区处理

datetime 模块本身支持时区处理，但需要结合pytz或zoneinfo模块（Python 3.9+）。以下是使用 zoneinfo 的示例：

from datetime import datetime
from zoneinfo import ZoneInfo

# 获取当前UTC时间
utc_now = datetime.now(ZoneInfo("UTC"))
print(f"UTC时间：{utc_now}")  # 输出：2021-10-31 16:00:00.123456+00:00

# 转换为北京时间
beijing_now = utc_now.astimezone(ZoneInfo("Asia/Shanghai"))
print(f"北京时间：{beijing_now}")  # 输出：2021-11-01 00:00:00.123456+08:00

# 转换为纽约时间
newyork_now = utc_now.astimezone(ZoneInfo("America/New_York"))
print(f"纽约时间：{newyork_now}")  # 输出：2021-10-31 12:00:00.123456-04:00

三、time 模块与 datetime 模块的对比

模块	特点	适用场景
time	接近底层，功能简单，效率高	简单的时间戳转换、性能测试、定时任务
datetime	面向对象，功能丰富，易用性强	复杂的时间运算、日期时间格式化、时区处理

选择建议

如果需要处理简单的时间戳或进行性能测试，使用 time 模块。
如果需要处理复杂的日期时间运算或格式化，使用 datetime 模块。
如果需要处理时区，使用 datetime 模块结合 zoneinfo 或 pytz 模块。

四、实战案例

1. 计算程序运行时间

import time

def calculate():
    sum = 0
    for i in range(10000000):
        sum += i
    return sum

# 使用time模块
start_time = time.time()
calculate()
end_time = time.time()
print(f"程序运行时间：{end_time - start_time}秒")  # 输出：0.234567秒

# 使用time.perf_counter()
start_time = time.perf_counter()
calculate()
end_time = time.perf_counter()
print(f"程序运行时间：{end_time - start_time}秒")  # 输出：0.234567秒

2. 生成日志时间戳

from datetime import datetime

def log(message):
    timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
    print(f"[{timestamp}] {message}")

# 使用示例
log("程序开始运行")  # 输出：[2021-11-01 00:00:00] 程序开始运行
log("程序运行结束")  # 输出：[2021-11-01 00:00:01] 程序运行结束

3. 计算两个日期之间的工作日天数

from datetime import datetime, timedelta

def count_weekdays(start_date, end_date):
    count = 0
    current_date = start_date
    while current_date <= end_date:
        # 周一到周五是工作日（tm_wday=0-4）
        if current_date.weekday() < 5:
            count += 1
        current_date += timedelta(days=1)
    return count

# 使用示例
start_date = datetime(2024, 12, 1)
end_date = datetime(2024, 12, 31)
weekdays = count_weekdays(start_date, end_date)
print(f"2024年12月工作日天数：{weekdays}")  # 输出：22