三大Python时间处理库datetime/arrow/pandas的使用通关指南

from datetime import datetime, date, time, timedelta

# 1. 获取当前时间（本地时间，naive）
now = datetime.now()
print(f"当前本地时间：{now}")  # 2026-03-24 14:30:45.123456

# 2. 获取当前utc时间（naive）
utc_now = datetime.utcnow()
print(f"当前utc时间：{utc_now}")  # 2026-03-24 06:30:45.123456

# 3. 创建指定时间
dt = datetime(2026, 3, 24, 14, 30, 0)
print(f"指定时间：{dt}")  # 2026-03-24 14:30:00

# 4. 从字符串解析
dt_str = "2026-03-24 14:30:00"
parsed = datetime.strptime(dt_str, "%y-%m-%d %h:%m:%s")
print(f"解析结果：{parsed}")  # 2026-03-24 14:30:00

from datetime import datetime, timedelta

now = datetime.now()

# 1. 时间加减（使用timedelta）
tomorrow = now + timedelta(days=1)
last_week = now - timedelta(weeks=1)
two_hours_later = now + timedelta(hours=2)

# 2. 时间比较
if now > tomorrow:
    print("这不可能")
else:
    print("今天还没到明天")

# 3. 计算时间差
start = datetime(2026, 3, 1, 8, 0, 0)
end = datetime(2026, 3, 24, 14, 30, 0)
delta = end - start
print(f"相差天数：{delta.days}")          # 23
print(f"相差秒数：{delta.total_seconds()}") # 2032200.0

# 正确：使用%z解析带偏移量的时间字符串
from datetime import datetime

# 带偏移量的字符串
dt_str = "2026-03-24 14:30:00+0800"
# 注意：%z在python 3.7+支持解析
dt = datetime.strptime(dt_str, "%y-%m-%d %h:%m:%s%z")
print(dt)  # 2026-03-24 14:30:00+08:00
print(dt.tzinfo)  # datetime.timezone(datetime.timedelta(seconds=28800), '+0800')

from datetime import datetime

# 错误示范：存储naive datetime
db_time = datetime.now()  # 本地时间，没有时区信息
print(db_time)  # 2026-03-24 14:30:00

# 如果这个时间被另一个时区的用户读取
# 他以为这是utc时间，就会产生8小时的偏差

from datetime import datetime, timezone
from zoneinfo import zoneinfo

# 创建aware datetime（python 3.9+）
# 方法1：直接指定utc
utc_now = datetime.now(timezone.utc)
print(utc_now)  # 2026-03-24 06:30:00+00:00

# 方法2：使用zoneinfo指定时区
beijing_tz = zoneinfo("asia/shanghai")
beijing_now = datetime.now(beijing_tz)
print(beijing_now)  # 2026-03-24 14:30:00+08:00

# 方法3：从字符串解析带时区的字符串
dt_str = "2026-03-24 14:30:00+08:00"
aware_dt = datetime.fromisoformat(dt_str)
print(aware_dt)  # 2026-03-24 14:30:00+08:00

from datetime import datetime, timezone
from zoneinfo import zoneinfo

# 1. utc转本地时间
utc_time = datetime.now(timezone.utc)
beijing_tz = zoneinfo("asia/shanghai")
beijing_time = utc_time.astimezone(beijing_tz)
print(f"utc: {utc_time}")          # 2026-03-24 06:30:00+00:00
print(f"北京时间: {beijing_time}")   # 2026-03-24 14:30:00+08:00

# 2. 本地时间转utc
beijing_time = datetime.now(zoneinfo("asia/shanghai"))
utc_time = beijing_time.astimezone(timezone.utc)
print(f"utc: {utc_time}")          # 2026-03-24 06:30:00+00:00

pip install arrow

import arrow

# 获取当前utc时间（默认aware）
utc_now = arrow.utcnow()
print(utc_now)  # 2026-03-24t06:30:00.123456+00:00

# 获取当前本地时间
local_now = arrow.now()
print(local_now)  # 2026-03-24t14:30:00.123456+08:00

# 从datetime对象创建
from datetime import datetime
dt = datetime(2026, 3, 24, 14, 30)
arrow_dt = arrow.get(dt)
print(arrow_dt)  # 2026-03-24t14:30:00+00:00

# 从字符串创建（自动识别格式）
arrow_parse = arrow.get("2026-03-24 14:30:00")
print(arrow_parse)  # 2026-03-24t14:30:00+00:00

import arrow

# 创建utc时间
utc = arrow.utcnow()
print(utc)  # 2026-03-24t06:30:00+00:00

# 转换为北京时间
beijing = utc.to("asia/shanghai")
print(beijing)  # 2026-03-24t14:30:00+08:00

# 转换为纽约时间
newyork = utc.to("america/new_york")
print(newyork)  # 2026-03-24t02:30:00-04:00（夏令时）

import arrow

now = arrow.now()

# 加减时间
tomorrow = now.shift(days=1)
yesterday = now.shift(days=-1)
two_hours_later = now.shift(hours=2)
next_week = now.shift(weeks=1)
complex_shift = now.shift(days=2, hours=3, minutes=30)

print(f"现在：{now}")           # 2026-03-24t14:30:00+08:00
print(f"明天：{tomorrow}")       # 2026-03-25t14:30:00+08:00
print(f"两小时后：{two_hours_later}")  # 2026-03-24t16:30:00+08:00

import arrow

now = arrow.now()

# 内置格式
print(now.format())           # 2026-03-24 14:30:00+08:00
print(now.format("yyyy-mm-dd"))  # 2026-03-24
print(now.format("mm/dd/yyyy hh:mm"))  # 03/24/2026 14:30

# 自定义格式
print(now.format("yyyy年mm月dd日 hh时mm分ss秒"))  # 2026年03月24日 14时30分00秒

# 解析字符串（支持多种格式）
parsed = arrow.get("2026-03-24t14:30:00+0800")
print(parsed)  # 2026-03-24t14:30:00+08:00

import arrow

# 过去时间
two_hours_ago = arrow.utcnow().shift(hours=-2)
print(two_hours_ago.humanize())  # "2 hours ago"
print(two_hours_ago.humanize(locale="zh_cn"))  # "2小时前"

# 未来时间
tomorrow = arrow.utcnow().shift(days=1)
print(tomorrow.humanize())  # "in a day"
print(tomorrow.humanize(locale="zh_cn"))  # "1天后"

# 支持的语言
# 常见语言代码：zh_cn（简体中文）、en（英文）、ja（日语）、fr（法语）等

import arrow

# 生成时间范围（每5分钟一个点）
start = arrow.get("2026-03-24 00:00:00")
end = arrow.get("2026-03-24 12:00:00")

for dt in arrow.arrow.range("hour", start, end):
    print(dt.format("hh:mm"))
# 输出：
# 00:00
# 01:00
# 02:00
# ...
# 12:00

import arrow
from datetime import datetime

# arrow → datetime
arrow_time = arrow.now()
dt = arrow_time.datetime  # 返回datetime对象
print(type(dt))  # <class 'datetime.datetime'>

# datetime → arrow
dt = datetime.now()
arrow_time = arrow.get(dt)
print(arrow_time)  # 2026-03-24t14:30:00+08:00

import arrow

# 假设有一批utc时间字符串
utc_strings = [
    "2026-03-24t00:00:00+00:00",
    "2026-03-24t01:00:00+00:00",
    "2026-03-24t02:00:00+00:00"
]

# 批量转换为北京时间
beijing_times = [
    arrow.get(s).to("asia/shanghai").format("yyyy-mm-dd hh:mm")
    for s in utc_strings
]
print(beijing_times)
# ['2026-03-24 08:00', '2026-03-24 09:00', '2026-03-24 10:00']

pip install pandas matplotlib

import pandas as pd
import numpy as np

import pandas as pd

# 生成连续日期
dates = pd.date_range(start="2026-03-01", end="2026-03-31", freq="d")
print(dates)  # datetimeindex(['2026-03-01', '2026-03-02', ...], dtype='datetime64[ns]', freq='d')

# 生成指定数量的日期
dates = pd.date_range(start="2026-01-01", periods=10, freq="m")
print(dates)  # 按月生成

# 常见频率（freq参数）
# 'd': 天
# 'h': 小时
# 't'或'min': 分钟
# 's': 秒
# 'w': 周
# 'm': 月末
# 'q': 季度末
# 'y': 年末

# 生成每5分钟一个点
minute_dates = pd.date_range("2026-03-24 00:00", "2026-03-24 23:55", freq="5t")
print(f"生成了{len(minute_dates)}个时间点")  # 288个

import pandas as pd
import numpy as np

# 创建示例数据
dates = pd.date_range("2026-03-01", periods=100, freq="d")
data = np.random.randn(100)  # 随机数据
df = pd.dataframe({"value": data}, index=dates)

print(df.head())
#              value
# 2026-03-01  0.123
# 2026-03-02 -0.456
# ... ...

# 快速筛选（切片）
# 筛选3月的数据
march_data = df["2026-03"]
print(march_data)

# 筛选3月1日到3月15日
range_data = df["2026-03-01":"2026-03-15"]

# 筛选特定日期
specific = df.loc["2026-03-10"]

import pandas as pd
import numpy as np

# 生成小时级数据（3月份，每小时一个点）
dates = pd.date_range("2026-03-01", "2026-03-31 23:00", freq="h")
data = np.random.randn(len(dates))
df = pd.dataframe({"value": data}, index=dates)

# 按天汇总（降采样）
daily = df.resample("d").mean()
print(daily.head())
#              value
# 2026-03-01  0.023
# 2026-03-02 -0.112
# ...

# 按周汇总
weekly = df.resample("w").sum()

# 按小时汇总（升采样，需要填充）
hourly = df.resample("15t").ffill()  # 前向填充

# 支持多种聚合函数
agg_daily = df.resample("d").agg(["mean", "max", "min", "std"])
print(agg_daily.head())

import pandas as pd
import numpy as np

# 创建naive时间索引
dates = pd.date_range("2026-03-01", periods=10, freq="d")
df = pd.dataframe({"value": np.random.randn(10)}, index=dates)

# 1. 本地化（为naive时间添加时区）
# 假设原始数据是utc时间
df_utc = df.tz_localize("utc")
print(df_utc.index)
# datetimeindex(['2026-03-01 00:00:00+00:00', ...], dtype='datetime64[ns, utc]', freq='d')

# 2. 时区转换（utc → 北京时间）
df_beijing = df_utc.tz_convert("asia/shanghai")
print(df_beijing.index)
# datetimeindex(['2026-03-01 08:00:00+08:00', ...], dtype='datetime64[ns, asia/shanghai]', freq='d')

import pandas as pd
import numpy as np

# 创建有缺失的时间序列
dates = pd.date_range("2026-03-01", periods=10, freq="d")
data = [1, 2, np.nan, 4, 5, np.nan, 7, 8, 9, 10]
df = pd.dataframe({"value": data}, index=dates)

# 前向填充
df_ffill = df.fillna(method="ffill")

# 后向填充
df_bfill = df.fillna(method="bfill")

# 插值（线性）
df_interp = df.interpolate()

import pandas as pd
import numpy as np

# 模拟用户行为数据（10000条随机时间）
np.random.seed(42)
timestamps = pd.date_range("2026-03-01", periods=10000, freq="15t")  # 15分钟一个点
# 随机打乱顺序
timestamps = np.random.permutation(timestamps)

df = pd.dataframe({"user_id": np.random.randint(1, 1000, 10000),
                   "action": np.random.choice(["click", "purchase", "view"], 10000),
                   "timestamp": timestamps})

# 按小时统计行为数量
df["hour"] = df["timestamp"].dt.hour
hourly_stats = df.groupby("hour").size()
print(hourly_stats)
# hour
# 0     417
# 1     389
# 2     412
# ... ...

# 按小时+行为类型统计
hourly_action = df.groupby(["hour", "action"]).size().unstack()
print(hourly_action)

import pandas as pd

# 模拟不同时区的日志数据
data = {
    "timestamp": [
        "2026-03-24 08:00:00+0800",  # 北京时间
        "2026-03-24 07:00:00+0900",  # 东京时间
        "2026-03-24 06:00:00+0000",  # utc时间
        "2026-03-23 22:00:00-0400"   # 纽约时间
    ],
    "event": ["login", "purchase", "logout", "login"]
}
df = pd.dataframe(data)

# 解析带时区的时间字符串
df["timestamp"] = pd.to_datetime(df["timestamp"], format="%y-%m-%d %h:%m:%s%z")
print(df["timestamp"])
# 0   2026-03-24 08:00:00+08:00
# 1   2026-03-24 07:00:00+09:00
# 2   2026-03-24 06:00:00+00:00
# 3   2026-03-23 22:00:00-04:00

# 统一转换为utc
df["timestamp_utc"] = df["timestamp"].dt.tz_convert("utc")
print(df["timestamp_utc"])
# 0   2026-03-24 00:00:00+00:00
# 1   2026-03-23 22:00:00+00:00
# 2   2026-03-24 06:00:00+00:00
# 3   2026-03-24 02:00:00+00:00

import pandas as pd
import matplotlib.pyplot as plt

# 生成模拟股票价格数据
dates = pd.date_range("2026-01-01", periods=365, freq="d")
prices = 100 + np.cumsum(np.random.randn(365) * 0.5)  # 随机游走

df = pd.dataframe({"price": prices}, index=dates)

# 绘制走势图
plt.figure(figsize=(12, 6))
plt.plot(df.index, df["price"], linewidth=1)
plt.title("stock price trend - 2026")
plt.xlabel("date")
plt.ylabel("price")
plt.grid(true, alpha=0.3)
plt.show()

# 按月绘制箱线图
df["month"] = df.index.month
df.boxplot(column="price", by="month", figsize=(12, 6))
plt.title("monthly price distribution")
plt.suptitle("")  # 去掉默认的suptitle
plt.show()

# 错误：存储naive datetime
db.save_time(datetime.now())  # 本地时间，无时区信息

# 正确：存储aware datetime（统一utc）
from datetime import datetime, timezone
db.save_time(datetime.now(timezone.utc))

from pytz import timezone as pytz_tz
from zoneinfo import zoneinfo

# 错误：混用
dt = datetime.now(zoneinfo("asia/shanghai"))
dt_ny = dt.astimezone(pytz_tz("america/new_york"))  # 可能报错

df = pd.read_csv("data.csv")
# df["timestamp"] 是字符串，无法使用dt访问器

df = pd.read_csv("data.csv", parse_dates=["timestamp"])
# 或读取后再转换
df["timestamp"] = pd.to_datetime(df["timestamp"])

import arrow
print(arrow.now().humanize())  # "1 hour ago" 英文

print(arrow.now().humanize(locale="zh_cn"))  # "1小时前"

if 场景 == "简单的时间格式化":
    使用 datetime
elif 场景 == "web应用，需要人性化输出和时区转换":
    使用 arrow
elif 场景 == "百万级数据分析，重采样/聚合":
    使用 pandas
else:
    # 复杂时区处理，需要精确控制夏令时
    使用 pendulum