在这里插入图片描述
想熟悉和使用一种数据结构，得从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()l

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

Python基础----Pandas