《Python 从入门到精通》105|时间与日期处理:写业务逻辑绕不过去的话题

学 Python 的时候，很多人一开始会觉得，时间处理没什么特别的。

不就是显示一下今天是几月几号，或者打印一下当前几点几分吗。

直到做项目时，才会发现这件事根本没那么简单。

会员什么时候到期 订单多久未支付 用户连续签到几天 日志是几点报错 报表统计昨天、本周、上个月 文件要不要按日期命名 任务要不要延后 3 天执行

这些场景表面不同，背后其实都绕不开同一类能力： 处理时间和日期

所以这一章非常重要。

如果说前面的 JSON、正则，解决的是结构化数据和文本规则的问题，那么这一章解决的，就是几乎所有业务系统都会遇到的时间问题。

很多程序写到最后，真正难缠的不是算法，而是时间。

因为时间看似直观，实际上特别容易出错。

一、为什么时间处理是业务逻辑里的高频问题

你先想想现实里有多少规则是和时间绑定的。

早于今天就算过期 晚于 24 小时就自动取消 超过 30 分钟没付款就关闭订单 连续 7 天打卡才有奖励 每月 1 号生成新报表 只统计最近 3 天的数据

你会发现，时间不是一个装饰性的字段。 它经常直接决定程序应该怎么运行。

比如电商系统里，订单创建时间和当前时间一比较，就能知道这笔订单是不是超时未支付。

再比如考勤系统里，上班打卡时间和规定时间一比较，就能知道是否迟到。

也就是说，时间处理本质上不只是显示。 更重要的是计算、比较、转换、判断。

这就是为什么它会成为写业务逻辑时绕不过去的话题。

二、先分清三个概念：date、time、datetime

在正式写代码前，你要先把这三个词分清楚。

date 只表示日期。 比如 2026-03-29。

time 只表示时间。 比如 14:30:15。

datetime 同时表示日期和时间。 比如 2026-03-29 14:30:15。

这三个概念看起来简单，但初学者特别容易混。

比如你想统计两个时刻相差多少小时，那你通常要用 datetime。 如果你只关心今天是周几、这个月几号，那 date 就足够了。 如果你只是在某些固定场景里记录时间点，比如闹钟时间 08:30:00，那可能会用到 time。

在真实开发里，最常用的其实还是 datetime。 因为绝大多数业务数据，不只要知道是哪一天，还要知道具体时分秒。

三、Python 里处理时间，最核心的是 datetime 模块

Python 标准库里已经给我们准备好了时间处理工具。 最常用的就是 datetime 模块。

先导入：

from datetime import datetime

这里你会看到一个容易让人迷糊的地方。

模块名叫 datetime，里面还有一个类也叫 datetime。

所以写成：

from datetime import datetime

意思就是： 从 datetime 这个模块里，导入 datetime 这个类。

虽然看起来有点绕，但用几次就习惯了。

以后你会经常看到这种写法。

四、如何获取当前时间

这是最常见的第一步。

如果你想拿到当前的日期和时间，可以这样写：

from datetime import datetimenow = datetime.now()print(now)print(type(now))

输出大致会像这样：

2026-03-2914:35:42.123456<class 'datetime.datetime'>

这里要注意几个点。

第一，now() 返回的不是字符串，而是一个 datetime 对象。 第二，它不仅有年月日时分秒，还有微秒。 第三，这个对象后面可以继续做比较、加减、格式化等操作。

很多新手看到打印结果，以为这就是普通文本。 其实不是。 它是一个真正的时间对象，只不过打印出来长得像时间字符串而已。

这点一定要分清。

五、只获取今天的日期

如果你不关心具体时分秒，只想知道今天是哪一天，可以这样写：

from datetime import datetoday = date.today()print(today)print(type(today))

输出大致是：

2026-03-29<class 'datetime.date'>

这个 today() 很适合做一些日期级别的业务判断。

比如今天是不是月初 今天是不是周末 今天和某个截止日期还差几天

如果你的逻辑只跟日期有关，而不关心具体时刻，用 date 会更清晰。

六、如何手动创建一个指定时间

除了拿当前时间，很多时候你还需要手动创建一个时间对象。

比如你要表示会员到期时间、订单创建时间、考试开始时间，就不能总靠 now()。

这时候可以直接写：

from datetime import datetimedt = datetime(2026, 3, 29, 20, 30, 0)print(dt)

输出：

2026-03-2920:30:00

这里参数的顺序非常重要：

年，月，日，时，分，秒

如果你只想创建日期，也可以这样写：

from datetime import dated = date(2026, 3, 29)print(d)

输出：

2026-03-29

手动创建时间对象这个能力非常实用。

因为真实业务里，很多时间不是程序自动取当前时刻，而是你根据数据字段、配置规则、用户输入，去构造出来的。

七、为什么时间对象比字符串更重要

这一点很关键。

很多新手刚开始做时间处理时，喜欢直接拿字符串操作。

比如：

start = "2026-03-29"end = "2026-04-01"

然后就在字符串上比较、切片、拼接。

短时间看，好像也能凑合。 但一旦涉及加减、比较、跨月、跨年，这种做法就非常脆弱。

时间对象和字符串最大的区别就在于：

字符串只是长得像时间 时间对象才真的懂时间

比如两个时间对象可以直接相减。 字符串就做不到。

比如时间对象知道 2 月有多少天，闰年怎么算。 字符串本身根本不懂这些。

所以你要尽早建立一个习惯：

展示给用户时，可以转成字符串 真正做业务计算时，尽量使用时间对象

这个思路会帮你少踩很多坑。

八、时间怎么格式化输出

虽然时间对象很适合计算，但直接打印出来，格式不一定总符合我们的需求。

比如：

2026-03-2914:35:42.123456

有时太长了。 有时我们只想显示日期。 有时想显示成中文形式。 有时想拼到文件名里。

这时候就要用到 strftime()。

它的作用是： 把时间对象格式化成你想要的字符串。

例如：

from datetime import datetimenow = datetime.now()print(now.strftime("%Y-%m-%d"))print(now.strftime("%Y-%m-%d %H:%M:%S"))print(now.strftime("%Y年%m月%d日"))print(now.strftime("%H:%M:%S"))

输出可能是：

2026-03-292026-03-2914:35:422026年03月29日14:35:42

这里你会看到几个特别常用的格式符：

%Y 表示四位年份%m 表示两位月份%d 表示两位日期%H 表示小时，24 小时制%M 表示分钟%S 表示秒

这几个几乎是最常用的组合。

以后做日志、报表、文件命名、页面显示，都会大量用到 strftime()。

九、为什么 strftime 这么重要

因为程序里的时间，不是总能直接拿来给人看。

比如数据库里存的是标准时间对象。 日志里可能要写成 20260329_143542 这种形式。 网页上可能希望显示成 2026年03月29日 14:35。 文件名里又不能随便用冒号。

这些都要求你能把同一个时间，转换成不同格式。

例如，做文件备份时，常见写法就是：

from datetime import datetimenow = datetime.now()filename = now.strftime("%Y%m%d_%H%M%S") + ".txt"print(filename)

输出可能是：

20260329_143542.txt

这个技巧非常高频。 你以后做日志归档、导出报表、自动生成文件名，都会遇到。

所以不要把 strftime() 当成一个孤零零的语法点。 它其实是连接程序内部时间和外部展示格式的桥梁。

十、字符串怎么转回时间对象

刚才讲的是时间对象转成字符串。

那反过来呢

如果你从文件、接口、表单、数据库里读到的是一段时间字符串，想把它变成时间对象，怎么办

这时候要用 strptime()。

它的作用是： 按指定格式，把字符串解析成时间对象。

例如：

from datetime import datetimetext = "2026-03-29 15:20:30"dt = datetime.strptime(text, "%Y-%m-%d %H:%M:%S")print(dt)print(type(dt))

输出大致是：

2026-03-2915:20:30<class 'datetime.datetime'>

这一步特别重要。

因为真实开发里，外部给你的时间，很多时候都是字符串。 只有先把它变成时间对象，你后面才能比较、计算、相减。

所以从工作流角度看，这里有一条很常见的链路：

先拿到字符串 再用 strptime() 解析 得到时间对象后做计算 最后再用 strftime() 输出

这个流程你一定要记住。

十一、strptime 最常见的坑是什么

最常见的坑就一句话：

字符串格式，必须和你写的规则完全一致。

比如字符串是：

2026-03-29

你却用下面这种规则去解析：

"%Y/%m/%d"

那就会报错。

因为实际字符串里用的是横杠，不是斜杠。

再比如字符串没有时分秒：

2026-03-29

你却写成：

"%Y-%m-%d %H:%M:%S"

同样也会报错。

所以 strptime() 的核心不是背方法名，而是养成仔细观察原始字符串格式的习惯。

现实里，很多时间解析失败，并不是代码复杂，而是格式没对上。

十二、时间相减，是最常见的业务需求之一

时间处理真正开始有价值，往往是从加减运算开始的。

比如：

两个时间相差多少天 一个订单距离现在过了多久 一个任务截止时间还剩几小时 某个用户已经连续签到多少天

这些都离不开时间差计算。

先看最简单的例子：

from datetime import datetimestart = datetime(2026, 3, 25, 10, 0, 0)end = datetime(2026, 3, 29, 15, 30, 0)diff = end - startprint(diff)print(type(diff))

输出大致是：

4 days, 5:30:00<class 'datetime.timedelta'>

这里返回的不是数字，而是一个 timedelta 对象。

这个对象专门表示时间差。

也就是说：

datetime 表示某个具体时刻timedelta 表示两个时刻之间的差值

这个概念非常关键。

十三、timedelta 到底能拿来干什么

你可以把 timedelta 理解成一段时间长度。

它可以表示 3 天、5 小时、20 分钟，也可以表示更复杂的时间间隔。

例如：

from datetime import datetimestart = datetime(2026, 3, 25, 10, 0, 0)end = datetime(2026, 3, 29, 15, 30, 0)diff = end - startprint(diff.days)print(diff.total_seconds())

输出可能是：

4365400.0

这里有两个很容易混的点。

diff.days 只能拿到整天数。diff.total_seconds() 可以拿到总秒数，更精确。

如果你想进一步换算成小时，可以这样写：

hours = diff.total_seconds() / 3600print(hours)

这在业务里非常常见。

比如某个任务执行了多少小时 某笔订单距离创建已经过去多少分钟 某个用户最后登录到现在过去了多久

很多时候，最终逻辑判断并不是按天，而是按分钟、按小时。

所以一定要知道 total_seconds() 这个方法。

十四、时间相加也非常重要

除了相减，时间相加同样常见。

比如：

下单后 30 分钟自动取消 注册后 7 天赠送试用 当前时间往后延 3 天作为截止时间 预约时间顺延 2 小时

这时就要用到 timedelta 加法。

from datetime import datetime, timedeltanow = datetime.now()future = now + timedelta(days=3)print(now)print(future)

这表示当前时间往后推 3 天。

再看几个常用写法：

from datetime import datetime, timedeltanow = datetime.now()print(now + timedelta(hours=2))print(now + timedelta(minutes=30))print(now + timedelta(days=7))print(now - timedelta(days=1))

这几个分别表示：

2 小时后 30 分钟后 7 天后 1 天前

这类写法在业务系统里几乎随处可见。

十五、一个非常真实的场景：订单超时未支付

我们来写个像业务代码的例子。

假设订单创建于 2026-03-29 10:00:00，规则是 30 分钟内未支付就自动取消。 现在当前时间是 2026-03-29 10:45:00，我们判断它是不是已经超时。

from datetime import datetime, timedeltacreated_at = datetime.strptime("2026-03-29 10:00:00", "%Y-%m-%d %H:%M:%S")now = datetime.strptime("2026-03-29 10:45:00", "%Y-%m-%d %H:%M:%S")deadline = created_at + timedelta(minutes=30)if now > deadline:    print("订单已超时，应该自动取消")else:    print("订单还在有效支付时间内")

输出：

订单已超时，应该自动取消

这段代码虽然不复杂，但非常接近真实项目。

重点不是方法本身，而是业务思路：

先拿到创建时间 再加上规则允许的时长 算出截止时间 最后和当前时间比较

你以后做会员过期、验证码失效、签到截止、任务延迟，本质上都是这种模式。

十六、再看一个场景：距离截止日期还剩几天

假设有个活动截止到 2026-04-10，今天是 2026-03-29，我们想知道还剩多少天。

from datetime import datetimetoday = datetime.strptime("2026-03-29", "%Y-%m-%d")deadline = datetime.strptime("2026-04-10", "%Y-%m-%d")diff = deadline - todayprint(f"距离截止还有 {diff.days} 天")

输出：

距离截止还有 12 天

这种逻辑在后台管理、考试报名、活动提醒、会员权益里都很常见。

所以你会发现，时间处理不是一个边角知识。 它和业务规则几乎是天然绑定的。

十七、如何比较两个时间谁早谁晚

这一点其实非常方便。

时间对象之间可以直接比较。

from datetime import datetimet1 = datetime.strptime("2026-03-29 09:00:00", "%Y-%m-%d %H:%M:%S")t2 = datetime.strptime("2026-03-29 18:00:00", "%Y-%m-%d %H:%M:%S")print(t1 < t2)print(t1 > t2)print(t1 == t2)

输出：

TrueFalseFalse

这在业务判断里非常常见。

比如：

当前时间是否晚于截止时间 开始时间是否早于结束时间 用户最后登录时间是否早于某个阈值 某条日志是否发生在指定时间范围内

只要是时间对象，比较起来和数字很像，直接用大于小于就行。

但这里有个前提： 两边都得是时间对象

如果一边是字符串，一边是时间对象，就不能乱比。

十八、为什么不建议直接拿时间字符串比较

有些情况下，格式统一的时间字符串，好像也能直接比较。 比如：

"2026-03-29" < "2026-04-01"

看起来确实成立。

但这种做法并不稳妥。

因为一旦格式不统一，问题就来了。

比如：

"2026-3-9""2026-12-01"

字符串比较关心的是字符顺序，不是真正的时间逻辑。

再比如有时带时分秒，有时不带；有时是横杠，有时是斜杠；有时还有中文。 那字符串比较很容易出错。

所以更稳妥的做法永远是：

先解析成时间对象 再做比较

这一点看起来像绕一步，但实际会让你的代码更可靠。

十九、时间戳是什么，为什么你迟早会遇到

除了常见的日期字符串，你以后还会经常看到一种时间表示方式：时间戳。

比如：

1711699200

它长得像一个普通数字，但其实表示的是某个时间点。

时间戳最大的特点是： 适合程序存储和传输，不太适合人直接阅读。

在很多接口、数据库、日志、缓存系统里，时间戳特别常见。

Python 里可以把时间对象转成时间戳：

from datetime import datetimenow = datetime.now()ts = now.timestamp()print(ts)

输出可能像这样：

1774767000.123456

也可以反过来，把时间戳转成时间对象：

from datetime import datetimets = 1774767000dt = datetime.fromtimestamp(ts)print(dt)

输出会变成正常可读的时间。

所以你可以这样理解：

时间对象适合计算 字符串适合展示 时间戳适合存储和传输

三者经常互相转换。

二十、时间处理里最常见的格式化符号，先掌握这些就够了

刚开始学时间处理，很多人一上来就想把所有格式符都背下来。 其实没必要。

你先把最常用的几个记住就够用了：

%Y 四位年份%m 两位月份%d 两位日期%H 24 小时制小时%M 分钟%S 秒%w 星期几，通常周日是 0%A 星期名称，英文环境下更常见

比如：

from datetime import datetimenow = datetime.now()print(now.strftime("%Y-%m-%d"))print(now.strftime("%Y-%m-%d %H:%M:%S"))print(now.strftime("%Y年%m月%d日 %H时%M分"))

这些写法已经足够覆盖大量场景。

真正用得少的格式符，以后查文档就行。 没必要一开始全背。

二十一、一个经常被忽视的能力：取出年月日时分秒

有时候你不是要把时间转成字符串，而是想直接拿到其中某一部分。

例如：

只要年份 只要月份 只要小时 判断今天是不是周末 根据月份归类数据

时间对象可以直接取属性：

from datetime import datetimenow = datetime.now()print(now.year)print(now.month)print(now.day)print(now.hour)print(now.minute)print(now.second)

输出会是对应的数字。

这个能力特别适合写业务判断。

比如判断是不是月末：

from datetime import datetimenow = datetime.now()if now.day == 1:    print("今天是每月第一天")

或者根据小时判断是否是工作时间：

from datetime import datetimenow = datetime.now()if9 <= now.hour < 18:    print("当前处于工作时间")else:    print("当前不在工作时间")

这类判断在自动化脚本、定时任务、统计逻辑里都非常常见。

二十二、再看一个完整小案例：会员是否过期

假设用户会员到期时间是 2026-04-05 23:59:59，现在系统要判断会员是否还有效。

from datetime import datetimeexpire_text = "2026-04-05 23:59:59"expire_time = datetime.strptime(expire_text, "%Y-%m-%d %H:%M:%S")now = datetime.strptime("2026-03-29 12:00:00", "%Y-%m-%d %H:%M:%S")if now <= expire_time:    diff = expire_time - now    print("会员仍然有效")    print(f"距离到期还有 {diff.days} 天")else:    print("会员已过期")

输出大致是：

会员仍然有效距离到期还有 7 天

你可以看到，时间处理一旦进入业务场景，马上就非常具体了。

不是为了展示当前几点。 而是为了支撑规则判断。

这才是这一章真正要让你掌握的能力。

二十三、为什么很多人一碰时间就容易写乱

因为时间问题特别像生活常识，大家容易想当然。

比如以为相差一天就一定是 24 小时。 可跨夏令时、跨时区时就不一定。

比如以为只要格式长得差不多就能解析。 结果一个横杠、一个斜杠，程序就直接报错。

比如以为日期减日期一定就够了。 结果业务里还要求精确到秒。

比如以为显示给用户的时间格式，和程序内部计算格式可以混着用。 最后展示和逻辑缠在一起，代码越来越乱。

所以时间处理最重要的，不是死记更多函数。 而是把思路分开。

程序内部尽量用时间对象 需要展示时再格式化成字符串 输入进来的字符串先解析 涉及比较和加减时用 datetime 和 timedelta

这个分层意识，会让你的代码清楚很多。

二十四、初学者最容易踩的几个坑

第一个坑，是把 strftime() 和 strptime() 搞反。

你可以这样记：

strftime() 里的 f，可以理解成 format 意思是把时间对象格式化成字符串

strptime() 里的 p，可以理解成 parse 意思是把字符串解析成时间对象

第二个坑，是格式写错一个字符。

比如把月份 %m 写成分钟 %M，结果解析完全不对。

第三个坑，是明明只关心日期，却非要带上时分秒，代码变复杂。

第四个坑，是反复多次调用 datetime.now()，导致前后结果微妙不同。

例如：

from datetime import datetimeprint(datetime.now())print(datetime.now())

这两个值不是完全相同的。

如果你的业务逻辑需要基于同一个当前时刻做多次计算，最好先保存下来：

from datetime import datetimenow = datetime.now()

第五个坑，是直接拿字符串做时间运算。

这一点前面已经说过了，尽量不要这样做。

二十五、给你一个很实用的写代码建议

以后只要遇到时间相关问题，你都可以先在脑子里问自己四个问题。

现在手里的是字符串，还是时间对象 我这一步是要展示，还是要计算 我要比的是早晚，还是要算差值 结果最终要输出成什么格式

这四个问题一问，思路通常就清楚了。

很多时间处理问题之所以显得难，不是因为函数多，而是因为自己一开始没想清楚要干什么。

比如你拿到一个时间字符串，下一步却去直接做加减，那很可能就会卡住。 因为你真正该做的，是先解析。

又比如你本来只是想在页面上显示得好看一点，却去拼命研究 timedelta，那方向也偏了。

所以，时间处理最重要的是明确步骤。

二十六、这一章真正要带走的能力

到这里，你应该慢慢能感觉到，时间与日期处理其实不是单独的一个知识点。 它是一整套非常实用的流程能力。

你要会获取当前时间。 你要会创建指定时间。 你要会在时间对象和字符串之间来回转换。 你要会做比较。 你要会做加减。 你要会用 timedelta 表示时间差。 你还要知道，什么时候该展示，什么时候该计算。

只要这些思路理顺，后面你碰到日志处理、数据分析、自动化定时任务、接口返回时间解析，都会顺很多。

因为这些东西表面不同，本质上都离不开时间处理。

本章小结

时间与日期处理，是业务逻辑里非常高频的一类能力。

Python 里最常用的工具是 datetime 模块。 其中：

datetime.now() 用来获取当前日期和时间date.today() 用来获取今天的日期strftime() 用来把时间对象格式化成字符串strptime() 用来把字符串解析成时间对象timedelta 用来表示时间差，也常用于时间加减运算

学这一章，最重要的不是记住几个函数名。 而是建立一套清晰思路：

输入进来的时间字符串，先解析成时间对象 真正做比较和加减时，用时间对象和 timedelta需要展示给用户时，再格式化成字符串

只要这个流程清楚，很多看起来麻烦的时间问题，其实都能一步一步拆开解决。

课后练习

你可以自己做这几个练习，做完会非常扎实。

第一，获取当前时间，分别输出成下面三种格式：

2026-03-29 2026-03-29 14:30:15 2026年03月29日 14时30分

第二，准备两个时间字符串，解析后计算它们相差多少天、多少小时。

第三，写一个小程序，输入订单创建时间，判断是否已经超过 30 分钟未支付。

第四，写一个会员到期判断程序，输出会员是否有效，以及距离到期还剩多少天。

第五，把当前时间转成文件名格式，例如 20260329_143015.txt。