如果要获取总分排名前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
以上就是本次的全部内容，希望能带给大家帮助~
