Python 之 time 与 datetime 模块的基本使用(43)

Python 之 time 与 datetime 模块的基本使用

一、引言

在编程的世界里，时间处理是一项极为常见且关键的任务。无论是记录事件发生的时间、计算程序的运行时长，还是进行定时任务的调度，都离不开对时间的精确掌控。Python 作为一门功能强大且应用广泛的编程语言，为我们提供了两个重要的模块——time 和 datetime，用于处理时间相关的操作。

time 模块主要提供了与时间相关的基本功能，例如获取当前时间戳、暂停程序执行等。而 datetime 模块则提供了更加高级和方便的时间处理功能，包括日期和时间的表示、计算、格式化等。本文将深入介绍这两个模块的基本使用，通过丰富的源码示例和详细的注释，帮助你全面掌握它们的使用方法。

二、time 模块概述

2.1 time 模块的作用

time 模块是 Python 标准库中的一个基础模块，它提供了与时间相关的各种函数和常量。这些功能可以帮助我们完成诸如获取当前时间、测量时间间隔、暂停程序执行等任务。time 模块主要基于 Unix 时间戳，即从 1970 年 1 月 1 日 00:00:00 UTC 到指定时间的秒数。

2.2 导入 time 模块

在使用 time 模块之前，需要先将其导入到 Python 脚本中。

import time  # 导入 time 模块，用于后续的时间处理操作

三、time 模块的基本函数

3.1 获取当前时间戳

时间戳是一个浮点数，表示从 1970 年 1 月 1 日 00:00:00 UTC 到当前时间的秒数。可以使用 time() 函数来获取当前时间戳。

import time

timestamp = time.time()  # 调用 time() 函数获取当前时间戳
print(f"当前时间戳: {timestamp}")  # 打印当前时间戳

在上述代码中，time.time() 函数返回当前的时间戳，并将其存储在变量 timestamp 中。然后使用 print() 函数将时间戳打印输出。

3.2 暂停程序执行

sleep() 函数可以让程序暂停执行指定的秒数。这在需要控制程序执行速度或模拟延迟的场景中非常有用。

import time

print("程序开始执行")
time.sleep(2)  # 暂停程序执行 2 秒
print("程序继续执行")

在这段代码中，time.sleep(2) 表示程序会暂停执行 2 秒，然后再继续执行后续的代码。

3.3 将时间戳转换为结构化时间

localtime() 函数可以将时间戳转换为本地时间的结构化时间对象。结构化时间对象是一个包含多个属性的元组，分别表示年、月、日、时、分、秒等信息。

import time

timestamp = time.time()  # 获取当前时间戳
local_time = time.localtime(timestamp)  # 将时间戳转换为本地结构化时间
print(f"本地结构化时间: {local_time}")  # 打印本地结构化时间

在上述代码中，time.localtime(timestamp) 函数将当前时间戳转换为本地结构化时间对象，并将其存储在变量 local_time 中。然后使用 print() 函数将结构化时间对象打印输出。

3.4 将结构化时间转换为时间戳

mktime() 函数可以将结构化时间对象转换为时间戳。

import time

timestamp = time.time()  # 获取当前时间戳
local_time = time.localtime(timestamp)  # 将时间戳转换为本地结构化时间
new_timestamp = time.mktime(local_time)  # 将结构化时间转换为时间戳
print(f"转换后的时间戳: {new_timestamp}")  # 打印转换后的时间戳

在这段代码中，先将当前时间戳转换为本地结构化时间对象，然后再使用 time.mktime(local_time) 函数将结构化时间对象转换回时间戳，并将其存储在变量 new_timestamp 中。最后使用 print() 函数将转换后的时间戳打印输出。

3.5 将结构化时间转换为字符串

strftime() 函数可以将结构化时间对象按照指定的格式转换为字符串。

import time

timestamp = time.time()  # 获取当前时间戳
local_time = time.localtime(timestamp)  # 将时间戳转换为本地结构化时间
time_str = time.strftime("%Y-%m-%d %H:%M:%S", local_time)  # 将结构化时间转换为指定格式的字符串
print(f"格式化后的时间字符串: {time_str}")  # 打印格式化后的时间字符串

在上述代码中，time.strftime("%Y-%m-%d %H:%M:%S", local_time) 函数将本地结构化时间对象按照 "%Y-%m-%d %H:%M:%S" 的格式转换为字符串，并将其存储在变量 time_str 中。然后使用 print() 函数将格式化后的时间字符串打印输出。

3.6 将字符串转换为结构化时间

strptime() 函数可以将字符串按照指定的格式转换为结构化时间对象。

import time

time_str = "2024-10-01 12:30:00"  # 定义一个时间字符串
struct_time = time.strptime(time_str, "%Y-%m-%d %H:%M:%S")  # 将字符串转换为结构化时间
print(f"转换后的结构化时间: {struct_time}")  # 打印转换后的结构化时间

在这段代码中，time.strptime(time_str, "%Y-%m-%d %H:%M:%S") 函数将时间字符串 time_str 按照 "%Y-%m-%d %H:%M:%S" 的格式转换为结构化时间对象，并将其存储在变量 struct_time 中。最后使用 print() 函数将转换后的结构化时间对象打印输出。

四、datetime 模块概述

4.1 datetime 模块的作用

datetime 模块是 Python 标准库中用于处理日期和时间的高级模块。它提供了多个类，如 datetime、date、time 和 timedelta，用于表示日期、时间、时间间隔等。与 time 模块相比，datetime 模块的接口更加直观和方便，适合进行复杂的日期和时间计算。

4.2 导入 datetime 模块

在使用 datetime 模块之前，需要先将其导入到 Python 脚本中。

import datetime  # 导入 datetime 模块，用于后续的日期和时间处理操作

五、datetime 模块的主要类

5.1 datetime 类

datetime 类是 datetime 模块中最常用的类，它可以表示一个具体的日期和时间。

5.1.1 创建 datetime 对象

可以使用 datetime 类的构造函数来创建一个 datetime 对象。

import datetime

# 创建一个表示 2024 年 10 月 1 日 12:30:00 的 datetime 对象
dt = datetime.datetime(2024, 10, 1, 12, 30, 0)
print(f"创建的 datetime 对象: {dt}")  # 打印创建的 datetime 对象

在上述代码中，datetime.datetime(2024, 10, 1, 12, 30, 0) 函数创建了一个表示 2024 年 10 月 1 日 12:30:00 的 datetime 对象，并将其存储在变量 dt 中。然后使用 print() 函数将创建的 datetime 对象打印输出。

5.1.2 获取当前日期和时间

可以使用 datetime.now() 方法来获取当前的日期和时间。

import datetime

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

在这段代码中，datetime.datetime.now() 方法返回当前的 datetime 对象，并将其存储在变量 now 中。最后使用 print() 函数将当前日期和时间打印输出。

5.1.3 日期和时间的格式化

datetime 对象可以使用 strftime() 方法将其按照指定的格式转换为字符串。

import datetime

now = datetime.datetime.now()  # 获取当前的日期和时间
formatted_time = now.strftime("%Y-%m-%d %H:%M:%S")  # 将 datetime 对象转换为指定格式的字符串
print(f"格式化后的时间字符串: {formatted_time}")  # 打印格式化后的时间字符串

在上述代码中，now.strftime("%Y-%m-%d %H:%M:%S") 方法将当前的 datetime 对象按照 "%Y-%m-%d %H:%M:%S" 的格式转换为字符串，并将其存储在变量 formatted_time 中。然后使用 print() 函数将格式化后的时间字符串打印输出。

5.1.4 字符串转换为 datetime 对象

可以使用 strptime() 类方法将字符串按照指定的格式转换为 datetime 对象。

import datetime

time_str = "2024-10-01 12:30:00"  # 定义一个时间字符串
dt = datetime.datetime.strptime(time_str, "%Y-%m-%d %H:%M:%S")  # 将字符串转换为 datetime 对象
print(f"转换后的 datetime 对象: {dt}")  # 打印转换后的 datetime 对象

在这段代码中，datetime.datetime.strptime(time_str, "%Y-%m-%d %H:%M:%S") 类方法将时间字符串 time_str 按照 "%Y-%m-%d %H:%M:%S" 的格式转换为 datetime 对象，并将其存储在变量 dt 中。最后使用 print() 函数将转换后的 datetime 对象打印输出。

5.2 date 类

date 类用于表示一个日期，不包含时间信息。

5.2.1 创建 date 对象

可以使用 date 类的构造函数来创建一个 date 对象。

import datetime

# 创建一个表示 2024 年 10 月 1 日的 date 对象
d = datetime.date(2024, 10, 1)
print(f"创建的 date 对象: {d}")  # 打印创建的 date 对象

在上述代码中，datetime.date(2024, 10, 1) 函数创建了一个表示 2024 年 10 月 1 日的 date 对象，并将其存储在变量 d 中。然后使用 print() 函数将创建的 date 对象打印输出。

5.2.2 获取当前日期

可以使用 date.today() 方法来获取当前的日期。

import datetime

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

在这段代码中，datetime.date.today() 方法返回当前的 date 对象，并将其存储在变量 today 中。最后使用 print() 函数将当前日期打印输出。

5.2.3 日期的格式化

date 对象可以使用 strftime() 方法将其按照指定的格式转换为字符串。

import datetime

today = datetime.date.today()  # 获取当前的日期
formatted_date = today.strftime("%Y-%m-%d")  # 将 date 对象转换为指定格式的字符串
print(f"格式化后的日期字符串: {formatted_date}")  # 打印格式化后的日期字符串

在上述代码中，today.strftime("%Y-%m-%d") 方法将当前的 date 对象按照 "%Y-%m-%d" 的格式转换为字符串，并将其存储在变量 formatted_date 中。然后使用 print() 函数将格式化后的日期字符串打印输出。

5.3 time 类

time 类用于表示一个时间，不包含日期信息。

5.3.1 创建 time 对象

可以使用 time 类的构造函数来创建一个 time 对象。

import datetime

# 创建一个表示 12:30:00 的 time 对象
t = datetime.time(12, 30, 0)
print(f"创建的 time 对象: {t}")  # 打印创建的 time 对象

在上述代码中，datetime.time(12, 30, 0) 函数创建了一个表示 12:30:00 的 time 对象，并将其存储在变量 t 中。然后使用 print() 函数将创建的 time 对象打印输出。

5.3.2 时间的格式化

time 对象可以使用 strftime() 方法将其按照指定的格式转换为字符串。

import datetime

# 创建一个表示 12:30:00 的 time 对象
t = datetime.time(12, 30, 0)
formatted_time = t.strftime("%H:%M:%S")  # 将 time 对象转换为指定格式的字符串
print(f"格式化后的时间字符串: {formatted_time}")  # 打印格式化后的时间字符串

在这段代码中，t.strftime("%H:%M:%S") 方法将 time 对象按照 "%H:%M:%S" 的格式转换为字符串，并将其存储在变量 formatted_time 中。最后使用 print() 函数将格式化后的时间字符串打印输出。

5.4 timedelta 类

timedelta 类用于表示两个日期或时间之间的时间间隔。

5.4.1 创建 timedelta 对象

可以使用 timedelta 类的构造函数来创建一个 timedelta 对象。

import datetime

# 创建一个表示 5 天时间间隔的 timedelta 对象
delta = datetime.timedelta(days=5)
print(f"创建的 timedelta 对象: {delta}")  # 打印创建的 timedelta 对象

在上述代码中，datetime.timedelta(days=5) 函数创建了一个表示 5 天时间间隔的 timedelta 对象，并将其存储在变量 delta 中。然后使用 print() 函数将创建的 timedelta 对象打印输出。

5.4.2 日期和时间的加减运算

可以使用 timedelta 对象对 datetime 或 date 对象进行加减运算。

import datetime

now = datetime.datetime.now()  # 获取当前的日期和时间
delta = datetime.timedelta(days=5)  # 创建一个表示 5 天时间间隔的 timedelta 对象
new_date = now + delta  # 计算 5 天后的日期和时间
print(f"5 天后的日期和时间: {new_date}")  # 打印 5 天后的日期和时间

在这段代码中，先获取当前的 datetime 对象，然后创建一个表示 5 天时间间隔的 timedelta 对象。最后将 timedelta 对象与 datetime 对象相加，得到 5 天后的日期和时间，并将其存储在变量 new_date 中。使用 print() 函数将 5 天后的日期和时间打印输出。

六、time 与 datetime 模块的综合应用

6.1 计算程序的运行时间

可以使用 time 模块来计算程序的运行时间。

import time

start_time = time.time()  # 记录程序开始执行的时间戳

# 模拟一段耗时的操作
for i in range(1000000):
    pass

end_time = time.time()  # 记录程序结束执行的时间戳
run_time = end_time - start_time  # 计算程序的运行时间
print(f"程序运行时间: {run_time} 秒")  # 打印程序的运行时间

在上述代码中，使用 time.time() 函数分别记录程序开始和结束执行的时间戳，然后计算两者的差值，得到程序的运行时间。最后使用 print() 函数将运行时间打印输出。

6.2 定时任务调度

可以使用 time 模块和 datetime 模块来实现简单的定时任务调度。

import time
import datetime

# 定义定时任务函数
def task():
    print("定时任务执行")

# 获取当前时间
now = datetime.datetime.now()
# 计算下一个整点时间
next_hour = now.replace(minute=0, second=0, microsecond=0) + datetime.timedelta(hours=1)
# 计算距离下一个整点的时间差
time_diff = (next_hour - now).total_seconds()

print(f"等待 {time_diff} 秒后执行定时任务")
time.sleep(time_diff)  # 暂停程序执行，直到下一个整点
task()  # 执行定时任务

在这段代码中，首先定义了一个定时任务函数 task()。然后获取当前时间，并计算下一个整点时间。接着计算距离下一个整点的时间差，并使用 time.sleep() 函数暂停程序执行，直到下一个整点。最后调用定时任务函数执行任务。

七、总结与展望

7.1 总结

Python 的 time 和 datetime 模块为我们提供了丰富的时间处理功能。time 模块基于 Unix 时间戳，提供了获取当前时间戳、暂停程序执行、时间戳与结构化时间的转换等基本功能。而 datetime 模块则提供了更加高级和方便的日期和时间处理功能，通过 datetime、date、time 和 timedelta 等类，我们可以方便地表示日期、时间、时间间隔，并进行日期和时间的计算、格式化等操作。

在实际应用中，我们可以根据具体的需求选择合适的模块和方法。如果只需要进行简单的时间测量和延迟操作，time 模块可能就足够了；如果需要进行复杂的日期和时间计算、格式化等操作，datetime 模块则是更好的选择。

7.2 展望

随着 Python 在数据分析、机器学习、自动化等领域的广泛应用，对时间处理的需求也会越来越复杂。未来，time 和 datetime 模块可能会进一步优化和扩展，提供更多的功能和更好的性能。例如，可能会增加对时区处理的更完善支持，提供更方便的时间序列分析工具等。

同时，随着 Python 生态系统的不断发展，可能会出现更多与时间处理相关的第三方库，这些库可能会结合 time 和 datetime 模块的功能，提供更强大和便捷的时间处理解决方案。对于开发者来说，需要不断学习和掌握这些新的功能和工具，以更好地应对实际项目中的时间处理需求。