几个高效Pandas函数
Pandas是python中最主要的数据分析库之一，它提供了非常多的函数、方法，可以高效地处理并分析数据。让pandas如此受欢迎的原因是它简洁、灵活、功能强大的语法。
这篇文章将会配合实例，讲解10个重要的pandas函数。其中有一些很常用，相信你可能用到过。还有一些函数出现的频率没那么高，但它们同样是分析数据的得力帮手。
介绍这些函数之前，第一步先要导入pandas和numpy。
import numpy as np
import pandas as pd1. 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 52. 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.8093983. 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 214. 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)
sample25. 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'] = 0Where是一种掩码操作。
「掩码」（英语：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 47. 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 08. 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: float649. 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: float6410. 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 611. 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 112. 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 3In [12]: df.dtypes
Out[12]:
A object
dtype: object使用infer_objects方法将object推断为int类型：
In [13]: df.infer_objects().dtypes
Out[13]:
A int64
dtype: object14. 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当前页面是本站的「Google AMP」版。查看和发表评论请点击：完整版 »