1.Pandas的介绍
Pandas 是基于 NumPy 的一个非常好用的库,正如名字一样,人见人爱。之所以如此,就在于不论是读取、处理数据,用它都非常简单。
Pandas 有两种自己独有的基本数据结构。读者应该注意的是,它固然有着两种数据结构,因为它依然是 Python 的一个库,所以,Python 中有的数据类型在这里依然适用,也同样还可以使用类自己定义数据类型。只不过,Pandas 里面又定义了两种数据类型:Series 和 DataFrame,它们让数据操作更简单了。
2.Pandas的基本数据结构Series
(1)Series的创建
1>创建方式一:通过列表转换为Series对象
import pandas as pd import numpy as np #创建一个列表 list_1 = list(range(5,10)) print(list_1) #输出结果[5, 6, 7, 8, 9] #通过把列表转换为Series对象 ser_obj = pd.Series(list_1) print(ser_obj) #输出结果 #0 5 #1 6 #2 7 #3 8 #4 9 #dtype: int64
从上面代码可以看出来,输出结果为两列,第一列为索引,第二列为值,并且数据类型为int64
2>创建方式二:通过字典创建Series对象
#通过字典创建Series对象 #创建一个字典data_dict data_dict = { '2010':15.6, '2011':16.2, '2012':13.2, '2013':12.9 } #转换为Series对象 ser_obj = pd.Series(data_dict) print(ser_obj) #输出结果 #2010 15.6 #2011 16.2 #2012 13.2 #2013 12.9 #dtype: float64从上面的代码可以看出,字典中的key作为了Series的索引,字典中的value作为了Series中的数据,并且数据类型为诶float64
>3创建方式三:手动添加索引和数据类型
#手动添加索引和数据类型 #手动添加索引 ser_obj = pd.Series(['数据A','数据B','数据C'],index=['a','b','c']) print(ser_obj) #输出结果 #a 数据A #b 数据B #c 数据C #dtype: objec,因为数据为字符串型,所以数据类型为object #手动添加索引,并设置数据类型为Int32 ser_obj = pd.Series([11.2,15.6,18.9],index=['a','b','c'],dtype='int32') print(ser_obj) #输出结果 #a 11 #b 15 #b 15 #c 18 #dtype: int32
(2)Series对象的各种属性
1>Series对象的index属性--->获得索引类型
ser = pd.Series(range(3)) print(ser) #输出结果 #0 0 #1 1 #2 2 #dtype: int32 #通过Series对象的index属性获得索引类型 print(ser.index) #输出结果RangeIndex(start=0, stop=3, step=1)
2>Series对象的values属性--->获得数据
ser = pd.Series(range(3)) print(ser) #输出结果 #0 0 #1 1 #2 2 #dtype: int32 #通过Series对象的values属性获得数据,看着为一维数组 print(ser.values) #输出结果[0 1 2]
3>Series对象的index.name属性--->指定索引名称
#通过Series.index.name属性设置index索引名称 ser = pd.Series(range(3)) #输出结果 #0 0 #1 1 #2 2 #dtype: int32 ser.index.name = 'index_name' print(ser) #输出结果 #index_name #0 0 #1 1 #2 2 #dtype: int32
4>Series对象的name属性--->指定Series对象的名称,为一列的时候作为一列的名称
#通过Series对象的name属性设置Series对象的名称,为一列时作为当列名称 ser = pd.Series(range(3)) ser.name = '列名' print(ser) #输出结果 #0 0 #1 1 #2 2 #Name: 列名, dtype: int32
(2)获取Series对象中的数据
1>根据一个索引获取数据
#创建一个series对象,并指定索引 ser = pd.Series(range(5,10),index=['a','b','c','d','e']) print(ser) #输出结果 #a 5 #b 6 #c 7 #d 8 #e 9 #dtype: int32 #根据默认的RangeIndex索引来获取数据7,索引从0开始 print(ser[2]) #输出结果7 #根据自己指定的索引来获取数据7 print(ser['c']) #输出结果为7
2>根据几个不连续的索引获取数据
#创建一个series对象,并指定索引 ser = pd.Series(range(5,10),index=['a','b','c','d','e']) #输出结果 #a 5 #b 6 #c 7 #d 8 #e 9 #dtype: int32 #根据默认的RangeIndex索引来获取数据 print(ser[[0,2,4]]) #输出结果 #a 5 #c 7 #e 9 #dtype: int32 #根据自己指定的索引来获取数据 print(ser[['a','d']]) #输出结果 #a 5 #d 8 #dtype: int32
3>通过切片获取指定数据
#创建一个series对象,并指定索引 ser = pd.Series(range(5,10),index=['a','b','c','d','e']) #输出结果 #a 5 #b 6 #c 7 #d 8 #e 9 #dtype: int32 #根据默认的RangeIndex索引来切片 print(ser[2:4]) #使用默认的RangeIndex索引来切片的话,只包含头元素,不包含尾部元素 #输出结果 #c 7 #d 8 #dtype: int32 #根据自己指定的索引来获取数据 print(ser['b':'e']) #使用自定义索引来切片的话,包含头尾两个元素 #输出结果 #b 6 #c 7 #d 8 #e 9 #dtype: int32
4>通过条件筛选出指定数据
#创建一个series对象,并指定索引 ser = pd.Series(range(5,10),index=['a','b','c','d','e']) #创建条件 bool_ser = ser>6 print(bool_ser) #输出结果 #a False #b False #c True #d True #e True #dtype: bool #根据布尔型数组筛选出符合条件的数据 ser = ser[bool_ser] print(ser) #输出结果 #c 7 #d 8 #e 9 #dtype: int32
(4)Series对象的运算
1>直接运算(每个Series对象的数据个数相同)
#创建两个个series对象 ser_1 = pd.Series(range(5,10)) ser_2 = pd.Series(range(20,25)) #加法计算 ser_3 = ser_1 + ser_2 #减法计算 ser_3 = ser_1 - ser_2 #乘法计算 ser_3 = ser_1 * ser_2 #除法计算 ser_3 = ser_1 / ser_2 print(ser_3)
2>对齐运算(每个Series对象的数据个数不同)
在对齐运算中,如果对应的位置没有数据,则自动填充为Nan
#创建两个个series对象 ser_1 = pd.Series(range(5,10)) #5个数据 ser_2 = pd.Series(range(20,30)) #10个数据 #加法计算 ser_3 = ser_1 + ser_2 print(ser_3) #输出结果 ''' 0 25.0 1 27.0 2 29.0 3 31.0 4 33.0 5 NaN 6 NaN 7 NaN 8 NaN 9 NaN dtype: float64 '''
但是在实际统计中,数据NaN会影响,所以可以使用add()函数
add()对齐运算--->对未对齐的数据填充,然后进行运算
参数一:需要对齐运算的数据对象
参数二:对应位置默认值
#创建两个个series对象 ser_1 = pd.Series(range(5,10)) #5个数据 ser_2 = pd.Series(range(20,30)) #10个数据 ser_3 = ser_1.add(ser_2,fill_value=0) print(ser_3) ''' 0 25.0 1 27.0 2 29.0 3 31.0 4 33.0 5 25.0 6 26.0 7 27.0 8 28.0 9 29.0 dtype: float64 '''
3.Pandas的基本数据结构DataFrame
(1)DataFrame的创建
1>创建方式一:把二维数组nparray对象转换为DataFrame对象
#将二维数组转换为DataFrame对象 #创建一个二维数组 arr = np.random.randn(3,4) #二维数组中每一个小数组中的数据在DataFrame中是一行 #二维数组中每一个小数组中对应索引的数据在DataFrame中是一列 print(arr) #输出结果 ''' [[ 2.04938227 1.71157949 1.0695802 -1.21246563] [ 1.59988925 -1.1689984 -1.15787772 0.24163685] [ 0.71197257 0.93078003 0.78163736 0.57635525]] ''' #对象转换,不指定行索引,列索引的话都是默认使用RangeIndex索引,从0开始 df_obj = pd.DataFrame(arr) print(df_obj) #输出结果 ''' 0 1 2 3 0 2.049382 1.711579 1.069580 -1.212466 1 1.599889 -1.168998 -1.157878 0.241637 2 0.711973 0.930780 0.781637 0.576355 ''' #对象换号.指定行索引,列索引 df_obj = pd.DataFrame(arr,index=['a','b','c'],columns=['A','B','C','D']) print(df_obj) #输出结果 ''' A B C D a 0.676696 -0.185332 0.951456 -3.416397 b 0.802608 -0.019629 0.533598 -0.064079 c -0.783926 -1.105331 2.659964 0.602179 '''
2>创建方式二:通过字典创建DataFrame对象
注意:
保证数据中至少有一列是带有行索引的
字典中的key作为列索引,value作为一列的数据
#通过字典创建DataFrame对象 #首先创建一个字典 data_dict = { #必须有一列数据带有行索引,否则报错 'A':pd.Series(range(5)), 'B':2, 'C':3, 'D':4, 'F':5 } #转换对象 df = pd.DataFrame(data_dict) print(df) #输出结果,A列使用了默认的RangeIndex索引 ''' A B C D F 0 0 2 3 4 5 1 1 2 3 4 5 2 2 2 3 4 5 3 3 2 3 4 5 4 4 2 3 4 5 '''
(2)DataFrame对象的各种属性
1>DataFrame对象的index属性--->获取行索引的类型
#通过字典创建DataFrame对象 #首先创建一个字典 data_dict = { #必须有一列数据带有行索引,否则报错 'A':pd.Series(range(5)), 'B':2, 'C':3, 'D':4, 'F':5 } #转换对象 df = pd.DataFrame(data_dict) print(df) #输出结果,A列使用了默认的RangeIndex索引 ''' A B C D F 0 0 2 3 4 5 1 1 2 3 4 5 2 2 2 3 4 5 3 3 2 3 4 5 4 4 2 3 4 5 ''' #通过DataFrame.index属性获得行索引的类型 print(df.index) #输出结果RangeIndex(start=0, stop=5, step=1)
2>DataFrame对象的columns属性--->获取列索引的类型
#通过字典创建DataFrame对象 #首先创建一个字典 data_dict = { #必须有一列数据带有行索引,否则报错 'A':pd.Series(range(5)), 'B':2, 'C':3, 'D':4, 'F':5 } #转换对象 df = pd.DataFrame(data_dict) print(df) #输出结果,A列使用了默认的RangeIndex索引 ''' A B C D F 0 0 2 3 4 5 1 1 2 3 4 5 2 2 2 3 4 5 3 3 2 3 4 5 4 4 2 3 4 5 ''' #通过DataFrame.columns属性获得行索引的类型 print(df.columns) #输出结果Index(['A', 'B', 'C', 'D', 'F'], dtype='object')
3>DataFrame对象的index.name和columns.name属性--->设置行索引和列索引的名称
#通过字典创建DataFrame对象 #首先创建一个字典 data_dict = { #必须有一列数据带有行索引,否则报错 'A':pd.Series(range(5)), 'B':2, 'C':3, 'D':4, 'F':5 } #转换对象 df = pd.DataFrame(data_dict) print(df) #输出结果,A列使用了默认的RangeIndex索引 ''' A B C D F 0 0 2 3 4 5 1 1 2 3 4 5 2 2 2 3 4 5 3 3 2 3 4 5 4 4 2 3 4 5 ''' #通过DataFrame.index/columns属性设置行索引名称,列索引名称 df.index.name = 'index_name' df.columns.name = 'columns_name' print(df) #输出结果 ''' columns_name A B C D F index_name 0 0 2 3 4 5 1 1 2 3 4 5 2 2 2 3 4 5 3 3 2 3 4 5 4 4 2 3 4 5 '''
4>DataFrame对象的values属性--->获取DataFrame对象的数据
#通过字典创建DataFrame对象 #首先创建一个字典 data_dict = { #必须有一列数据带有行索引,否则报错 'A':pd.Series(range(5)), 'B':2, 'C':3, 'D':4, 'F':5 } #转换对象 df = pd.DataFrame(data_dict) print(df) #输出结果,A列使用了默认的RangeIndex索引 ''' A B C D F 0 0 2 3 4 5 1 1 2 3 4 5 2 2 2 3 4 5 3 3 2 3 4 5 4 4 2 3 4 5 ''' #通过DataFrame.values属性获得数组 res = df.values print(res) #输出结果 ''' [[0 2 3 4 5] [1 2 3 4 5] [2 2 3 4 5] [3 2 3 4 5] [4 2 3 4 5]] '''
(3)获取DataFrame对象的数据
1>通过列索引取出某一列
DataFrame对象是由多个Series对象组成,取出的每一列都是一个Series对象
#通过字典创建DataFrame对象 data_dict = { 'A':pd.Series(range(5)), 'B':pd.Series(['张三','李四','王五','赵柳','王炸']), 'C':3, 'D':4, 'F':5 } #转换对象 df = pd.DataFrame(data_dict) print(df) ''' 输出原内容 A B C D F 0 0 张三 3 4 5 1 1 李四 3 4 5 2 2 王五 3 4 5 3 3 赵柳 3 4 5 4 4 王炸 3 4 5 ''' #通过B列索引获取B列 print(df['B']) print(type(df['B'])) #输出结果<class 'pandas.core.series.Series'> #输出结果 ''' 0 张三 1 李四 2 王五 3 赵柳 4 王炸 Name: B, dtype: object '''
2>通过列索引和元素索引取出某个值
#通过字典创建DataFrame对象 data_dict = { 'A':pd.Series(range(5)), 'B':pd.Series(['张三','李四','王五','赵柳','王炸']), 'C':3, 'D':4, 'F':5 } df = pd.DataFrame(data_dict) print(df) ''' 输出原内容 A B C D F 0 0 张三 3 4 5 1 1 李四 3 4 5 2 2 王五 3 4 5 3 3 赵柳 3 4 5 4 4 王炸 3 4 5 ''' #取出王炸这个值 print(df['B'][4]) #输出 王炸
3>通过不连续的列索引取出多列数据
注意:在Series中根据不连续索引可以根据默认的RangeIndex索引来取,也可以根据自己指定的索引来获取,但是在DataFrame中不能使用默认的RangeIndex索引来获取
#通过字典创建DataFrame对象 data_dict = { 'A':pd.Series(range(5)), 'B':pd.Series(['张三','李四','王五','赵柳','王炸']), 'C':3, 'D':4, 'F':5 } df = pd.DataFrame(data_dict) print(df) ''' 输出原内容 A B C D F 0 0 张三 3 4 5 1 1 李四 3 4 5 2 2 王五 3 4 5 3 3 赵柳 3 4 5 4 4 王炸 3 4 5 ''' #根据不连续列索引取出多列数据 print(df[['B','D']]) #输出结果 ''' B D 0 张三 4 1 李四 4 2 王五 4 3 赵柳 4 4 王炸 4 '''
4>通过切片来获取数据
由于切片必须根据行索引来切,所以先指定下行索引
data_dict = { 'A':pd.Series(range(5)), 'B':pd.Series(['张三','李四','王五','赵柳','王炸']), 'C':3, 'D':4, 'F':5 } #指定行索引 df.index=['a','b','c','d','e'] print(df) #输出结果 ''' A B C D F a 0 张三 3 4 5 b 1 李四 3 4 5 c 2 王五 3 4 5 d 3 赵柳 3 4 5 e 4 王炸 3 4 5 ''' print(df['b':'d']) ''' 输出结果 A B C D F b 1 李四 3 4 5 c 2 王五 3 4 5 d 3 赵柳 3 4 5 ''' print(type(df['b':'d'])) #输出结果<class 'pandas.core.frame.DataFrame'> #切片出来的数据也是个DataFrame对象
5>通过条件来筛选指定的数据
data_dict = { 'A':pd.Series(range(5)), 'B':pd.Series(['张三','李四','王五','赵柳','王炸']), 'C':3, 'D':4, 'F':5 } #指定行索引 df.index=['a','b','c','d','e'] print(df) ''' 原内容 A B C D F a 0 张三 3 4 5 b 1 李四 3 4 5 c 2 王五 3 4 5 d 3 赵柳 3 4 5 e 4 王炸 3 4 5 ''' #添加条件,返回一个布尔类型 bool_df = df>4 print(bool_df) ''' 输出结果 A B C D F a False True False False True b False True False False True c False True False False True d False True False False True e False True False False True ''' #根据布尔型的DataFrame对象筛选出数据 df = df[bool_df] print(df) #True的值正常输出,False的值用NaN填充 ''' A B C D F a NaN 张三 NaN NaN 5 b NaN 李四 NaN NaN 5 c NaN 王五 NaN NaN 5 d NaN 赵柳 NaN NaN 5 e N
(4)DataFrame对象的运算
1>直接运算(每个DataFrame对象的数据个数相同,位置一一对应)
#创建两个DataFrame对象 df_1 = pd.DataFrame([[1,2,3,4,5],[1,2,3,4,5]],index=['a','b'],columns=['A','B','C','D','E']) print(df_1) ''' 输出结果 A B C D E a 1 2 3 4 5 b 1 2 3 4 5 ''' df_2 = pd.DataFrame([[10,20,30,40,50],[10,20,30,40,50]],index=['a','b'],columns=['A','B','C','D','E']) print(df_2) ''' 输出结果 A B C D E a 10 20 30 40 50 b 10 20 30 40 50 ''' #加法计算 df_3 = df_1 + df_2 print(df_3) ''' 输出结果 A B C D E a 11 22 33 44 55 b 11 22 33 44 55 ''' #减法计算 df_3 = df_1 - df_2 #乘法计算 df_3 = df_1 * df_2 #除法计算 df_3 = df_1 / df_2
2>对齐运算(每个DataFrame对象的数据个数不相同)
#创建两个DataFrame对象 #两行五列 df_1 = pd.DataFrame([[1,2,3,4,5],[1,2,3,4,5]],index=['a','b'],columns=['A','B','C','D','E']) print(df_1) ''' 输出结果 A B C D E a 1 2 3 4 5 b 1 2 3 4 5 ''' #三行三列 df_2 = pd.DataFrame([[10,20,30],[10,20,30],[10,20,30]],index=['a','b','c'],columns=['A','B','C']) print(df_2) ''' 输出结果 A B C a 10 20 30 b 10 20 30 c 10 20 30 ''' df_3 = df_1 + df_2 print(df_3) #和Series中的对齐运算一样,找不到对应的位置的数据给Nan ''' 输出结果 A B C D E a 11.0 22.0 33.0 NaN NaN b 11.0 22.0 33.0 NaN NaN c NaN NaN NaN NaN NaN '''
但是在实际统计中,数据NaN会影响,所以可以使用add()函数
add()对齐运算--->对未对齐的数据填充,然后进行运算
参数一:需要对齐运算的数据对象
参数二:对应位置默认值#创建两个DataFrame对象 #两行五列 df_1 = pd.DataFrame([[1,2,3,4,5],[1,2,3,4,5]],index=['a','b'],columns=['A','B','C','D','E']) print(df_1) ''' 输出结果 A B C D E a 1 2 3 4 5 b 1 2 3 4 5 ''' #三行三列 df_2 = pd.DataFrame([[10,20,30],[10,20,30]],index=['a','b'],columns=['A','B','C']) print(df_2) ''' 输出结果 A B C a 10 20 30 b 10 20 30 ''' df_3 = df_1.add(df_2,fill_value=1) print(df_3) #使用add()函数,fill_value参数为需要设置的默认值 ''' 输出结果 A B C D E a 11 22 33 5.0 6.0 b 11 22 33 5.0 6.0 '''
(5)DataFrame对象的数据修改
1>修改列数据
df_1 = pd.DataFrame([[1,2,3,4,5],[1,2,3,4,5]],index=['a','b'],columns=['A','B','C','D','E']) print(df_1) ''' A B C D E a 1 2 3 4 5 b 1 2 3 4 5 ''' #修改B这一列 df_1['B'] = pd.Series([100,200],index=['a','b']) print(df_1) ''' A B C D E a 1 100 3 4 5 b 1 200 3 4 5 '''
2>添加新列
df_1 = pd.DataFrame([[1,2,3,4,5],[1,2,3,4,5]],index=['a','b'],columns=['A','B','C','D','E']) print(df_1) ''' A B C D E a 1 2 3 4 5 b 1 2 3 4 5 ''' df_1['F'] = pd.Series(['你好',"世界"],index=['a','b']) print(df_1) ''' A B C D E F a 1 2 3 4 5 你好 b 1 2 3 4 5 世界 '''
3>删除某列
df_1 = pd.DataFrame([[1,2,3,4,5],[1,2,3,4,5]],index=['a','b'],columns=['A','B','C','D','E']) print(df_1) ''' A B C D E a 1 2 3 4 5 b 1 2 3 4 5 ''' #使用del del(df_1['E']) print(df_1) ''' A B C D a 1 2 3 4 b 1 2 3 4 '''
4>通常会遇到有Nan的空数据
可以通过fillna()这个函数把Nan数据转换为正常数据
参数1:需要填充的数据
参数2:inplace,默认为False,替换后需要新对象接收,改为True的话就为就地填充
#创建两个DataFrame对象 #两行五列 df_1 = pd.DataFrame([[1,2,3,4,5],[1,2,3,4,5]],index=['a','b'],columns=['A','B','C','D','E']) print(df_1) ''' 输出结果 A B C D E a 1 2 3 4 5 b 1 2 3 4 5 ''' #三行三列 df_2 = pd.DataFrame([[10,20,30],[10,20,30]],index=['a','b'],columns=['A','B','C']) print(df_2) ''' 输出结果 A B C a 10 20 30 b 10 20 30 ''' df_3 = df_1 + df_2 print(df_3) ''' A B C D E a 11 22 33 NaN NaN b 11 22 33 NaN NaN ''' #使用fillan()函数,设置需要填充的数据为0 df_4 = df_3.fillna(0) ''' 直接输出 A B C D E a 11 22 33 NaN NaN b 11 22 33 NaN NaN 发现并没有改变,因为inplace默认为False,替换后需要新对象接收 ''' print(df_4) ''' A B C D E a 11 22 33 0.0 0.0 b 11 22 33 0.0 0.0 ''' #如果fillna()中的inplace=True的话,则不需要新对象接收,直接输出即可
3.Pandas的其他高级应用
(1)Pandas高级函数
1>allpy()函数
作用:将某个函数应用到行数据或列数据
参数1:某个函数
参数2:axis=0/1 0为列轴向,1为行轴向
注意:默认为0是列轴向
#创建一个DataFrame对象 df = pd.DataFrame(np.random.randn(4,5)) print(df) ''' 0 1 2 3 4 0 -0.424642 0.245011 0.234163 2.020902 -2.008150 1 1.071732 -0.356165 -0.051649 0.081620 -0.416612 2 0.618656 1.271960 0.126436 0.138978 -0.924348 3 1.848569 -0.563261 -1.321456 -0.537379 0.521588 ''' #使用allpy(某个函数,axis=0/1)函数 #默认的话axis=0,是每列,所以取出了每列最大值 print(df.apply(lambda x:x.max())) ''' 0 1.848569 1 1.271960 2 0.234163 3 2.020902 4 0.521588 dtype: float64 '''
2>allpymap()函数
作用:将某个函数应用对象的每一个数据上
参数1:某个函数
#创建一个DataFrame对象 df = pd.DataFrame(np.random.randn(4,5)) print(df) ''' 0 1 2 3 4 0 -0.416850 0.721202 0.407990 0.706786 2.205044 1 0.187485 0.721705 -1.781101 -0.389938 0.385217 2 1.042906 -0.121288 -0.108704 0.220526 -1.943875 3 -0.817982 0.329798 -0.830090 -0.609012 -0.255436 ''' #使用allpymap(某个函数)函数 #所有数据保留2个小数 print(df.applymap(lambda x:'%.2f'%x)) ''' 0 1 2 3 4 0 -0.42 0.72 0.41 0.71 2.21 1 0.19 0.72 -1.78 -0.39 0.39 2 1.04 -0.12 -0.11 0.22 -1.94 3 -0.82 0.33 -0.83 -0.61 -0.26 '''
3>sort_index()函数
作用:根据索引排序
#创建一个Series对象 ser = pd.Series(range(10,15),index=np.random.randint(5,size=5)) print(ser) ''' 2 10 0 11 4 12 2 13 2 14 dtype: int32 ''' #使用sort_index()函数排序,默认ascending=True升序 #ascending=False为降序 print(ser.sort_index()) ''' 0 11 2 10 2 13 2 14 4 12 dtype: int32 ''' #创建一个DataFrame对象 df = pd.DataFrame(np.random.randn(3,4),index=np.random.randint(3,size=3),columns=np.random.randint(4,size=4)) print(df) ''' 2 0 3 2 2 0.217727 1.203948 -0.688645 -0.863836 2 -0.180206 -0.077609 -0.611350 0.150716 1 0.658392 -0.658513 0.076823 -0.106351 ''' #不指定排序轴向,默认按照行轴向排序 #asix=0按照行排序 asix=1按照列排序 print(df.sort_index()) ''' 2 0 3 2 1 0.658392 -0.658513 0.076823 -0.106351 2 0.217727 1.203948 -0.688645 -0.863836 2 -0.180206 -0.077609 -0.611350 0.150716 '''
4>sort_values()函数
作用:根据索引排序#创建一个Series对象 ser = pd.Series([2,5,7,8,1,0]) print(ser) ''' 0 2 1 5 2 7 3 8 4 1 5 0 dtype: int64 ''' #使用sort_values()函数排序,默认ascending=True升序 #ascending=False为降序 print(ser.sort_values()) ''' 5 0 4 1 0 2 1 5 2 7 3 8 dtype: int64 ''' #创建一个DataFrame对象 df = pd.DataFrame(np.random.randn(3,4),index=range(1,4),columns=range(1,5)) print(df) ''' 1 2 3 4 1 -0.856200 -1.824741 -1.283182 0.427393 2 -0.689118 1.020502 -0.146721 0.677232 3 0.968071 -0.010719 -0.444609 0.519839 ''' #不指定排序轴向,默认按照行轴向排序 #asix=0按照行排序 asix=1按照列排序 print(df.sort_values(by=2,ascending=False)) ''' 1 2 3 4 2 -0.689118 1.020502 -0.146721 0.677232 3 0.968071 -0.010719 -0.444609 0.519839 1 -0.856200 -1.824741 -1.283182 0.427393 ''' #指定按照多列进行排序,优先按照第一个指定的列进行排序 print(df.sort_values(by=[2,3])) ''' 1 2 3 4 1 -0.856200 -1.824741 -1.283182 0.427393 3 0.968071 -0.010719 -0.444609 0.519839 2 -0.689118 1.020502 -0.146721 0.677232 '''
5>fillna()函数
# fillna() 填充缺失数据的 df = pd.DataFrame([np.random.randn(4), [1,2,np.nan,np.nan], [3,np.nan,np.nan,np.nan], ['hello','world','test','qq'] ]) print(df) # 获取布尔类型索引,判断数据中哪些为空数据 print(df.isnull())
6>dropna()函数
# fillna() 填充缺失数据的 df = pd.DataFrame([np.random.randn(4), [1,2,np.nan,np.nan], [3,np.nan,np.nan,np.nan], ['hello','world','test','qq'] ]) print(df) # df.fillna(1) # dropna()丢弃缺失数据 默认按照行丢弃缺失数据,如果该行有NaN数据,则丢弃该行数据 # axis=0 按照行丢弃空数据 axis=1按照列丢弃空数据 print(df.dropna(axis=1))
(2)Pandas数据的分组和聚合
分组对数据进行分组,然后对一组的数据进行计算
SQL是可以对数据进行分组和过滤的
Pandas可以通过groupby函数进行复杂的分组运算
分组运算过程:
1.分组 根据某些要求分组
2.运算 根据不同的分组数据进行不同的运算
3.合并 把每一个分组的运算结果合并在一起
首先创建数据模型
dict_data = { 'key1':['a','b','c','d','a','b','c','d'], 'key2':['one','two','three','one','two','three','one','two'], 'data1':[3.6,1.8,2,6,8,10,5.8,4], 'data2':[11,5,6,2,7,9,1,2] } #根据字典创建df对象 df = pd.DataFrame(dict_data) print(df) ''' data1 data2 key1 key2 0 3.6 11 a one 1 1.8 5 b two 2 2.0 6 c three 3 6.0 2 d one 4 8.0 7 a two 5 10.0 9 b three 6 5.8 1 c one 7 4.0 2 d two '''
1>根据指定列进行分组
#按照指定列进行分组 #DataFrameGroupBy 类型的对象,储存分组之后的数据 print(df.groupby('key1')) #输出结果<pandas.core.groupby.DataFrameGroupBy object at 0x088687D0> print(df.groupby('key1').sum()) ''' data1 data2 key1 a 11.6 18 b 11.8 14 c 7.8 7 d 10.0 4 ''' ''' a data1 data2 0 3.6 11 1 8.0 7 b 0 1.8 5 1 10.0 9 c 0 2.0 6 1 5.8 1 d 0 6.0 2 1 4.0 2 '''
2>把某列数据按照另一列进行分组
#把某列数据按照另一列进行分组 #1.找到要分组的列 print(df['data1']) ''' 0 3.6 1 1.8 2 2.0 3 6.0 4 8.0 5 10.0 6 5.8 7 4.0 Name: data1, dtype: float64 ''' #根据key1这一列进行分组 #SeriesGroupBy print(df['data1'].groupby(df['key1']).sum()) ''' key1 a 11.6 b 11.8 c 7.8 d 10.0 Name: data1, dtype: float64 '''
3>按照数据类型分组
#按照数据类型分组 group = df.groupby(df.dtypes,axis=1) print(group) for group_name,group_data in group: print(group_name) #分组运算,让每一个df对象中的每一列的数据累加 #print(group_data) print('*'*30)
#按照数据类型分组 group = df.groupby(df.dtypes,axis=1) print(group) for group_name,group_data in group: print(group_name) #分组运算,让每一个df对象中的每一列的数据累加 print(group_data.sum()) print('*'*30)
4>根据字典进行分组
#根据字典进行分组 df = pd.DataFrame(np.random.randint(1,10,(5,5)), index = ['a','b','c','d','e'], columns = ['A','B','C','D','E'] ) print(df) ''' A B C D E a 5 1 5 5 9 b 1 1 5 2 5 c 9 4 3 6 4 d 6 6 3 4 9 e 5 9 2 5 5 ''' #自己指定每一列的数据对应的分组名称 dict_mapping = { 'A':'Python', 'B':'Java', 'C':'C', 'D':'Java', 'E':'Python' } print(df.groupby(dict_mapping,axis=1).size()) ''' C 1 Java 2 Python 2 dtype: int64 ''' print(df.groupby(dict_mapping,axis=1).sum()) ''' C Java Python a 5 6 14 b 5 3 6 c 3 10 13 d 3 10 15 e 2 14 10 '''