Press "Enter" to skip to content

学会这些好用的pandas函数,让你的数据处理更快人一步

本站内容均来自兴趣收集,如不慎侵害的您的相关权益,请留言告知,我们将尽快删除.谢谢.

如果要获取总分排名前10的学生信息,大家可能会按照总分排序然后
head(10)
来操作一番,但是如果遇到同排名的情况导致前10的学生数超过10个肿幺办呢?

 

今天,我们就来看看pandas都提供了哪些便捷的函数方法,让我们数据处理快人一步~

 

目录:

 

1. 求最大或最小的前N组数据

 

2. 求当前元素和前一元素间变化率

 

3. 将列表中每个元素转化为一行

 

1. 求最大或最小的前N组数据

 

我们在进行数据处理的时候,往往会遇到一个场景,那就是 求这组数据中最大或最小的前N组数据
。一般情况下,我们可能会采用 df.sort_values(columns, ascending=False).head(n)
来求取,但是往往存在一些并列排名的数据会被无情的截断而获取不到。那幺,今天我们可以试试以下方法,也会就好了。

 

以下我们用求取最大的前N组数据为例进行介绍:

 

DataFrame.nlargest(n,columns,keep='first') Series.nlargest(n=5,keep='first')

 

 

keep参数可选值:默认为 first,可选 last 和 all (字面意思)

 

我们先构造一个案例数据

 

>>> import pandas as pd
>>> df = pd.DataFrame({'population': [59000000, 65000000, 434000,
...                                   434000, 434000, 337000, 11300,
...                                   11300, 11300],
...                    'GDP': [1937894, 2583560 , 12011, 4520, 12128,
...                            17036, 182, 38, 311],
...                    'alpha-2': ["IT", "FR", "MT", "MV", "BN",
...                                "IS", "NR", "TV", "AI"]},
...                   index=["Italy", "France", "Malta",
...                          "Maldives", "Brunei", "Iceland",
...                          "Nauru", "Tuvalu", "Anguilla"])
>>> df
          population      GDP alpha-2
Italy       59000000  1937894      IT
France      65000000  2583560      FR
Malta         434000    12011      MT
Maldives      434000     4520      MV
Brunei        434000    12128      BN
Iceland       337000    17036      IS
Nauru          11300      182      NR
Tuvalu         11300       38      TV
Anguilla       11300      311      AI

 

对于上述案例数据,如果我们想获取population字段最多的前3组数据,发现第三名都是434000。如果采用 head(3)
,实际有2个满足要求的数据行被我们漏掉了;这个时候使用 df.nlargest(3, 'population',keep='all')
,即可获取我们需要的结果。

 

>>> df.head(3)
        population      GDP alpha-2
Italy     59000000  1937894      IT
France    65000000  2583560      FR
Malta       434000    12011      MT
>>> df.nlargest(3, 'population')
        population      GDP alpha-2
France    65000000  2583560      FR
Italy     59000000  1937894      IT
Malta       434000    12011      MT
# keep = 'all' 即表示满足排名的全部返回
>>> df.nlargest(3, 'population',keep='all')
          population      GDP alpha-2
France      65000000  2583560      FR
Italy       59000000  1937894      IT
Malta         434000    12011      MT
Maldives      434000     4520      MV
Brunei        434000    12128      BN

 

当然,我们可能面临更复杂的需求,比如按照多个字段取最大的前N组数据,这个案例中我们要取population最多的中GDP前三的数据。

 

>>> df.nlargest(3, ['population', 'GDP'])
        population      GDP alpha-2
France    65000000  2583560      FR
Italy     59000000  1937894      IT
Brunei      434000    12128      BN

 

对于最小的前N组数据,函数如下(参数含义同):

 

DataFrame.nsmallest(n,columns,keep='first') Series.nsmallest(n=5,keep='first')

 

2. 求当前元素和前一元素间变化率

 

有时候,我们的数据可能是时间序列下的,为了更方便看到随着时间变化某行或列数据的变化率,这里就可以采用 pct_change
方法直接获取。

 

pct_change(periods=1,fill_method='pad',limit=None,freq=None,kwargs)

 

先看看对于 Series
类型数据:

 

>>> s = pd.Series([90, 91, 85])
>>> s.pct_change()
0         NaN
1    0.011111
2   -0.065934
dtype: float64
# 设置间隔periods=2,在这里就是85相比90的变化率
>>> s.pct_change(periods=2)
0         NaN
1         NaN
2   -0.055556
dtype: float64

 

对于有缺失值的情况,我们可以填充缺失值后参与计算或者在计算百分比时设置填充参数 fill_method

 

>>> s = pd.Series([90, 91, None, 85])
>>> s
0    90.0
1    91.0
2     NaN
3    85.0
dtype: float64
>>> s.pct_change(fill_method='bfill')
0         NaN
1    0.011111
2   -0.065934
3    0.000000
dtype: float64
>>> s.pct_change(fill_method='ffill')
0         NaN
1    0.011111
2    0.000000
3   -0.065934
dtype: float64
>>> s.pct_change()
0         NaN
1    0.011111
2    0.000000
3   -0.065934
dtype: float64

 

也可以直接对 Dataframe
类型数据进行处理:

 

>>> df = pd.DataFrame({
...     'FR': [4.0405, 4.0963, 4.3149],
...     'GR': [1.7246, 1.7482, 1.8519],
...     'IT': [804.74, 810.01, 860.13]},
...     index=['1980-01-01', '1980-02-01', '1980-03-01'])
>>> df
                FR      GR      IT
1980-01-01  4.0405  1.7246  804.74
1980-02-01  4.0963  1.7482  810.01
1980-03-01  4.3149  1.8519  860.13
>>> df.pct_change()
                  FR        GR        IT
1980-01-01       NaN       NaN       NaN
1980-02-01  0.013810  0.013684  0.006549
1980-03-01  0.053365  0.059318  0.061876
>>> df = pd.DataFrame({
...     '2016': [1769950, 30586265],
...     '2015': [1500923, 40912316],
...     '2014': [1371819, 41403351]},
...     index=['GOOG', 'APPL'])
>>> df
2016      2015      2014
GOOG   1769950   1500923   1371819
APPL  30586265  40912316  41403351
# 对行进行操作axis=1或'columns'
>>> df.pct_change(axis = 1)
2016      2015      2014
GOOG   NaN -0.151997 -0.086016
APPL   NaN  0.337604  0.012002
>>> df.pct_change(axis = 'columns')
2016      2015      2014
GOOG   NaN -0.151997 -0.086016
APPL   NaN  0.337604  0.012002

 

3. 将列表中每个元素转化为一行

 

有时候,我们的原始数据中某些元素可能是列表的形式,而我们需要对它进行展开操作,于是 explode
方法就来了。

 

Series.explode(ignore_index=False) DataFrame.explode(column,ignore_index=False)

 

先看看对 Series
类型数据的处理:

 

>>> s = pd.Series([[1, 2, 3], 'foo', [], [3, 4]])
>>> s
0    [1, 2, 3]
1          foo
2           []
3       [3, 4]
dtype: object
# 默认情况下,会复制索引
>>> s.explode()
0      1
0      2
0      3
1    foo
2    NaN
3      3
3      4
dtype: object
# 设置参数ignore_index=True,则会重置索引
>>> s.explode(ignore_index=True)
0      1
1      2
2      3
3    foo
4    NaN
5      3
6      4
dtype: object

 

再看看在 Dataframe
类型数据下的操作:

 

>>> df = pd.DataFrame({'A': [[1, 2, 3], 'foo', [], [3, 4]], 'B': 1})
>>> df
           A  B
0  [1, 2, 3]  1
1        foo  1
2         []  1
3     [3, 4]  1
# 默认情况下,会复制索引
>>> df.explode('A')
     A  B
0    1  1
0    2  1
0    3  1
1  foo  1
2  NaN  1
3    3  1
3    4  1
# 设置参数ignore_index=True,则会重置索引
>>> df.explode('A',ignore_index=True)
     A  B
0    1  1
1    2  1
2    3  1
3  foo  1
4  NaN  1
5    3  1
6    4  1

 

以上就是本次的全部内容,希望能带给大家帮助~

Be First to Comment

发表评论

您的电子邮箱地址不会被公开。 必填项已用*标注