1: 将字符串解析为时区感知的日期时间对象

Python 3.2+ 在将字符串解析为日期时间对象时支持 %z 格式。

UTC 偏移量，格式为 +HHMM 或 -HHMM（如果对象是本地化的，则为空字符串）。

Python 3.x Version ≥ 3.2

import datetimebr
dt = datetime.datetime.strptime("2024-04-15T08:27:18-0500", "%Y-%m-%dT%H:%M:%S%z")

对于其他版本的 Python，可以使用 dateutil 这样的外部库，它可以快速将包含时区的字符串解析为日期时间对象。

import dateutil.parser
dt = dateutil.parser.parse("2024-04-15T08:27:18-0500")

dt 变量现在是一个日期时间对象，其值如下：

datetime.datetime(2024, 4, 15, 8, 27, 18, tzinfo=tzoffset(None, -18000))

2: 构建可识别时区的日期时间

默认情况下，所有日期时间对象都是本地化的。要使其具有时区感知功能，必须附加一个 tzinfo 对象，该对象可提供 UTC 偏移量和时区缩写，作为日期和时间的函数。

固定偏移时区

对于从 UTC 固定偏移的时区，在 Python 3.2+ 中，datetime 模块提供了时区类（timezone class），它是 tzinfo 的具体实现，需要一个 timedelta 和一个（可选的）名称参数：

Python 3.x 版本 ≥ 3.2

from datetime import datetime, timedelta, timezone
JST = timezone(timedelta(hours=+9))

dt = datetime(2025, 1, 1, 12, 0, 0, tzinfo=JST)
print(dt)
# 2025-01-01 12:00:00+09:00br

print(dt.tzname())
# UTC+09:00

dt = datetime(2025, 1, 1, 12, 0, 0, tzinfo=timezone(timedelta(hours=9), 'JST'))
print(dt.tzname)
# <built-in method tzname of datetime.datetime object at 0x7fd12020a420>

对于 3.2 之前的 Python 版本，有必要使用第三方库，如 dateutil。dateutil 提供了一个等价类 tzoffset，它（从 2.5.3 版起）接受 dateutil.tz.tzoffset(tzname, offset) 形式的参数，其中 offset 以秒为单位指定：

from datetime import datetime, timedelta
from dateutil import tz
JST = tz.tzoffset('JST', 9 * 3600) # 3600 seconds per hour
dt = datetime(2025, 1, 1, 12, 0, tzinfo=JST)
print(dt)
# 2025-01-01 12:00:00+09:00
print(dt.tzname)
# 'JST'

采用夏令时的地区

pytz 和 dateutil 是提供时区类的常用库。

除了静态时区，dateutil 还提供了使用夏令时的时区类（参见 tz 模块的文档）。您可以使用 tz.gettz() 方法获取时区对象，然后直接将其传递给 datetime 构造函数：

from datetime import datetime
from dateutil import tz

local = tz.gettz() # Local time
PT = tz.gettz('US/Pacific') # Pacific time

dt_l = datetime(2025, 1, 1, 12, tzinfo=local) # I am in EST
dt_pst = datetime(2025, 1, 1, 12, tzinfo=PT)
dt_pdt = datetime(2024, 7, 1, 12, tzinfo=PT) # DST is handled automatically
print(dt_l)
# 2025-01-01 12:00:00-05:00
print(dt_pst)
# 2025-01-01 12:00:00-08:00
print(dt_pdt)
# 2024-07-01 12:00:00-07:00

注意：从 2.5.3 版开始，dateutil 无法正确处理含糊不清的日期时间，总是默认为较晚的日期。没有办法用 dateutil 时区构建一个对象，例如 2024-11-01 1:30 EDT-4，因为这是在夏令时转换期间。

使用 pytz 时，所有边缘情况都能得到妥善处理，但不应通过构造函数直接将 pytz 时区附加到时区上。相反，应使用时区的 localize 方法附加 pytz 时区：

from datetime import datetime, timedelta
import pytz

PT = pytz.timezone('US/Pacific')
dt_pst = PT.localize(datetime(2025, 1, 1, 12))
dt_pdt = PT.localize(datetime(2024, 11, 1, 0, 30))
print(dt_pst)
# 2025-01-01 12:00:00-08:00
print(dt_pdt)
# 2024-11-01 00:30:00-07:00

需要注意的是，如果在 pytz 感知的时区上执行日期时间运算，则必须以 UTC 进行计算（如果需要绝对经过时间），或者必须对计算结果调用 normalize()：

dt_new = dt_pdt + timedelta(hours=3) # This should be 2:30 AM PST
print(dt_new)
# 2024-11-01 03:30:00-07:00
dt_corrected = PT.normalize(dt_new)
print(dt_corrected)
# 2024-11-01 02:30:00-08:00

3: 计算时间差

timedelta 模块在计算时间差时非常有用：

from datetime import datetime, timedelta
now = datetime.now()
then = datetime(2024, 5, 23) # datetime.datetime(2024, 05, 23, 0, 0, 0)

创建新的日期时间对象时，指定时间是可选项：

delta = now-then

delta 是 timedelta 类型：

print(delta.days)
# 213 (运行此代码段的时间为2024年12月22日)
print(delta.seconds)
# 47554

要获得 n 天后的日期和 n 天前的日期，我们可以使用以下方法：

单前日期后 n 天：

def get_n_days_after_date(date_format="%d %B %Y", add_days=120):
    date_n_days_after = datetime.datetime.now() + timedelta(days=add_days)
    return date_n_days_after.strftime(date_format)

下面的截图，是计算 120 天后的日期，运行的日期是2024年12月22日，所以得到的结果是 2025 年 4 月21日。

单前日期前 n 天：

def get_n_days_before_date(date_format="%d %B %Y", days_before=120):
    date_n_days_ago = datetime.datetime.now() - timedelta(days=days_before)
    return date_n_days_ago.strftime(date_format)

下面的截图，是计算 120 天前的日期，运行的日期是2024年12月22日，所以得到的结果是 2024 年 8 月24日。

4: 日期时间对象的基本用法

日期时间模块包含三种主要类型的对象：date、 time、和 datetime。

import datetime

# Date object
today = datetime.date.today()
new_year = datetime.date(2025, 01, 01) #datetime.date(2025, 1, 1)

# Time object
noon = datetime.time(12, 0, 0) #datetime.time(12, 0)

# Current datetimebr
now = datetime.datetime.now()

# Datetime object
millenium_turn = datetime.datetime(2020, 1, 1, 0, 0, 0) #datetime.datetime(2020, 1, 1, 0, 0)

这些对象的算术运算只支持在相同数据类型内进行，对不同类型的实例进行简单算术运算将导致 TypeError。

# subtraction of noon from todaybr
noon-todaybr
Traceback (most recent call last):br
  File "<stdin>", line 1, in <module>br
TypeError: unsupported operand type(s) for -: 'datetime.time' and 'datetime.date'br
However, it is straightforward to convert between types.br
br
# Do this insteadbr
print('Time since the millenium at midnight: ',br
      datetime.datetime(today.year, today.month, today.day) - millenium_turn)br
br
# Or thisbr
print('Time since the millenium at noon: ',br
      datetime.datetime.combine(today, noon) - millenium_turn)

5: 在时区之间切换

要在不同时区之间切换，需要使用具有时区感知功能的日期时间对象。

from datetime import datetime
from dateutil import tz

utc = tz.tzutc()
local = tz.tzlocal()

utc_now = datetime.utcnow()
utc_now # Not timezone-aware.

utc_now = utc_now.replace(tzinfo=utc)
utc_now # Timezone-aware.

local_now = utc_now.astimezone(local)
local_now # Converted to local time.

6: 简单的日期计算

日期并不是孤立存在的。通常，您需要查找日期之间的时间间隔或确定明天的日期。这可以通过使用 timedelta 对象来实现

import datetimebr

today = datetime.date.today()
print('Today:', today)

yesterday = today - datetime.timedelta(days=1)
print('Yesterday:', yesterday)

tomorrow = today + datetime.timedelta(days=1)
print('Tomorrow:', tomorrow)

print('Time between tomorrow and yesterday:', tomorrow - yesterday)

其结果类似于：

Today: 2024-12-22
Yesterday: 2024-12-21
Tomorrow: 2024-12-23
Difference between tomorrow and yesterday: 2 days, 0:00:00