Python time 模块从时间表示到时间转化的深度解析

目录

• 开篇：时间处理的 “瑞士军刀”
• 一、time 模块的基础认知
• 1.1 什么是 time 模块？
• 1.2 时间的三种表示方式
• 1.3 time 模块的导入
• 二、时间格式字符串详解
• 2.1 时间格式说明符表格
• 2.1.1 年份
• 2.1.2 月份
• 2.1.3 日期
• 2.1.4 星期
• 2.1.5 时间
• 2.1.6 时区与时间戳
• 2.1.7 其他
• 三、time 模块核心函数全解析
• 3.1 获取时间相关的函数
• 3.1.1 time.time()
• 3.1.2 time.localtime()
• 3.1.3 time.gmtime()
• 3.1.4 time.strftime()
• 3.1.5 time.strptime()
• 3.1.6 time.asctime()
• 3.1.7 time.ctime()
• 3.2 时间计算相关的函数
• 3.2.1 time.sleep()
• 3.2.2 time.clock()
• 3.2.3 time.process_time()
• 3.2.4 time.perf_counter()
• 3.2.5 time.time_ns()
• 3.3 其他函数
• 3.3.1 time.tzset()
• 3.3.2 time.gettimeofday()
• 四、time 模块实战应用
• 4.1 时间转化实战
• 4.1.1 时间戳转化为字符串时间
• 4.1.2 字符串时间转化为时间戳
• 4.1.3 结构化时间转化为字符串时间
• 4.2 时间计算实战
• 4.2.1 计算程序执行时间
• 4.2.2 实现定时任务
• 4.3 LLM 开发实战
• 4.3.1 记录对话历史时间戳
• 4.3.2 统计 LLM 响应时间
• 五、常见问题与解决方案
• 5.1 时间格式转化错误
• 5.2 时区问题
• 5.3 时间戳精度问题
• 5.4 字符串时间转时间戳的时区问题
• 六、time 模块与 datetime 模块的对比
• 七、总结：time 模块的核心价值

在 Python 开发中，时间处理是永恒的主题—— 无论是日志记录、任务调度、数据分析还是 LLM 开发中的对话历史时间戳，都离不开对时间的精确控制和转化。Python 的time模块就是处理时间的核心工具，它提供了：

• 时间的表示方式（时间戳、结构化时间、字符串时间）
• 时间的转化功能（时间戳→结构化时间→字符串时间）
• 时间的计算功能（时间差、睡眠等）
• 时间的获取功能（当前时间、CPU 时间等）

本文将系统性地解析 Python 的 time 模块，从基础的时间格式到复杂的时间转化，从核心函数到实战应用，帮你全方位掌握 time 模块的使用。

time 模块是 Python 标准库中的时间处理模块，提供了与时间相关的各种功能，包括时间的获取、表示、转化和计算等。

在 Python 中，时间主要有以下三种表示方式：

时间类型	含义	示例
时间戳	从 1970 年 1 月 1 日 00:00:00 UTC 开始经过的秒数	1635705600.0
结构化时间	包含年、月、日、时、分、秒等时间字段的元组	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=-1)
字符串时间	可读性强的字符串表示形式	"2021-11-01 00:00:00"

import time

时间格式字符串是用于将结构化时间或时间戳转化为字符串时间的模板，由普通字符和格式说明符组成。格式说明符以%开头，用于指定时间字段的格式。

格式说明符	含义	示例
%Y	4 位年份	2024
%y	2 位年份	24

格式说明符	含义	示例
%m	2 位月份（01-12）	05
%b	英文月份缩写（Jan-Dec）	May
%B	英文月份全称（January-December）	May

格式说明符	含义	示例
%d	2 位日期（01-31）	15
%j	1 年中的第几天（001-366）	135

格式说明符	含义	示例
%a	英文星期缩写（Mon-Sun）	Wed
%A	英文星期全称（Monday-Sunday）	Wednesday
%w	星期几（0-6，0 代表周日）	3
%W	1 年中的第几周（00-53）	20
%U	1 年中的第几周（00-53）	20

格式说明符	含义	示例
%H	24 小时制小时数（00-23）	14
%I	12 小时制小时数（01-12）	02
%p	AM/PM	PM
%M	分钟数（00-59）	30
%S	秒数（00-59）	45
%f	微秒数（000000-999999）	123456

格式说明符	含义	示例
%z	UTC 偏移量	+0800
%Z	时区名称	CST
%c	本地时间的字符串表示	Wed May 15 14:30:45 2024
%x	本地日期的字符串表示	05/15/24
%X	本地时间的字符串表示	14:30:45

格式说明符	含义	示例
%%	百分号	%

功能：获取当前时间的时间戳（从 1970 年 1 月 1 日 00:00:00 UTC 开始经过的秒数）语法：time.time() -> float返回值：浮点数时间戳实战案例：

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

功能：将时间戳转化为本地时间的结构化时间语法：time.localtime([secs]) -> struct_time参数：

• secs：可选参数，时间戳，默认为当前时间返回值：结构化时间元组实战案例：

import time
# 获取当前本地时间的结构化时间
local_time = time.localtime()
print(f"当前本地时间的结构化时间：{local_time}")
# 输出：当前本地时间的结构化时间：time.struct_time(tm_year=2024, tm_mon=5, tm_mday=15, tm_hour=14, tm_min=30, tm_sec=45, tm_wday=2, tm_yday=136, tm_isdst=0)

功能：将时间戳转化为 UTC 时间的结构化时间语法：time.gmtime([secs]) -> struct_time参数：

• secs：可选参数，时间戳，默认为当前时间返回值：结构化时间元组实战案例：

import time
# 获取当前UTC时间的结构化时间
utc_time = time.gmtime()
print(f"当前UTC时间的结构化时间：{utc_time}")
# 输出：当前UTC时间的结构化时间：time.struct_time(tm_year=2024, tm_mon=5, tm_mday=15, tm_hour=6, tm_min=30, tm_sec=45, tm_wday=2, tm_yday=136, tm_isdst=0)

功能：将结构化时间转化为字符串时间语法：time.strftime(format[, t]) -> str参数：

• format：时间格式字符串
• t：可选参数，结构化时间，默认为当前本地时间返回值：字符串时间实战案例：

import time
# 将当前本地时间转化为字符串时间
formatted_time = time.strftime("%Y-%m-%d %H:%M:%S")
print(f"当前时间：{formatted_time}")
# 输出：当前时间：2024-05-15 14:30:45
# 将指定的结构化时间转化为字符串时间
struct_time = time.struct_time(tm_year=2024, tm_mon=5, tm_mday=15, tm_hour=14, tm_min=30, tm_sec=45, tm_wday=2, tm_yday=136, tm_isdst=0)
formatted_time = time.strftime("%B %d, %Y %I:%M:%S %p", struct_time)
print(f"格式化时间：{formatted_time}")
# 输出：格式化时间：May 15, 2024 02:30:45 PM

功能：将字符串时间转化为结构化时间语法：time.strptime(string, format) -> struct_time参数：

• string：字符串时间
• format：时间格式字符串返回值：结构化时间元组实战案例：

import time
# 将字符串时间转化为结构化时间
string_time = "2024-05-15 14:30:45"
struct_time = time.strptime(string_time, "%Y-%m-%d %H:%M:%S")
print(f"结构化时间：{struct_time}")
# 输出：结构化时间：time.struct_time(tm_year=2024, tm_mon=5, tm_mday=15, tm_hour=14, tm_min=30, tm_sec=45, tm_wday=2, tm_yday=136, tm_isdst=-1)

功能：将结构化时间转化为可读性强的字符串时间语法：time.asctime([t]) -> str参数：

• t：可选参数，结构化时间，默认为当前本地时间返回值：字符串时间实战案例：

import time
# 将当前本地时间转化为可读性强的字符串时间
asctime = time.asctime()
print(f"当前时间：{asctime}")
# 输出：当前时间：Wed May 15 14:30:45 2024

功能：将时间戳转化为可读性强的字符串时间语法：time.ctime([secs]) -> str参数：

• secs：可选参数，时间戳，默认为当前时间返回值：字符串时间实战案例：

import time
# 将当前时间戳转化为可读性强的字符串时间
ctime = time.ctime()
print(f"当前时间：{ctime}")
# 输出：当前时间：Wed May 15 14:30:45 2024

功能：让程序休眠指定的秒数语法：time.sleep(secs) -> None参数：

• secs：休眠的秒数，可以是浮点数返回值：无实战案例：

import time
print("开始执行")
time.sleep(2)  # 休眠2秒
print("执行结束")
# 输出：开始执行
# 等待2秒后输出：执行结束

功能：获取 CPU 时间语法：time.clock() -> float返回值：浮点数 CPU 时间说明：在 Python 3.8 + 中已被废弃，建议使用time.process_time()或time.perf_counter()替代

功能：获取当前进程的 CPU 时间语法：time.process_time() -> float返回值：浮点数 CPU 时间实战案例：

import time
# 记录开始时间
start_time = time.process_time()
# 执行一段耗时的代码
sum = 0
for i in range(1000000):
    sum += i
# 记录结束时间
end_time = time.process_time()
# 计算耗时
elapsed_time = end_time - start_time
print(f"耗时：{elapsed_time}秒")
# 输出：耗时：0.015625秒

功能：获取高精度计时器的时间语法：time.perf_counter() -> float返回值：浮点数时间实战案例：

import time
# 记录开始时间
start_time = time.perf_counter()
# 执行一段耗时的代码
time.sleep(0.5)
# 记录结束时间
end_time = time.perf_counter()
# 计算耗时
elapsed_time = end_time - start_time
print(f"耗时：{elapsed_time}秒")
# 输出：耗时：0.500123456秒

功能：获取当前时间的纳秒时间戳语法：time.time_ns() -> int返回值：整数纳秒时间戳实战案例：

import time
# 获取当前时间的纳秒时间戳
time_ns = time.time_ns()
print(f"当前纳秒时间戳：{time_ns}")
# 输出：当前纳秒时间戳：1715781045123456789

功能：设置当前时区语法：time.tzset() -> None返回值：无说明：仅在 Unix 系统上有效

功能：获取当前时间和时区信息语法：time.gettimeofday() -> tuple返回值：包含秒和微秒的元组说明：仅在 Unix 系统上有效

import time
# 获取当前时间戳
timestamp = time.time()
# 转化为格式化的字符串时间
formatted_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime(timestamp))
print(f"时间戳 {timestamp} 转化为字符串时间：{formatted_time}")

import time
# 字符串时间
string_time = "2024-05-15 14:30:45"
# 转化为结构化时间
struct_time = time.strptime(string_time, "%Y-%m-%d %H:%M:%S")
# 转化为时间戳
timestamp = time.mktime(struct_time)
print(f"字符串时间 {string_time} 转化为时间戳：{timestamp}")

import time
# 结构化时间
struct_time = time.struct_time(tm_year=2024, tm_mon=5, tm_mday=15, tm_hour=14, tm_min=30, tm_sec=45, tm_wday=2, tm_yday=136, tm_isdst=0)
# 转化为格式化的字符串时间
formatted_time = time.strftime("%B %d, %Y %I:%M:%S %p", struct_time)
print(f"结构化时间 {struct_time} 转化为字符串时间：{formatted_time}")

import time
# 记录开始时间
start_time = time.perf_counter()
# 执行一段耗时的代码
sum = 0
for i in range(10000000):
    sum += i
# 记录结束时间
end_time = time.perf_counter()
# 计算耗时
elapsed_time = end_time - start_time
print(f"程序执行时间：{elapsed_time}秒")

import time
def task():
    print(f"任务执行时间：{time.strftime('%Y-%m-%d %H:%M:%S')}")
# 每2秒执行一次任务
while True:
    task()
    time.sleep(2)

import time
# LLM对话历史
chat_history = []
def add_message(role, content):
    message = {
        "role": role,
        "content": content,
        "timestamp": time.strftime("%Y-%m-%d %H:%M:%S")
    }
    chat_history.append(message)
# 添加对话
add_message("user", "什么是LLM？")
add_message("assistant", "LLM是大语言模型的缩写。")
# 打印对话历史
for message in chat_history:
    print(f"[{message['timestamp']}] {message['role']}: {message['content']}")
# 输出：
# [2024-05-15 14:30:45] user: 什么是LLM？
# [2024-05-15 14:30:45] assistant: LLM是大语言模型的缩写。

import time
import openai
from dotenv import load_dotenv
import os
# 加载API密钥
load_dotenv()
openai.api_key = os.getenv("OPENAI_API_KEY")
def call_llm(prompt):
    # 记录开始时间
    start_time = time.perf_counter()
    # 调用LLM API
    response = openai.ChatCompletion.create(
        model="gpt-3.5-turbo",
        messages=[{"role": "user", "content": prompt}]
    )
    # 记录结束时间
    end_time = time.perf_counter()
    # 计算响应时间
    response_time = end_time - start_time
    # 提取回答
    answer = response["choices"][0]["message"]["content"]
    return answer, response_time
# 测试
prompt = "什么是LLM？"
answer, response_time = call_llm(prompt)
print(f"回答：{answer}")
print(f"响应时间：{response_time}秒")

问题：在使用time.strptime()转化字符串时间时提示ValueError: time data '2024/05/15' does not match format '%Y-%m-%d'。解决方案：确保时间格式字符串与字符串时间的格式一致。例如，将%Y-%m-%d改为%Y/%m/%d。

问题：在不同的时区下，时间戳转化为字符串时间的结果不同。解决方案：使用time.gmtime()获取 UTC 时间，或使用datetime模块处理时区。

问题：在 Python 2.x 中，time.time()返回的是整数时间戳，而在 Python 3.x 中返回的是浮点数时间戳。解决方案：在 Python 2.x 中，可以使用time.time()结合time.sleep()实现高精度时间。

问题：在使用time.mktime()转化结构化时间为时间戳时，会自动添加本地时区。解决方案：使用datetime模块的datetime.timestamp()方法。

模块	功能	特点
time	时间的获取、表示、转化和计算	功能基础，适合处理简单的时间问题
datetime	时间和日期的处理	功能强大，支持时区、日期计算等

建议：

• 对于简单的时间处理，使用time模块
• 对于复杂的时间处理（如时区、日期计算等），使用datetime模块

time 模块是 Python 中处理时间的核心工具，它提供了时间的表示、转化、计算和获取等功能。通过本文的学习，你已经掌握了 time 模块的所有核心函数和时间格式字符串的用法，并结合实战案例进行了深入的应用。

在实际开发中，要注意以下几点：

1. 选择合适的时间表示方式
2. 确保时间格式字符串与字符串时间的格式一致
3. 注意时区问题
4. 对于复杂的时间处理，使用 datetime 模块

time 模块虽然功能基础，但却是 Python 开发中不可或缺的工具。掌握它的使用，可以帮助你在日志记录、任务调度、数据分析和 LLM 开发等领域中更加高效地处理时间问题。

到此这篇关于Python time 模块深度解析：从时间表示到时间转化的全指南的文章就介绍到这了,更多相关Python time 模块内容请搜索风君子博客以前的文章或继续浏览下面的相关文章希望大家以后多多支持风君子博客！

您可能感兴趣的文章:

• python中time模块的几个时间转化方式
• Python标准库datetime模块日期和时间数据类型解读
• Python datetime模块高效处理日期和时间的方法
• Python时间处理模块time和datetime详解
• python使用datetime模块处理日期时间及常用功能详解
• Python时间处理模块Time和DateTime
• python time模块计算时间之间的差距(练习题)
• python常用的时间模块之datetime模块示例详解
• 详解Python中的时间格式的读取与转换(time模块)