SC.Pandas 03 | 如何使用Pandas分析时间序列数据？

RitasCake

已于 2024-07-15 13:10:43 修改

阅读量1.1k

点赞数 25

分类专栏：科学计算地球科学方法的Python实现 Python 文章标签： pandas python

于 2024-07-15 01:22:16 首次发布

本文链接：https://blog.csdn.net/qq_38576162/article/details/140426403

版权

地球科学方法的Python实现同时被 3 个专栏收录

12 篇文章 0 订阅

订阅专栏

Python

12 篇文章 0 订阅

订阅专栏

科学计算

8 篇文章 0 订阅

订阅专栏

Introduction

前两期我们对Pandas的数据结构和常用的计算方法进行了介绍，在地球科学领域时间序列分析是很重要的一种数据处理方式。

通过理解数据的时间变化特征，我们可以更深入地理解研究对象的演化规律与物理机制。

因此，本期我们就从Pandas中时间序列数据处理的角度，来探究地球科学领域中时间序列数据的一些常用方法。

❝
时间戳

是指一个表示某个特定时间点的字符串或编码信息。它通常由一组数字组成，代表从某个参考时间(例如格林威治时间 1970 年 1 月 1 日 00:00:00 UTC)开始经过的时间量，单位为秒或毫秒。

Python中，可以使用time模块和datetime模块来处理时间戳。由于Pandas模块中内置了这些函数，因此我们不需要再单独使用上述模块处理。

时间序列的创建

Pandas中时间序列的创建主要有两种方式：

通过Pandas中内置的date_range函数创建时间序列，该函数可以指定起始日期、结束日期、时间步长等参数，并返回一个DatetimeIndex对象。
通过Pandas中to_datetime函数将其他格式的日期时间字符串转换为DatetimeIndex对象(当我们需要将读取到Pandas中的表格日期转换为时间格式时，将十分有用)。

下面通过例子来说明这两种方法的使用。

使用date_range创建时间序列

date_range函数能通过组合不同的参数以多种形式创建连续的时间序列，我们首先通过指定起止时间和时间步长freq生成时间序列。

Pandas中常见的时间步长包括：

S：秒
T：分钟
H：小时
D：天
B：工作日
W：周
M：月
Q：季度
Y：年

我们可以在时间步长前面加上数字来自定义时间步长，比如2H表示2小时。

import pandas as pd

# 已知起始日期和结束日期，生成日期序列，默认时间步长为1天
date_range = pd.date_range(start='2021-01-01', end='2021-01-04')
print(date_range)

date_range = pd.date_range(start='2021-01-01', end='2021-05-07', freq='M')          # 设置步长为月
print(date_range)

date_range = pd.date_range(start='2021-01-01', end='2021-08-07', freq='3M')         # 设置步长为3个月
print(date_range)

date_range = pd.date_range(start='2021-01-01', end='2021-05-07', freq='5W')          # 设置步长为周
print(date_range)

date_range = pd.date_range(start='2021-01-01', end='2021-01-06', freq='B')          # 设置步长为工作日
print(date_range)

date_range = pd.date_range(start='2021-01-01', end='2021-11-07', freq='Q')          # 设置步长为季度
print(date_range)

date_range = pd.date_range(start='2021-01-01', end='2023-05-07', freq='YS')          # 设置步长为半年
print(date_range)

DatetimeIndex(['2021-01-01', '2021-01-02', '2021-01-03', '2021-01-04'], dtype='datetime64[ns]', freq='D')
DatetimeIndex(['2021-01-31', '2021-02-28', '2021-03-31', '2021-04-30'], dtype='datetime64[ns]', freq='M')
DatetimeIndex(['2021-01-31', '2021-04-30', '2021-07-31'], dtype='datetime64[ns]', freq='3M')
DatetimeIndex(['2021-01-03', '2021-02-07', '2021-03-14', '2021-04-18'], dtype='datetime64[ns]', freq='5W-SUN')
DatetimeIndex(['2021-01-01', '2021-01-04', '2021-01-05', '2021-01-06'], dtype='datetime64[ns]', freq='B')
DatetimeIndex(['2021-03-31', '2021-06-30', '2021-09-30'], dtype='datetime64[ns]', freq='Q-DEC')
DatetimeIndex(['2021-01-01', '2022-01-01', '2023-01-01'], dtype='datetime64[ns]', freq='AS-JAN')

我们可以注意到，Pandas按周、月份、季度步长生成的日期为最后一天。而且，季度的计算方式默认按照了自然节律的3-4-5月为第一季度来计算。

我们可以进行一些自定义操作：

date_range = pd.date_range(start='2021-01-01', end='2021-04-07', freq='MS')         # 设置生成日期为当月第一天，MS(month start)
print(date_range)

date_range = pd.date_range(start='2021-01-01', end='2021-05-07', freq='QS')         # 设置生成日期为季度第一天，且季度起算月变为了1月
print(date_range)

date_range = pd.date_range(start='2021-01-01', end='2024-05-07', freq='YS')         # 设置生成日期为每年第一天
print(date_range)

date_range = pd.date_range(start='2021-01-01', end='2021-01-15', freq='W-MON')      # 设置生成日期为每周的星期一
print(date_range)

date_range = pd.date_range(start='2023-01-01', end='2024-01-15', freq='QS-FEB')     # 设置生成日期为季度第一天，且以2月为季度起始
print(date_range)

DatetimeIndex(['2021-01-01', '2021-02-01', '2021-03-01', '2021-04-01'], dtype='datetime64[ns]', freq='MS')
DatetimeIndex(['2021-01-01', '2021-04-01'], dtype='datetime64[ns]', freq='QS-JAN')
DatetimeIndex(['2021-01-01', '2022-01-01', '2023-01-01', '2024-01-01'], dtype='datetime64[ns]', freq='AS-JAN')
DatetimeIndex(['2021-01-04', '2021-01-11'], dtype='datetime64[ns]', freq='W-MON')
DatetimeIndex(['2023-02-01', '2023-05-01', '2023-08-01', '2023-11-01'], dtype='datetime64[ns]', freq='QS-FEB')

有些情况下，我们只知道初始日期或截止日期，我们可以通过所需的时间步长和周期数来计算时间序列。

date_range = pd.date_range(start='2021-01-01', freq='D', periods=7)         # 已知起始日期、频率、周期，生成日期序列
print(date_range)

date_range = pd.date_range(end='2021-01-07', freq='W', periods=7)           # 已知结束日期、频率、周期，生成日期序列
print(date_range)

DatetimeIndex(['2021-01-01', '2021-01-02', '2021-01-03', '2021-01-04',
               '2021-01-05', '2021-01-06', '2021-01-07'],
              dtype='datetime64[ns]', freq='D')
DatetimeIndex(['2020-11-22', '2020-11-29', '2020-12-06', '2020-12-13',
               '2020-12-20', '2020-12-27', '2021-01-03'],
              dtype='datetime64[ns]', freq='W-SUN')

此外，date_range函数还包含了几个可能用到的参数：

tz：指定时区，默认为None，表示使用系统默认时区
normalize：将日期归一化到00:00，默认为False
name：指定生成的时间序列名称
inclusive：旧版中为closed，生成的日期范围是否包含开始和结束日期，默认为left(左闭右开)。其他可选值有right（左开右闭）、both（左闭右闭）、neither（左开右开）

date_range = pd.date_range('2021-01-01', '2021-01-05', freq='D', tz='Asia/Tokyo')           # 东九区东京时间
print(date_range)

print(date_range.tz_convert('UTC'))             # 转换为中时区标准时间

DatetimeIndex(['2021-01-01 00:00:00+09:00', '2021-01-02 00:00:00+09:00',
               '2021-01-03 00:00:00+09:00', '2021-01-04 00:00:00+09:00',
               '2021-01-05 00:00:00+09:00'],
              dtype='datetime64[ns, Asia/Tokyo]', freq='D')
DatetimeIndex(['2020-12-31 15:00:00+00:00', '2021-01-01 15:00:00+00:00',
               '2021-01-02 15:00:00+00:00', '2021-01-03 15:00:00+00:00',
               '2021-01-04 15:00:00+00:00'],
              dtype='datetime64[ns, UTC]', freq='D')

date_range = pd.date_range('2021-01-01 12:25:56', '2021-12-31', freq='M')
print(date_range[0])

date_range = pd.date_range('2021-01-01 12:25:56', '2021-12-31', freq='M', normalize=True)       # 归一化日期至00:00:00
print(date_range[0])

2021-01-31 12:25:56
2021-01-31 00:00:00

date_range = pd.date_range('2021-01-01', '2021-12-31', freq='Q', name='Seasonal')
print(date_range)

date_range = pd.date_range('2024-05-01', '2024-05-04', inclusive='left')
print(date_range)

date_range = pd.date_range('2024-05-01', '2024-05-04', inclusive='right')
print(date_range)

date_range = pd.date_range('2024-05-01', '2024-05-04', inclusive='both')
print(date_range)

date_range = pd.date_range('2024-05-01', '2024-05-04', inclusive='neither')
print(date_range)

DatetimeIndex(['2021-03-31', '2021-06-30', '2021-09-30', '2021-12-31'], dtype='datetime64[ns]', name='Seasonal', freq='Q-DEC')
DatetimeIndex(['2024-05-01', '2024-05-02', '2024-05-03'], dtype='datetime64[ns]', freq='D')
DatetimeIndex(['2024-05-02', '2024-05-03', '2024-05-04'], dtype='datetime64[ns]', freq='D')
DatetimeIndex(['2024-05-01', '2024-05-02', '2024-05-03', '2024-05-04'], dtype='datetime64[ns]', freq='D')
DatetimeIndex(['2024-05-02', '2024-05-03'], dtype='datetime64[ns]', freq='D')

从其他格式创建时间序列

这里的其他格式一般就是指字符串形式的日期时间，如'2021-01-01'。当我们从外部文件导入大量带时间的数据时，可以通过to_datetime函数便捷地将其转换为时间序列。

我们从外部读取一个.csv文件，并将其日期时间列转换为时间序列。

pth = r'F:\Proj_Geoscience.Philosophy\Material\tmp_SSP2.csv'

df = pd.read_csv(pth, index_col=0)
print(df)

            ACCESS-CM2  EC-Earth3  EC-Earth3-Veg  MPI-ESM1-2-HR  GFDL-ESM4  \
1990-12-31   -9.838771  -9.637003      -9.321887     -10.383628  -9.549001   
1991-12-31  -10.165740  -9.453364      -9.650858     -10.076542  -9.783594   
1992-12-31  -10.944804 -10.569817      -9.624666     -10.221733  -9.442735   
1993-12-31  -11.011893 -10.919116      -9.689930     -10.822980  -9.617322   
1994-12-31   -9.935500  -9.687431     -10.403852     -10.077468  -9.583637   
...                ...        ...            ...            ...        ...   
2096-12-31   -6.101502  -6.675644      -5.595156      -6.935057  -8.173742   
2097-12-31   -6.801526  -4.585644      -6.461058      -7.107297  -7.350170   
2098-12-31   -7.923017  -6.654356      -6.137528      -6.842564  -7.736062   
2099-12-31   -6.628777  -7.413971      -4.578230      -7.274006  -7.175193   
2100-12-31   -6.997662  -4.661766      -5.654026      -7.408147  -7.621691   
[111 rows x 7 columns]

❝
这里对一个气温数据进行了读取，我们使用了Pandas中的read_csv函数。第一行默认成为了DataFrame的列名，由于我们指定了参数index_col=0，因此第一列被设置为行名。

下面我们将DataFrame的索引由字符串转换为日期格式：

print(df.index)

df.index = pd.to_datetime(df.index)
print(df.index)

Index(['1990-12-31', '1991-12-31', '1992-12-31', '1993-12-31', '1994-12-31',
       '1995-12-31', '1996-12-31', '1997-12-31', '1998-12-31', '1999-12-31',
       ...
       '2091-12-31', '2092-12-31', '2093-12-31', '2094-12-31', '2095-12-31',
       '2096-12-31', '2097-12-31', '2098-12-31', '2099-12-31', '2100-12-31'],
      dtype='object', length=111)
DatetimeIndex(['1990-12-31', '1991-12-31', '1992-12-31', '1993-12-31',
               '1994-12-31', '1995-12-31', '1996-12-31', '1997-12-31',
               '1998-12-31', '1999-12-31',
               ...
               '2091-12-31', '2092-12-31', '2093-12-31', '2094-12-31',
               '2095-12-31', '2096-12-31', '2097-12-31', '2098-12-31',
               '2099-12-31', '2100-12-31'],
              dtype='datetime64[ns]', length=111, freq=None)

我们也可以直接对字符串、列表等进行转换，而不一定都是Pandas对象。

print(pd.to_datetime('2021-01'))
print(pd.to_datetime(['2021-01-01', '2021-01-02']))

2021-01-01 00:00:00
DatetimeIndex(['2021-01-01', '2021-01-02'], dtype='datetime64[ns]', freq=None)

to_datetime函数中，format参数可以指定日期格式，如%Y-%m-%d表示年-月-日。对于非常规的日期格式，我们可以自定义日期格式来解析和转换。

其中，年、月、日、时、分、秒分别用%Y、%m、%d、%H、%M、%S表示。

print(pd.to_datetime('202101', format='%Y%m'))          # 直接解析将报错，因此需要指定日期的格式
print(pd.to_datetime(['20211', '20212', '202112'], format='%Y%m'))

2021-01-01 00:00:00
DatetimeIndex(['2021-01-01', '2021-02-01', '2021-12-01'], dtype='datetime64[ns]', freq=None)

偏移时间序列

一些情况下，存在多源时间序列不匹配的问题，可能需要对时间序列进行偏移。Pandas中提供了多种方法对时间序列进行偏移。

date_range = pd.date_range('2021-01-01', '2021-01-05', freq='D')
print(date_range)
print(date_range.shift(1))          # 根据当前步长单位进行偏移
print(date_range.shift(-3))
print(date_range.shift(2, freq='M'))    # 根据指定步长单位进行偏移
print(date_range + pd.offsets.Week(3))

# 生成时间偏移量
dt = pd.to_timedelta(3, unit='D')
print(dt)
print(date_range + dt)

dt = pd.to_timedelta(['1 D', '2 H', '3 minutes', '4 seconds', '5 w'])
print(date_range + dt)

dt = pd.to_timedelta('5 days 7 hours 30 minutes 10 seconds')
print(date_range + dt)

DatetimeIndex(['2021-01-01', '2021-01-02', '2021-01-03', '2021-01-04',
               '2021-01-05'],
              dtype='datetime64[ns]', freq='D')
DatetimeIndex(['2021-01-02', '2021-01-03', '2021-01-04', '2021-01-05',
               '2021-01-06'],
              dtype='datetime64[ns]', freq='D')
DatetimeIndex(['2020-12-29', '2020-12-30', '2020-12-31', '2021-01-01',
               '2021-01-02'],
              dtype='datetime64[ns]', freq='D')
DatetimeIndex(['2021-02-28', '2021-02-28', '2021-02-28', '2021-02-28',
               '2021-02-28'],
              dtype='datetime64[ns]', freq=None)
DatetimeIndex(['2021-01-22', '2021-01-23', '2021-01-24', '2021-01-25',
               '2021-01-26'],
              dtype='datetime64[ns]', freq=None)
3 days 00:00:00
DatetimeIndex(['2021-01-04', '2021-01-05', '2021-01-06', '2021-01-07',
               '2021-01-08'],
              dtype='datetime64[ns]', freq='D')
DatetimeIndex(['2021-01-02 00:00:00', '2021-01-02 02:00:00',
               '2021-01-03 00:03:00', '2021-01-04 00:00:04',
               '2021-02-09 00:00:00'],
              dtype='datetime64[ns]', freq=None)
DatetimeIndex(['2021-01-06 07:30:10', '2021-01-07 07:30:10',
               '2021-01-08 07:30:10', '2021-01-09 07:30:10',
               '2021-01-10 07:30:10'],
              dtype='datetime64[ns]', freq='D')

时间序列数据处理

由于时间的周期性、月份长度不一致等的存在，时间序列数据相较简单的代数运算更为繁琐。下面我们通过一组伪气象数据来举例说明。

import numpy as np

# 生成一组日气温数据
df_tmp = pd.DataFrame(index=pd.date_range('2024-01-01', '2024-12-31', freq='D'))
df_tmp['Moscow'] = np.random.rand(len(df_tmp)) * 10 - 15
df_tmp['Istanbul'] = np.random.rand(len(df_tmp)) * 10 + 5
df_tmp['Delhi'] = np.random.rand(len(df_tmp)) * 10 + 25
df_tmp['Tokyo'] = np.random.rand(len(df_tmp)) * 10 + 15
df_tmp['Oslo'] = np.random.rand(len(df_tmp)) * 10 - 5

print(df_tmp)

               Moscow   Istanbul      Delhi      Tokyo      Oslo
2024-01-01 -12.507333   8.843648  33.246008  22.083794  1.464828
2024-01-02  -5.420229  10.210387  26.832628  18.923657 -0.535928
2024-01-03  -5.777253  11.924500  32.288078  16.753620 -1.134632
2024-01-04 -10.513435   7.863196  29.965339  20.013110 -1.965073
2024-01-05 -14.257012   9.221470  25.657996  17.241110 -0.337181
...               ...        ...        ...        ...       ...
2024-12-27 -12.507982  13.790553  30.266854  18.228648  3.433193
2024-12-28  -6.739498  10.727600  25.824327  21.259728  2.114948
2024-12-29  -9.713740   6.009821  28.296607  15.202731 -1.782476
2024-12-30 -12.356168  13.890982  27.810067  23.585278  2.910837
2024-12-31 -13.592953   9.560644  25.159271  22.388183 -3.792435

[366 rows x 5 columns]

# 常规的代数统计
print(df_tmp.mean())
print(df_tmp.min())
print(df_tmp.max())

Moscow     -10.028244
Istanbul     9.980530
Delhi       29.889565
Tokyo       19.897225
Oslo        -0.263960
dtype: float64
Moscow     -14.968037
Istanbul     5.008738
Delhi       25.021508
Tokyo       15.016760
Oslo        -4.997246
dtype: float64
Moscow      -5.049498
Istanbul    14.995171
Delhi       34.974616
Tokyo       24.968358
Oslo         4.908233
dtype: float64

长期气候态是地球科学的重要内容，因此我们可以使用resample方法将日尺度数据采样为月度、年度、季度、周度等。

print(df_tmp.resample('M').mean())           # 月平均气温
print(df_tmp.resample('QS-DEC').mean())      # 季节平均气温

               Moscow   Istanbul      Delhi      Tokyo      Oslo
2024-01-31 -10.254586   9.863383  29.811591  19.542478  0.118495
2024-02-29 -10.574170   8.663596  29.921715  20.434315 -0.765250
2024-03-31 -10.193746  10.903090  29.499974  20.089061 -0.521395
2024-04-30  -9.694386  10.436401  30.207367  19.352587 -0.458590
2024-05-31 -10.342069   9.759788  29.882693  19.872505  0.738848
2024-06-30 -10.516414   9.650099  30.606493  19.379372 -0.368868
2024-07-31  -9.736534   9.504273  29.598204  19.380998  0.145924
2024-08-31 -10.828593   9.994522  29.959532  20.387590 -0.642251
2024-09-30  -9.257497  10.375339  30.400341  19.200840  0.207057
2024-10-31  -9.458752  10.574113  29.696168  20.774836 -0.787231
2024-11-30  -9.482097  10.315962  30.240406  20.126591 -0.410509
2024-12-31  -9.997802   9.668432  28.913538  20.210843 -0.455287
               Moscow   Istanbul      Delhi      Tokyo      Oslo
2023-12-01 -10.409052   9.283486  29.864818  19.973533 -0.308648
2024-03-01 -10.080890  10.365666  29.859606  19.775936 -0.076268
2024-06-01 -10.358819   9.717018  30.048746  19.719645 -0.287524
2024-09-01  -9.400100  10.423478  30.107732  20.042229 -0.335250
2024-12-01  -9.997802   9.668432  28.913538  20.210843 -0.455287
               Moscow   Istanbul      Delhi      Tokyo      Oslo
2024-01-01 -12.507333   8.843648  33.246008  22.083794  1.464828
2024-01-02  -5.420229  10.210387  26.832628  18.923657 -0.535928
2024-01-03  -5.777253  11.924500  32.288078  16.753620 -1.134632
2024-01-04 -10.513435   7.863196  29.965339  20.013110 -1.965073
2024-01-05 -14.257012   9.221470  25.657996  17.241110 -0.337181
...               ...        ...        ...        ...       ...
2024-12-27 -12.507982  13.790553  30.266854  18.228648  3.433193
2024-12-28  -6.739498  10.727600  25.824327  21.259728  2.114948
2024-12-29  -9.713740   6.009821  28.296607  15.202731 -1.782476
2024-12-30 -12.356168  13.890982  27.810067  23.585278  2.910837
2024-12-31 -13.592953   9.560644  25.159271  22.388183 -3.792435

[366 rows x 5 columns]

若该要素为降水，总降水量相对平均降水可能更有意义，此时采样函数可将mean更换为sum计算总降水量。

df_prc = df_tmp.copy() / 10
df_prc[df_prc < 0] = 0

print(df_prc)
print(df_prc.resample('Y').sum())       # 年降水量

            Moscow  Istanbul     Delhi     Tokyo      Oslo
2024-01-01     0.0  0.884365  3.324601  2.208379  0.146483
2024-01-02     0.0  1.021039  2.683263  1.892366  0.000000
2024-01-03     0.0  1.192450  3.228808  1.675362  0.000000
2024-01-04     0.0  0.786320  2.996534  2.001311  0.000000
2024-01-05     0.0  0.922147  2.565800  1.724111  0.000000
...            ...       ...       ...       ...       ...
2024-12-27     0.0  1.379055  3.026685  1.822865  0.343319
2024-12-28     0.0  1.072760  2.582433  2.125973  0.211495
2024-12-29     0.0  0.600982  2.829661  1.520273  0.000000
2024-12-30     0.0  1.389098  2.781007  2.358528  0.291084
2024-12-31     0.0  0.956064  2.515927  2.238818  0.000000

[366 rows x 5 columns]
            Moscow    Istanbul        Delhi       Tokyo       Oslo
2024-12-31     0.0  365.287396  1093.958072  728.238447  41.132944

在我们常见的ERA5数据中，它提供的月降水数据通常为月内日均降水。针对每个月长度不一致和平闰年的问题，我们可以使用Pandas的时间序列简单解决。

df_prc_month_day = pd.DataFrame(index=pd.date_range('2024-01-01', periods=12, freq='M'))
df_prc_month_day['Delhi'] = np.random.rand(df_prc_month_day.shape[0]) * 15
df_prc_month_day['Mumbai'] = np.random.rand(df_prc_month_day.shape[0]) * 15
df_prc_month_day['Bangalore'] = np.random.rand(df_prc_month_day.shape[0]) * 15
print(df_prc_month_day)

                Delhi     Mumbai  Bangalore
2024-01-31   3.940283  14.243030  14.550210
2024-02-29  10.600057   3.372597  11.475781
2024-03-31  10.650589   0.588919   9.247578
2024-04-30   0.923979  11.217988   8.438911
2024-05-31   1.447532  10.217217  13.743340
2024-06-30  12.765974   8.176907   3.823629
2024-07-31   6.710510  13.173852   2.471967
2024-08-31  11.528575   0.201862   3.447648
2024-09-30   9.430506  14.604422  12.244354
2024-10-31   7.503884  14.636888  10.372287
2024-11-30   9.426874  12.573375   3.150358
2024-12-31   7.260503   8.289384   1.363746

print(df_prc_month_day.mul(df_prc_month_day.index.days_in_month, axis=0))

                 Delhi      Mumbai   Bangalore
2024-01-31  122.148777  441.533943  451.056512
2024-02-29  307.401667   97.805311  332.797655
2024-03-31  330.168271   18.256477  286.674931
2024-04-30   27.719360  336.539649  253.167335
2024-05-31   44.873482  316.733731  426.043535
2024-06-30  382.979229  245.307224  114.708863
2024-07-31  208.025813  408.389426   76.630984
2024-08-31  357.385838    6.257732  106.877081
2024-09-30  282.915194  438.132673  367.330612
2024-10-31  232.620416  453.743526  321.540895
2024-11-30  282.806225  377.201245   94.510754
2024-12-31  225.075581  256.970890   42.276127

针对气象条件的不稳定，平滑去噪是我们常用到的方法，或者我们需要计算三日内降水等指标，均需要使用时间序列数据处理实现。下面我们使用Pandas中内置的经典方法——滑动窗口法rolling来实现滤波。

该函数常用参数包括：

window：滑动窗口大小，一般需要两端对称，因此多设置为奇数
min_periods：窗口内最小观测值个数，若窗口内数值个数小于该值将赋空值
center：是否将窗口中心点对齐到原始时间序列的中间，默认为False(居右)。
axis：指定滑动轴，默认为0

print(df_tmp.rolling(window=7).mean())                                       # 7天滑动平均气温
print(df_tmp.rolling(window=7, center=True).mean())                          # 窗口中心居中
print(df_tmp.rolling(window=7, min_periods=1, center=True).mean())           # 最小窗口设为1

              Moscow   Istanbul      Delhi      Tokyo      Oslo
2024-01-01       NaN        NaN        NaN        NaN       NaN
2024-01-02       NaN        NaN        NaN        NaN       NaN
2024-01-03       NaN        NaN        NaN        NaN       NaN
2024-01-04       NaN        NaN        NaN        NaN       NaN
2024-01-05       NaN        NaN        NaN        NaN       NaN
...              ...        ...        ...        ...       ...
2024-12-27 -7.933149   9.308903  28.475941  21.106085  0.941338
2024-12-28 -7.550998   9.987686  27.761081  20.676448  1.004559
2024-12-29 -7.847822   9.231643  27.501335  19.853021  1.114749
2024-12-30 -8.812310  10.297097  27.865765  20.486932  1.071464
2024-12-31 -9.804272  10.878143  27.248562  21.308512  0.326890

[366 rows x 5 columns]
               Moscow   Istanbul      Delhi      Tokyo      Oslo
2024-01-01        NaN        NaN        NaN        NaN       NaN
2024-01-02        NaN        NaN        NaN        NaN       NaN
2024-01-03        NaN        NaN        NaN        NaN       NaN
2024-01-04 -10.173355  10.262110  29.808843  19.473300 -0.561775
2024-01-05  -9.968426  10.657593  29.773274  19.517357 -1.058107
...               ...        ...        ...        ...       ...
2024-12-27  -8.812310  10.297097  27.865765  20.486932  1.071464
2024-12-28  -9.804272  10.878143  27.248562  21.308512  0.326890
2024-12-29        NaN        NaN        NaN        NaN       NaN
2024-12-30        NaN        NaN        NaN        NaN       NaN
2024-12-31        NaN        NaN        NaN        NaN       NaN

[366 rows x 5 columns]
               Moscow   Istanbul      Delhi      Tokyo      Oslo
2024-01-01  -8.554563   9.710433  30.583013  19.443545 -0.542701
2024-01-02  -9.695053   9.612640  29.598010  19.003058 -0.501597
2024-01-03 -10.340545   9.784317  29.339153  18.711367 -0.478302
2024-01-04 -10.173355  10.262110  29.808843  19.473300 -0.561775
2024-01-05  -9.968426  10.657593  29.773274  19.517357 -1.058107
...               ...        ...        ...        ...       ...
2024-12-27  -8.812310  10.297097  27.865765  20.486932  1.071464
2024-12-28  -9.804272  10.878143  27.248562  21.308512  0.326890
2024-12-29 -10.303311  11.334780  27.572287  20.931878  0.193201
2024-12-30 -10.982069  10.795920  27.471426  20.132914  0.576813
2024-12-31 -10.600590  10.047262  26.772568  20.608980 -0.137281

[366 rows x 5 columns]

df_tmp.plot(figsize=(7, 3.5), title='Original', colormap='autumn')
df_tmp.rolling(window=7, min_periods=1, center=True).mean().plot(figsize=(7, 3.5), title='7D Rolling', colormap='autumn')

# 根据日降水量计算72小时总降水量(三天求和)
print(df_prc.rolling(window=3, center=True, min_periods=1).sum())

df_prc.plot(figsize=(7, 3), title='Original', colormap='tab10')
df_prc.rolling(window=3, center=True, min_periods=1).sum().plot(figsize=(7, 3), title='72 Hours Total Precipitation', colormap='tab10')

            Moscow  Istanbul     Delhi     Tokyo      Oslo
2024-01-01     0.0  1.905404  6.007864  4.100745  0.146483
2024-01-02     0.0  3.097854  9.236671  5.776107  0.146483
2024-01-03     0.0  2.999808  8.908604  5.569039  0.000000
2024-01-04     0.0  2.900917  8.791141  5.400784  0.000000
2024-01-05     0.0  2.772737  8.366820  5.450713  0.000000
...            ...       ...       ...       ...       ...
2024-12-27     0.0  3.854723  8.416778  6.441508  0.554814
2024-12-28     0.0  3.052797  8.438779  5.469111  0.554814
2024-12-29     0.0  3.062840  8.193100  6.004774  0.502579
2024-12-30     0.0  2.946145  8.126595  6.117619  0.291084
2024-12-31     0.0  2.345163  5.296934  4.597346  0.291084

[366 rows x 5 columns]

后记

以上就是关于Pandas处理时间序列数据的一些介绍，更多丰富、深入的用法也不过是在此基础上的拼装和拓展。我们只需要掌握好这些基础的组件，就可以通过不同的组装方式达到我们最终的目的。

但毫无疑问，这些内容还是过于浅显，更多内容还需要大家自行探索。另外，与date_range和to_datetime类似，还存在period_range和to_period函数。它们的用法几乎一致，但后者更强调时间段的概念。

但一般而言，如果我们认为连续两个时间戳之间的步长是固定的，那么时间段的概念也不再必要。因此，本文就不再赘述了(好长的一期，比我想象中的长了快一倍)。

这次我们还涉及到了与外部数据交互和可视化，这部分内容也会尽快提上议程。

那么，我们下期再见！

Manuscript: RitasCake

Proof: Philero; RitasCake

获取更多资讯，欢迎订阅微信公众号：Westerlies

跳转和鲸社区，云端运行本文案例。https://www.heywhale.com/mw/project/66221ce2e584e69fbfef87ba/content

RitasCake

关注

25
点赞
踩
21

收藏

觉得还不错? 一键收藏
1
评论
SC.Pandas 03 | 如何使用Pandas分析时间序列数据？

我们只需要掌握好这些基础的组件，就可以通过不同的组装方式达到我们最终的目的。针对气象条件的不稳定，平滑去噪是我们常用到的方法，或者我们需要计算三日内降水等指标，均需要使用时间序列数据处理实现。前两期我们对Pandas的数据结构和常用的计算方法进行了介绍，在地球科学领域时间序列分析是很重要的一种数据处理方式。因此，本期我们就从Pandas中时间序列数据处理的角度，来探究地球科学领域中时间序列数据的一些常用方法。有些情况下，我们只知道初始日期或截止日期，我们可以通过所需的时间步长和周期数来计算时间序列。
复制链接

扫一扫

专栏目录