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

妖狐艹你老母 2023-01-13 05:29 144阅读 0赞

如果要获取总分排名前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

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