想熟悉和使用一种数据结构,得从3个方面进行学习:
- 创建,一般有多种创建形式
- 变形,此时不涉及各种计算函数,主要对数据结构进行切片,筛选和变形等操作
- 计算,进行分析处理的主要部分
Pandas处理以下三个数据结构:
- 系列(Series)
- 数据帧(DataFrame)
- 面板(Panel)
数据帧(DataFrame)是一个具有异构数据的二维数组,数据分析中使用最多的是DataFrame,主要对DataFrame进行总结。
1、Series
1.1、series的创建
1.1.1、来自构造函数pandas.Series( data, index, dtype, copy)
参数 | 说明 |
---|---|
data | 数据采取各种形式,如:ndarray,list,constants |
index | 索引值必须是唯一的和散列的,与数据的长度相同。 默认np.arange(n)如果没有索引被传递。 |
dtype | dtype用于数据类型。如果没有,将推断数据类型 |
copy | 复制数据,默认为false |
1.1.2、从ndarray创建一个系列
1.1.3、从字典创建一个系列
1.1.4、从标量创建一个系列
import numpy as np
import pandas as pd
pd.set_option('expand_frame_repr','False') # 打印表格不换行
# pd.set_option('display.max_columns', 40) # 打印最大列数
pd.set_option('display.max_colwidth', 50) # 打印显示最多行数设置
s1 = pd.Series([1,2,3,4],index=list('abcd'))
print (s1)
arr1 = np.array([1,2,3,4,5])
s2 = pd.Series(arr1)
print (s2,type(s2))
print ('*_* '*5,'',' *_*'*5)
dict1 = dict(s1)
print (dict1)
s3 = pd.Series(dict1)
print (s3)
s4 = pd.Series(3,index = list('abcd'))
print (s4)
a 1
b 2
c 3
d 4
dtype: int64
0 1
1 2
2 3
3 4
4 5
dtype: int32 <class 'pandas.core.series.Series'>
*_* *_* *_* *_* *_* *_* *_* *_* *_* *_*
{'a': 1, 'b': 2, 'c': 3, 'd': 4}
a 1
b 2
c 3
d 4
dtype: int64
a 3
b 3
c 3
d 3
dtype: int64
1.2、series的查找、修改和删除
s5 = s3.copy()
print (s5)
print ('*_* '*5,'',' *_*'*5)
print (s5[1])
print (s5['b'])
s5['b'] = 5
print (s5)
del s5['b']
print (s5)
a 1
b 2
c 3
d 4
dtype: int64
*_* *_* *_* *_* *_* *_* *_* *_* *_* *_*
2
2
a 1
b 5
c 3
d 4
dtype: int64
a 1
c 3
d 4
dtype: int64
2、DataFrame
数据帧(DataFrame)的功能特点:
- 潜在的列是不同的类型
- 大小可变
- 标记轴(行和列)
- 可以对行和列执行算术运算
2.1、DataFrame创建
2.1.1、可以使用构造函数创建 pandas.DataFrame( data, index, columns, dtype, copy)
参数 | 说明 |
---|---|
data | 数据采取各种形式,如:ndarray,series,map,lists,dict,constant和另一个DataFrame。 |
index | 对于行标签,要用于结果帧的索引是可选缺省值np.arrange(n),如果没有传递索引值。 |
columns | 对于列标签,可选的默认语法是 - np.arange(n)。 这只有在没有索引传递的情况下才是这样。 |
dtype | 每列的数据类型。 |
copy | 如果默认值为False,则此命令(或任何它)用于复制数据。 |
2.1.2、Pandas数据帧(DataFrame)可以使用各种输入创建
- 列表
- 字典
- 系列
- Numpy ndarrays
- 另一个数据帧(DataFrame)
np.random.seed(1)
d1 = pd.DataFrame(np.random.randn(4,3),index=list('abcd'),columns=list('xyz'))
print (d1)
list1 = [[1,2,3],[2,3,4]]
d2 = pd.DataFrame(list1)
print (d2)
dict1 = {'Name':['Tom', 'Jack', 'Steve', 'Ricky'],'Age':[28,34,29,42]}
d3 = pd.DataFrame(dict1)
print (d3)
arr1 = np.random.randint(3,7,(4,3))
d4 = pd.DataFrame(arr1)
print (d4)
d5 = d4.copy()
print (d5)
x y z
a 1.624345 -0.611756 -0.528172
b -1.072969 0.865408 -2.301539
c 1.744812 -0.761207 0.319039
d -0.249370 1.462108 -2.060141
0 1 2
0 1 2 3
1 2 3 4
Name Age
0 Tom 28
1 Jack 34
2 Steve 29
3 Ricky 42
0 1 2
0 6 5 3
1 5 4 4
2 4 6 6
3 4 5 4
0 1 2
0 6 5 3
1 5 4 4
2 4 6 6
3 4 5 4
2.1.3、外部文件读入
more details for pandas IO tools:
http://pandas.pydata.org/pandas-docs/stable/user_guide/io.html
np.random.seed(3)
arr1 = np.random.randn(200,5)
print (arr1[:5,:])
d1 = pd.DataFrame(arr1,index=np.arange(3,203),columns=list('ABCDE'))
print (d1.head())
d1.to_csv('csv_test.csv')
d2 = pd.read_csv('csv_test.csv',index_col=0)
'''
index_col为指定数据中那一列作为Dataframe的行索引,也可以可指定多列,形成层次索引,默认为None,即不指定行索引,这样系统会自动加上行索引
'''
print (d2.head())
d3 = pd.read_excel('excel_test.xls', sheet_name='Sheet1')
print (d3.head())
d4 = d3[['零件号','零件名称','数量','计量单位代码']]
print (d4.head())
[[ 1.78862847 0.43650985 0.09649747 -1.8634927 -0.2773882 ]
[-0.35475898 -0.08274148 -0.62700068 -0.04381817 -0.47721803]
[-1.31386475 0.88462238 0.88131804 1.70957306 0.05003364]
[-0.40467741 -0.54535995 -1.54647732 0.98236743 -1.10106763]
[-1.18504653 -0.2056499 1.48614836 0.23671627 -1.02378514]]
A B C D E
3 1.788628 0.436510 0.096497 -1.863493 -0.277388
4 -0.354759 -0.082741 -0.627001 -0.043818 -0.477218
5 -1.313865 0.884622 0.881318 1.709573 0.050034
6 -0.404677 -0.545360 -1.546477 0.982367 -1.101068
7 -1.185047 -0.205650 1.486148 0.236716 -1.023785
A B C D E
3 1.788628 0.436510 0.096497 -1.863493 -0.277388
4 -0.354759 -0.082741 -0.627001 -0.043818 -0.477218
5 -1.313865 0.884622 0.881318 1.709573 0.050034
6 -0.404677 -0.545360 -1.546477 0.982367 -1.101068
7 -1.185047 -0.205650 1.486148 0.236716 -1.023785
零件号 零件名称 数量 计量单位代码 Unnamed: 4 Unnamed: 5 车牌号 Unnamed: 7
0 1.0 水准仪 1.0 1.0 404门 NaN 粤A4FU10 NaN
1 2.0 扭力扳手 1.0 1.0 404门 NaN 粤A4FU10 NaN
2 3.0 三角架 1.0 1.0 404门 NaN 粤A4FU10 NaN
3 4.0 安全带 10.0 1.0 404门 NaN 粤A4FU10 NaN
4 5.0 吊带 20.0 2.0 404门 NaN 粤A4FU10 NaN
零件号 零件名称 数量 计量单位代码
0 1.0 水准仪 1.0 1.0
1 2.0 扭力扳手 1.0 1.0
2 3.0 三角架 1.0 1.0
3 4.0 安全带 10.0 1.0
4 5.0 吊带 20.0 2.0
2.2、DataFrame操作
此处的操作仅指改变DataFrame的形状,元素位置和筛选出特定条件的元素
2.2.1、索引和切片
Python和NumPy索引运算符"[]“和属性运算符”."。 可以在广泛的用例中快速轻松地访问Pandas数据结构。然而,由于要访问的数据类型不是预先知道的,所以直接使用标准运算符具有一些优化限制。对于生产环境的代码,我们建议利用本章介绍的优化Pandas数据访问方法。
- .loc()|基于标签
- .iloc()|基于整数
.loc()具有多种访问方式:
- 单个标量标签
- 标签列表
- 切片对象
- 一个布尔数组
np.random.seed(32)
d1 = pd.DataFrame(np.random.randn(6,4),index = list('abcdef'),columns = list('ABCD'))
print (d1)
print (d1.loc[:,['A','C']])
print (d1.loc['a']>0.5)
A B C D
a -0.348894 0.983703 0.580923 0.070284
b 0.777533 0.581959 1.471791 1.663181
c -0.261177 -0.688677 -0.694923 1.940423
d 1.805415 0.456314 -0.574812 0.114181
e 1.513581 0.351132 -0.088933 0.916954
f 0.505645 -0.815271 0.389151 -0.424962
A C
a -0.348894 0.580923
b 0.777533 1.471791
c -0.261177 -0.694923
d 1.805415 -0.574812
e 1.513581 -0.088933
f 0.505645 0.389151
A False
B True
C True
D False
Name: a, dtype: bool
.iloc(),Pandas提供了各种方法,以获得纯整数索引。像python和numpy一样,第一个位置是基于0的索引。
各种访问方式:
- 整数
- 整数列表
- 系列值
d2 = d1.copy()
print (d2)
print (d2.iloc[:2])
print (d2.iloc[1,1])
print (d2.iloc[1:3,1:3])
print (d2.iloc[[1,2],[2,3]])
A B C D
a -0.348894 0.983703 0.580923 0.070284
b 0.777533 0.581959 1.471791 1.663181
c -0.261177 -0.688677 -0.694923 1.940423
d 1.805415 0.456314 -0.574812 0.114181
e 1.513581 0.351132 -0.088933 0.916954
f 0.505645 -0.815271 0.389151 -0.424962
A B C D
a -0.348894 0.983703 0.580923 0.070284
b 0.777533 0.581959 1.471791 1.663181
0.5819587452054185
B C
b 0.581959 1.471791
c -0.688677 -0.694923
C D
b 1.471791 1.663181
c -0.694923 1.940423
属性访问:可以使用属性运算符.来选择列
d3 = d2.copy()
print (d3)
print (d3.A)
A B C D
a -0.348894 0.983703 0.580923 0.070284
b 0.777533 0.581959 1.471791 1.663181
c -0.261177 -0.688677 -0.694923 1.940423
d 1.805415 0.456314 -0.574812 0.114181
e 1.513581 0.351132 -0.088933 0.916954
f 0.505645 -0.815271 0.389151 -0.424962
a -0.348894
b 0.777533
c -0.261177
d 1.805415
e 1.513581
f 0.505645
Name: A, dtype: float64
2.2.2、Pandas排序
Pandas有两种排序方式,它们分别:
- 按标签 pd.sort_index()
- 按实际值 pd.sort_values()
np.random.seed(31)
unsorted_df = pd.DataFrame(np.random.randn(5,2),index=[1,4,5,2,3],columns = ['col2','col1'])
# 按行标签排序
sorted_df1 = unsorted_df.sort_index(axis = 0) # 默认axis=0
print (sorted_df1)
# 按列标签排序
sorted_df2 = unsorted_df.sort_index(axis = 1)
print (sorted_df2)
print ('*_* '*5,'按某一列的值排序',' *_*'*5)
sorted_df3 = unsorted_df.sort_values(by = 'col1') # 默认是升序排列
print (sorted_df3)
sorted_df31 = unsorted_df.sort_values(by = 'col1',ascending=False)
print (sorted_df31)
print ('*_* '*5,'按多列的值排序',' *_*'*5)
sorted_df4 = unsorted_df.sort_values(by = ['col1','col2'])
print (sorted_df4)
col2 col1
1 -0.414757 -0.333369
2 -0.777120 1.849357
3 -0.705600 -0.086042
4 0.081092 -0.791027
5 -0.218600 -0.763197
col1 col2
1 -0.333369 -0.414757
4 -0.791027 0.081092
5 -0.763197 -0.218600
2 1.849357 -0.777120
3 -0.086042 -0.705600
*_* *_* *_* *_* *_* 按某一列的值排序 *_* *_* *_* *_* *_*
col2 col1
4 0.081092 -0.791027
5 -0.218600 -0.763197
1 -0.414757 -0.333369
3 -0.705600 -0.086042
2 -0.777120 1.849357
col2 col1
2 -0.777120 1.849357
3 -0.705600 -0.086042
1 -0.414757 -0.333369
5 -0.218600 -0.763197
4 0.081092 -0.791027
*_* *_* *_* *_* *_* 按多列的值排序 *_* *_* *_* *_* *_*
col2 col1
4 0.081092 -0.791027
5 -0.218600 -0.763197
1 -0.414757 -0.333369
3 -0.705600 -0.086042
2 -0.777120 1.849357
2.2.3、Pandas合并和级联
- 合并pd.merge
- 级联pd.concat
pd.merge(left, right, how=‘inner’, on=None, left_on=None, right_on=None,left_index=False, right_index=False, sort=True)
参数 | 说明 |
---|---|
left | 一个DataFrame对象 |
right | 另一个DataFrame对象。 |
on | 列(名称)连接,必须在左和右DataFrame对象中存在(找到)。 |
left_on | 左侧DataFrame中的列用作键,可以是列名或长度等于DataFrame长度的数组。 |
right_on | 来自右的DataFrame的列作为键,可以是列名或长度等于DataFrame长度的数组。 |
left_index | 如果为True,则使用左侧DataFrame中的索引(行标签)作为其连接键。 在具有MultiIndex(分层)的DataFrame的情况下,级别的数量必须与来自右DataFrame的连接键的数量相匹配。 |
right_index | 与右DataFrame的left_index具有相同的用法。 |
how | 它是left, right, outer以及inner之中的一个,默认为内inner。 |
sort | 按照字典顺序通过连接键对结果DataFrame进行排序。默认为True,设置为False时,在很多情况下大大提高性能。 |
np.random.seed(54)
d1 = pd.DataFrame(np.random.randint(3,7,(5,3)),index = list('abcde'),columns = list('ABC'))
print (d1)
d2 = pd.DataFrame(np.random.randint(3,7,(5,3)),index = list('abcdf'),columns = list('ABD'))
print (d2)
print ('*_* '*5,'',' *_*'*5)
df_merge1 = pd.merge(d1,d2,on = 'A')
print (df_merge1)
df_merge2 = pd.merge(d1,d2,on = ['A','B']) # 默认how = inner
print (df_merge2)
print ('*_* '*5,'left',' *_*'*5)
df_merge3 = pd.merge(d1,d2,on = ['A','B'],how = 'left')
print (df_merge3)
df_merge4 = pd.merge(d1,d2,on = ['A','B'],how = 'right')
print (df_merge4)
print ('*_* '*5,'outer',' *_*'*5)
df_merge5 = pd.merge(d1,d2,on = ['A','B'],how = 'outer')
print (df_merge5)
df_merge51 = pd.merge(d1,d2,on = ['A'],how = 'outer')
print (df_merge51)
A B C
a 6 4 5
b 6 6 4
c 3 3 6
d 4 4 5
e 4 6 3
A B D
a 3 3 4
b 5 5 3
c 5 3 5
d 3 4 6
f 6 5 4
*_* *_* *_* *_* *_* *_* *_* *_* *_* *_*
A B_x C B_y D
0 6 4 5 5 4
1 6 6 4 5 4
2 3 3 6 3 4
3 3 3 6 4 6
A B C D
0 3 3 6 4
*_* *_* *_* *_* *_* left *_* *_* *_* *_* *_*
A B C D
0 6 4 5 NaN
1 6 6 4 NaN
2 3 3 6 4.0
3 4 4 5 NaN
4 4 6 3 NaN
A B C D
0 3 3 6.0 4
1 5 5 NaN 3
2 5 3 NaN 5
3 3 4 NaN 6
4 6 5 NaN 4
*_* *_* *_* *_* *_* outer *_* *_* *_* *_* *_*
A B C D
0 6 4 5.0 NaN
1 6 6 4.0 NaN
2 3 3 6.0 4.0
3 4 4 5.0 NaN
4 4 6 3.0 NaN
5 5 5 NaN 3.0
6 5 3 NaN 5.0
7 3 4 NaN 6.0
8 6 5 NaN 4.0
A B_x C B_y D
0 6 4.0 5.0 5.0 4.0
1 6 6.0 4.0 5.0 4.0
2 3 3.0 6.0 3.0 4.0
3 3 3.0 6.0 4.0 6.0
4 4 4.0 5.0 NaN NaN
5 4 6.0 3.0 NaN NaN
6 5 NaN NaN 5.0 3.0
7 5 NaN NaN 3.0 5.0
pd.concat(objs,axis=0,join=‘outer’,join_axes=None,ignore_index=False)
参数 | 说明 |
---|---|
objs | 这是Series,DataFrame或Panel对象的序列或映射 |
axis | {0,1,…},默认为0,这是连接的轴。 |
join | {‘inner’, ‘outer’},默认inner。如何处理其他轴上的索引。联合的外部和交叉的内部。 |
ignore_index | 布尔值,默认为False。如果指定为True,则不要使用连接轴上的索引值。结果轴将被标记为:0,…,n-1。 |
join_axes | 这是Index对象的列表。用于其他(n-1)轴的特定索引,而不是执行内部/外部集逻辑 |
np.random.seed(54)
d1 = pd.DataFrame(np.random.randint(3,7,(3,3)),index = list('abe'),columns = list('ABC'))
print (d1)
d2 = pd.DataFrame(np.random.randint(3,7,(3,3)),index = list('abf'),columns = list('ABD'))
print (d2)
# 纵向拼接
df_concat1 = pd.concat([d1,d2],axis = 0,sort = False)
print (df_concat1)
# 横向拼接
df_concat2 = pd.concat([d1,d2],axis = 1,sort = True)
print (df_concat2)
# 如果想要生成的对象必须遵循自己的索引,请将ignore_index设置为True
df_concat3 = pd.concat([d1,d2],axis = 0,ignore_index = True,sort = True)
print (df_concat3)
# 想把特定的键与每个碎片的DataFrame关联起来。可以通过使用键参数来实现这一点
df_concat31 = pd.concat([d1,d2],axis = 0,keys = ['x','y'],ignore_index = False,sort = True)
print (df_concat31)
print (df_concat31.loc['x'])
A B C
a 6 4 5
b 6 6 4
e 3 3 6
A B D
a 4 4 5
b 4 6 3
f 3 3 4
A B C D
a 6 4 5.0 NaN
b 6 6 4.0 NaN
e 3 3 6.0 NaN
a 4 4 NaN 5.0
b 4 6 NaN 3.0
f 3 3 NaN 4.0
A B C A B D
a 6.0 4.0 5.0 4.0 4.0 5.0
b 6.0 6.0 4.0 4.0 6.0 3.0
e 3.0 3.0 6.0 NaN NaN NaN
f NaN NaN NaN 3.0 3.0 4.0
A B C D
0 6 4 5.0 NaN
1 6 6 4.0 NaN
2 3 3 6.0 NaN
3 4 4 NaN 5.0
4 4 6 NaN 3.0
5 3 3 NaN 4.0
A B C D
x a 6 4 5.0 NaN
b 6 6 4.0 NaN
e 3 3 6.0 NaN
y a 4 4 NaN 5.0
b 4 6 NaN 3.0
f 3 3 NaN 4.0
A B C D
a 6 4 5.0 NaN
b 6 6 4.0 NaN
e 3 3 6.0 NaN
# pd.concat(axis=0)时与df.append()效果一样
df_concat1 = pd.concat([d1,d2],sort = False)
print (df_concat1)
df_append = d1.append([d2],sort = False)
print (df_append)
A B C D
a 6 4 5.0 NaN
b 6 6 4.0 NaN
e 3 3 6.0 NaN
a 4 4 NaN 5.0
b 4 6 NaN 3.0
f 3 3 NaN 4.0
A B C D
a 6 4 5.0 NaN
b 6 6 4.0 NaN
e 3 3 6.0 NaN
a 4 4 NaN 5.0
b 4 6 NaN 3.0
f 3 3 NaN 4.0
2.2.4、Pandas分组
任何分组(groupby)操作都涉及原始对象的以下操作之一
- 分割对象
- 应用一个函数
- 结合的结果
将数据拆分成组
- obj.groupby(‘key’)
- obj.groupby([‘key1’,’key2’])
- obj.groupby(key,axis=1)
ipl_data = {'Team': ['Riders', 'Riders', 'Devils', 'Devils', 'Kings',
'kings', 'Kings', 'Kings', 'Riders', 'Royals', 'Royals', 'Riders'],
'Rank': [1, 2, 2, 3, 3,4 ,1 ,1,2 , 4,1,2],
'Year': [2014,2015,2014,2015,2014,2015,2016,2017,2016,2014,2015,2017],
'Points':[876,789,863,673,741,812,756,788,694,701,804,690]}
df = pd.DataFrame(ipl_data)
print (df.groupby('Team'))
print ('*_* '*5,'查看分组',' *_*'*5)
print (df.groupby('Team').groups)
print ('*_* '*5,'遍历分组',' *_*'*5)
grouped = df.groupby('Year')
for name,group in grouped:
print (name)
print (group)
print ('*_* '*5,'选择一个分组',' *_*'*5)
print (grouped.get_group(2014))
<pandas.core.groupby.groupby.DataFrameGroupBy object at 0x000001863AFCCBA8>
*_* *_* *_* *_* *_* 查看分组 *_* *_* *_* *_* *_*
{'Devils': Int64Index([2, 3], dtype='int64'), 'Kings': Int64Index([4, 6, 7], dtype='int64'), 'Riders': Int64Index([0, 1, 8, 11], dtype='int64'), 'Royals': Int64Index([9, 10], dtype='int64'), 'kings': Int64Index([5], dtype='int64')}
*_* *_* *_* *_* *_* 遍历分组 *_* *_* *_* *_* *_*
2014
Team Rank Year Points
0 Riders 1 2014 876
2 Devils 2 2014 863
4 Kings 3 2014 741
9 Royals 4 2014 701
2015
Team Rank Year Points
1 Riders 2 2015 789
3 Devils 3 2015 673
5 kings 4 2015 812
10 Royals 1 2015 804
2016
Team Rank Year Points
6 Kings 1 2016 756
8 Riders 2 2016 694
2017
Team Rank Year Points
7 Kings 1 2017 788
11 Riders 2 2017 690
*_* *_* *_* *_* *_* 选择一个分组 *_* *_* *_* *_* *_*
Team Rank Year Points
0 Riders 1 2014 876
2 Devils 2 2014 863
4 Kings 3 2014 741
9 Royals 4 2014 701
在许多情况下,我们将数据分成多个集合,并在每个子集上应用一些函数。在应用函数中,可以执行以下操作
- 聚合 : 计算汇总统计
- 转换 : 执行一些特定于组的操作
- 过滤 : 在某些情况下丢弃数据
聚合函数为每个组返回单个聚合值。当创建了分组(group by)对象,就可以对分组数据执行多个聚合操作。一个比较常用的是通过聚合或等效的agg方法聚合
print (grouped['Points'].agg(np.mean))
# 查看每个分组的大小的方法是应用size()函数
grouped = df.groupby('Team')
print (grouped.agg(np.size))
print ('*_* '*5,'一次应用多个聚合函数',' *_*'*5)
grouped = df.groupby('Team')
agg = grouped['Points'].agg([np.sum, np.mean, np.std])
print (agg)
Year
2014 795.25
2015 769.50
2016 725.00
2017 739.00
Name: Points, dtype: float64
Rank Year Points
Team
Devils 2 2 2
Kings 3 3 3
Riders 4 4 4
Royals 2 2 2
kings 1 1 1
*_* *_* *_* *_* *_* 一次应用多个聚合函数 *_* *_* *_* *_* *_*
sum mean std
Team
Devils 1536 768.000000 134.350288
Kings 2285 761.666667 24.006943
Riders 3049 762.250000 88.567771
Royals 1505 752.500000 72.831998
kings 812 812.000000 NaN
转换:分组或列上的转换返回索引大小与被分组的索引相同的对象。因此,转换应该返回与组块大小相同的结果
grouped = df.groupby('Team')
score = lambda x: (x - x.mean()) / x.std()*10
print (grouped.transform(score))
Rank Year Points
0 -15.000000 -11.618950 12.843272
1 5.000000 -3.872983 3.020286
2 -7.071068 -7.071068 7.071068
3 7.071068 7.071068 -7.071068
4 11.547005 -10.910895 -8.608621
5 NaN NaN NaN
6 -5.773503 2.182179 -2.360428
7 -5.773503 8.728716 10.969049
8 5.000000 3.872983 -7.705963
9 7.071068 -7.071068 -7.071068
10 -7.071068 7.071068 7.071068
11 5.000000 11.618950 -8.157595
过滤:过滤根据定义的标准过滤数据并返回数据的子集。filter()函数用于过滤数据
filter = df.groupby('Team').filter(lambda x: len(x) >= 3)
print (filter)
Team Rank Year Points
0 Riders 1 2014 876
1 Riders 2 2015 789
4 Kings 3 2014 741
6 Kings 1 2016 756
7 Kings 1 2017 788
8 Riders 2 2016 694
11 Riders 2 2017 690
2.2.5、Pandas重建索引
- reindex、reindex_like
- rename
- set_index
重建索引会更改DataFrame的行标签和列标签。重新索引意味着符合数据以匹配特定轴上的一组给定的标签。可以通过索引来实现多个操作 :
- 重新排序现有数据以匹配一组新的标签。
- 在没有标签数据的标签位置插入缺失值(NA)标记
N=20
df = pd.DataFrame({
'A': pd.date_range(start='2016-01-01',periods=N,freq='D'),
'x': np.linspace(0,stop=N-1,num=N),
'y': np.random.rand(N),
'C': np.random.choice(['Low','Medium','High'],N).tolist(),
'D': np.random.normal(100, 10, size=(N)).tolist()
})
print (df)
# 相当于从前面的DataFrame取出指定的行和列,没有的行和列填充Nan
df_reindexed = df.reindex(index=[0,2,5], columns=['A', 'C', 'B'])
print (df_reindexed)
A x y C D
0 2016-01-01 0.0 0.029657 Medium 103.725234
1 2016-01-02 1.0 0.391562 Low 102.927891
2 2016-01-03 2.0 0.404794 High 95.196174
3 2016-01-04 3.0 0.189631 High 99.235528
4 2016-01-05 4.0 0.767106 Medium 98.186441
5 2016-01-06 5.0 0.616723 Low 103.020348
6 2016-01-07 6.0 0.926274 High 114.321327
7 2016-01-08 7.0 0.325124 Medium 77.463464
8 2016-01-09 8.0 0.253154 Low 111.284293
9 2016-01-10 9.0 0.720218 Medium 104.540236
10 2016-01-11 10.0 0.996957 High 107.186053
11 2016-01-12 11.0 0.307873 Medium 96.600417
12 2016-01-13 12.0 0.171987 Medium 110.426177
13 2016-01-14 13.0 0.175385 Low 100.698078
14 2016-01-15 14.0 0.163827 High 120.105054
15 2016-01-16 15.0 0.585014 Medium 95.531293
16 2016-01-17 16.0 0.473536 High 105.837680
17 2016-01-18 17.0 0.460757 Low 101.349455
18 2016-01-19 18.0 0.235154 Medium 110.458596
19 2016-01-20 19.0 0.856217 Low 92.097722
A C B
0 2016-01-01 Medium NaN
2 2016-01-03 High NaN
5 2016-01-06 Low NaN
重建索引与其他对象对齐reindex_like
df1 = pd.DataFrame(np.random.randn(10,3),columns=['col1','col2','col3'])
df2 = pd.DataFrame(np.random.randn(7,3),columns=['col1','col2','col3'])
print (df1)
print ('*_* '*5,'reindex',' *_*'*5)
df1 = df1.reindex_like(df2)
print (df1) #多余的行被提出,相当于切片
df11 = df1.iloc[:7,:]
print (df11)
col1 col2 col3
0 -0.081435 -0.661577 -1.416617
1 -0.971915 0.052638 1.111264
2 0.539296 0.770577 -0.566106
3 0.520304 0.399645 -0.721968
4 0.361812 0.414445 -1.496016
5 0.267946 -1.545895 1.561335
6 -2.138090 1.146079 2.337570
7 -0.853020 0.920033 -0.175578
8 -0.816983 3.558997 -1.759333
9 0.081396 0.263669 -0.128221
*_* *_* *_* *_* *_* reindex *_* *_* *_* *_* *_*
col1 col2 col3
0 -0.081435 -0.661577 -1.416617
1 -0.971915 0.052638 1.111264
2 0.539296 0.770577 -0.566106
3 0.520304 0.399645 -0.721968
4 0.361812 0.414445 -1.496016
5 0.267946 -1.545895 1.561335
6 -2.138090 1.146079 2.337570
col1 col2 col3
0 -0.081435 -0.661577 -1.416617
1 -0.971915 0.052638 1.111264
2 0.539296 0.770577 -0.566106
3 0.520304 0.399645 -0.721968
4 0.361812 0.414445 -1.496016
5 0.267946 -1.545895 1.561335
6 -2.138090 1.146079 2.337570
重命名rename()方法:允许基于一些映射(字典或者系列)或任意函数来重新标记一个轴
df1 = pd.DataFrame(np.random.randn(6,3),columns=['col1','col2','col3'])
print (df1)
print ('*_* '*5,'rename',' *_*'*5)
print (df1.rename(columns={'col1' : 'c1', 'col2' : 'c2'},
index = {0 : 'apple', 1 : 'banana', 2 : 'durian'})
)
col1 col2 col3
0 0.429814 -1.689590 -1.118293
1 -1.790794 0.787013 -0.157452
2 -1.010745 1.107981 -0.873061
3 -1.245218 1.303670 0.644618
4 1.010768 -0.539939 1.424593
5 -0.421400 -2.151440 0.318811
*_* *_* *_* *_* *_* rename *_* *_* *_* *_* *_*
c1 c2 col3
apple 0.429814 -1.689590 -1.118293
banana -1.790794 0.787013 -0.157452
durian -1.010745 1.107981 -0.873061
3 -1.245218 1.303670 0.644618
4 1.010768 -0.539939 1.424593
5 -0.421400 -2.151440 0.318811
set_index:把某一列作为索引
np.random.seed(1)
df1 = pd.DataFrame(np.random.randn(6,3),columns=['col1','col2','col3'])
print (df1)
df1['col4'] = list('abcdef')
print (df1)
df1.set_index('col4',inplace = True)
print (df1)
print (df1.reset_index()) # 生成一个新的DataFrame
print (df1)
col1 col2 col3
0 1.624345 -0.611756 -0.528172
1 -1.072969 0.865408 -2.301539
2 1.744812 -0.761207 0.319039
3 -0.249370 1.462108 -2.060141
4 -0.322417 -0.384054 1.133769
5 -1.099891 -0.172428 -0.877858
col1 col2 col3 col4
0 1.624345 -0.611756 -0.528172 a
1 -1.072969 0.865408 -2.301539 b
2 1.744812 -0.761207 0.319039 c
3 -0.249370 1.462108 -2.060141 d
4 -0.322417 -0.384054 1.133769 e
5 -1.099891 -0.172428 -0.877858 f
col1 col2 col3
col4
a 1.624345 -0.611756 -0.528172
b -1.072969 0.865408 -2.301539
c 1.744812 -0.761207 0.319039
d -0.249370 1.462108 -2.060141
e -0.322417 -0.384054 1.133769
f -1.099891 -0.172428 -0.877858
col4 col1 col2 col3
0 a 1.624345 -0.611756 -0.528172
1 b -1.072969 0.865408 -2.301539
2 c 1.744812 -0.761207 0.319039
3 d -0.249370 1.462108 -2.060141
4 e -0.322417 -0.384054 1.133769
5 f -1.099891 -0.172428 -0.877858
col1 col2 col3
col4
a 1.624345 -0.611756 -0.528172
b -1.072969 0.865408 -2.301539
c 1.744812 -0.761207 0.319039
d -0.249370 1.462108 -2.060141
e -0.322417 -0.384054 1.133769
f -1.099891 -0.172428 -0.877858
2.3、DataFrame计算
2.3.1、在计算前,DataFrame可能存在缺失值,那第一步就是对缺失值处理,涉及的常用函数
- isnull()和notnull()函数
- fillna()函数
- dropna函数
检测缺失值isnull()
np.random.seed(39)
df = pd.DataFrame(np.random.randn(5, 3), index=['a', 'c', 'e', 'f',
'h'],columns=['one', 'two', 'three'])
df = df.reindex(['a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'])
print (df)
# 检测缺失值
print (df['one'].isnull())
# 含有缺失值的计算
print (df['one'].sum(),df['one'].mean())
print ('*_* '*5,'查看每一行缺失值情况',' *_*'*5)
print(df.isnull().sum(axis=1))
one two three
a 1.404840 0.221121 -0.145327
b NaN NaN NaN
c 0.123199 0.606027 2.422770
d NaN NaN NaN
e -1.916609 -2.422527 0.646294
f 0.201501 -0.156713 0.772046
g NaN NaN NaN
h -1.357610 0.701717 1.053325
a False
b True
c False
d True
e False
f False
g True
h False
Name: one, dtype: bool
-1.5446790899908942 -0.3089358179981788
*_* *_* *_* *_* *_* 查看每一行缺失值情况 *_* *_* *_* *_* *_*
a 0
b 3
c 0
d 3
e 0
f 0
g 3
h 0
dtype: int64
fillna()函数:
用标量值替换NaN
填写NA前进和后退
- pad/ffill ,填充方法向前
- bfill/backfill ,填充方法向后
df['one'] = df['one'].fillna(0)
print (df)
print ('*_* '*10)
df0 = df.copy()
print (df0.fillna(0))
print ('*_* '*5,'ffill',' *_*'*5)
df1 = df0.fillna(method='ffill')
print (df1)
print ('*_* '*5,'bfill',' *_*'*5)
df2 = df0.fillna(method='bfill')
print (df2)
one two three
a 1.404840 0.221121 -0.145327
b 0.000000 NaN NaN
c 0.123199 0.606027 2.422770
d 0.000000 NaN NaN
e -1.916609 -2.422527 0.646294
f 0.201501 -0.156713 0.772046
g 0.000000 NaN NaN
h -1.357610 0.701717 1.053325
*_* *_* *_* *_* *_* *_* *_* *_* *_* *_*
one two three
a 1.404840 0.221121 -0.145327
b 0.000000 0.000000 0.000000
c 0.123199 0.606027 2.422770
d 0.000000 0.000000 0.000000
e -1.916609 -2.422527 0.646294
f 0.201501 -0.156713 0.772046
g 0.000000 0.000000 0.000000
h -1.357610 0.701717 1.053325
*_* *_* *_* *_* *_* ffill *_* *_* *_* *_* *_*
one two three
a 1.404840 0.221121 -0.145327
b 0.000000 0.221121 -0.145327
c 0.123199 0.606027 2.422770
d 0.000000 0.606027 2.422770
e -1.916609 -2.422527 0.646294
f 0.201501 -0.156713 0.772046
g 0.000000 -0.156713 0.772046
h -1.357610 0.701717 1.053325
*_* *_* *_* *_* *_* bfill *_* *_* *_* *_* *_*
one two three
a 1.404840 0.221121 -0.145327
b 0.000000 0.606027 2.422770
c 0.123199 0.606027 2.422770
d 0.000000 -2.422527 0.646294
e -1.916609 -2.422527 0.646294
f 0.201501 -0.156713 0.772046
g 0.000000 0.701717 1.053325
h -1.357610 0.701717 1.053325
dropna函数
replace函数
df4 = df0.copy()
print (df4)
print ('*_* '*5,'dropna',' *_*'*5)
print (df4.dropna())
print ('*_* '*5,'replace',' *_*'*5)
df5 = pd.DataFrame({'one':[10,20,30,40,50,2000],
'two':[1000,0,30,40,50,60]})
print (df5)
print (df5.replace({1000:10,2000:60}))
# 如果需要替换原有的DataFrame就加参数inplace = True
print (df5)
one two three
a 1.404840 0.221121 -0.145327
b 0.000000 NaN NaN
c 0.123199 0.606027 2.422770
d 0.000000 NaN NaN
e -1.916609 -2.422527 0.646294
f 0.201501 -0.156713 0.772046
g 0.000000 NaN NaN
h -1.357610 0.701717 1.053325
*_* *_* *_* *_* *_* dropna *_* *_* *_* *_* *_*
one two three
a 1.404840 0.221121 -0.145327
c 0.123199 0.606027 2.422770
e -1.916609 -2.422527 0.646294
f 0.201501 -0.156713 0.772046
h -1.357610 0.701717 1.053325
*_* *_* *_* *_* *_* replace *_* *_* *_* *_* *_*
one two
0 10 1000
1 20 0
2 30 30
3 40 40
4 50 50
5 2000 60
one two
0 10 10
1 20 0
2 30 30
3 40 40
4 50 50
5 60 60
one two
0 10 1000
1 20 0
2 30 30
3 40 40
4 50 50
5 2000 60
2.3.2、Pandas描述性统计
常用的重要函数有:
函数 | 描述 |
---|---|
count() | 非空观测数量 |
sum() | 所有值之和 |
mean() | 所有值的平均值 |
median() | 所有值的中位数 |
mode() | 值的模值 |
std() | 值的标准偏差 |
min() | 所有值中的最小值 |
max() | 所有值中的最大值 |
abs() | 绝对值 |
prod() | 数组元素的乘积 |
cumsum() | 累计总和 |
cumprod() | 累计乘积 |
np.random.seed(9)
df = pd.DataFrame(np.random.randn(5,4),columns = list('ABCD'))
print (df)
'''axis = 0,在纵轴方向应用方法,axis = 1在横轴方向应用方法'''
print (df.sum(axis = 0))
print (df.sum(axis = 1))
print (df.cumsum(axis = 0))
print (df.cumsum(axis = 1))
A B C D
0 0.001109 -0.289544 -1.116066 -0.012883
1 -0.378361 -0.481135 -1.517331 -0.490872
2 -0.240681 -0.647947 0.635891 1.740117
3 0.296682 0.707504 1.822816 0.430769
4 1.542730 -0.900721 -0.137125 1.297579
A 1.221478
B -1.611844
C -0.311816
D 2.964711
dtype: float64
0 -1.417385
1 -2.867700
2 1.487380
3 3.257771
4 1.802462
dtype: float64
A B C D
0 0.001109 -0.289544 -1.116066 -0.012883
1 -0.377253 -0.770679 -2.633397 -0.503755
2 -0.617933 -1.418627 -1.997506 1.236363
3 -0.321251 -0.711123 -0.174691 1.667132
4 1.221478 -1.611844 -0.311816 2.964711
A B C D
0 0.001109 -0.288436 -1.404502 -1.417385
1 -0.378361 -0.859497 -2.376828 -2.867700
2 -0.240681 -0.888628 -0.252737 1.487380
3 0.296682 1.004186 2.827002 3.257771
4 1.542730 0.642008 0.504883 1.802462
汇总数据df.describe
print (df)
print ('*_* '*5,'decribe',' *_*'*5)
print (df.describe())
print ('*_* '*5,'info',' *_*'*5)
print (df.info())
A B C D
0 0.001109 -0.289544 -1.116066 -0.012883
1 -0.378361 -0.481135 -1.517331 -0.490872
2 -0.240681 -0.647947 0.635891 1.740117
3 0.296682 0.707504 1.822816 0.430769
4 1.542730 -0.900721 -0.137125 1.297579
*_* *_* *_* *_* *_* decribe *_* *_* *_* *_* *_*
A B C D
count 5.000000 5.000000 5.000000 5.000000
mean 0.244296 -0.322369 -0.062363 0.592942
std 0.769857 0.617943 1.348543 0.919307
min -0.378361 -0.900721 -1.517331 -0.490872
25% -0.240681 -0.647947 -1.116066 -0.012883
50% 0.001109 -0.481135 -0.137125 0.430769
75% 0.296682 -0.289544 0.635891 1.297579
max 1.542730 0.707504 1.822816 1.740117
*_* *_* *_* *_* *_* info *_* *_* *_* *_* *_*
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 5 entries, 0 to 4
Data columns (total 4 columns):
A 5 non-null float64
B 5 non-null float64
C 5 non-null float64
D 5 non-null float64
dtypes: float64(4)
memory usage: 240.0 bytes
None
2.3.3、Pandas统计函数
- pct_change()函数
- 协方差
- 相关性
- 数据排名
pct_change():此函数将每个元素与其前一个元素进行比较,并计算变化百分比
np.random.seed(56)
df = pd.DataFrame(np.random.randn(5, 2))
print (df)
print (df.pct_change()) # 默认axis = 0
df[3] = df[1].shift(1)
df[4] = (df[1] - df[3])/df[3]
print (df)
0 1
0 -1.037643 0.593658
1 1.102681 -0.512178
2 -0.265420 -1.617006
3 -0.271514 0.945554
4 -0.626993 -0.265947
0 1
0 NaN NaN
1 -2.062678 -1.862749
2 -1.240704 2.157119
3 0.022962 -1.584756
4 1.309242 -1.281261
0 1 3 4
0 -1.037643 0.593658 NaN NaN
1 1.102681 -0.512178 0.593658 -1.862749
2 -0.265420 -1.617006 -0.512178 2.157119
3 -0.271514 0.945554 -1.617006 -1.584756
4 -0.626993 -0.265947 0.945554 -1.281261
协方差:Series对象有一个方法cov用来计算序列对象之间的协方差。NA将被自动排除
np.random.seed(3)
frame = pd.DataFrame(np.random.randn(10, 5), columns=['a', 'b', 'c', 'd', 'e'])
print (frame['a'].cov(frame['b']))
print (frame.cov())
0.4460048094021359
a b c d e
a 1.425945 0.446005 -0.129857 -0.743712 -0.074716
b 0.446005 0.808374 0.002175 -0.130362 -0.005201
c -0.129857 0.002175 0.880191 -0.033975 0.075192
d -0.743712 -0.130362 -0.033975 1.856407 -0.011295
e -0.074716 -0.005201 0.075192 -0.011295 0.150021
相关性:相关性显示了任何两个数值(系列)之间的线性关系。有多种方法来计算pearson(默认),spearman和kendall之间的相关性
print (frame['a'].corr(frame['b']))
print (frame.corr())
0.41541485108000525
a b c d e
a 1.000000 0.415415 -0.115911 -0.457106 -0.161542
b 0.415415 1.000000 0.002578 -0.106416 -0.014934
c -0.115911 0.002578 1.000000 -0.026579 0.206923
d -0.457106 -0.106416 -0.026579 1.000000 -0.021404
e -0.161542 -0.014934 0.206923 -0.021404 1.000000
数据排名rank()函数:数据排名为元素数组中的每个元素生成排名
Rank可选地使用一个默认为true的升序参数; 当False,数据被反向排序,也就是较大的值被分配较小的排序。
Rank支持不同的tie-breaking方法,用方法参数指定:
- average - 并列组平均排序等级
- min - 组中最低的排序等级
- max - 组中最高的排序等级
- first - 按照它们出现在数组中的顺序分配队列
np.random.seed(4)
frame = pd.DataFrame(np.random.randint(1, 5,(4,5)), columns=['a', 'b', 'c', 'd', 'e'])
frame['a_Rank'] = frame['a'].rank()
print (frame)
print ('*_* '*5,'first',' *_*'*5)
frame['a_Rank'] = frame['a'].rank(method='first')
print (frame)
print ('*_* '*5,'不平均排名,对数字相同的使用最小排名进行统一排名',' *_*'*5)
frame['a_Rank'] = frame['a'].rank(method='min')
print (frame)
a b c d e a_Rank
0 3 3 4 2 2 2.5
1 1 4 1 3 2 1.0
2 3 1 4 2 3 2.5
3 4 4 2 1 1 4.0
*_* *_* *_* *_* *_* first *_* *_* *_* *_* *_*
a b c d e a_Rank
0 3 3 4 2 2 2.0
1 1 4 1 3 2 1.0
2 3 1 4 2 3 3.0
3 4 4 2 1 1 4.0
*_* *_* *_* *_* *_* 不平均排名,对数字相同的使用最小排名进行统一排名 *_* *_* *_* *_* *_*
a b c d e a_Rank
0 3 3 4 2 2 2.0
1 1 4 1 3 2 1.0
2 3 1 4 2 3 2.0
3 4 4 2 1 1 4.0
2.3.4、Pandas窗口函数,常用的函数
- .rolling()函数
- .expanding()函数
- .ewm()函数
- ewma 指数加权移动
- ewma(arg[, com, span, halflife, …])
- ewmstd(arg[, com, span, halflife, …])指数加权移动标准差
- ewmvar(arg[, com, span, halflife, …])指数加权移动方差
- ewmcorr(arg1[, arg2, com, span, halflife, …])指数加权移动相关系数
- ewmcov(arg1[, arg2, com, span, halflife, …])指数加权移动协方差
窗口函数主要用于通过平滑曲线来以图形方式查找数据内的趋势。如果日常数据中有很多变化,并且有很多数据点可用,那么采样和绘图就是一种方法,应用窗口计算并在结果上绘制图形是另一种方法。 通过这些方法,可以平滑曲线或趋势。
np.random.seed(5)
df = pd.DataFrame(np.random.randn(5, 4),
index = pd.date_range('4/6/2019', periods=5),
columns = ['A', 'B', 'C', 'D'])
print (df)
df1 = df.rolling(window=3).mean()
print (df1)
print ('*_* '*5,'min_periods=1',' *_*'*5)
df2 = df.rolling(window=3,min_periods=1).mean()
print (df2)
A B C D
2019-04-06 0.441227 -0.330870 2.430771 -0.252092
2019-04-07 0.109610 1.582481 -0.909232 -0.591637
2019-04-08 0.187603 -0.329870 -1.192765 -0.204877
2019-04-09 -0.358829 0.603472 -1.664789 -0.700179
2019-04-10 1.151391 1.857331 -1.511180 0.644848
A B C D
2019-04-06 NaN NaN NaN NaN
2019-04-07 NaN NaN NaN NaN
2019-04-08 0.246147 0.307247 0.109591 -0.349535
2019-04-09 -0.020539 0.618694 -1.255595 -0.498897
2019-04-10 0.326722 0.710311 -1.456244 -0.086736
*_* *_* *_* *_* *_* min_periods=1 *_* *_* *_* *_* *_*
A B C D
2019-04-06 0.441227 -0.330870 2.430771 -0.252092
2019-04-07 0.275419 0.625805 0.760769 -0.421864
2019-04-08 0.246147 0.307247 0.109591 -0.349535
2019-04-09 -0.020539 0.618694 -1.255595 -0.498897
2019-04-10 0.326722 0.710311 -1.456244 -0.086736
2.3.4、Pandas函数应用
要将自定义或其他库的函数应用于Pandas对象,有三个重要的方法,下面来讨论如何使用这些方法。使用适当的方法取决于函数是否期望在整个DataFrame,行或列或元素上进行操作。
- 表格函数应用:pipe()
- 行或列函数应用:apply()
- 元素函数应用:applymap()
- map让函数作用于Series每一个元素的操作
np.random.seed(9)
def adder(ele1,ele2):
return ele1+ele2
df = pd.DataFrame(np.random.randn(5,3),columns=['col1','col2','col3'])
print (df)
print ('*_* '*5,'pipe',' *_*'*5)
df1 = df.pipe(adder,2)
print (df1)
print ('*_* '*5,'apply',' *_*'*5)
df2 = df.apply(np.mean)
print (df2)
df21 = df.apply(np.mean,axis=1)
print (df21)
print ('*_* '*5,'other function',' *_*'*5)
df3 = df.apply(lambda x: x.max() - x.min())
print (df3)
col1 col2 col3
0 0.001109 -0.289544 -1.116066
1 -0.012883 -0.378361 -0.481135
2 -1.517331 -0.490872 -0.240681
3 -0.647947 0.635891 1.740117
4 0.296682 0.707504 1.822816
*_* *_* *_* *_* *_* pipe *_* *_* *_* *_* *_*
col1 col2 col3
0 2.001109 1.710456 0.883934
1 1.987117 1.621639 1.518865
2 0.482669 1.509128 1.759319
3 1.352053 2.635891 3.740117
4 2.296682 2.707504 3.822816
*_* *_* *_* *_* *_* apply *_* *_* *_* *_* *_*
col1 -0.376074
col2 0.036923
col3 0.345010
dtype: float64
0 -0.468167
1 -0.290793
2 -0.749628
3 0.576020
4 0.942334
dtype: float64
*_* *_* *_* *_* *_* other function *_* *_* *_* *_* *_*
col1 1.814013
col2 1.198376
col3 2.938882
dtype: float64
并不是所有的函数都可以向量化(也不是返回另一个数组的NumPy数组,也不是任何值),在DataFrame上的方法applymap()类似于在Series上的map()接受任何Python函数,并且返回单个值.
df4 = df.copy()
print (df4)
print ('*_* '*5,'map',' *_*'*5)
df5['col1'] = df4['col1'].map(lambda x:x*100)
print (df5)
print ('*_* '*5,'applymap',' *_*'*5)
df6 = df4.applymap(lambda x:x*100)
print (df6)
col1 col2 col3
0 0.001109 -0.289544 -1.116066
1 -0.012883 -0.378361 -0.481135
2 -1.517331 -0.490872 -0.240681
3 -0.647947 0.635891 1.740117
4 0.296682 0.707504 1.822816
*_* *_* *_* *_* *_* map *_* *_* *_* *_* *_*
one two col1
0 10 1000 0.110855
1 20 0 -1.288276
2 30 30 -151.733118
3 40 40 -64.794746
4 50 50 29.668222
5 2000 60 NaN
*_* *_* *_* *_* *_* applymap *_* *_* *_* *_* *_*
col1 col2 col3
0 0.110855 -28.954407 -111.606630
1 -1.288276 -37.836146 -48.113536
2 -151.733118 -49.087198 -24.068058
3 -64.794746 63.589108 174.011731
4 29.668222 70.750366 182.281576
后续遇到各种好的玩法再更新……
部分内容来源于下面这篇博客:
https://www.yiibai.com/pandas/python_pandas_function_application.html