Python日期时间处理全攻略：从基础到高阶技巧-代码聚汇网

Python日期时间处理全攻略：从基础到高阶技巧

生命的光彩

1. 为什么我们需要专门处理日期和时间？

刚接触Python那会儿，我也觉得日期时间处理能有多复杂？直到真正做项目时才发现，光是时区转换就能让人抓狂。有一次给国际客户做系统，因为没处理好夏令时，导致整个排班系统的时间全乱了。从那以后，我养成了认真对待日期时间处理的习惯。

Python中的日期时间处理远不止简单的显示当前时间那么简单。它涉及到：

不同格式的解析与转换（"2023-07-15" vs "07/15/23" vs "15 Jul 2023"）
时区与夏令时处理（纽约时间 vs 伦敦时间）
时间间隔计算（两个日期相差多少天？包含多少工作日？）
性能敏感场景下的高效处理（百万级时间戳的快速转换）

2. Python日期时间核心模块详解

2.1 datetime模块：基础但强大

datetime模块是处理日期时间的瑞士军刀，包含几个关键类：

python复制from datetime import datetime, date, time, timedelta

# 获取当前日期和时间
now = datetime.now()  # 返回datetime对象
today = date.today()  # 只获取日期部分

# 创建特定时间
some_day = datetime(2023, 7, 15, 14, 30)  # 2023年7月15日14:30

重要提示：datetime对象分为"naive"(无时区)和"aware"(有时区)。混合使用会导致错误：
python复制from datetime import datetime
import pytz

naive = datetime.now()
aware = datetime.now(pytz.UTC)

# 下面这行会报TypeError
naive - aware

2.2 time模块：底层时间操作

time模块更接近系统层，适合处理时间戳和性能敏感场景：

python复制import time

# 获取时间戳（秒级）
timestamp = time.time()  # 1689400000.123456

# 格式化输出
local_time = time.strftime("%Y-%m-%d %H:%M:%S", time.localtime())

# 高性能计时
start = time.perf_counter()
# 执行一些操作
end = time.perf_counter()
print(f"耗时：{end - start:.6f}秒")

2.3 calendar模块：日期计算神器

处理周、月、年相关的计算时特别有用：

python复制import calendar

# 判断闰年
is_leap = calendar.isleap(2024)  # True

# 获取某月日历
cal = calendar.month(2023, 7)
"""
     July 2023
Mo Tu We Th Fr Sa Su
             1  2
 3  4  5  6  7  8  9
10 11 12 13 14 15 16
17 18 19 20 21 22 23
24 25 26 27 28 29 30
31
"""

# 计算某个月有多少个工作日
weekdays = calendar.monthrange(2023, 7)[1]  # 31天

3. 实战中的日期时间处理技巧

3.1 时区处理：pytz和zoneinfo

时区是日期处理中最容易出错的部分。Python 3.9+推荐使用zoneinfo：

python复制from datetime import datetime
from zoneinfo import ZoneInfo

# 创建带时区的时间
ny_time = datetime(2023, 7, 15, 12, tzinfo=ZoneInfo("America/New_York"))
london_time = datetime(2023, 7, 15, 17, tzinfo=ZoneInfo("Europe/London"))

# 时区转换
ny_to_london = ny_time.astimezone(ZoneInfo("Europe/London"))
print(ny_to_london)  # 2023-07-15 17:00:00+01:00

对于老版本Python，可以使用pytz：

python复制import pytz
from datetime import datetime

eastern = pytz.timezone('US/Eastern')
utc = pytz.utc

# 必须使用localize方法
ny_time = eastern.localize(datetime(2023, 7, 15, 12))

踩坑警告：pytz的时区处理方式与zoneinfo不同，混用会导致奇怪的问题。建议新项目统一使用zoneinfo。

3.2 高效解析各种日期格式

实际业务中日期格式千奇百怪，dateutil的parser是救命神器：

python复制from dateutil import parser

dates = [
    "2023-07-15",
    "07/15/2023",
    "15-Jul-2023",
    "July 15, 2023",
    "20230715"
]

parsed_dates = [parser.parse(d) for d in dates]

对于已知格式的大批量解析，建议使用datetime.strptime，速度更快：

python复制from datetime import datetime

date_str = "2023-07-15 14:30:00"
fmt = "%Y-%m-%d %H:%M:%S"

dt = datetime.strptime(date_str, fmt)

3.3 时间差计算与业务逻辑

计算两个日期间的工作日天数（排除周末）：

python复制from datetime import datetime, timedelta

def workdays_between(start, end):
    delta = end - start
    days = []
    for i in range(delta.days + 1):
        day = start + timedelta(days=i)
        if day.weekday() < 5:  # 0-4是周一到周五
            days.append(day)
    return len(days)

start_date = datetime(2023, 7, 1)
end_date = datetime(2023, 7, 31)
print(workdays_between(start_date, end_date))  # 21个工作日

处理每月固定某天的业务逻辑（如每月15日扣款）：

python复制from datetime import date

def is_billing_day(today=None):
    today = today or date.today()
    return today.day == 15

# 测试
print(is_billing_day(date(2023, 7, 15)))  # True
print(is_billing_day(date(2023, 7, 16)))  # False

4. 性能优化与高级技巧

4.1 处理大规模时间数据

当需要处理数百万个时间戳时，原生datetime可能较慢。可以使用numpy或pandas的日期时间功能：

python复制import numpy as np
import pandas as pd

# 使用numpy处理时间戳数组
timestamps = np.arange(
    np.datetime64('2023-07-01'),
    np.datetime64('2023-07-31'),
    np.timedelta64(1, 'D')
)

# 使用pandas进行高效日期运算
date_range = pd.date_range('2023-07-01', periods=30, freq='D')
weekdays = date_range.day_name()  # 获取每天是星期几

4.2 自定义日期间隔处理

实现一个灵活的日期范围生成器：

python复制from datetime import datetime, timedelta
from typing import Iterator

def date_range(
    start: datetime,
    end: datetime,
    step: timedelta = timedelta(days=1),
    skip_weekends: bool = False
) -> Iterator[datetime]:
    current = start
    while current <= end:
        if not (skip_weekends and current.weekday() >= 5):
            yield current
        current += step

# 使用示例
start = datetime(2023, 7, 1)
end = datetime(2023, 7, 31)
for day in date_range(start, end, skip_weekends=True):
    print(day.strftime("%Y-%m-%d %A"))

4.3 缓存时区信息提升性能

频繁创建时区对象会影响性能，可以缓存常用时区：

python复制from functools import lru_cache
from zoneinfo import ZoneInfo

@lru_cache(maxsize=32)
def get_timezone(tzname: str) -> ZoneInfo:
    return ZoneInfo(tzname)

# 使用缓存后的时区
ny_time = datetime(2023, 7, 15, 12, tzinfo=get_timezone("America/New_York"))

5. 常见问题与解决方案

5.1 夏令时导致的诡异问题

问题：2023年3月12日美国东部时间2:30 AM不存在（夏令时跳变）

python复制from datetime import datetime
from zoneinfo import ZoneInfo

try:
    # 这个时间在纽约时区不存在
    dt = datetime(2023, 3, 12, 2, 30, tzinfo=ZoneInfo("America/New_York"))
except Exception as e:
    print(f"错误：{e}")

# 正确做法：使用pytz或zoneinfo的localize/normalize方法
eastern = ZoneInfo("America/New_York")
dt = datetime(2023, 3, 12, 2, 30)
dt = eastern.localize(dt, is_dst=None)  # 会报错，因为时间不明确

解决方案：

明确处理不存在的时间（跳过或调整）
使用is_dst参数明确指定是否使用夏令时
业务逻辑中尽量使用UTC时间，只在显示时转换

5.2 日期字符串解析的陷阱

不同地区对"03/04/2023"的理解不同：

美国：3月4日
欧洲：4月3日

解决方案：

python复制from dateutil import parser

# 明确指定dayfirst或yearfirst
dt = parser.parse("03/04/2023", dayfirst=True)  # 强制按日/月/年解析

5.3 月份天数计算的边界情况

二月份的天数计算：

python复制from datetime import date
import calendar

def days_in_month(year, month):
    return calendar.monthrange(year, month)[1]

print(days_in_month(2023, 2))  # 28
print(days_in_month(2024, 2))  # 29 (闰年)

5.4 性能问题排查

当日期处理成为性能瓶颈时：

避免在循环中重复创建时区对象
对于简单格式，优先使用strptime而非dateutil.parser
考虑使用numpy或pandas处理批量日期数据
对于只读操作，可以考虑使用time.struct_time代替datetime对象

6. 实际项目经验分享

在电商项目中，我们遇到过几个典型的日期时间问题：

促销活动时间计算：

python复制from datetime import datetime, timedelta
from zoneinfo import ZoneInfo

def is_promotion_active(promo):
    now = datetime.now(ZoneInfo("Asia/Shanghai"))
    return promo["start"] <= now <= promo["end"]

# 处理跨日促销（如23:00到次日2:00）
def is_night_promo_active(start_hour, end_hour):
    now = datetime.now(ZoneInfo("Asia/Shanghai"))
    start_time = now.replace(hour=start_hour, minute=0, second=0)
    end_time = now.replace(hour=end_hour, minute=0, second=0)
    
    if start_hour > end_hour:  # 跨日情况
        return now >= start_time or now <= end_time
    return start_time <= now <= end_time

订单超时处理：

python复制from datetime import datetime, timedelta

def check_order_timeout(order, timeout_hours=48):
    return datetime.now() - order["create_time"] > timedelta(hours=timeout_hours)

# 处理时区敏感的订单超时
def check_order_timeout_with_tz(order, timeout_hours=48):
    now = datetime.now(ZoneInfo(order["timezone"]))
    return now - order["create_time"] > timedelta(hours=timeout_hours)

生成月度报表时处理月末：

python复制from datetime import date
import calendar

def last_day_of_month(year, month):
    return date(year, month, calendar.monthrange(year, month)[1])

# 获取上个月的最后一天
def prev_month_end():
    today = date.today()
    first_day = today.replace(day=1)
    return first_day - timedelta(days=1)

7. 测试日期时间代码的最佳实践

日期时间相关的bug往往在特定时间才会暴露。好的测试策略包括：

使用freezegun库模拟特定时间：

python复制from freezegun import freeze_time
import pytest

@freeze_time("2023-07-15 12:00:00")
def test_promotion_active():
    promo = {
        "start": datetime(2023, 7, 15, 10, 0),
        "end": datetime(2023, 7, 15, 14, 0)
    }
    assert is_promotion_active(promo) is True

边界测试：

python复制@pytest.mark.parametrize("year,month,expected", [
    (2023, 1, 31),
    (2023, 2, 28),
    (2024, 2, 29),  # 闰年
    (2023, 4, 30),
])
def test_days_in_month(year, month, expected):
    assert days_in_month(year, month) == expected

时区转换测试：

python复制def test_timezone_conversion():
    ny_time = datetime(2023, 7, 15, 12, tzinfo=ZoneInfo("America/New_York"))
    london_time = ny_time.astimezone(ZoneInfo("Europe/London"))
    assert london_time.hour == 17  # 纽约中午12点是伦敦下午5点

8. 扩展工具与库推荐

Arrow：更人性化的日期时间库

python复制import arrow

# 更直观的API
now = arrow.now()
next_week = now.shift(weeks=1)
humanized = next_week.humanize()  # "in a week"

Pendulum：替代datetime的解决方案

python复制import pendulum

# 处理时区更简单
in_paris = pendulum.now('Europe/Paris')
in_tokyo = pendulum.now('Asia/Tokyo')
diff = in_paris.diff(in_tokyo).in_hours()

Maya：简化时间解析

python复制import maya

# 超级简单的解析
dt = maya.parse("2023-07-15").datetime()

Business Duration：计算工作时间

python复制from business_duration import businessDuration
import pandas as pd

start = pd.Timestamp('2023-07-14 16:30:00')
end = pd.Timestamp('2023-07-17 09:15:00')

# 计算工作时间（排除周末和下班时间）
duration = businessDuration(
    startdate=start,
    enddate=end,
    starttime=time(9,0,0),
    endtime=time(17,0,0),
    weekendlist=[5,6]
)
print(duration)  # 2.75小时

9. 性能对比：不同方法的效率差异

在处理百万级日期数据时，选择正确的方法至关重要：

python复制from datetime import datetime
import timeit
import numpy as np
import pandas as pd

# 测试数据量
size = 1_000_000
timestamps = [datetime.now() for _ in range(size)]

# 方法1：原生datetime
def test_native():
    return [dt.strftime("%Y-%m-%d") for dt in timestamps]

# 方法2：numpy
np_timestamps = np.array(timestamps, dtype='datetime64[s]')
def test_numpy():
    return np.datetime_as_string(np_timestamps, unit='D')

# 方法3：pandas
pd_series = pd.Series(timestamps)
def test_pandas():
    return pd_series.dt.strftime("%Y-%m-%d")

# 性能测试
print("原生datetime:", timeit.timeit(test_native, number=10))
print("numpy:", timeit.timeit(test_numpy, number=10))
print("pandas:", timeit.timeit(test_pandas, number=10))

典型结果：

原生datetime: 4.2秒
numpy: 0.8秒
pandas: 1.5秒

经验法则：小数据量用datetime足够，大数据量用numpy或pandas

10. 日期时间处理的最佳实践总结

经过多年项目实践，我总结了以下黄金法则：

时区三原则：
- 存储时用UTC
- 计算时用UTC
- 只在显示时转换为本地时间
格式处理四要点：
- 输入时尽早解析为datetime对象
- 内部处理始终使用datetime对象
- 输出时最后时刻才格式化为字符串
- 文档中明确注明所有日期格式
性能优化三策略：
- 批量操作使用numpy/pandas
- 缓存时区对象
- 避免在循环中重复解析/格式化
测试四边界：
- 闰年2月29日
- 每月最后一天
- 夏令时转换点
- 时区转换边界
代码可读性两建议：
- 为所有魔法日期添加注释
- 使用具名常量代替裸数字（如HOURS_IN_DAY = 24）

最后分享一个我常用的日期工具函数集，包含了90%的日常需求：

python复制from datetime import datetime, timedelta, date
from typing import Optional, Tuple
import calendar
from zoneinfo import ZoneInfo

def get_current_time(tz: str = "UTC") -> datetime:
    """获取当前时间，支持时区"""
    return datetime.now(ZoneInfo(tz))

def parse_date_str(date_str: str, fmt: Optional[str] = None) -> datetime:
    """安全解析日期字符串"""
    if fmt:
        return datetime.strptime(date_str, fmt)
    from dateutil import parser
    return parser.parse(date_str)

def format_date(dt: datetime, fmt: str = "%Y-%m-%d %H:%M:%S") -> str:
    """统一格式化日期"""
    return dt.strftime(fmt)

def add_business_days(start: date, days: int) -> date:
    """添加工作日"""
    current = start
    remaining = days
    while remaining > 0:
        current += timedelta(days=1)
        if current.weekday() < 5:  # 周一到周五
            remaining -= 1
    return current

def last_day_of_month(year: int, month: int) -> date:
    """获取月份的最后一天"""
    return date(year, month, calendar.monthrange(year, month)[1])

def is_weekend(dt: date) -> bool:
    """判断是否是周末"""
    return dt.weekday() >= 5

def split_date_range(start: date, end: date, max_days: int) -> list[Tuple[date, date]]:
    """拆分日期范围"""
    ranges = []
    current_start = start
    while current_start < end:
        current_end = min(current_start + timedelta(days=max_days-1), end)
        ranges.append((current_start, current_end))
        current_start = current_end + timedelta(days=1)
    return ranges