pandas 学习 第4篇：序列的处理（应用聚合转换映射分组滚动扩展指数加权移动平均）

Posted 2022-11-12 ljhdo

序列内置一些函数，用于循环对序列的元素执行操作。

一，应用函数

对序列的各个原始应用函数：

Series.apply(self, func, convert_dtype=True, args=(), **kwds)

参数注释：

• func：应用的函数，可以是自定义的函数，或NumPy函数
• convert_dtype：默认值是True，尝试把func应用的结果转换为更好的数据类型，如果设置为False，把结果转换为dtype=object.
• args：元组，在序列值之后，传递给func的位置参数（positional arguments）
• **kwds：传递给func的关键字（keyword）参数，可以有0、1、多个

位置参数和关键字参数的区别是：

• 位置参数是通过匹配位置来传参，关键字参数是通过匹配参数名称来传参。
• 关键字参数可以有多个，参数的名称不固定，只能在apply函数()的最后面，例如，关键字参数k1,k2,k3，那么kwargs=[k1,k2,k3]
• 位置参数args只能有一个

1，传递自定义的函数（使用位置参数）

创建自定义的函数，把函数应用于序列之上

>>> s = pd.Series([20, 21, 12], index=[‘London‘, ‘New York‘, ‘Helsinki‘])
>>> def subtract_custom_value(x, custom_value):
...     return x - custom_value
>>> s.apply(subtract_custom_value, args=(5,))
London      15
New York    16
Helsinki     7
dtype: int64

2，传递自定义的函数（使用关键字参数）

可以看到，关键字参数只能在apply函数的后面，

>>> def add_custom_values(x, **kwargs):
...     for month in kwargs:
...         x += kwargs[month]
...     return x
>>> s.apply(add_custom_values, june=30, july=20, august=25)
London      95
New York    96
Helsinki    87
dtype: int64

3，传递NumPy定义的函数

>>> s.apply(np.log)
London      2.995732
New York    3.044522
Helsinki    2.484907
dtype: float64

二，聚合

agg是aggregate的缩写，两个函数是等价的，对序列执行聚合操作，调用的函数只能返回单个标量值。聚合用于对序列的所有元素执行聚合操作，具体的聚合操作是由参数func决定的：

Series.agg(self, func, axis=0, *args, **kwargs)
Series.aggregate(self, func, axis=0, *args, **kwargs)

参数注释：

• func：函数变量、函数名称（字符串），列表（函数变量、函数名称的列表）
• axis：对于序列来说，axis只能是0

举个例子，对序列求最小值和最大值：

>>> s = pd.Series([1, 2, 3, 4])
>>> s.agg([‘min‘, ‘max‘])
min   1
max   4
dtype: int64

三，转换

转换是调用函数，对序列的值进行转换，transform函数和apply很相似，不同的是transform可以调用多个函数，而apply只能调用一个函数：

Series.transform(self, func, axis=0, *args, **kwargs)

参数注释：

func：函数变量、函数名称、函数列表

>>> s = pd.Series(range(3))
>>> s
0    0
1    1
2    2
dtype: int64
>>> s.transform([np.sqrt, np.exp])
       sqrt        exp
0  0.000000   1.000000
1  1.000000   2.718282
2  1.414214   7.389056

四，映射

把序列的值映射为其他值

Series.map(self, arg, na_action=None)

参数注释：

• arg：映射，可以是函数、字典或序列
• na_action：默认值是None，默认处理；如果是ignore，那么显示为NaN。

arg通常情况下是使用字典，用字典的key匹配序列的值，把原始序列的值替换为字典的value。

当arg是序列时，使用索引对齐方式，把原始序列的值映射为arg序列的值。

五，分组

对序列分组，返回分组之后的对象，并可以调用聚合函数获得每个分组的聚合值：

Series.groupby(self, by=None, axis=0, level=None, as_index=True, sort=True, group_keys=True, squeeze=False, observed=False, **kwargs)

参数注释：

by：用于对序列进行分组，参数by的值可以是函数，列名或列名列表，映射

1，by是函数

如果by是函数，那么调用的是序列索引的值

>>> s=pd.Series([1,2,3,4])
>>> s.groupby(by=lambda x: x<3).count()
False    1
True     3
dtype: int64

可以通过索引值来访问序列的元素值：

>>> s.groupby(by=lambda x: s.iat[x]<3).count()
False    2
True     2
dtype: int64

2，by是标签列表

如果by是标签列表，通常是按照列值来对数据进行分组，通常用于数据框（DataFrame）中

3，映射（字典）

当使用字典作为映射时，字典的key对应序列的值，按照字典的value对原始序列进行分组

>>> s.groupby(by=1:‘a‘,2:‘a‘,3:‘b‘,4:‘b‘).count()
a    2
b    1
dtype: int64

4，映射（序列）

当使用序列作为映射时，by序列的值用于对原始序列进行分组，by序列中相同的值对应着原始序列的值属于同一个分组；原始序列和by序列进行匹配的方法是索引对齐。

>>> s.groupby(by=pd.Series(data=[1,2,1,1],index=[0,2,3,1])).mean()
1    2.333333
2    3.000000
dtype: float64

索引对齐是怎么回事？

对于by参数的序列，数据是1, 2, 1, 1，这意味着，把原始序列分为2组，分组的key分别是1和2。

by序列的索引是0, 2, 3, 1，也就是说，当原始序列的索引为0, 3, 1 时，对应的分组key是1，当原始序列的索引为2时，对应的分组key是2。

索引对齐之后，原始序列中的值1,2,4属于分组1；原始序列中的值3属于分组2，再计算每个分组的均值。

六，滚动

滚动窗口计算，每个窗口计算一个聚合值，每次向前滚动一步（一步是一个元素）：

Series.rolling(self, window, min_periods=None, center=False, win_type=None, on=None, axis=0, closed=None)

参数注释：

• window：滚动的窗口值，或偏移量，每一个窗口都是一个固定值。
• min_periods：每个窗口的最小值，如果窗口中的元素数量小于min_periods，返回NaN；默认情况下，min_periods等于window参数的值。

举个例子，对于序列，当窗口设置为2时，如果不设置min_periods，那么窗口要想有值，那么窗口的大小必须是2，序列的第一个元素在窗口中只有一个值，因此返回NaN。

>>> s=pd.Series([1,2,3,4])
>>> s.rolling(2).sum()
0    NaN
1    3.0
2    5.0
3    7.0
dtype: float64
>>> s.rolling(window=2,min_periods =1).sum()
0    1.0
1    3.0
2    5.0
3    7.0
dtype: float64

七，扩展

扩展是指由序列的第一个元素开始，逐个元素向后计算聚合值，当聚合函数是sum时，表示从第一个元素开始，计算累加：

Series.expanding(self, min_periods=1, center=False, axis=0)

举个例子，从第一个元素开始计算序列1,2,3,4的累加：

>>> s=pd.Series([1,2,3,4])
>>> s.expanding().sum()
0     1.0
1     3.0
2     6.0
3    10.0
dtype: float64

八，指数加权移动平均

ewm（Exponentially Weighted Moving）是指数加权移动的简称，通常情况下，是对序列的元素进行指数加权，计算加权后的均值：

Series.ewm(self, com=None, span=None, halflife=None, alpha=None, min_periods=0, adjust=True, ignore_na=False, axis=0)

1，参数注释

在进行指数加权时，平滑因子有四种指定方式得出：

adjust：处于初期的衰减调整因子，以解决相对权重不平衡的问题。

• 当设置adjust为True时，加权均值的计算公式是： (1-alpha)**(n-1), (1-alpha)**(n-2), …, 1-alpha, 1
• 当设置adjust为False时，加权均值的计算公式是：weighted_average[0] = arg[0]; weighted_average[i] = (1-alpha)*weighted_average[i-1] + alpha*arg[i].

2，指数加权移动平均的意义

指数加权移动均值（EWMA，Exponentially Weighted Moving Average) 的公式是：EWMA(t) = aY(t) + (1-a)EWMA(t-1)，t = 1,2,.....,n；

表示的含义是：在t时刻，根据实际的观测值可以求取EWMA(t)，其中，EWMA(t)  表示 t 时刻的估计值；Y(t) t时刻的测量值；n 所观察的总的时间；a(0 < a <1)表示对于历史测量值权重系数。

之所以称之为指数加权，是因为加权系数a是以指数式递减的，即各指数随着时间而呈现出指数式递减。系数a越接近1表示对当前抽样值的权重越高，对过去测量值得权重越低，估计值(器)的时效性就越强，反之，越弱。

这种现象可以描述为应付突变的平稳性，平稳性随着a的增大而减小。当设置较小的系数a时，得出的均值更大程度上是参考过去的测量值，在较小程度上参考当前值，表现出很强的平稳性；当设置较大的系数a，得出的均值更大程度上是参考当前的测量值，表现出很强的波动性。举个例子，对于序列，设置较大的指数a=0.8和较小的指数a=0.2，位置越靠后，得出的均值越接近或越远离当前值：

>>> s=pd.Series([1,2,3,4])
>>> s.ewm(alpha=0.8).mean()
0    1.000000
1    1.833333
2    2.774194
3    3.756410
dtype: float64
>>> s.ewm(alpha=0.2).mean()
0    1.000000
1    1.555556
2    2.147541
3    2.775068
dtype: float64

 

 

 

参考文档：

pandas.Series.apply