几个高效Pandas函数

实验室日常摸鱼...

请注意，本文编写于 1307 天前，最后修改于 1307 天前，其中某些信息可能已经过时。

Pandas是python中最主要的数据分析库之一，它提供了非常多的函数、方法，可以高效地处理并分析数据。让pandas如此受欢迎的原因是它简洁、灵活、功能强大的语法。

这篇文章将会配合实例，讲解10个重要的pandas函数。其中有一些很常用，相信你可能用到过。还有一些函数出现的频率没那么高，但它们同样是分析数据的得力帮手。

介绍这些函数之前，第一步先要导入pandas和numpy。

import numpy as np
import pandas as pd

1. Query

Query是pandas的过滤查询函数，使用布尔表达式来查询DataFrame的列，就是说按照列的规则进行过滤操作。

用法：

pandas.DataFrame.query(self, expr, inplace = False, **kwargs)

参数作用：

expr：要评估的查询字符串；
inplace=False：查询是应该修改数据还是返回修改后的副本
kwargs：dict关键字参数

首先生成一段df：

values_1 = np.random.randint(10, size=10)
values_2 = np.random.randint(10, size=10)
years = np.arange(2010,2020)
groups = ['A','A','B','A','B','B','C','A','C','C']
df = pd.DataFrame({'group':groups, 'year':years, 'value_1':values_1, 'value_2':values_2})

生成的数据集为：

In [45]: df
Out[45]:
  group  year  value_1  value_2
0     A  2010        7        0
1     A  2011        9        0
2     B  2012        4        0
3     A  2013        8        0
4     B  2014        7        6
5     B  2015        7        3
6     C  2016        1        9
7     A  2017        1        4
8     C  2018        6        7
9     C  2019        0        5

过滤查询用起来比较简单，比如要查列value_1<value_2的行记录：

In [46]: df.query('value_1 < value_2')
Out[46]:
  group  year  value_1  value_2
6     C  2016        1        9
7     A  2017        1        4
8     C  2018        6        7
9     C  2019        0        5

In [47]: df[df.value_1 < df.value_2]  # 等价写法
Out[47]:
  group  year  value_1  value_2
6     C  2016        1        9
7     A  2017        1        4
8     C  2018        6        7
9     C  2019        0        5

查询列year>=2016的行记录：

In [48]: df.query('year >= 2016 ')
Out[48]:
  group  year  value_1  value_2
6     C  2016        1        9
7     A  2017        1        4
8     C  2018        6        7
9     C  2019        0        5

In [49]: df[df.year >= 2016]  # 等价写法
Out[49]:
  group  year  value_1  value_2
6     C  2016        1        9
7     A  2017        1        4
8     C  2018        6        7
9     C  2019        0        5

2. Insert

Insert用于在DataFrame的指定位置中插入新的数据列。默认情况下新列是添加到末尾的，但可以更改位置参数，将新列添加到任何位置。

用法：

Dataframe.insert(loc, column, value, allow_duplicates=False)

参数作用：

loc: int型，表示插入位置在第几列；若在第一列插入数据，则 loc=0
column: 给插入的列取名，如 column='新的一列'
value：新列的值，数字、array、series等都可以
allow_duplicates: 是否允许列名重复，选择Ture表示允许新的列名与已存在的列名重复

在第三列的位置插入新列：

#新列的值
new_col = np.random.randn(10)
#在第三列位置插入新列，从0开始计算
df.insert(2, 'new_col', new_col)

控制台输出数据集：

In [51]: df
Out[51]:
  group  year   new_col  value_1  value_2
0     A  2010  2.792077        7        0
1     A  2011 -0.827499        9        0
2     B  2012 -0.611400        4        0
3     A  2013  0.988884        8        0
4     B  2014  1.098097        7        6
5     B  2015  0.584294        7        3
6     C  2016 -0.231389        1        9
7     A  2017  0.530017        1        4
8     C  2018  0.423939        6        7
9     C  2019 -0.809398        0        5

In [56]: df['new_col'] = new_col  # 等价写法，但是这种写法不能指定插入列的位置

In [57]: df
Out[57]:
  group  year  value_1  value_2   new_col
0     A  2010        7        0  2.792077
1     A  2011        9        0 -0.827499
2     B  2012        4        0 -0.611400
3     A  2013        8        0  0.988884
4     B  2014        7        6  1.098097
5     B  2015        7        3  0.584294
6     C  2016        1        9 -0.231389
7     A  2017        1        4  0.530017
8     C  2018        6        7  0.423939
9     C  2019        0        5 -0.809398

3. Cumsum

Cumsum是pandas的累加函数，用来求列的累加值。用法：

DataFrame.cumsum(axis=None, skipna=True, args, kwargs)

参数作用：

axis：index或者轴的名字
skipna：排除NA/null值

以前面的df为例，group列有A、B、C三组，year列有多个年份。我们只知道当年度的值value_1、value_2，现在求group分组下的累计值，比如A、2014之前的累计值，可以用cumsum函数来实现。

当然仅用cumsum函数没办法对groups (A, B, C)进行区分，所以需要结合分组函数groupby分别对(A, B, C)进行值的累加。

In [63]: df['cumsum'] = df[['value_2','group']].groupby('group').cumsum()

In [64]: df
Out[64]:
  group  year  value_1  value_2   new_col  cumsum
0     A  2010        7        0  2.792077       0  # A组2010年累计value_2为0
1     A  2011        9        0 -0.827499       0  # A组2011年累计value_2为0
2     B  2012        4        0 -0.611400       0
3     A  2013        8        0  0.988884       0  # A组2013年累计value_2为0
4     B  2014        7        6  1.098097       6
5     B  2015        7        3  0.584294       9
6     C  2016        1        9 -0.231389       9
7     A  2017        1        4  0.530017       4  # A组2010年累计value_2为4
8     C  2018        6        7  0.423939      16
9     C  2019        0        5 -0.809398      21

4. Sample

Sample用于从DataFrame中随机选取若干个行或列。用法：

DataFrame.sample(n=None, frac=None, replace=False, weights=None, random_state=None, axis=None)

参数作用：

n：要抽取的行数
frac：抽取行的比例例如frac=0.8，就是抽取其中80%
replace：是否为有放回抽样， True:有放回抽样 False:未放回抽样
weights：字符索引或概率数组
random_state ：随机数发生器种子
axis：选择抽取数据的行还是列 axis=0:抽取行 axis=1:抽取列

比如要从df中随机抽取1行：

In [71]: df.sample(n=1)
Out[71]:
  group  year  value_1  value_2   new_col  cumsum
9     C  2019        0        5 -0.809398      21

从df随机抽取60%的行，并且设置随机数种子，每次能抽取到一样的样本：

sample2 = df.sample(frac=0.6,random_state=2)
sample2

5. Where

Where用来根据条件替换行或列中的值。如果满足条件，保持原来的值，不满足条件则替换为其他值。默认替换为NaN，也可以指定特殊值。

用法：

DataFrame.where(cond, other=nan, inplace=False, axis=None, level=None, errors='raise', try_cast=False, raise_on_error=None)

参数作用：

cond：布尔条件，如果 cond 为真，保持原来的值，否则替换为other
other：替换的特殊值
inplace：inplace为真则在原数据上操作，为False则在原数据的copy上操作
axis：行或列

将df中列value_1里小于5的值替换为0：

df['value_1'].where(df['value_1'] > 5 , 0)

# 等价于（好像该方法已经弃用）
df[df['value_1'] <= 5]['value_1'] = 0

Where是一种掩码操作。

「掩码」（英语：Mask）在计算机学科及数字逻辑中指的是一串二进制数字，通过与目标数字的按位操作，达到屏蔽指定位而实现需求。

6. Isin

Isin也是一种过滤方法，用于查看某列中是否包含某个字符串，返回值为布尔Series，来表明每一行的情况。

用法：

Series.isin(values)
或者
DataFrame.isin(values)

筛选df中year列值在['2010','2014','2017']里的行：

In [96]: years = ['2010','2014','2017']
    ...: df[df.year.isin(years)]
Out[96]:
  group  year  value_1  value_2   new_col  cumsum
0     A  2010        7        0  2.792077       0
4     B  2014        7        6  1.098097       6
7     A  2017        1        4  0.530017       4

7. Loc and iloc

Loc和iloc通常被用来选择行和列，它们的功能相似，但用法是有区别的。

用法：

DataFrame.loc[]
# 或者
DataFrame.iloc[]

loc：按标签（column和index）选择行和列
iloc：按索引位置选择行和列

选择df第1~3行、第1~2列的数据，使用iloc（先行后列）：

In [100]: df.iloc[:3,:2]
Out[100]:
  group  year
0     A  2010
1     A  2011
2     B  2012

使用loc：

In [105]: df.loc[:2,['group','year']]
Out[105]:
  group  year
0     A  2010
1     A  2011
2     B  2012

混合索引的使用：

In [108]: df
Out[108]:
  group  year  value_1  value_2   new_col  cumsum
0     A  2010        7        0  2.792077       0
1     A  2011        9        0 -0.827499       0
2     B  2012        4        0 -0.611400       0
3     A  2013        8        0  0.988884       0
4     B  2014        7        6  1.098097       6
5     B  2015        7        3  0.584294       9
6     C  2016        1        9 -0.231389       9
7     A  2017        1        4  0.530017       4
8     C  2018        6        7  0.423939      16
9     C  2019        0        5 -0.809398      21

In [109]: df.loc[df.index[0:4], ['group', 'year', 'value_2']]
Out[109]:
  group  year  value_2
0     A  2010        0
1     A  2011        0
2     B  2012        0
3     A  2013        0

In [110]: df.iloc[0:4, df.columns.get_indexer(['group', 'year', 'value_2'])]
Out[110]:
  group  year  value_2
0     A  2010        0
1     A  2011        0
2     B  2012        0
3     A  2013        0

8. Pct_change

Pct_change是一个统计函数，用于表示当前元素与前面元素的相差百分比，两元素的区间可以调整。

比如说给定三个元素[2,3,6]，计算相差百分比后得到[NaN, 0.5, 1.0]，从第一个元素到第二个元素增加50％，从第二个元素到第三个元素增加100％。

用法：

DataFrame.pct_change(periods=1, fill_method=‘pad’, limit=None, freq=None, **kwargs)

参数作用：

periods：间隔区间，即步长
fill_method：处理空值的方法

对df的value_1列进行增长率的计算：

In [112]: df.value_1
Out[112]:
0    7
1    9
2    4
3    8
4    7
5    7
6    1
7    1
8    6
9    0
Name: value_1, dtype: int32

In [113]: df.value_1.pct_change()
Out[113]:
0         NaN
1    0.285714
2   -0.555556
3    1.000000
4   -0.125000
5    0.000000
6   -0.857143
7    0.000000
8    5.000000
9   -1.000000
Name: value_1, dtype: float64

9. Rank

Rank是一个排名函数，按照规则（从大到小，从小到大）给原序列的值进行排名，返回的是排名后的名次。

比如有一个序列[1,7,5,3]，使用rank从小到大排名后，返回[1,4,3,2]，这就是前面那个序列每个值的排名位置。

用法：

rank(axis=0, method: str = 'average', numeric_only: Union[bool, NoneType] = None, na_option: str = 'keep', ascending: bool = True, pct: bool = False)

参数作用：

axis：行或者列

method：返回名次的方式，可选{‘average’, ‘min’, ‘max’, ‘first’, ‘dense’}

method=average 默认设置: 相同的值占据前两名，分不出谁是1谁是2，那么去中值即1.5，下面一名为第三名
method=max: 两人并列第 2 名，下一个人是第 3 名
method=min: 两人并列第 1 名，下一个人是第 3 名
method=dense: 两人并列第1名，下一个人是第 2 名
method=first: 相同值会按照其在序列中的相对位置定值

ascending：正序和倒序

对df中列value_1进行排名：

In [115]: df
Out[115]:
  group  year  value_1  value_2   new_col  cumsum
0     A  2010        7        0  2.792077       0
1     A  2011        9        0 -0.827499       0
2     B  2012        4        0 -0.611400       0
3     A  2013        8        0  0.988884       0
4     B  2014        7        6  1.098097       6
5     B  2015        7        3  0.584294       9
6     C  2016        1        9 -0.231389       9
7     A  2017        1        4  0.530017       4
8     C  2018        6        7  0.423939      16
9     C  2019        0        5 -0.809398      21

In [116]: df.value_1.rank()
Out[116]:
0     7.0
1    10.0
2     4.0
3     9.0
4     7.0
5     7.0
6     2.5
7     2.5
8     5.0
9     1.0
Name: value_1, dtype: float64

In [118]: df.value_1.rank(method='min')
Out[118]:
0     6.0
1    10.0
2     4.0
3     9.0
4     6.0
5     6.0
6     2.0
7     2.0
8     5.0
9     1.0
Name: value_1, dtype: float64

10. Melt

Melt用于将宽表变成窄表，是 pivot透视逆转操作函数，将列名转换为列数据(columns name → column values)，重构DataFrame。

简单说就是将指定的列放到铺开放到行上变成两列，类别是variable(可指定)列，值是value(可指定)列。

用法：

pandas.melt(frame, id_vars=None, value_vars=None, var_name=None, value_name='value', col_level=None)

参数作用：

frame：它是指DataFrame
id_vars [元组, 列表或ndarray, 可选]：不需要被转换的列名，引用用作标识符变量的列
value_vars [元组, 列表或ndarray, 可选]：引用要取消透视的列。如果未指定, 请使用未设置为id_vars的所有列
var_name [scalar]：指代用于”变量”列的名称。如果为None, 则使用- - frame.columns.name或’variable’
value_name [标量, 默认为’value’]：是指用于” value”列的名称
col_level [int或string, 可选]：如果列为MultiIndex, 它将使用此级别来融化

例如有一串数据，表示不同城市和每天的人口流动：

In [119]: df = pd.DataFrame({'city': {0: 'a', 1: 'b', 2: 'c'},
     ...:                      'day1': {0: 1, 1: 3, 2: 5},
     ...:                      'day2': {0: 2, 1: 4, 2: 6}})

In [120]: df
Out[120]:
  city  day1  day2
0    a     1     2
1    b     3     4
2    c     5     6

现在将day1、day2列变成变量列，再加一个值列：

In [121]: pd.melt(df, id_vars=['city'])
Out[121]:
  city variable  value
0    a     day1      1
1    b     day1      3
2    c     day1      5
3    a     day2      2
4    b     day2      4
5    c     day2      6

11. explode

explode用于将一行数据展开成多行。比如说dataframe中某一行其中一个元素包含多个同类型的数据，若想要展开成多行进行分析，这时候explode就派上用场，而且只需一行代码，非常节省时间。

用法：

DataFrame.explode(self, column: Union[str, Tuple])

参数作用：

column ：str或tuple

以下表中第三行、第二列为例，展开[2,3,8]：

In [3]: # 先创建表
   ...: id = ['a','b','c']
   ...: measurement = [4,6,[2,3,8]]
   ...: day = [1,1,1]
   ...: df = pd.DataFrame({'id':id, 'measurement':measurement, 'day':day})
   ...: df
    
Out[3]:
  id measurement  day
0  a           4    1
1  b           6    1
2  c   [2, 3, 8]    1

使用explode轻松将[2,3,8]转换成多行，且行内其他元素保持不变。

In [4]: df.explode('measurement').reset_index(drop=True)
Out[4]:
  id measurement  day
0  a           4    1
1  b           6    1
2  c           2    1
3  c           3    1
4  c           8    1

12. Nunique

注意：nunique()与unique()方法的不同。

Nunique用于计算行或列上唯一值的数量，即去重后计数。这个函数在分类问题中非常实用，当不知道某字段中有多少类元素时，Nunique能快速生成结果。

用法：

Series.nunique(dropna=True)
# 或者
DataFrame.nunique(axis=0, dropna=True)

参数作用：

axis：int型，0代表行，1代表列，默认0；
dropna：bool类型，默认为True，计数中不包括NaN；

先创建一个df：

In [5]: values_1 = np.random.randint(10, size=10)
   ...: values_2 = np.random.randint(10, size=10)
   ...: years = np.arange(2010,2020)
   ...: groups = ['A','A','B','A','B','B','C','A','C','C']
   ...: df = pd.DataFrame({'group':groups, 'year':years, 'value_1':values_1, 'value_2'
   ...: :values_2})
   ...: df
Out[5]:
  group  year  value_1  value_2
0     A  2010        0        6
1     A  2011        2        3
2     B  2012        9        7
3     A  2013        3        6
4     B  2014        7        2
5     B  2015        3        3
6     C  2016        3        6
7     A  2017        5        9
8     C  2018        3        8
9     C  2019        2        5

对year列进行唯一值计数：

In [6]: df.year.nunique()
Out[6]: 10

In [7]: df.year.unique()  # 对比有什么不同
Out[7]: array([2010, 2011, 2012, 2013, 2014, 2015, 2016, 2017, 2018, 2019])

输出：10 对整个dataframe的每一个字段进行唯一值计数：

In [8]: df.nunique()
Out[8]:
group       3
year       10
value_1     6
value_2     7
dtype: int64

In [9]: df.unique()
---------------------------------------------------------------------------
AttributeError                            Traceback (most recent call last)
<ipython-input-9-84bc62f43960> in <module>
----> 1 df.unique()

c:\users\myxc\appdata\local\programs\python\python37\lib\site-packages\pandas\core\generic.py in __getattr__(self, name)
   5134             if self._info_axis._can_hold_identifiers_and_holds_name(name):
   5135                 return self[name]
-> 5136             return object.__getattribute__(self, name)
   5137
   5138     def __setattr__(self, name: str, value) -> None:

AttributeError: 'DataFrame' object has no attribute 'unique'

13. infer_objects

infer_objects用于将object类型列推断为更合适的数据类型。

用法：

# 直接将df或者series推断为合适的数据类型
DataFrame.infer_objects()

pandas支持多种数据类型，其中之一是object类型。object类型包括字符串和混合值（数字及非数字）。

object类型比较宽泛，如果可以确定为具体数据类型，则不建议用object。

In [10]: df = pd.DataFrame({"A": ["a", 1, 2, 3]})
    ...: df = df.iloc[1:]

In [11]: df
Out[11]:
   A
1  1
2  2
3  3

In [12]: df.dtypes
Out[12]:
A    object
dtype: object

使用infer_objects方法将object推断为int类型：

In [13]: df.infer_objects().dtypes
Out[13]:
A    int64
dtype: object

14. memory_usage

memory_usage用于计算dataframe每一列的字节存储大小，这对于大数据表非常有用。

用法：

DataFrame.memory_usage(index=True, deep=False)

参数解释：
index：指定是否返回df中索引字节大小，默认为True，返回的第一行即是索引的内存使用情况；
deep：如果为True，则通过查询object类型进行系统级内存消耗来深入地检查数据，并将其包括在返回值中。

首先创建一个df，共2列，1000000行。

In [14]: df_large = pd.DataFrame({'A': np.random.randn(1000000),
    ...:                     'B': np.random.randint(100, size=1000000)})
    ...: df_large.shape
Out[14]: (1000000, 2)

返回每一列的占用字节大小：

In [15]: df_large.memory_usage()
Out[15]:
Index        128
A        8000000
B        4000000
dtype: int64

第一行是索引index的内存情况，其余是各列的内存情况。

15. replace

顾名思义，replace是用来替换df中的值，赋以新的值。

用法：

DataFrame.replace(to_replace=None, value=None, inplace=False, limit=None, regex=False, method='pad')

参数解释：

to_replace：被替换的值
value：替换后的值
inplace：是否要改变原数据，False是不改变，True是改变，默认是False
limit：控制填充次数
regex：是否使用正则,False是不使用，True是使用，默认是False
method：填充方式，pad,ffill,bfill分别是向前、向前、向后填充

创建一个df：

In [16]: values_1 = np.random.randint(10, size=10)
    ...: values_2 = np.random.randint(10, size=10)
    ...: years = np.arange(2010,2020)
    ...: groups = ['A','A','B','A','B','B','C','A','C','C']
    ...: df = pd.DataFrame({'group':groups, 'year':years, 'value_1':values_1, 'value_2
    ...: ':values_2})
    ...: df
Out[16]:
  group  year  value_1  value_2
0     A  2010        5        4
1     A  2011        5        5
2     B  2012        2        2
3     A  2013        3        2
4     B  2014        6        0
5     B  2015        7        7
6     C  2016        3        9
7     A  2017        4        7
8     C  2018        6        8
9     C  2019        1        4

将A全部替换为D：

In [17]: df.replace('A','D')
Out[17]:
  group  year  value_1  value_2
0     D  2010        5        4
1     D  2011        5        5
2     B  2012        2        2
3     D  2013        3        2
4     B  2014        6        0
5     B  2015        7        7
6     C  2016        3        9
7     D  2017        4        7
8     C  2018        6        8
9     C  2019        1        4

将B替换为E，C替换为F：

In [18]: df.replace({'B':'E','C':'F'})
Out[18]:
  group  year  value_1  value_2
0     A  2010        5        4
1     A  2011        5        5
2     E  2012        2        2
3     A  2013        3        2
4     E  2014        6        0
5     E  2015        7        7
6     F  2016        3        9
7     A  2017        4        7
8     F  2018        6        8
9     F  2019        1        4

----- END -----

博客站点：亚灿网志（Yacan's Blog）
本文链接：https://blog.manyacan.com/archives/1890/
版权声明：本文章采用 知识共享署名-非商业性使用-相同方式共享 4.0 国际许可协议 。

Python 数据可视化

几个高效Pandas函数

1. Query

2. Insert

3. Cumsum

4. Sample

5. Where

6. Isin

7. Loc and iloc

8. Pct_change

9. Rank

10. Melt

11. explode

12. Nunique

13. infer_objects

14. memory_usage

15. replace

添加新评论

--------------- 此处无声胜有声~ ---------------

几个高效Pandas函数

1. Query

2. Insert

3. Cumsum

4. Sample

5. Where

6. Isin

7. Loc and iloc

8. Pct_change

9. Rank

10. Melt

11. explode

12. Nunique

13. infer_objects

14. memory_usage

15. replace

Pandas高级应用

终究还是又回来了

添加新评论

--------------- 此处无声胜有声~ ---------------