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

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

一,应用函数

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

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

posted @ 2019-09-24 10:59 悦光阴 阅读(...) 评论(...) 编辑 收藏