深入解析Pandas时间函数 从基础时间戳创建到高级时间序列分析全面掌握数据处理时间技巧提升数据分析效率解决实际工作中的时间问题

威震华夏关云长

引言

在数据分析领域，时间序列数据是一种常见且重要的数据类型。无论是金融市场的股票价格、气象数据中的温度变化，还是网站访问量的日波动，时间序列数据都无处不在。Pandas作为Python数据分析的核心库，提供了强大而灵活的时间函数工具集，使我们能够高效地处理和分析时间序列数据。

本文将深入探讨Pandas中的时间函数，从基础的时间戳创建到高级的时间序列分析技术，帮助读者全面掌握数据处理中的时间技巧，提升数据分析效率，并解决实际工作中遇到的时间相关问题。

基础时间戳创建

什么是时间戳

在Pandas中，Timestamp对象是时间数据的基本单位，它表示一个特定的时间点。Timestamp是Python标准库中datetime.datetime的子类，但提供了更多的功能和更好的性能。

创建时间戳

最简单的创建时间戳的方法是使用字符串：

2. import pandas as pd
4. # 从字符串创建时间戳
5. ts1 = pd.Timestamp('2023-01-01')
6. print(ts1)  # 输出: 2023-01-01 00:00:00
8. ts2 = pd.Timestamp('2023/01/01 10:30:45')
9. print(ts2)  # 输出: 2023-01-01 10:30:45
11. ts3 = pd.Timestamp('Jan 01, 2023')
12. print(ts3)  # 输出: 2023-01-01 00:00:00

复制代码

也可以使用数值（Unix时间戳）来创建时间戳：

2. # 使用Unix时间戳创建时间戳（秒）
3. ts4 = pd.Timestamp(1672531200)  # 2023-01-01 00:00:00的Unix时间戳
4. print(ts4)  # 输出: 2023-01-01 00:00:00
6. # 使用Unix时间戳创建时间戳（毫秒）
7. ts5 = pd.Timestamp(1672531200000, unit='ms')
8. print(ts5)  # 输出: 2023-01-01 00:00:00

复制代码

2. from datetime import datetime
4. # 使用datetime对象创建时间戳
5. dt = datetime(2023, 1, 1, 10, 30, 45)
6. ts6 = pd.Timestamp(dt)
7. print(ts6)  # 输出: 2023-01-01 10:30:45

复制代码

时间戳的属性和方法

Timestamp对象有许多有用的属性和方法：

2. ts = pd.Timestamp('2023-01-01 10:30:45')
4. # 基本属性
5. print(ts.year)       # 输出: 2023
6. print(ts.month)      # 输出: 1
7. print(ts.day)        # 输出: 1
8. print(ts.hour)       # 输出: 10
9. print(ts.minute)     # 输出: 30
10. print(ts.second)     # 输出: 45
12. # 星期相关
13. print(ts.dayofweek)  # 输出: 6 (星期日，0=星期一，6=星期日)
14. print(ts.day_name()) # 输出: Sunday
16. # 时间格式化
17. print(ts.strftime('%Y-%m-%d %H:%M:%S'))  # 输出: 2023-01-01 10:30:45
19. # 时间戳转换
20. print(ts.to_pydatetime())  # 转换为Python的datetime对象
21. print(ts.to_datetime64())  # 转换为numpy的datetime64对象

复制代码

时间索引和日期范围

创建日期范围

Pandas提供了date_range()函数，用于创建固定频率的日期范围：

2. # 创建日期范围
3. dates = pd.date_range('2023-01-01', '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 = pd.date_range('2023-01-01', periods=10, freq='D')  # 10天
15. print(dates)
17. dates = pd.date_range('2023-01-01', periods=5, freq='H')  # 5小时
18. print(dates)
20. dates = pd.date_range('2023-01-01', periods=5, freq='M')  # 5个月
21. print(dates)

复制代码

时间索引

使用日期范围作为索引创建Series或DataFrame：

2. # 创建带有时间索引的Series
3. dates = pd.date_range('2023-01-01', periods=10, freq='D')
4. ts = pd.Series(range(10), index=dates)
5. print(ts)
6. """
7. 输出:
8. 2023-01-01    0
9. 2023-01-02    1
10. 2023-01-03    2
11. 2023-01-04    3
12. 2023-01-05    4
13. 2023-01-06    5
14. 2023-01-07    6
15. 2023-01-08    7
16. 2023-01-09    8
17. 2023-01-10    9
18. Freq: D, dtype: int64
19. """
21. # 创建带有时间索引的DataFrame
22. df = pd.DataFrame({
23.     'value': range(10),
24.     'category': ['A', 'B', 'A', 'B', 'A', 'B', 'A', 'B', 'A', 'B']
25. }, index=dates)
26. print(df)
27. """
28. 输出:
29.             value category
30. 2023-01-01      0        A
31. 2023-01-02      1        B
32. 2023-01-03      2        A
33. 2023-01-04      3        B
34. 2023-01-05      4        A
35. 2023-01-06      5        B
36. 2023-01-07      6        A
37. 2023-01-08      7        B
38. 2023-01-09      8        A
39. 2023-01-10      9        B
40. """

复制代码

时间索引的操作

2. # 创建示例时间序列
3. dates = pd.date_range('2023-01-01', periods=30, freq='D')
4. ts = pd.Series(range(30), index=dates)
6. # 通过日期字符串索引
7. print(ts['2023-01-05'])  # 输出: 4
9. # 通过年份和月份索引
10. print(ts['2023-01'])  # 选择2023年1月的数据
12. # 切片
13. print(ts['2023-01-05':'2023-01-10'])
14. """
15. 输出:
16. 2023-01-05    4
17. 2023-01-06    5
18. 2023-01-07    6
19. 2023-01-08    7
20. 2023-01-09    8
21. 2023-01-10    9
22. Freq: D, dtype: int64
23. """

复制代码

2. # 创建示例时间序列
3. dates = pd.date_range('2023-01-01', periods=30, freq='D')
4. ts = pd.Series(range(30), index=dates)
6. # 时间索引的属性
7. print(ts.index.year)      # 获取年份
8. print(ts.index.month)     # 获取月份
9. print(ts.index.day)       # 获取日
10. print(ts.index.dayofweek) # 获取星期几 (0=星期一，6=星期日)
11. print(ts.index.day_name()) # 获取星期名称

复制代码

时间序列数据操作

时间序列的创建和转换

2. # 创建包含日期字符串的DataFrame
3. df = pd.DataFrame({
4.     'date': ['2023-01-01', '2023-01-02', '2023-01-03', '2023-01-04', '2023-01-05'],
5.     'value': [10, 20, 30, 40, 50]
6. })
8. # 将日期字符串转换为时间戳
9. df['date'] = pd.to_datetime(df['date'])
10. print(df.dtypes)
12. # 将日期列设置为索引
13. df = df.set_index('date')
14. print(df)
15. """
16. 输出:
17.             value
18. date            
19. 2023-01-01     10
20. 2023-01-02     20
21. 2023-01-03     30
22. 2023-01-04     40
23. 2023-01-05     50
24. """

复制代码

2. # 创建包含不同格式日期的DataFrame
3. df = pd.DataFrame({
4.     'date': ['01/01/2023', '2023-01-02', 'Jan 03, 2023', '20230104', '05-Jan-2023'],
5.     'value': [10, 20, 30, 40, 50]
6. })
8. # 转换日期
9. df['date'] = pd.to_datetime(df['date'], infer_datetime_format=True)
10. print(df)
11. """
12. 输出:
13.         date  value
14. 0 2023-01-01     10
15. 1 2023-01-02     20
16. 2 2023-01-03     30
17. 3 2023-01-04     40
18. 4 2023-01-05     50
19. """

复制代码

时间序列的移动和偏移

2. # 创建示例时间序列
3. dates = pd.date_range('2023-01-01', periods=5, freq='D')
4. ts = pd.Series(range(5), index=dates)
6. # 向前移动1天
7. print(ts.shift(1))
8. """
9. 输出:
10. 2023-01-01    NaN
11. 2023-01-02    0.0
12. 2023-01-03    1.0
13. 2023-01-04    2.0
14. 2023-01-05    3.0
15. Freq: D, dtype: float64
16. """
18. # 向后移动1天
19. print(ts.shift(-1))
20. """
21. 输出:
22. 2023-01-01    1.0
23. 2023-01-02    2.0
24. 2023-01-03    3.0
25. 2023-01-04    4.0
26. 2023-01-05    NaN
27. Freq: D, dtype: float64
28. """
30. # 使用时间频率进行移动
31. print(ts.shift(1, freq='D'))  # 向后移动1天
32. print(ts.shift(1, freq='W'))  # 向后移动1周

复制代码

2. # 创建示例时间序列
3. dates = pd.date_range('2023-01-01', periods=5, freq='D')
4. ts = pd.Series(range(5), index=dates)
6. # 计算时间差值
7. diff = ts.diff()
8. print(diff)
9. """
10. 输出:
11. 2023-01-01    NaN
12. 2023-01-02    1.0
13. 2023-01-03    1.0
14. 2023-01-04    1.0
15. 2023-01-05    1.0
16. Freq: D, dtype: float64
17. """
19. # 计算百分比变化
20. pct_change = ts.pct_change()
21. print(pct_change)
22. """
23. 输出:
24. 2023-01-01         NaN
25. 2023-01-02         inf
26. 2023-01-03    1.000000
27. 2023-01-04    0.500000
28. 2023-01-05    0.333333
29. Freq: D, dtype: float64
30. """

复制代码

时间序列的重采样和频率转换

重采样是指将时间序列从一个频率转换到另一个频率的过程。这包括降采样（从高频率到低频率，如从日到月）和升采样（从低频率到高频率，如从月到日）。

2. # 创建示例时间序列（日频率）
3. dates = pd.date_range('2023-01-01', periods=30, freq='D')
4. ts = pd.Series(range(30), index=dates)
6. # 降采样：从日到周，计算每周的平均值
7. weekly_mean = ts.resample('W').mean()
8. print(weekly_mean)
9. """
10. 输出:
11. 2023-01-01     3.0
12. 2023-01-08    10.5
13. 2023-01-15    17.5
14. 2023-01-22    24.5
15. 2023-01-29    28.0
16. Freq: W-SUN, dtype: float64
17. """
19. # 降采样：从日到月，计算每月的总和
20. monthly_sum = ts.resample('M').sum()
21. print(monthly_sum)
22. """
23. 输出:
24. 2023-01-31    435
25. Freq: M, dtype: int64
26. """
28. # 升采样：从日到小时，使用前向填充
29. hourly = ts.resample('H').ffill()
30. print(hourly.head(10))
31. """
32. 输出:
33. 2023-01-01 00:00:00    0
34. 2023-01-01 01:00:00    0
35. 2023-01-01 02:00:00    0
36. 2023-01-01 03:00:00    0
37. 2023-01-01 04:00:00    0
38. 2023-01-01 05:00:00    0
39. 2023-01-01 06:00:00    0
40. 2023-01-01 07:00:00    0
41. 2023-01-01 08:00:00    0
42. 2023-01-01 09:00:00    0
43. Freq: H, dtype: int64
44. """

复制代码

2. # 创建示例时间序列（日频率）
3. dates = pd.date_range('2023-01-01', periods=5, freq='D')
4. ts = pd.Series(range(5), index=dates)
6. # 转换为工作日频率
7. ts_business = ts.asfreq('B')
8. print(ts_business)
9. """
10. 输出:
11. 2023-01-02    1.0  # 2023-01-01是星期日，不是工作日
12. 2023-01-03    2.0
13. 2023-01-04    3.0
14. 2023-01-05    4.0
15. 2023-01-06    NaN
16. Freq: B, dtype: float64
17. """
19. # 转换为小时频率，使用前向填充
20. ts_hourly = ts.asfreq('H', method='ffill')
21. print(ts_hourly.head(10))
22. """
23. 输出:
24. 2023-01-01 00:00:00    0
25. 2023-01-01 01:00:00    0
26. 2023-01-01 02:00:00    0
27. 2023-01-01 03:00:00    0
28. 2023-01-01 04:00:00    0
29. 2023-01-01 05:00:00    0
30. 2023-01-01 06:00:00    0
31. 2023-01-01 07:00:00    0
32. 2023-01-01 08:00:00    0
33. 2023-01-01 09:00:00    0
34. Freq: H, dtype: int64
35. """

复制代码

时间窗口操作

滚动窗口

滚动窗口计算是指在一个固定大小的窗口上应用统计函数，然后沿着时间轴移动窗口。这对于计算移动平均值、移动标准差等非常有用。

2. # 创建示例时间序列
3. dates = pd.date_range('2023-01-01', periods=30, freq='D')
4. ts = pd.Series(range(30), index=dates)
6. # 计算滚动平均值（窗口大小为3）
7. rolling_mean = ts.rolling(window=3).mean()
8. print(rolling_mean.head(10))
9. """
10. 输出:
11. 2023-01-01    NaN
12. 2023-01-02    NaN
13. 2023-01-03    1.0
14. 2023-01-04    2.0
15. 2023-01-05    3.0
16. 2023-01-06    4.0
17. 2023-01-07    5.0
18. 2023-01-08    6.0
19. 2023-01-09    7.0
20. 2023-01-10    8.0
21. Freq: D, dtype: float64
22. """
24. # 计算滚动标准差（窗口大小为5）
25. rolling_std = ts.rolling(window=5).std()
26. print(rolling_std.head(10))
27. """
28. 输出:
29. 2023-01-01    NaN
30. 2023-01-02    NaN
31. 2023-01-03    NaN
32. 2023-01-04    NaN
33. 2023-01-05    1.581139
34. 2023-01-06    1.581139
35. 2023-01-07    1.581139
36. 2023-01-08    1.581139
37. 2023-01-09    1.581139
38. 2023-01-10    1.581139
39. Freq: D, dtype: float64
40. """
42. # 计算滚动最大值（窗口大小为7）
43. rolling_max = ts.rolling(window=7).max()
44. print(rolling_max.head(10))
45. """
46. 输出:
47. 2023-01-01    NaN
48. 2023-01-02    NaN
49. 2023-01-03    NaN
50. 2023-01-04    NaN
51. 2023-01-05    NaN
52. 2023-01-06    NaN
53. 2023-01-07    6.0
54. 2023-01-08    7.0
55. 2023-01-09    8.0
56. 2023-01-10    9.0
57. Freq: D, dtype: float64
58. """

复制代码

扩展窗口

扩展窗口是从序列的开始到当前点的窗口，窗口大小随着时间增长。

2. # 创建示例时间序列
3. dates = pd.date_range('2023-01-01', periods=10, freq='D')
4. ts = pd.Series(range(10), index=dates)
6. # 计算扩展平均值
7. expanding_mean = ts.expanding().mean()
8. print(expanding_mean)
9. """
10. 输出:
11. 2023-01-01    0.0
12. 2023-01-02    0.5
13. 2023-01-03    1.0
14. 2023-01-04    1.5
15. 2023-01-05    2.0
16. 2023-01-06    2.5
17. 2023-01-07    3.0
18. 2023-01-08    3.5
19. 2023-01-09    4.0
20. 2023-01-10    4.5
21. Freq: D, dtype: float64
22. """
24. # 计算扩展最大值
25. expanding_max = ts.expanding().max()
26. print(expanding_max)
27. """
28. 输出:
29. 2023-01-01    0.0
30. 2023-01-02    1.0
31. 2023-01-03    2.0
32. 2023-01-04    3.0
33. 2023-01-05    4.0
34. 2023-01-06    5.0
35. 2023-01-07    6.0
36. 2023-01-08    7.0
37. 2023-01-09    8.0
38. 2023-01-10    9.0
39. Freq: D, dtype: float64
40. """

复制代码

指数加权窗口

指数加权窗口是一种给予近期数据更高权重的窗口方法。

2. # 创建示例时间序列
3. dates = pd.date_range('2023-01-01', periods=10, freq='D')
4. ts = pd.Series(range(10), index=dates)
6. # 计算指数加权移动平均值
7. ewm_mean = ts.ewm(span=3).mean()
8. print(ewm_mean)
9. """
10. 输出:
11. 2023-01-01    0.000000
12. 2023-01-02    0.750000
13. 2023-01-03    1.615385
14. 2023-01-04    2.550000
15. 2023-01-05    3.520661
16. 2023-01-06    4.508197
17. 2023-01-07    5.504098
18. 2023-01-08    6.502049
19. 2023-01-09    7.501024
20. 2023-01-10    8.500512
21. Freq: D, dtype: float64
22. """

复制代码

时间序列可视化

可视化是理解时间序列数据的重要工具。Pandas与Matplotlib和Seaborn等可视化库集成良好，使我们能够轻松创建时间序列图表。

基本时间序列图

2. import matplotlib.pyplot as plt
3. import numpy as np
5. # 创建示例时间序列
6. dates = pd.date_range('2023-01-01', periods=100, freq='D')
7. ts = pd.Series(np.random.randn(100).cumsum(), index=dates)
9. # 绘制时间序列图
10. plt.figure(figsize=(12, 6))
11. ts.plot()
12. plt.title('Time Series Plot')
13. plt.xlabel('Date')
14. plt.ylabel('Value')
15. plt.grid(True)
16. plt.show()

复制代码

多个时间序列的比较

2. # 创建示例时间序列
3. dates = pd.date_range('2023-01-01', periods=100, freq='D')
4. ts1 = pd.Series(np.random.randn(100).cumsum(), index=dates, name='Series 1')
5. ts2 = pd.Series(np.random.randn(100).cumsum(), index=dates, name='Series 2')
6. ts3 = pd.Series(np.random.randn(100).cumsum(), index=dates, name='Series 3')
8. # 合并为DataFrame
9. df = pd.concat([ts1, ts2, ts3], axis=1)
11. # 绘制多个时间序列
12. plt.figure(figsize=(12, 6))
13. df.plot()
14. plt.title('Multiple Time Series')
15. plt.xlabel('Date')
16. plt.ylabel('Value')
17. plt.grid(True)
18. plt.legend()
19. plt.show()

复制代码

季节性分解图

2. from statsmodels.tsa.seasonal import seasonal_decompose
4. # 创建示例时间序列（带有趋势和季节性）
5. dates = pd.date_range('2023-01-01', periods=365, freq='D')
6. trend = np.linspace(0, 10, 365)
7. seasonality = 5 * np.sin(np.linspace(0, 4*np.pi, 365))
8. noise = np.random.randn(365) * 0.5
9. ts = pd.Series(trend + seasonality + noise, index=dates)
11. # 季节性分解
12. decomposition = seasonal_decompose(ts, model='additive', period=7)
14. # 绘制分解结果
15. plt.figure(figsize=(12, 10))
16. plt.subplot(411)
17. plt.plot(ts, label='Original')
18. plt.legend()
19. plt.subplot(412)
20. plt.plot(decomposition.trend, label='Trend')
21. plt.legend()
22. plt.subplot(413)
23. plt.plot(decomposition.seasonal, label='Seasonality')
24. plt.legend()
25. plt.subplot(414)
26. plt.plot(decomposition.resid, label='Residuals')
27. plt.legend()
28. plt.tight_layout()
29. plt.show()

复制代码

滚动统计量图

2. # 创建示例时间序列
3. dates = pd.date_range('2023-01-01', periods=100, freq='D')
4. ts = pd.Series(np.random.randn(100).cumsum(), index=dates)
6. # 计算滚动统计量
7. rolling_mean = ts.rolling(window=10).mean()
8. rolling_std = ts.rolling(window=10).std()
10. # 绘制原始数据和滚动统计量
11. plt.figure(figsize=(12, 6))
12. plt.plot(ts, label='Original')
13. plt.plot(rolling_mean, label='Rolling Mean (window=10)')
14. plt.plot(rolling_std, label='Rolling Std (window=10)')
15. plt.title('Rolling Statistics')
16. plt.xlabel('Date')
17. plt.ylabel('Value')
18. plt.grid(True)
19. plt.legend()
20. plt.show()

复制代码

实际案例分析

案例1：股票价格分析

2. # 假设我们有一只股票的日交易数据
3. dates = pd.date_range('2023-01-01', periods=100, freq='D')
4. prices = np.random.normal(100, 5, 100).cumsum()
5. volumes = np.random.randint(1000, 10000, 100)
7. # 创建DataFrame
8. stock_data = pd.DataFrame({
9.     'Price': prices,
10.     'Volume': volumes
11. }, index=dates)
13. # 计算移动平均线
14. stock_data['MA5'] = stock_data['Price'].rolling(window=5).mean()
15. stock_data['MA20'] = stock_data['Price'].rolling(window=20).mean()
17. # 计算每日收益率
18. stock_data['Daily_Return'] = stock_data['Price'].pct_change()
20. # 计算波动率（滚动标准差）
21. stock_data['Volatility'] = stock_data['Daily_Return'].rolling(window=20).std()
23. # 绘制价格和移动平均线
24. plt.figure(figsize=(12, 6))
25. plt.plot(stock_data['Price'], label='Price')
26. plt.plot(stock_data['MA5'], label='MA5')
27. plt.plot(stock_data['MA20'], label='MA20')
28. plt.title('Stock Price with Moving Averages')
29. plt.xlabel('Date')
30. plt.ylabel('Price')
31. plt.grid(True)
32. plt.legend()
33. plt.show()
35. # 绘制波动率
36. plt.figure(figsize=(12, 6))
37. plt.plot(stock_data['Volatility'])
38. plt.title('Stock Price Volatility (20-day rolling)')
39. plt.xlabel('Date')
40. plt.ylabel('Volatility')
41. plt.grid(True)
42. plt.show()

复制代码

案例2：网站流量分析

2. # 假设我们有网站的每小时访问量数据
3. dates = pd.date_range('2023-01-01', periods=24*30, freq='H')  # 30天的小时数据
4. # 模拟流量数据：工作日流量高，周末流量低；白天流量高，夜间流量低
5. hourly_pattern = np.sin(np.linspace(0, 2*np.pi, 24)) * 50 + 100  # 一天内的流量模式
6. daily_pattern = np.tile(hourly_pattern, 30)  # 重复30天
7. weekend_effect = np.zeros(24*30)
8. for i in range(30):
9.     if i % 7 >= 5:  # 周末
10.         weekend_effect[i*24:(i+1)*24] = -30  # 周末流量减少
11. traffic = daily_pattern + weekend_effect + np.random.randn(24*30) * 10  # 添加噪声
12. traffic = np.maximum(traffic, 0)  # 确保流量非负
14. # 创建DataFrame
15. traffic_data = pd.DataFrame({
16.     'Traffic': traffic
17. }, index=dates)
19. # 按天重采样，计算每日总流量
20. daily_traffic = traffic_data.resample('D').sum()
22. # 按周重采样，计算每周平均流量
23. weekly_traffic = traffic_data.resample('W').mean()
25. # 计算滚动平均值（24小时窗口）
26. rolling_traffic = traffic_data['Traffic'].rolling(window=24).mean()
28. # 绘制原始流量数据（前7天）
29. plt.figure(figsize=(12, 6))
30. traffic_data['Traffic'][:24*7].plot()
31. plt.title('Hourly Website Traffic (First Week)')
32. plt.xlabel('Date')
33. plt.ylabel('Traffic')
34. plt.grid(True)
35. plt.show()
37. # 绘制每日总流量
38. plt.figure(figsize=(12, 6))
39. daily_traffic.plot()
40. plt.title('Daily Website Traffic')
41. plt.xlabel('Date')
42. plt.ylabel('Traffic')
43. plt.grid(True)
44. plt.show()
46. # 绘制滚动平均值
47. plt.figure(figsize=(12, 6))
48. rolling_traffic.plot()
49. plt.title('24-hour Rolling Average of Website Traffic')
50. plt.xlabel('Date')
51. plt.ylabel('Traffic')
52. plt.grid(True)
53. plt.show()

复制代码

案例3：销售数据分析

2. # 假设我们有产品的日销售数据
3. dates = pd.date_range('2022-01-01', periods=365*2, freq='D')  # 2年的日数据
4. # 模拟销售数据：有年度增长趋势，有季节性（年末销售高），有周效应（周末销售高）
5. trend = np.linspace(100, 300, 365*2)  # 年度增长趋势
6. seasonality = 50 * np.sin(np.linspace(0, 4*np.pi, 365*2))  # 年度季节性
7. weekly_effect = np.zeros(365*2)
8. for i in range(365*2):
9.     if i % 7 >= 5:  # 周末
10.         weekly_effect[i] = 30  # 周末销售增加
11. sales = trend + seasonality + weekly_effect + np.random.randn(365*2) * 20  # 添加噪声
12. sales = np.maximum(sales, 0)  # 确保销售量非负
14. # 创建DataFrame
15. sales_data = pd.DataFrame({
16.     'Sales': sales
17. }, index=dates)
19. # 按月重采样，计算每月总销售量
20. monthly_sales = sales_data.resample('M').sum()
22. # 按年重采样，计算每年总销售量
23. yearly_sales = sales_data.resample('Y').sum()
25. # 计算同比增长率（与去年同期相比）
26. year_over_year = monthly_sales / monthly_sales.shift(12) - 1
28. # 计算滚动平均值（30天窗口）
29. rolling_sales = sales_data['Sales'].rolling(window=30).mean()
31. # 绘制原始销售数据
32. plt.figure(figsize=(12, 6))
33. sales_data['Sales'].plot()
34. plt.title('Daily Sales')
35. plt.xlabel('Date')
36. plt.ylabel('Sales')
37. plt.grid(True)
38. plt.show()
40. # 绘制月度销售量
41. plt.figure(figsize=(12, 6))
42. monthly_sales.plot(kind='bar')
43. plt.title('Monthly Sales')
44. plt.xlabel('Date')
45. plt.ylabel('Sales')
46. plt.grid(True)
47. plt.show()
49. # 绘制同比增长率
50. plt.figure(figsize=(12, 6))
51. year_over_year.plot()
52. plt.title('Year-over-Year Growth Rate')
53. plt.xlabel('Date')
54. plt.ylabel('Growth Rate')
55. plt.grid(True)
56. plt.axhline(y=0, color='r', linestyle='-')
57. plt.show()

复制代码

性能优化和最佳实践

使用适当的数据类型

Pandas提供了专门的时间数据类型，使用它们可以提高性能：

2. # 创建大型时间序列数据集
3. dates = pd.date_range('2000-01-01', periods=1000000, freq='H')
4. values = np.random.randn(1000000)
6. # 使用datetime64[ns]类型（默认）
7. df_default = pd.DataFrame({'value': values}, index=dates)
8. print(df_default.index.dtype)  # 输出: datetime64[ns]
10. # 使用datetime64[s]类型（秒精度）
11. df_seconds = df_default.copy()
12. df_seconds.index = df_seconds.index.astype('datetime64[s]')
13. print(df_seconds.index.dtype)  # 输出: datetime64[s]
15. # 使用datetime64[ms]类型（毫秒精度）
16. df_milliseconds = df_default.copy()
17. df_milliseconds.index = df_milliseconds.index.astype('datetime64[ms]')
18. print(df_milliseconds.index.dtype)  # 输出: datetime64[ms]
20. # 比较内存使用
21. print(f"Default: {df_default.index.memory_usage() / 1024 / 1024:.2f} MB")
22. print(f"Seconds: {df_seconds.index.memory_usage() / 1024 / 1024:.2f} MB")
23. print(f"Milliseconds: {df_milliseconds.index.memory_usage() / 1024 / 1024:.2f} MB")

复制代码

避免循环，使用向量化操作

在处理时间序列数据时，应尽量避免使用循环，而是使用Pandas提供的向量化操作：

2. # 创建示例时间序列
3. dates = pd.date_range('2023-01-01', periods=10000, freq='D')
4. ts = pd.Series(range(10000), index=dates)
6. # 不好的方法：使用循环计算移动平均
7. def rolling_mean_loop(ts, window):
8.     result = pd.Series(index=ts.index, dtype=float)
9.     for i in range(window-1, len(ts)):
10.         result.iloc[i] = ts.iloc[i-window+1:i+1].mean()
11.     return result
13. %timeit rolling_mean_loop(ts, 10)  # 测量执行时间
15. # 好的方法：使用内置的rolling函数
16. %timeit ts.rolling(window=10).mean()  # 测量执行时间

复制代码

使用分类数据类型处理重复的时间属性

当处理时间序列数据时，年、月、日、星期等属性经常重复出现，使用分类数据类型可以节省内存：

2. # 创建大型时间序列数据集
3. dates = pd.date_range('2000-01-01', periods=1000000, freq='D')
4. df = pd.DataFrame({'value': np.random.randn(1000000)}, index=dates)
6. # 提取时间属性
7. df['year'] = df.index.year
8. df['month'] = df.index.month
9. df['day'] = df.index.day
10. df['weekday'] = df.index.day_name()
12. # 检查内存使用
13. print(f"Before: {df.memory_usage(deep=True).sum() / 1024 / 1024:.2f} MB")
15. # 转换为分类数据类型
16. df['year'] = df['year'].astype('category')
17. df['month'] = df['month'].astype('category')
18. df['day'] = df['day'].astype('category')
19. df['weekday'] = df['weekday'].astype('category')
21. # 检查内存使用
22. print(f"After: {df.memory_usage(deep=True).sum() / 1024 / 1024:.2f} MB")

复制代码

使用适当的索引和排序

对于时间序列数据，确保时间索引是排序的可以提高查询和操作的性能：

2. # 创建大型时间序列数据集
3. dates = pd.date_range('2000-01-01', periods=1000000, freq='D')
4. values = np.random.randn(1000000)
5. df = pd.DataFrame({'value': values}, index=dates)
7. # 打乱索引
8. df_shuffled = df.sample(frac=1)
10. # 测量查询性能
11. %timeit df.loc['2010-01-01':'2010-01-31']  # 排序后的数据
12. %timeit df_shuffled.loc['2010-01-01':'2010-01-31']  # 未排序的数据
14. # 对未排序的数据进行排序
15. df_shuffled_sorted = df_shuffled.sort_index()
17. # 再次测量查询性能
18. %timeit df_shuffled_sorted.loc['2010-01-01':'2010-01-31']  # 排序后的数据

复制代码

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

对于非常大的时间序列数据集，可以考虑使用并行处理来加速操作：

2. from multiprocessing import Pool
3. import numpy as np
5. # 创建大型时间序列数据集
6. dates = pd.date_range('2000-01-01', periods=1000000, freq='D')
7. ts = pd.Series(np.random.randn(1000000), index=dates)
9. # 定义一个函数，用于处理时间序列的一部分
10. def process_chunk(chunk):
11.     return chunk.rolling(window=30).mean()
13. # 将时间序列分成多个块
14. n_chunks = 4
15. chunks = np.array_split(ts, n_chunks)
17. # 使用并行处理
18. with Pool(n_chunks) as p:
19.     results = p.map(process_chunk, chunks)
21. # 合并结果
22. result_parallel = pd.concat(results)
24. # 比较串行处理
25. %timeit ts.rolling(window=30).mean()
27. # 比较并行处理
28. %timeit with Pool(n_chunks) as p: results = p.map(process_chunk, chunks); result_parallel = pd.concat(results)

复制代码

总结

本文深入探讨了Pandas中的时间函数，从基础的时间戳创建到高级的时间序列分析技术。我们学习了如何创建和操作时间戳，如何使用时间索引和日期范围，如何对时间序列数据进行各种操作，如何进行时间重采样和频率转换，以及如何使用时间窗口操作。我们还探讨了时间序列的可视化方法，并通过实际案例展示了如何解决工作中的时间问题。最后，我们讨论了性能优化和最佳实践，以帮助我们更高效地处理时间序列数据。

通过掌握这些技术，我们可以更有效地处理和分析时间序列数据，从中提取有价值的信息，并做出更好的决策。无论是金融分析、销售预测、网站流量分析还是其他领域的时间序列问题，Pandas的时间函数都能提供强大的支持。

希望本文能够帮助读者全面掌握Pandas中的时间函数，提升数据分析效率，解决实际工作中的时间问题。