Python datetime库完全指南：从核心类到实战避坑

1. 项目概述：为什么datetime是Python开发的“时间管家”

在Python的世界里，处理时间日期是绕不开的日常。无论是记录日志、分析用户行为数据、定时执行任务，还是处理来自数据库的时间戳，一个可靠的时间处理工具至关重要。Python内置的datetime库，就是这样一个功能强大且易于上手的“时间管家”。它不像一些第三方库那样需要额外安装，开箱即用，是处理绝大多数时间相关问题的首选。

很多新手在接触时间处理时，容易陷入字符串和数字的混乱转换中，或者被时区问题搞得晕头转向。datetime库通过清晰的类结构，将日期、时间、时间差、时区等概念封装得明明白白。掌握了它，你就能优雅地解决诸如“计算两个日期相差多少天”、“将时间戳转换为可读格式”、“判断某个日期是星期几”等常见需求。这篇文章，我将结合十多年的开发经验，带你从零开始，深入datetime库的每一个角落，不仅告诉你“怎么用”，更会解释“为什么这么用”，并分享那些官方文档里不会写的实战避坑技巧。

2. 核心类解析：datetime库的四大金刚

datetime模块的核心是四个类：date、time、datetime和timedelta。理解它们各自的分工和联系，是高效使用这个库的基础。

2.1 date类：纯粹的日期

date对象只关心年、月、日，不包含任何时间（时、分、秒）和时区信息。它适用于那些只与日期相关的场景，比如生日、纪念日、合同生效日等。

创建一个date对象非常简单：

from datetime import date # 方法1：使用构造函数，参数为年、月、日 d1 = date(2023, 10, 27) print(d1) # 输出：2023-10-27 # 方法2：使用today()类方法获取当前日期 today = date.today() print(f"今天是：{today}") # 方法3：使用fromisoformat()从标准格式字符串创建 d2 = date.fromisoformat('2023-12-25') print(d2) # 输出：2023-12-25

date对象有几个非常实用的属性：

• year、month、day：获取具体的年、月、日。
• weekday()：返回星期几，周一为0，周日为6。
• isoweekday()：返回星期几，周一为1，周日为7（符合ISO标准，更直观）。
• strftime(format)：按照指定格式将日期格式化为字符串，这是输出定制化日期格式的利器。

注意：date对象是不可变的。一旦创建，其年、月、日的值就无法更改。任何看似修改的操作（如替换年份）实际上都会返回一个新的date对象。这是为了保证时间数据的可靠性和线程安全。

2.2 time类：独立的时间点

与date相反，time对象只关心一天内的时间，包含时、分、秒、微秒，并且可以包含可选的时区信息（tzinfo）。它适用于那些与具体日期无关，只关注时刻的场景，比如每天的会议时间、商店的营业时间。

创建time对象：

from datetime import time # 创建时间，参数依次为时、分、秒、微秒 t1 = time(14, 30, 15) # 14:30:15 print(t1) # 输出：14:30:15 t2 = time(9, 0) # 09:00:00，秒和微秒默认为0 print(t2) # 包含微秒 t3 = time(23, 59, 59, 999999) print(t3) # 输出：23:59:59.999999

time对象常用的属性有hour、minute、second、microsecond和tzinfo。同样，它也可以通过strftime()方法进行格式化。一个常见的坑是，一个单纯的time对象（不带时区）在进行比较或运算时，其意义是模糊的，因为它脱离了具体的日期上下文。通常，我们会将time与date结合成datetime来使用。

2.3 datetime类：日期与时间的完美结合

datetime类是date和time的组合体，也是我们最常打交道的类。它包含年、月、日、时、分、秒、微秒，并且可以附加时区信息。它几乎能应对所有需要精确时间点的场景。

创建datetime对象的方式最为丰富：

from datetime import datetime # 1. 使用构造函数 dt1 = datetime(2023, 10, 27, 14, 30, 0) print(dt1) # 输出：2023-10-27 14:30:00 # 2. 获取当前本地时间（无时区信息） now_local = datetime.now() print(f"当前本地时间：{now_local}") # 3. 获取当前UTC时间 now_utc = datetime.utcnow() print(f"当前UTC时间：{now_utc}") # 4. 从时间戳创建（Unix时间戳，秒为单位） timestamp = 1698413400 dt_from_ts = datetime.fromtimestamp(timestamp) print(dt_from_ts) # 输出本地时间表示 # 5. 从字符串解析（需要匹配格式） dt_str = "2023-10-27 14:30:00" dt_from_str = datetime.strptime(dt_str, "%Y-%m-%d %H:%M:%S") print(dt_from_str)

datetime对象继承了date和time的所有方法，功能最为全面。它既可以提取日期部分（.date()），也可以提取时间部分（.time()），还可以进行丰富的日期时间运算。

2.4 timedelta类：表示时间间隔

timedelta对象表示两个date或datetime对象之间的时间差。你可以用它来进行时间的加减运算，比如“三天后”、“一小时前”。

创建timedelta：

from datetime import timedelta # 参数可以是天数、秒数、微秒数、毫秒数、分钟数、小时数、周数 delta1 = timedelta(days=7) # 一周 delta2 = timedelta(hours=2, minutes=30) # 两个半小时 delta3 = timedelta(weeks=2, days=1) # 两周零一天

它的核心用途是进行日期时间运算：

from datetime import datetime, timedelta now = datetime.now() print(f"现在：{now}") # 计算未来时间 one_week_later = now + timedelta(weeks=1) print(f"一周后：{one_week_later}") # 计算过去时间 two_hours_ago = now - timedelta(hours=2) print(f"两小时前：{two_hours_ago}") # 计算两个时间点之间的差值 future = datetime(2024, 1, 1) diff = future - now print(f"距离2024年元旦还有：{diff}") print(type(diff)) # <class 'datetime.timedelta'> print(f"具体天数：{diff.days}， 具体秒数（除去天数）：{diff.seconds}")

实操心得：timedelta内部只存储days、seconds和microseconds三个属性。所有传入的参数最终都会转换成这三个单位。当你进行diff.seconds时，它返回的是不足一天的那部分秒数（0到86399之间）。要获取总秒数，请使用diff.total_seconds()方法。

3. 格式化与解析：在字符串和时间对象间自由穿梭

时间数据在程序中以对象形式处理，但在存储（如数据库、文件）或展示（如前端页面、日志）时，通常需要转换成字符串。反之，从外部系统接收到的字符串时间也需要解析成对象。strftime（格式化）和strptime（解析）就是完成这两项工作的核心方法。

3.1 使用strftime进行格式化输出

strftime方法接受一个格式字符串，将时间对象转换为指定格式的字符串。格式字符串由特定的指令组成，每个指令以%开头。

下表列出了最常用的格式指令：

实战示例：

from datetime import datetime now = datetime.now() # 常用格式 print(now.strftime("%Y-%m-%d")) # 2023-10-27 print(now.strftime("%H:%M:%S")) # 14:30:05 print(now.strftime("%Y/%m/%d %H:%M:%S")) # 2023/10/27 14:30:05 # 更友好的格式 print(now.strftime("%A, %B %d, %Y")) # Friday, October 27, 2023 print(now.strftime("今天是%Y年%m月%d日， %H点%M分")) # 今天是2023年10月27日， 14点30分 # 用于文件名（避免特殊字符） filename = now.strftime("log_%Y%m%d_%H%M%S.txt") print(filename) # 例如：log_20231027_143005.txt

3.2 使用strptime进行字符串解析

strptime是strftime的逆过程。它根据给定的格式字符串，将时间字符串解析成datetime对象。格式字符串必须与输入字符串严格匹配，否则会抛出ValueError。

from datetime import datetime date_str = "27-10-2023 14:30" # 定义与字符串完全匹配的格式 dt_obj = datetime.strptime(date_str, "%d-%m-%Y %H:%M") print(dt_obj) # 输出：2023-10-27 14:30:00 print(type(dt_obj)) # <class 'datetime.datetime'> # 另一个例子 iso_str = "20231027T143000" dt_obj2 = datetime.strptime(iso_str, "%Y%m%dT%H%M%S") print(dt_obj2)

避坑技巧：解析用户输入或第三方数据的时间字符串时，格式不匹配是最常见的问题。建议在strptime调用外围使用try...except块进行捕获。对于来源复杂、格式不定的时间字符串，可以考虑使用功能更强大的第三方库，如dateutil的parser.parse函数，它能自动识别多种常见格式。

3.3 ISO 8601格式：国际通用的时间表示法

ISO 8601是一种国际标准的时间日期表示方法，格式为YYYY-MM-DDTHH:MM:SS.ssssss。datetime库提供了直接处理该格式的方法，这是跨系统传递时间信息的推荐方式。

from datetime import datetime, date now = datetime.now() iso_string = now.isoformat() print(iso_string) # 例如：2023-10-27T14:30:05.123456 # 如果包含时区信息，会一并输出 # from datetime import timezone # now_utc = now.replace(tzinfo=timezone.utc) # print(now_utc.isoformat()) # 2023-10-27T14:30:05.123456+00:00 # 从ISO格式字符串创建 dt_from_iso = datetime.fromisoformat(iso_string) print(dt_from_iso) # date对象也有isoformat today = date.today() print(today.isoformat()) # 2023-10-27

使用ISO 8601格式的最大好处是清晰、无歧义，并且字符串的字典序就是时间顺序，非常适合用于排序或作为数据库索引。

4. 日期时间计算与比较：让时间为你所用

掌握了对象的创建和转换，下一步就是让它们“动”起来，进行实际的运算和比较。这是datetime库在业务逻辑中最核心的应用。

4.1 时间的加减运算

通过timedelta对象，我们可以轻松地对date和datetime对象进行加减。

from datetime import datetime, timedelta, date # 计算未来/过去的某个时间点 current_dt = datetime.now() print(f"当前时间：{current_dt}") # 增加10天 future_dt = current_dt + timedelta(days=10) print(f"十天后：{future_dt}") # 减少3小时30分钟 past_dt = current_dt - timedelta(hours=3, minutes=30) print(f"三小时三十分钟前：{past_dt}") # date对象同样适用 today = date.today() next_week = today + timedelta(weeks=1) print(f"下周的今天：{next_week}") # 计算项目截止日期（假设开发需要15个工作日） start_date = date(2023, 11, 1) work_days = 15 # 一个简单的循环，跳过周末（这里仅作示例，更复杂的需用dateutil等库） current = start_date days_counted = 0 while days_counted < work_days: current += timedelta(days=1) # 周一为0，周日为6，判断是否为工作日（周一到周五） if current.weekday() < 5: days_counted += 1 print(f"项目开始于{start_date}， {work_days}个工作日后的截止日期是：{current}")

4.2 时间的比较

date和datetime对象支持所有常见的比较操作符（==,!=,<,<=,>,>=）。比较是基于时间先后顺序进行的。

from datetime import datetime, date dt1 = datetime(2023, 10, 1, 12, 0, 0) dt2 = datetime(2023, 10, 27, 12, 0, 0) dt3 = datetime(2023, 10, 1, 12, 0, 0) print(dt1 < dt2) # True print(dt1 > dt2) # False print(dt1 == dt3) # True print(dt1 != dt2) # True # 日期比较 d1 = date(2023, 9, 1) d2 = date(2023, 10, 1) print(d1 <= d2) # True # 判断某个日期是否在一个时间范围内 start = date(2023, 10, 1) end = date(2023, 10, 31) target = date(2023, 10, 15) if start <= target <= end: print(f"{target} 在十月内")

4.3 提取特定时间成分与替换

有时我们不需要整个对象，只想获取或修改其中的一部分。

from datetime import datetime dt = datetime(2023, 10, 27, 14, 30, 15, 123456) # 提取成分 print(f"年：{dt.year}") # 2023 print(f"月：{dt.month}") # 10 print(f"日：{dt.day}") # 27 print(f"时：{dt.hour}") # 14 print(f"分：{dt.minute}") # 30 print(f"秒：{dt.second}") # 15 print(f"微秒：{dt.microsecond}") # 123456 print(f"星期几（0-6，周一为0）：{dt.weekday()}") # 4（星期五） print(f"星期几（1-7，周一为1）：{dt.isoweekday()}") # 5 # 替换成分 - 返回一个新的datetime对象 new_dt = dt.replace(year=2024, month=1, day=1, hour=0, minute=0, second=0, microsecond=0) print(f"原时间：{dt}") print(f"替换后：{new_dt}") # 2024-01-01 00:00:00 # 只替换部分字段 noon_today = dt.replace(hour=12, minute=0, second=0, microsecond=0) print(f"今天中午：{noon_today}") # 2023-10-27 12:00:00

注意事项：replace()方法不会修改原对象，而是生成一个新的对象。这是因为datetime对象是不可变的。这种设计避免了在多线程或复杂数据流中意外修改时间数据带来的错误。

5. 时区处理：跨越时空的难题

时区是时间处理中最复杂也最容易出错的部分。一个没有时区信息的datetime对象被称为“naive”（幼稚的），它无法明确对应到地球上的某个确切时刻。带有时区信息的对象则被称为“aware”（清醒的）。

5.1 理解naive和aware对象

from datetime import datetime import pytz # 需要安装第三方库：pip install pytz # Naive datetime (本地时间，但不知道是哪个时区) naive_dt = datetime.now() print(f"Naive datetime: {naive_dt}") print(f"Is it aware? {naive_dt.tzinfo}") # 输出：None # Aware datetime (知道自己在UTC时区) # 使用pytz库处理时区更标准 utc_tz = pytz.UTC aware_dt_utc = datetime.now(utc_tz) # 或者 datetime.utcnow().replace(tzinfo=utc_tz) print(f"Aware datetime (UTC): {aware_dt_utc}") print(f"Its timezone: {aware_dt_utc.tzinfo}") # 输出：UTC

核心原则：避免将naive时间与aware时间进行比较或运算，这会导致TypeError。所有涉及时区的操作，都应使用aware对象。

5.2 使用pytz库进行时区转换

Python标准库的datetime.timezone类功能有限，社区广泛使用pytz库来处理复杂的时区规则（包括历史夏令时变化）。

from datetime import datetime import pytz # 获取当前UTC时间 utc_now = datetime.now(pytz.UTC) print(f"当前UTC时间：{utc_now}") # 定义其他时区 eastern_tz = pytz.timezone('US/Eastern') # 美国东部时间 shanghai_tz = pytz.timezone('Asia/Shanghai') # 中国上海时间 # 将UTC时间转换为上海时间 shanghai_time = utc_now.astimezone(shanghai_tz) print(f"对应的上海时间：{shanghai_time}") # 将上海时间转换为美国东部时间 eastern_time = shanghai_time.astimezone(eastern_tz) print(f"对应的美国东部时间：{eastern_time}") # 创建一个特定时区的当前时间 now_in_shanghai = datetime.now(shanghai_tz) print(f"上海当前时间：{now_in_shanghai}")

5.3 本地化（Localize）与规范化（Normalize）

这是pytz库使用的两个关键概念，也是最大的坑点。

• 本地化：给一个naive时间附加一个时区。必须使用时区对象的localize()方法，而不是直接replace(tzinfo=...)，因为后者无法正确处理夏令时等历史时区规则。
• 规范化：当时区转换导致时间模糊（如夏令时开始或结束时）或不存在时，用于调整时间。

from datetime import datetime import pytz # 假设我们有一个表示上海时间2023-10-27 14:30的naive对象 naive_dt = datetime(2023, 10, 27, 14, 30) shanghai_tz = pytz.timezone('Asia/Shanghai') # 错误做法：直接replace（可能在某些时区出错） # wrong_dt = naive_dt.replace(tzinfo=shanghai_tz) # 正确做法：使用localize correct_dt = shanghai_tz.localize(naive_dt) print(f"本地化后的上海时间：{correct_dt}") # 转换为UTC utc_dt = correct_dt.astimezone(pytz.UTC) print(f"对应的UTC时间：{utc_dt}") # 再转换回上海时间（使用astimezone即可） back_to_shanghai = utc_dt.astimezone(shanghai_tz) print(f"转换回来的上海时间：{back_to_shanghai}")

避坑技巧：在涉及时区的项目中，我始终坚持一个最佳实践：在系统内部，所有时间都使用UTC进行存储和计算。只在需要展示给用户时，才根据用户所在的时区转换为本地时间。这样可以完全避免时区转换带来的混乱，也便于进行跨时区的时间比较和运算。数据库中的时间戳字段也应存储为UTC时间。

6. 实战应用场景与代码示例

理论讲完了，我们来看几个实际开发中高频出现的场景，看看如何用datetime库优雅地解决。

6.1 场景一：计算程序运行时间

这是性能分析和调试的常用手段。

from datetime import datetime import time # 记录开始时间 start_time = datetime.now() # 模拟一个耗时的操作，比如睡眠2秒 time.sleep(2) # 记录结束时间 end_time = datetime.now() # 计算时间差 elapsed = end_time - start_time print(f"操作开始于：{start_time}") print(f"操作结束于：{end_time}") print(f"总共耗时：{elapsed}") print(f"耗时（秒）：{elapsed.total_seconds():.2f}秒") print(f"耗时（毫秒）：{elapsed.total_seconds() * 1000:.2f}毫秒")

6.2 场景二：生成按时间序列的文件名或目录

在日志记录、数据备份等场景中非常有用。

from datetime import datetime import os def create_time_based_filename(prefix="data", extension=".csv"): """生成一个基于当前时间的唯一文件名""" now = datetime.now() # 格式化为：前缀_年月日_时分秒 timestamp = now.strftime("%Y%m%d_%H%M%S") filename = f"{prefix}_{timestamp}{extension}" return filename def create_daily_log_directory(base_path="/var/log/myapp"): """创建按日期组织的日志目录结构，例如 /var/log/myapp/2023/10/27/""" now = datetime.now() year_dir = os.path.join(base_path, str(now.year)) month_dir = os.path.join(year_dir, f"{now.month:02d}") day_dir = os.path.join(month_dir, f"{now.day:02d}") # 创建目录（如果不存在） os.makedirs(day_dir, exist_ok=True) log_file_path = os.path.join(day_dir, "app.log") return log_file_path # 使用示例 print(f"生成的文件名：{create_time_based_filename('log', '.txt')}") # 假设在合适的环境下运行下一行 # log_path = create_daily_log_directory() # print(f"日志文件路径：{log_path}")

6.3 场景三：处理用户输入的生日期并计算年龄

这是一个经典的Web应用或表单处理场景。

from datetime import date def calculate_age(birth_date_str): """根据生日字符串（格式：YYYY-MM-DD）计算周岁年龄""" try: # 解析生日 birth_date = date.fromisoformat(birth_date_str) # Python 3.7+ # 如果是旧版本，可以用：datetime.strptime(birth_date_str, "%Y-%m-%d").date() today = date.today() # 计算初步年龄 age = today.year - birth_date.year # 调整：如果今年的生日还没过，年龄减一 # 比较 (月，日) 元组 if (today.month, today.day) < (birth_date.month, birth_date.day): age -= 1 return age except ValueError as e: print(f"日期格式错误：{e}") return None # 测试 birthday = "1990-05-15" age = calculate_age(birthday) if age is not None: print(f"生日为{birthday}的人，今天年龄是：{age}岁") # 更健壮的版本，处理多种输入格式 def parse_date_flexible(date_str): """尝试用多种格式解析日期字符串""" from datetime import datetime formats_to_try = [ "%Y-%m-%d", # 2023-10-27 "%Y/%m/%d", # 2023/10/27 "%d-%m-%Y", # 27-10-2023 "%d/%m/%Y", # 27/10/2023 "%Y%m%d", # 20231027 ] for fmt in formats_to_try: try: return datetime.strptime(date_str, fmt).date() except ValueError: continue raise ValueError(f"无法解析日期字符串：'{date_str}'")

6.4 场景四：实现一个简单的定时任务调度器（模拟）

虽然生产环境会用APScheduler或celery，但理解其原理很重要。

from datetime import datetime, timedelta import time class SimpleScheduler: """一个简单的内存定时任务调度器（仅用于演示原理）""" def __init__(self): self.tasks = [] # 存储任务列表，每个任务是一个元组 (执行时间, 任务函数, 参数) def add_task(self, delay_seconds, task_func, *args, **kwargs): """添加一个延迟执行的任务""" execute_at = datetime.now() + timedelta(seconds=delay_seconds) self.tasks.append((execute_at, task_func, args, kwargs)) # 按执行时间排序 self.tasks.sort(key=lambda x: x[0]) print(f"任务已添加，将于 {execute_at} 执行") def run(self): """运行调度器，检查并执行到期任务""" print("调度器开始运行...") try: while True: now = datetime.now() # 检查是否有任务到期 while self.tasks and self.tasks[0][0] <= now: _, task_func, args, kwargs = self.tasks.pop(0) print(f"[{now}] 执行任务：{task_func.__name__}") # 在新线程或进程中执行任务会更安全，此处简单演示 task_func(*args, **kwargs) # 短暂睡眠以避免CPU空转 time.sleep(0.1) except KeyboardInterrupt: print("\n调度器已停止") # 示例任务函数 def send_reminder(message): print(f"提醒：{message}") def generate_report(report_name): print(f"正在生成报告：{report_name}") # 使用示例 if __name__ == "__main__": scheduler = SimpleScheduler() # 添加一个10秒后执行的任务 scheduler.add_task(10, send_reminder, "该开会了！") # 添加一个25秒后执行的任务 scheduler.add_task(25, generate_report, "日报") print("等待任务执行...") # 在实际应用中，调度器会在后台线程运行 # 这里我们简单运行一段时间 start = datetime.now() while (datetime.now() - start).total_seconds() < 30: now = datetime.now() for task_time, func, args, _ in scheduler.tasks[:]: # 浅拷贝遍历 if task_time <= now: print(f"[{now}] 模拟执行：{func.__name__}{args}") scheduler.tasks.remove((task_time, func, args, _)) time.sleep(1) print("演示结束。")

7. 性能考量、常见陷阱与最佳实践

即使掌握了基本用法，在实际项目中还是会踩到一些坑。下面是我总结的一些关键点和最佳实践。

7.1 性能考量

• 对象创建开销：频繁创建datetime对象（如在紧密循环中调用datetime.now()）会有开销。在性能敏感的代码段，可以考虑在循环外获取一次时间。
• 字符串解析开销：strptime比fromisoformat或直接使用构造函数慢得多。如果处理大量已知格式（如ISO格式）的字符串，优先使用fromisoformat。
• 时区转换开销：时区转换，特别是使用pytz和历史时区规则时，相对较慢。尽量避免在循环中进行不必要的时区转换。

7.2 十大常见陷阱与解决方案

1. 陷阱：混淆naive和aware时间现象：TypeError: can't compare offset-naive and offset-aware datetimes解决：始终确保比较或运算的时间对象要么都是naive，要么都是aware。使用UTC作为内部统一时区是根本解决方案。

2. 陷阱：错误地给naive时间附加时区现象：dt.replace(tzinfo=timezone)在某些时区（尤其是有夏令时的）得到错误结果。解决：对于pytz时区，始终使用timezone.localize(naive_dt)。对于Python 3.9+的zoneinfo，可以使用dt.replace(tzinfo=zone)。

3. 陷阱：使用datetime.utcnow()获取带时区的UTC时间现象：datetime.utcnow()返回的是naive的UTC时间，不是aware的。解决：使用datetime.now(timezone.utc)（Python 3.2+）或datetime.utcnow().replace(tzinfo=pytz.UTC)。

4. 陷阱：忽略夏令时（DST）现象：在夏令时切换日，时间计算出现一小时偏差。解决：使用像pytz或Python 3.9+的zoneinfo这样的库，它们包含了历史夏令时规则。避免自己手动计算。

5. 陷阱：月份和日期溢出现象：datetime(2023, 2, 30)或datetime(2023, 13, 1)会引发ValueError。解决：在构造日期前进行验证，或者使用calendar.monthrange(year, month)获取某月的最大天数。

6. 陷阱：timedelta的seconds属性误解现象：timedelta(days=1, seconds=3600).seconds输出是3600，而不是(24*3600+3600)=90000。解决：记住.seconds只包含不足一天的秒数。要获取总秒数，使用.total_seconds()。

7. 陷阱：字符串格式不匹配现象：strptime(date_str, "%Y-%m-%d")解析"27/10/2023"失败。解决：使用try...except捕获ValueError，或者使用dateutil.parser.parse等更灵活的解析器处理多种输入格式。

8. 陷阱：时间戳的单位混淆现象：某些API返回毫秒时间戳，而datetime.fromtimestamp()期望秒。解决：确认时间戳单位。毫秒时间戳需要除以1000：datetime.fromtimestamp(ts_ms / 1000)。

9. 陷阱：跨月/年计算错误现象：简单使用timedelta(days=30)来增加一个月，但月份天数不同。解决：对于复杂的日历计算（如下个月同一天、上个月最后一天），使用dateutil库的relativedelta：from dateutil.relativedelta import relativedelta; new_date = old_date + relativedelta(months=1)。

10. 陷阱：默认字符串表示用于存储现象：将str(datetime对象)或print(datetime对象)的输出直接存入数据库，格式可能因区域设置而异。解决：为了持久化存储，始终使用ISO 8601格式（dt.isoformat()）或时间戳（dt.timestamp()）。

7.3 最佳实践总结

1. 内部统一使用UTC：在系统内部、数据库、API通信中，坚持使用UTC时间。这是避免时区混乱的黄金法则。
2. 仅在展示层转换时区：在需要向最终用户显示时间时，再根据用户的偏好或地理位置转换为本地时间。
3. 使用ISO 8601格式进行序列化：在JSON、配置文件或日志中存储或传输时间时，优先使用ISO 8601字符串。它清晰、标准且易于排序。
4. 为时间字段选择合适的数据库类型：在MySQL中使用DATETIME或TIMESTAMP，在PostgreSQL中使用TIMESTAMP WITH TIME ZONE（即使你存UTC，也建议用这个类型，让数据库管理时区转换）。
5. 利用类型提示：在Python 3.8+中，可以使用from datetime import datetime和from typing import Optional，然后为函数参数和返回值添加类型提示，如def process_event(time: datetime) -> Optional[datetime]:，这能大大提高代码可读性和可靠性。
6. 对于复杂日期运算，使用高级库：Python标准库的datetime适合基础操作。对于诸如“下个工作日”、“上个月最后一天”、“两个日期之间的工作日数”等复杂需求，不要自己造轮子，使用dateutil或pandas等库。