Pandas时间戳从入门到精通高效处理时间数据提升分析能力必备技巧

威震华夏关云长

引言

在数据分析领域，时间数据无处不在。无论是金融市场的股票价格、气象数据的温度记录，还是网站的用户访问日志，时间都是关键的维度。正确高效地处理时间数据，能够帮助我们揭示数据中的时间模式、趋势和周期性，从而做出更准确的预测和决策。

Pandas作为Python数据分析的核心库，提供了强大而灵活的时间数据处理功能。其中，时间戳（Timestamp）是处理时间数据的基础。本文将带你从基础概念到高级应用，全面掌握Pandas时间戳的处理技巧，提升你的数据分析能力。

Pandas时间戳基础

什么是时间戳

时间戳是表示特定时间点的对象，在Pandas中，Timestamp是对Python标准库datetime的扩展，提供了更多的功能和更好的性能。它可以精确到纳秒级别，并支持时区操作。

创建时间戳

在Pandas中，有多种方式可以创建时间戳对象：

2. import pandas as pd
3. from datetime import datetime
5. # 使用字符串创建时间戳
6. ts1 = pd.Timestamp('2023-01-15')
7. print(ts1)
8. # 输出: 2023-01-15 00:00:00
10. # 使用更详细的字符串
11. ts2 = pd.Timestamp('2023-01-15 14:30:25')
12. print(ts2)
13. # 输出: 2023-01-15 14:30:25
15. # 使用datetime对象
16. dt = datetime(2023, 1, 15, 14, 30, 25)
17. ts3 = pd.Timestamp(dt)
18. print(ts3)
19. # 输出: 2023-01-15 14:30:25
21. # 使用Unix时间戳（秒）
22. ts4 = pd.Timestamp(1673775025)
23. print(ts4)
24. # 输出: 2023-01-15 14:30:25
26. # 使用参数创建
27. ts5 = pd.Timestamp(year=2023, month=1, day=15, hour=14, minute=30, second=25)
28. print(ts5)
29. # 输出: 2023-01-15 14:30:25

复制代码

获取当前时间戳

2. # 获取当前时间戳
3. now = pd.Timestamp.now()
4. print(now)
5. # 输出类似: 2023-11-05 10:30:45.123456
7. # 获取当前日期（时间为00:00:00）
8. today = pd.Timestamp.today()
9. print(today)
10. # 输出类似: 2023-11-05 00:00:00

复制代码

时间戳的属性和方法

Pandas时间戳对象提供了丰富的属性和方法，方便我们访问和操作时间的各个组成部分。

访问时间组件

2. ts = pd.Timestamp('2023-01-15 14:30:25.123456')
4. # 获取年、月、日、时、分、秒
5. print(ts.year)      # 输出: 2023
6. print(ts.month)     # 输出: 1
7. print(ts.day)       # 输出: 15
8. print(ts.hour)      # 输出: 14
9. print(ts.minute)    # 输出: 30
10. print(ts.second)    # 输出: 25
11. print(ts.microsecond)  # 输出: 123456
12. print(ts.nanosecond)   # 输出: 123456000
14. # 获取星期几（0=周一，6=周日）
15. print(ts.dayofweek)  # 输出: 6 (周日)
16. print(ts.day_name()) # 输出: Sunday
18. # 获取一年中的第几天
19. print(ts.dayofyear)  # 输出: 15
21. # 获取季度
22. print(ts.quarter)    # 输出: 1
24. # 获取是否为月末
25. print(ts.is_month_end)  # 输出: False
27. # 获取是否为季末
28. print(ts.is_quarter_end)  # 输出: False
30. # 获取是否为年末
31. print(ts.is_year_end)  # 输出: False

复制代码

时间戳的格式化输出

2. ts = pd.Timestamp('2023-01-15 14:30:25.123456')
4. # 使用strftime方法格式化输出
5. print(ts.strftime('%Y-%m-%d %H:%M:%S'))  # 输出: 2023-01-15 14:30:25
6. print(ts.strftime('%A, %B %d, %Y'))     # 输出: Sunday, January 15, 2023
7. print(ts.strftime('%Y年%m月%d日 %H时%M分%S秒'))  # 输出: 2023年01月15日 14时30分25秒
9. # 使用isoformat方法获取ISO格式
10. print(ts.isoformat())  # 输出: 2023-01-15T14:30:25.123456

复制代码

时间序列的创建和操作

创建时间序列

2. # 使用date_range创建日期范围
3. dates = pd.date_range(start='2023-01-01', end='2023-01-10')
4. print(dates)
5. """
6. 输出:
7. DatetimeIndex(['2023-01-01', '2023-01-02', '2023-01-03', '2023-01-04',
8.                '2023-01-05', '2023-01-06', '2023-01-07', '2023-01-08',
9.                '2023-01-09', '2023-01-10'],
10.               dtype='datetime64[ns]', freq='D')
11. """
13. # 指定频率
14. dates_hourly = pd.date_range(start='2023-01-01', periods=24, freq='H')
15. print(dates_hourly)
16. """
17. 输出:
18. DatetimeIndex(['2023-01-01 00:00:00', '2023-01-01 01:00:00',
19.                '2023-01-01 02:00:00', '2023-01-01 03:00:00',
20.                '2023-01-01 04:00:00', '2023-01-01 05:00:00',
21.                '2023-01-01 06:00:00', '2023-01-01 07:00:00',
22.                '2023-01-01 08:00:00', '2023-01-01 09:00:00',
23.                '2023-01-01 10:00:00', '2023-01-01 11:00:00',
24.                '2023-01-01 12:00:00', '2023-01-01 13:00:00',
25.                '2023-01-01 14:00:00', '2023-01-01 15:00:00',
26.                '2023-01-01 16:00:00', '2023-01-01 17:00:00',
27.                '2023-01-01 18:00:00', '2023-01-01 19:00:00',
28.                '2023-01-01 20:00:00', '2023-01-01 21:00:00',
29.                '2023-01-01 22:00:00', '2023-01-01 23:00:00'],
30.               dtype='datetime64[ns]', freq='H')
31. """
33. # 创建带时间戳的Series
34. import numpy as np
35. ts_series = pd.Series(np.random.randn(10), index=pd.date_range('2023-01-01', periods=10, freq='D'))
36. print(ts_series)
37. """
38. 输出:
39. 2023-01-01    0.469112
40. 2023-01-02   -0.282863
41. 2023-01-03   -1.509059
42. 2023-01-04   -1.135632
43. 2023-01-05    1.212112
44. 2023-01-06   -0.173215
45. 2023-01-07    0.119209
46. 2023-01-08   -1.044236
47. 2023-01-09   -0.861849
48. 2023-01-10   -2.104569
49. Freq: D, dtype: float64
50. """

复制代码

时间序列的索引和切片

2. # 创建时间序列数据
3. dates = pd.date_range('2023-01-01', periods=100, freq='D')
4. ts = pd.Series(np.random.randn(100), index=dates)
6. # 通过日期字符串索引
7. print(ts['2023-01-15'])  # 获取特定日期的值
9. # 切片操作
10. print(ts['2023-01-15':'2023-01-20'])  # 获取日期范围内的值
12. # 使用年份和月份索引
13. print(ts['2023-01'])  # 获取2023年1月的所有数据
14. print(ts['2023'])     # 获取2023年的所有数据
16. # 使用truncate方法截取时间范围
17. print(ts.truncate(before='2023-01-15', after='2023-01-20'))

复制代码

时间戳的计算和比较

时间差计算

2. # 创建两个时间戳
3. ts1 = pd.Timestamp('2023-01-15')
4. ts2 = pd.Timestamp('2023-02-20')
6. # 计算时间差
7. delta = ts2 - ts1
8. print(delta)
9. # 输出: 36 days 00:00:00
11. # 时间差的天数和秒数
12. print(delta.days)      # 输出: 36
13. print(delta.seconds)   # 输出: 0
15. # 创建Timedelta对象
16. td = pd.Timedelta(days=5, hours=3, minutes=30)
17. print(td)
18. # 输出: 5 days 03:30:00
20. # 时间戳加减时间差
21. ts3 = ts1 + td
22. print(ts3)
23. # 输出: 2023-01-20 03:30:00
25. ts4 = ts2 - td
26. print(ts4)
27. # 输出: 2023-02-14 20:30:00

复制代码

时间戳的比较

2. # 创建时间戳列表
3. timestamps = [
4.     pd.Timestamp('2023-01-15'),
5.     pd.Timestamp('2023-02-20'),
6.     pd.Timestamp('2023-03-10'),
7.     pd.Timestamp('2022-12-25')
8. ]
10. # 找出最早和最晚的时间戳
11. print(min(timestamps))  # 输出: 2022-12-25 00:00:00
12. print(max(timestamps))  # 输出: 2023-03-10 00:00:00
14. # 排序时间戳
15. sorted_ts = sorted(timestamps)
16. print(sorted_ts)
17. """
18. 输出:
19. [Timestamp('2022-12-25 00:00:00'),
20. Timestamp('2023-01-15 00:00:00'),
21. Timestamp('2023-02-20 00:00:00'),
22. Timestamp('2023-03-10 00:00:00')]
23. """
25. # 比较时间戳
26. ts1 = pd.Timestamp('2023-01-15')
27. ts2 = pd.Timestamp('2023-02-20')
29. print(ts1 < ts2)  # 输出: True
30. print(ts1 > ts2)  # 输出: False
31. print(ts1 == ts1) # 输出: True

复制代码

时区处理

时区感知时间戳

2. # 创建时区感知时间戳
3. ts_utc = pd.Timestamp('2023-01-15 14:30:25', tz='UTC')
4. print(ts_utc)
5. # 输出: 2023-01-15 14:30:25+00:00
7. # 创建带有时区的时间戳
8. ts_ny = pd.Timestamp('2023-01-15 14:30:25', tz='America/New_York')
9. print(ts_ny)
10. # 输出: 2023-01-15 14:30:25-05:00
12. # 获取时区信息
13. print(ts_utc.tz)  # 输出: UTC
14. print(ts_ny.tz)   # 输出: America/New_York

复制代码

时区转换

2. # 创建UTC时间戳
3. ts_utc = pd.Timestamp('2023-01-15 14:30:25', tz='UTC')
5. # 转换为其他时区
6. ts_ny = ts_utc.tz_convert('America/New_York')
7. print(ts_ny)
8. # 输出: 2023-01-15 09:30:25-05:00
10. ts_tokyo = ts_utc.tz_convert('Asia/Tokyo')
11. print(ts_tokyo)
12. # 输出: 2023-01-15 23:30:25+09:00
14. # 本地化无时区时间戳
15. ts_naive = pd.Timestamp('2023-01-15 14:30:25')
16. ts_localized = ts_naive.tz_localize('UTC')
17. print(ts_localized)
18. # 输出: 2023-01-15 14:30:25+00:00
20. # 去除时区信息
21. ts_naive_again = ts_localized.tz_convert(None)
22. print(ts_naive_again)
23. # 输出: 2023-01-15 14:30:25

复制代码

处理夏令时

2. # 创建一个跨越夏令时变化的时间范围
3. dates = pd.date_range('2023-03-11', '2023-03-13', tz='America/New_York', freq='H')
4. print(dates)
5. """
6. 输出:
7. DatetimeIndex(['2023-03-11 00:00:00-05:00', '2023-03-11 01:00:00-05:00',
8.                '2023-03-11 03:00:00-04:00', '2023-03-11 04:00:00-04:00',
9.                '2023-03-11 05:00:00-04:00', '2023-03-11 06:00:00-04:00',
10.                '2023-03-11 07:00:00-04:00', '2023-03-11 08:00:00-04:00',
11.                '2023-03-11 09:00:00-04:00', '2023-03-11 10:00:00-04:00',
12.                '2023-03-11 11:00:00-04:00', '2023-03-11 12:00:00-04:00',
13.                '2023-03-11 13:00:00-04:00', '2023-03-11 14:00:00-04:00',
14.                '2023-03-11 15:00:00-04:00', '2023-03-11 16:00:00-04:00',
15.                '2023-03-11 17:00:00-04:00', '2023-03-11 18:00:00-04:00',
16.                '2023-03-11 19:00:00-04:00', '2023-03-11 20:00:00-04:00',
17.                '2023-03-11 21:00:00-04:00', '2023-03-11 22:00:00-04:00',
18.                '2023-03-11 23:00:00-04:00', '2023-03-12 00:00:00-04:00',
19.                '2023-03-12 01:00:00-04:00', '2023-03-12 02:00:00-04:00',
20.                '2023-03-12 03:00:00-04:00', '2023-03-12 04:00:00-04:00',
21.                '2023-03-12 05:00:00-04:00', '2023-03-12 06:00:00-04:00',
22.                '2023-03-12 07:00:00-04:00', '2023-03-12 08:00:00-04:00',
23.                '2023-03-12 09:00:00-04:00', '2023-03-12 10:00:00-04:00',
24.                '2023-03-12 11:00:00-04:00', '2023-03-12 12:00:00-04:00',
25.                '2023-03-12 13:00:00-04:00', '2023-03-12 14:00:00-04:00',
26.                '2023-03-12 15:00:00-04:00', '2023-03-12 16:00:00-04:00',
27.                '2023-03-12 17:00:00-04:00', '2023-03-12 18:00:00-04:00',
28.                '2023-03-12 19:00:00-04:00', '2023-03-12 20:00:00-04:00',
29.                '2023-03-12 21:00:00-04:00', '2023-03-12 22:00:00-04:00',
30.                '2023-03-12 23:00:00-04:00', '2023-03-13 00:00:00-04:00',
31.                '2023-03-13 01:00:00-04:00', '2023-03-13 02:00:00-04:00',
32.                '2023-03-13 03:00:00-04:00', '2023-03-13 04:00:00-04:00',
33.                '2023-03-13 05:00:00-04:00', '2023-03-13 06:00:00-04:00',
34.                '2023-03-13 07:00:00-04:00', '2023-03-13 08:00:00-04:00'],
35.               dtype='datetime64[ns, America/New_York]', freq='H')
36. """
38. # 注意：在2023-03-11 02:00:00，时钟从01:59:59直接跳到03:00:00（夏令时开始）

复制代码

时间重采样和频率转换

降采样（将高频数据转换为低频数据）

2. # 创建高频时间序列数据
3. dates = pd.date_range('2023-01-01', periods=1000, freq='H')
4. ts = pd.Series(np.random.randn(1000), index=dates)
6. # 降采样为日数据，计算每日平均值
7. daily_mean = ts.resample('D').mean()
8. print(daily_mean.head())
10. # 降采样为周数据，计算每周总和
11. weekly_sum = ts.resample('W').sum()
12. print(weekly_sum.head())
14. # 降采样为月数据，计算每月最大值
15. monthly_max = ts.resample('M').max()
16. print(monthly_max.head())
18. # 使用OHLC（开高低收）重采样
19. ohlc = ts.resample('D').ohlc()
20. print(ohlc.head())

复制代码

升采样（将低频数据转换为高频数据）

2. # 创建低频时间序列数据
3. dates = pd.date_range('2023-01-01', periods=10, freq='D')
4. ts = pd.Series(np.random.randn(10), index=dates)
6. # 升采样为小时数据，使用前向填充
7. hourly_ffill = ts.resample('H').ffill()
8. print(hourly_ffill.head(24))
10. # 升采样为小时数据，使用后向填充
11. hourly_bfill = ts.resample('H').bfill()
12. print(hourly_bfill.head(24))
14. # 升采样为小时数据，使用插值
15. hourly_interpolate = ts.resample('H').interpolate()
16. print(hourly_interpolate.head(24))

复制代码

自定义重采样规则

2. # 创建时间序列数据
3. dates = pd.date_range('2023-01-01', periods=100, freq='D')
4. ts = pd.Series(np.random.randn(100), index=dates)
6. # 每3天重采样一次
7. three_day_mean = ts.resample('3D').mean()
8. print(three_day_mean.head())
10. # 每周周一重采样
11. weekly_monday = ts.resample('W-MON').sum()
12. print(weekly_monday.head())
14. # 每月15号重采样
15. monthly_15th = ts.resample('MS').sum()  # MS表示月初
16. print(monthly_15th.head())
18. # 使用自定义函数进行重采样
19. custom_resample = ts.resample('M').apply(lambda x: x.max() - x.min())
20. print(custom_resample.head())

复制代码

时间窗口操作

滚动窗口计算

2. # 创建时间序列数据
3. dates = pd.date_range('2023-01-01', periods=100, freq='D')
4. ts = pd.Series(np.random.randn(100), index=dates)
6. # 计算3天滚动平均值
7. rolling_mean_3d = ts.rolling(window=3).mean()
8. print(rolling_mean_3d.head())
10. # 计算7天滚动标准差
11. rolling_std_7d = ts.rolling(window=7).std()
12. print(rolling_std_7d.head())
14. # 计算30天滚动最大值
15. rolling_max_30d = ts.rolling(window=30).max()
16. print(rolling_max_30d.head())
18. # 计算滚动相关系数
19. ts2 = pd.Series(np.random.randn(100), index=dates)
20. rolling_corr = ts.rolling(window=10).corr(ts2)
21. print(rolling_corr.head())

复制代码

扩展窗口计算

2. # 创建时间序列数据
3. dates = pd.date_range('2023-01-01', periods=100, freq='D')
4. ts = pd.Series(np.random.randn(100), index=dates)
6. # 计算扩展窗口平均值（从开始到当前点的所有数据）
7. expanding_mean = ts.expanding().mean()
8. print(expanding_mean.head())
10. # 计算扩展窗口最大值
11. expanding_max = ts.expanding().max()
12. print(expanding_max.head())
14. # 计算扩展窗口累积和
15. expanding_sum = ts.expanding().sum()
16. print(expanding_sum.head())

复制代码

指数加权窗口

2. # 创建时间序列数据
3. dates = pd.date_range('2023-01-01', periods=100, freq='D')
4. ts = pd.Series(np.random.randn(100), index=dates)
6. # 计算指数加权移动平均（span=10）
7. ewm_span = ts.ewm(span=10).mean()
8. print(ewm_span.head())
10. # 计算指数加权移动平均（halflife=5）
11. ewm_halflife = ts.ewm(halflife=5).mean()
12. print(ewm_halflife.head())
14. # 计算指数加权移动标准差
15. ewm_std = ts.ewm(span=10).std()
16. print(ewm_std.head())

复制代码

时间戳与字符串的转换

将字符串解析为时间戳

2. # 使用to_datetime将字符串转换为时间戳
3. date_str = '2023-01-15'
4. ts = pd.to_datetime(date_str)
5. print(ts)
6. # 输出: 2023-01-15 00:00:00
8. # 解析不同格式的日期字符串
9. date_str1 = '15/01/2023'
10. date_str2 = 'January 15, 2023'
11. date_str3 = '20230115'
13. ts1 = pd.to_datetime(date_str1, format='%d/%m/%Y')
14. ts2 = pd.to_datetime(date_str2)
15. ts3 = pd.to_datetime(date_str3, format='%Y%m%d')
17. print(ts1)  # 输出: 2023-01-15 00:00:00
18. print(ts2)  # 输出: 2023-01-15 00:00:00
19. print(ts3)  # 输出: 2023-01-15 00:00:00
21. # 批量转换字符串列表
22. date_strings = ['2023-01-01', '2023-01-02', '2023-01-03', '2023-01-04']
23. timestamps = pd.to_datetime(date_strings)
24. print(timestamps)
25. """
26. 输出:
27. DatetimeIndex(['2023-01-01', '2023-01-02', '2023-01-03', '2023-01-04'], dtype='datetime64[ns]', freq=None)
28. """
30. # 处理无效日期
31. invalid_dates = ['2023-01-01', '2023-02-30', '2023-03-01']  # 2月没有30号
32. # 使用errors='coerce'将无效日期转换为NaT
33. valid_dates = pd.to_datetime(invalid_dates, errors='coerce')
34. print(valid_dates)
35. """
36. 输出:
37. DatetimeIndex(['2023-01-01', 'NaT', '2023-03-01'], dtype='datetime64[ns]', freq=None)
38. """

复制代码

将时间戳格式化为字符串

2. # 创建时间戳
3. ts = pd.Timestamp('2023-01-15 14:30:25')
5. # 使用strftime方法格式化
6. date_str = ts.strftime('%Y-%m-%d %H:%M:%S')
7. print(date_str)
8. # 输出: 2023-01-15 14:30:25
10. # 批量格式化时间戳
11. timestamps = pd.date_range('2023-01-01', periods=5, freq='D')
12. date_strings = timestamps.strftime('%Y/%m/%d')
13. print(date_strings)
14. """
15. 输出:
16. Index(['2023/01/01', '2023/01/02', '2023/01/03', '2023/01/04', '2023/01/05'], dtype='object')
17. """
19. # 在DataFrame中格式化日期
20. df = pd.DataFrame({
21.     'date': pd.date_range('2023-01-01', periods=5, freq='D'),
22.     'value': [1, 2, 3, 4, 5]
23. })
25. # 添加格式化后的日期字符串列
26. df['date_str'] = df['date'].dt.strftime('%Y年%m月%d日')
27. print(df)
28. """
29. 输出:
30.         date  value      date_str
31. 0 2023-01-01      1  2023年01月01日
32. 1 2023-01-02      2  2023年01月02日
33. 2 2023-01-03      3  2023年01月03日
34. 3 2023-01-04      4  2023年01月04日
35. 4 2023-01-05      5  2023年01月05日
36. """

复制代码

实际应用案例

案例1：股票数据分析

2. import pandas as pd
3. import numpy as np
4. import matplotlib.pyplot as plt
6. # 创建模拟股票数据
7. np.random.seed(42)
8. date_rng = pd.date_range(start='2022-01-01', end='2022-12-31', freq='D')
9. prices = np.cumsum(np.random.randn(len(date_rng)) * 0.5 + 100)
10. volumes = np.random.randint(10000, 100000, size=len(date_rng))
12. # 创建DataFrame
13. stock_df = pd.DataFrame({
14.     'date': date_rng,
15.     'price': prices,
16.     'volume': volumes
17. }).set_index('date')
19. # 只保留工作日的数据
20. stock_df = stock_df[stock_df.index.dayofweek < 5]
22. print(stock_df.head())
24. # 计算移动平均
25. stock_df['ma_5'] = stock_df['price'].rolling(window=5).mean()
26. stock_df['ma_20'] = stock_df['price'].rolling(window=20).mean()
27. stock_df['ma_60'] = stock_df['price'].rolling(window=60).mean()
29. # 计算日收益率
30. stock_df['daily_return'] = stock_df['price'].pct_change()
32. # 计算波动率（20日滚动标准差）
33. stock_df['volatility'] = stock_df['daily_return'].rolling(window=20).std() * np.sqrt(252)
35. # 绘制价格和移动平均线
36. plt.figure(figsize=(12, 6))
37. plt.plot(stock_df.index, stock_df['price'], label='Price')
38. plt.plot(stock_df.index, stock_df['ma_5'], label='MA 5')
39. plt.plot(stock_df.index, stock_df['ma_20'], label='MA 20')
40. plt.plot(stock_df.index, stock_df['ma_60'], label='MA 60')
41. plt.title('Stock Price with Moving Averages')
42. plt.xlabel('Date')
43. plt.ylabel('Price')
44. plt.legend()
45. plt.grid(True)
46. plt.show()
48. # 绘制波动率
49. plt.figure(figsize=(12, 6))
50. plt.plot(stock_df.index, stock_df['volatility'])
51. plt.title('Stock Volatility (20-day rolling annualized)')
52. plt.xlabel('Date')
53. plt.ylabel('Volatility')
54. plt.grid(True)
55. plt.show()
57. # 按月重采样数据
58. monthly_data = stock_df.resample('M').agg({
59.     'price': 'last',
60.     'volume': 'sum',
61.     'daily_return': 'mean',
62.     'volatility': 'mean'
63. })
65. print(monthly_data.head())

复制代码

案例2：网站流量分析

2. import pandas as pd
3. import numpy as np
4. import matplotlib.pyplot as plt
6. # 创建模拟网站访问数据
7. np.random.seed(42)
8. date_rng = pd.date_range(start='2023-01-01', end='2023-01-31', freq='H')
9. visitors = np.random.randint(50, 500, size=len(date_rng))
11. # 添加周末效应（周末访问量更高）
12. weekend_effect = np.where(date_rng.dayofweek >= 5, 1.5, 1.0)
13. visitors = (visitors * weekend_effect).astype(int)
15. # 添加日内效应（白天访问量更高）
16. hour_effect = np.sin(np.pi * (date_rng.hour - 6) / 12) * 0.5 + 1.0
17. hour_effect = np.where(hour_effect < 0.5, 0.5, hour_effect)
18. visitors = (visitors * hour_effect).astype(int)
20. # 创建DataFrame
21. traffic_df = pd.DataFrame({
22.     'datetime': date_rng,
23.     'visitors': visitors
24. }).set_index('datetime')
26. print(traffic_df.head())
28. # 按天重采样
29. daily_traffic = traffic_df.resample('D').sum()
30. print(daily_traffic.head())
32. # 按周重采样
33. weekly_traffic = traffic_df.resample('W').sum()
34. print(weekly_traffic.head())
36. # 按小时分析平均访问量
37. hourly_pattern = traffic_df.groupby(traffic_df.index.hour).mean()
38. print(hourly_pattern.head())
40. # 绘制每日访问量
41. plt.figure(figsize=(12, 6))
42. daily_traffic['visitors'].plot()
43. plt.title('Daily Website Traffic')
44. plt.xlabel('Date')
45. plt.ylabel('Visitors')
46. plt.grid(True)
47. plt.show()
49. # 绘制小时访问模式
50. plt.figure(figsize=(12, 6))
51. hourly_pattern['visitors'].plot()
52. plt.title('Average Hourly Traffic Pattern')
53. plt.xlabel('Hour of Day')
54. plt.ylabel('Average Visitors')
55. plt.grid(True)
56. plt.xticks(range(24))
57. plt.show()
59. # 检测异常访问量（使用Z-score）
60. daily_traffic['z_score'] = (daily_traffic['visitors'] - daily_traffic['visitors'].mean()) / daily_traffic['visitors'].std()
61. anomalies = daily_traffic[abs(daily_traffic['z_score']) > 2]
62. print("Anomalous days:")
63. print(anomalies)
65. # 绘制异常访问量
66. plt.figure(figsize=(12, 6))
67. daily_traffic['visitors'].plot(label='Daily Visitors')
68. plt.scatter(anomalies.index, anomalies['visitors'], color='red', label='Anomalies')
69. plt.title('Daily Website Traffic with Anomalies')
70. plt.xlabel('Date')
71. plt.ylabel('Visitors')
72. plt.legend()
73. plt.grid(True)
74. plt.show()

复制代码

案例3：传感器数据分析

2. import pandas as pd
3. import numpy as np
4. import matplotlib.pyplot as plt
6. # 创建模拟传感器数据
7. np.random.seed(42)
8. date_rng = pd.date_range(start='2023-01-01', periods=1440, freq='min')  # 24小时的数据
9. temperature = 20 + 5 * np.sin(2 * np.pi * np.arange(1440) / (24 * 60)) + np.random.normal(0, 0.5, 1440)
10. humidity = 50 + 20 * np.sin(2 * np.pi * np.arange(1440) / (24 * 60) + np.pi/4) + np.random.normal(0, 2, 1440)
12. # 创建DataFrame
13. sensor_df = pd.DataFrame({
14.     'timestamp': date_rng,
15.     'temperature': temperature,
16.     'humidity': humidity
17. }).set_index('timestamp')
19. print(sensor_df.head())
21. # 检测并处理异常值
22. def detect_outliers(series, window=10, sigma=3):
23.     rolling_mean = series.rolling(window=window).mean()
24.     rolling_std = series.rolling(window=window).std()
25.     z_scores = (series - rolling_mean) / rolling_std
26.     return np.abs(z_scores) > sigma
28. # 标记异常值
29. sensor_df['temp_outlier'] = detect_outliers(sensor_df['temperature'])
30. sensor_df['humidity_outlier'] = detect_outliers(sensor_df['humidity'])
32. # 替换异常值为滚动平均值
33. sensor_df.loc[sensor_df['temp_outlier'], 'temperature'] = sensor_df['temperature'].rolling(window=10).mean()
34. sensor_df.loc[sensor_df['humidity_outlier'], 'humidity'] = sensor_df['humidity'].rolling(window=10).mean()
36. # 按小时重采样
37. hourly_data = sensor_df.resample('H').agg({
38.     'temperature': ['mean', 'min', 'max'],
39.     'humidity': ['mean', 'min', 'max']
40. })
41. print(hourly_data.head())
43. # 计算温湿度相关性
44. correlation = sensor_df['temperature'].corr(sensor_df['humidity'])
45. print(f"Temperature-Humidity Correlation: {correlation:.2f}")
47. # 绘制温度数据
48. plt.figure(figsize=(12, 6))
49. sensor_df['temperature'].plot(label='Temperature')
50. plt.scatter(sensor_df[sensor_df['temp_outlier']].index,
51.             sensor_df[sensor_df['temp_outlier']]['temperature'],
52.             color='red', label='Outliers')
53. plt.title('Temperature Readings with Outliers')
54. plt.xlabel('Time')
55. plt.ylabel('Temperature (°C)')
56. plt.legend()
57. plt.grid(True)
58. plt.show()
60. # 绘制湿度数据
61. plt.figure(figsize=(12, 6))
62. sensor_df['humidity'].plot(label='Humidity')
63. plt.scatter(sensor_df[sensor_df['humidity_outlier']].index,
64.             sensor_df[sensor_df['humidity_outlier']]['humidity'],
65.             color='red', label='Outliers')
66. plt.title('Humidity Readings with Outliers')
67. plt.xlabel('Time')
68. plt.ylabel('Humidity (%)')
69. plt.legend()
70. plt.grid(True)
71. plt.show()
73. # 绘制温湿度散点图
74. plt.figure(figsize=(10, 6))
75. plt.scatter(sensor_df['temperature'], sensor_df['humidity'], alpha=0.5)
76. plt.title('Temperature vs Humidity')
77. plt.xlabel('Temperature (°C)')
78. plt.ylabel('Humidity (%)')
79. plt.grid(True)
80. plt.show()

复制代码

性能优化技巧

使用适当的数据类型

2. import pandas as pd
3. import numpy as np
5. # 创建大数据集
6. dates = pd.date_range('2000-01-01', periods=1000000, freq='H')
7. values = np.random.randn(1000000)
8. df = pd.DataFrame({'timestamp': dates, 'value': values})
10. # 检查内存使用
11. print(f"Memory usage with datetime64[ns]: {df.memory_usage(deep=True).sum() / 1024**2:.2f} MB")
13. # 如果时间戳精度不需要纳秒级别，可以转换为秒级精度
14. df['timestamp_sec'] = df['timestamp'].astype('datetime64[s]')
15. print(f"Memory usage with datetime64[s]: {df.memory_usage(deep=True).sum() / 1024**2:.2f} MB")
17. # 对于周期性数据，可以考虑使用周期数据类型
18. df['period'] = df['timestamp'].dt.to_period('H')
19. print(f"Memory usage with period: {df.memory_usage(deep=True).sum() / 1024**2:.2f} MB")

复制代码

使用向量化操作

2. import pandas as pd
3. import numpy as np
4. import time
6. # 创建大数据集
7. dates = pd.date_range('2000-01-01', periods=1000000, freq='H')
8. df = pd.DataFrame({'timestamp': dates, 'value': np.random.randn(1000000)})
10. # 方法1：使用循环提取小时信息（慢）
11. start_time = time.time()
12. hours_loop = []
13. for ts in df['timestamp']:
14.     hours_loop.append(ts.hour)
15. print(f"Loop method: {time.time() - start_time:.4f} seconds")
17. # 方法2：使用向量化操作（快）
18. start_time = time.time()
19. hours_vectorized = df['timestamp'].dt.hour
20. print(f"Vectorized method: {time.time() - start_time:.4f} seconds")
22. # 验证结果是否相同
23. print(f"Results are equal: {np.array_equal(hours_loop, hours_vectorized)}")

复制代码

使用分类数据类型处理重复时间戳

2. import pandas as pd
3. import numpy as np
5. # 创建带有重复时间戳的数据集
6. dates = pd.date_range('2000-01-01', periods=1000, freq='D')
7. repeated_dates = np.random.choice(dates, 100000)
8. df = pd.DataFrame({'timestamp': repeated_dates, 'value': np.random.randn(100000)})
10. # 检查内存使用
11. print(f"Memory usage before converting to category: {df.memory_usage(deep=True).sum() / 1024**2:.2f} MB")
13. # 将时间戳转换为分类类型
14. df['timestamp_cat'] = df['timestamp'].astype('category')
15. print(f"Memory usage after converting to category: {df.memory_usage(deep=True).sum() / 1024**2:.2f} MB")

复制代码

使用高效的时间范围查询

2. import pandas as pd
3. import numpy as np
4. import time
6. # 创建大数据集
7. dates = pd.date_range('2000-01-01', periods=1000000, freq='H')
8. df = pd.DataFrame({'timestamp': dates, 'value': np.random.randn(1000000)}).set_index('timestamp')
10. # 方法1：使用布尔索引（慢）
11. start_time = time.time()
12. result1 = df.loc[(df.index >= '2005-01-01') & (df.index <= '2005-01-31')]
13. print(f"Boolean indexing method: {time.time() - start_time:.4f} seconds")
15. # 方法2：使用切片（快）
16. start_time = time.time()
17. result2 = df.loc['2005-01-01':'2005-01-31']
18. print(f"Slicing method: {time.time() - start_time:.4f} seconds")
20. # 验证结果是否相同
21. print(f"Results are equal: {result1.equals(result2)}")

复制代码

使用并行处理加速时间序列操作

2. import pandas as pd
3. import numpy as np
4. from multiprocessing import Pool, cpu_count
5. import time
7. # 创建大数据集
8. dates = pd.date_range('2000-01-01', periods=1000000, freq='H')
9. df = pd.DataFrame({'timestamp': dates, 'value': np.random.randn(1000000)})
11. # 定义一个处理函数
12. def process_chunk(chunk):
13.     chunk['hour'] = chunk['timestamp'].dt.hour
14.     chunk['day_of_week'] = chunk['timestamp'].dt.dayofweek
15.     chunk['rolling_mean'] = chunk['value'].rolling(window=24).mean()
16.     return chunk
18. # 方法1：顺序处理
19. start_time = time.time()
20. result_sequential = process_chunk(df)
21. print(f"Sequential processing: {time.time() - start_time:.4f} seconds")
23. # 方法2：并行处理
24. def parallel_processing(df, n_chunks=4):
25.     chunks = np.array_split(df, n_chunks)
26.    
27.     with Pool(cpu_count()) as pool:
28.         results = pool.map(process_chunk, chunks)
29.    
30.     return pd.concat(results)
32. start_time = time.time()
33. result_parallel = parallel_processing(df)
34. print(f"Parallel processing: {time.time() - start_time:.4f} seconds")
36. # 验证结果是否相同
37. print(f"Results are equal: {result_sequential.equals(result_parallel)}")

复制代码

总结与进阶学习资源

本文详细介绍了Pandas时间戳的基础知识和高级应用技巧，包括时间戳的创建、属性访问、时间序列操作、时区处理、时间重采样、窗口操作以及时间戳与字符串的转换等内容。通过实际案例，我们展示了如何将这些技巧应用于股票数据分析、网站流量分析和传感器数据分析等场景。最后，我们还分享了一些性能优化技巧，帮助你在处理大规模时间数据时提高效率。

要进一步提升你的时间数据处理能力，以下是一些推荐的学习资源：

1. 官方文档：Pandas时间序列/日期功能文档：https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.htmlPandas时间戳API参考：https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.Timestamp.html
2. Pandas时间序列/日期功能文档：https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html
3. Pandas时间戳API参考：https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.Timestamp.html
4. 书籍：《Python for Data Analysis》by Wes McKinney (Pandas的创始人)《Pandas Cookbook》by Theodore Petrou《Mastering Pandas》by Femi Anthony
5. 《Python for Data Analysis》by Wes McKinney (Pandas的创始人)
6. 《Pandas Cookbook》by Theodore Petrou
7. 《Mastering Pandas》by Femi Anthony
8. 在线课程：DataCamp的”Pandas Time Series Analysis”课程Coursera的”Applied Data Science with Python”系列课程Udemy的”Pandas for Data Analysis”课程
9. DataCamp的”Pandas Time Series Analysis”课程
10. Coursera的”Applied Data Science with Python”系列课程
11. Udemy的”Pandas for Data Analysis”课程
12. 博客和教程：Real Python上的”Pandas Time Series Examples”教程Towards Data Science上的时间序列分析文章Machine Learning Mastery上的时间序列预测教程
13. Real Python上的”Pandas Time Series Examples”教程
14. Towards Data Science上的时间序列分析文章
15. Machine Learning Mastery上的时间序列预测教程
16. 实践项目：尝试分析真实的时间序列数据集，如Kaggle上的股票价格、天气数据或网站流量数据构建一个时间序列预测模型，如ARIMA、Prophet或LSTM创建一个交互式的时间序列可视化仪表板
17. 尝试分析真实的时间序列数据集，如Kaggle上的股票价格、天气数据或网站流量数据
18. 构建一个时间序列预测模型，如ARIMA、Prophet或LSTM
19. 创建一个交互式的时间序列可视化仪表板

官方文档：

• Pandas时间序列/日期功能文档：https://pandas.pydata.org/pandas-docs/stable/user_guide/timeseries.html
• Pandas时间戳API参考：https://pandas.pydata.org/pandas-docs/stable/reference/api/pandas.Timestamp.html

书籍：

• 《Python for Data Analysis》by Wes McKinney (Pandas的创始人)
• 《Pandas Cookbook》by Theodore Petrou
• 《Mastering Pandas》by Femi Anthony

在线课程：

• DataCamp的”Pandas Time Series Analysis”课程
• Coursera的”Applied Data Science with Python”系列课程
• Udemy的”Pandas for Data Analysis”课程

博客和教程：

• Real Python上的”Pandas Time Series Examples”教程
• Towards Data Science上的时间序列分析文章
• Machine Learning Mastery上的时间序列预测教程

实践项目：

• 尝试分析真实的时间序列数据集，如Kaggle上的股票价格、天气数据或网站流量数据
• 构建一个时间序列预测模型，如ARIMA、Prophet或LSTM
• 创建一个交互式的时间序列可视化仪表板

通过不断实践和学习，你将能够熟练掌握Pandas时间戳的各种技巧，并在数据分析项目中游刃有余地处理时间数据，提升你的数据分析能力。