一、DataFrame简介
DataFrame是一个带有索引的二维数据结构,每列可以有自己的名字,并且可以有不同的数据类型。你可以把它想象成一个excel表格或者数据库中的一张表,DataFrame是最常用的Pandas对象。如下图所示:
Pandas中的DataFrame可以使用下列函数构建:
import pandas as pd
pd. DataFrame( data= None , index: Union[ Collection, NoneType] = None , \
columns: Union[ Collection, NoneType] = None , \
dtype: Union[ str , numpy. dtype, _ForwardRef( 'ExtensionDtype' ) , \
NoneType] = None , copy: bool = False )
参数 说明 是否必要 data ndarray(结构化或同类),可迭代,dict或DataFrame、Dict可以包含Series,数组,常量或类似列表的对象 必要 index 设置行标签,如果未提供列标签,则为(0,1,2,…,n),长度必须与行长度一致 非必要 columns 设置列标签,如果未提供列标签,则为(0,1,2,…,n),长度必须与列长度一致 非必要 dtype 每列的数据类型,如果没有,则推断 非必要 copy 默认为False,从输入中复制数据。 非必要
二、创建DataFrame
2.1 创建空DataFrame
import pandas as pd
pd. DataFrame( )
2.2 列表创建DataFrame
import pandas as pd
lst = [ 1 , 2 , 3 ]
pd. Series( lst)
0 1
1 2
2 3
dtype: int64
import pandas as pd
lst = [ 1 , 2 , 3 ]
pd. DataFrame( lst)
import pandas as pd
lst = [ [ 1 , 2 , 3 ] , [ 2 , 3 , 4 ] ]
pd. DataFrame( lst)
lst = [ [ 1 , 2 , 3 ] , [ 2 , 3 , 4 , 5 ] ]
pd. DataFrame( lst)
2.3 字典创建DataFrame
import pandas as pd
dic = { "a" : 1 , "b" : 2 }
import pandas as pd
data = { 'Name' : [ '小明' , '小猪' , '蘑菇头' , '毛台' ] , 'Age' : [ 18 , 34 , 29 , 22 ] }
pd. DataFrame( data)
Name Age 0 小明 18 1 小猪 34 2 蘑菇头 29 3 毛台 22
import pandas as pd
data = { 'Name' : ( '小明' , '小猪' , '蘑菇头' , '毛台' ) , 'Age' : [ 18 , 34 , 29 , 22 ] }
pd. DataFrame( data)
Name Age 0 小明 18 1 小猪 34 2 蘑菇头 29 3 毛台 22
Series字典创建DataFrame
import pandas as pd
d = { 'one' : pd. Series( [ 1 , 2 , 3 ] , index= [ 'a' , 'b' , 'c' ] ) ,
'two' : pd. Series( [ 1 , 2 , 3 , 4 ] , index= [ 'a' , 'b' , 'c' , 'd' ] ) }
pd. DataFrame( d)
one two a 1.0 1 b 2.0 2 c 3.0 3 d NaN 4
2.4 二维数组创建DataFrame
这里仅仅只有二维数组(矩阵)能够创建出DataFrame,其余都不可。【NumPy数组学习参考】
import numpy as np
import pandas as pd
x = np. arange( 15 ) . reshape( 5 , 3 )
pd. DataFrame( x, index= [ "a" , "b" , "c" , "d" , "e" ] , columns= [ "A" , "B" , "C" ] )
A B C a 0 1 2 b 3 4 5 c 6 7 8 d 9 10 11 e 12 13 14
三、DataFrame的增删改查
本节引例
import numpy as np
import pandas as pd
x = np. arange( 15 ) . reshape( 5 , 3 )
df = pd. DataFrame( x, index= [ "a" , "b" , "c" , "d" , "e" ] , columns= [ "A" , "B" , "C" ] )
df
A B C a 0 1 2 b 3 4 5 c 6 7 8 d 9 10 11 e 12 13 14
3.1 DataFrame的增
3.1.1 行增加
利用append方法将它们拼接起来,注意参数中的ignore_index=True,如果不把这个参数设为True,新排的数据块索引不会重新排列。
df111 = df. copy( )
a = df111[ : 2 ]
b = df111[ 2 : ]
a. append( b, ignore_index= True )
A B C 0 0 1 2 1 3 4 5 2 6 7 8 3 9 10 11 4 12 13 14
用.concat()的方法来进行拼接,与append类似
pd. concat( [ a, b] , ignore_index= True )
A B C 0 0 1 2 1 3 4 5 2 6 7 8 3 9 10 11 4 12 13 14
loc法
df112 = df. copy( )
df112. loc[ "f" ] = list ( range ( 3 ) )
df112. loc[ "g" ] = 3
df112
A B C a 0 1 2 b 3 4 5 c 6 7 8 d 9 10 11 e 12 13 14 f 0 1 2 g 3 3 3
若需指定行位置添加,可以通过DataFrame.T先将其行列互换,添加后再次转置回来即可。
3.1.2 列增加
新增空白列,注意空白不是缺失值,NaN才是缺失值
df121 = df. copy( )
df121[ "C" ] = ""
df121
只能在末尾新增,同时可创建列索引
df122 = df. copy( )
df122[ "D" ] = 3
df122[ "E" ] = list ( range ( len ( df4) ) )
df122
A B C D E a 0 1 2 3 0 b 3 4 5 3 1 c 6 7 8 3 2 d 9 10 11 3 3 e 12 13 14 3 4
如果需要在指定的位置添加新的一列,用insert( )函数
df. insert( loc, column, value, allow_duplicates= False )
参数 说明 loc 插入索引(int型)。 0 <= loc <= len(columns) column str,数字或可哈希对象,插入列的标签。 value int,Series或类似数组的值 allow_duplicates 布尔值,可选
df123 = df. copy( ) . T
df123. insert( 2 , "D" , "" )
df123. T
A B C a 0 1 2 b 3 4 5 D c 6 7 8 d 9 10 11 e 12 13 14
3.2 DataFrame的删
DataFrame. drop( labels= None , axis= 0 , index= None , columns= None , inplace= False )
参数 说明 labels 就是要删除的行列的名字,用列表给定 axis 默认为0,指删除行,因此删除columns时要指定axis=1 index 直接指定要删除的行 columns 直接指定要删除的列 inplace=False 默认该删除操作不改变原数据,而是返回一个执行删除操作后的dataframe inplace=True 则会直接在原数据上进行删除操作,删除后无法返回
df. pop( item)
3.2.1 行删除
根据行索引,指定位置删除行
df211 = df. copy( )
df211. drop( "a" , axis= 0 , inplace= True )
df211
df211. drop( [ "b" , "c" ] )
3.2.2 列删除
根据列索引,指定位置删除列
df221 = df. copy( )
df221. drop( "A" , axis= 1 , inplace= True )
df221
pop法
df222 = df. copy( )
df222. pop( "A" )
df222
del法
del df222[ "B" ]
df222
3.3 DataFrame的改
3.3.1 根据索引更改行
df31 = df. copy( )
df31. loc[ "a" ] = ""
df31
A B C a b 3 4 5 c 6 7 8 d 9 10 11 e 12 13 14
3.3.2 根据索引更改列
df32 = df. copy( )
df32[ "A" ] = ""
df32
3.3.3 通过行列索引更改指定位置元素
df33 = df. copy( )
df33. loc[ "a" ] [ "A" ] = 2
df33. iloc[ 0 , 2 ] = "a"
df33
A B C a 2 1 a b 3 4 5 c 6 7 8 d 9 10 11 e 12 13 14
3.4 DataFrame的查
3.4.1 查看行
获取某一行,或者多行行
df41 = df. copy( )
df41[ 2 : 3 ]
df41[ : 3 ]
获取某行或某几行
df41. loc[ "a" ]
A 0
B 1
C 2
Name: a, dtype: int32
df41. loc[ "a" : "c" ]
df41. iloc[ 1 : 2 , : ]
获取指定位置元素
df41. loc[ "a" ] [ "A" ]
0
df41. iloc[ 0 , 2 ]
2
df41. at[ "a" , "B" ]
1
df41. iat[ 1 , 2 ]
5
获取指定位置多个元素
df41. iloc[ 0 : 3 , 1 : 3 ]
查看前n行
df41. head( 2 )
查看后n行
df41. tail( 2 )
3.4.2 查看列
df42 = df. copy( )
df42[ [ "A" ] ]
df42[ [ "A" , "B" ] ]
df42. iloc[ : , 1 : 3 ]
get访问列(结果为一个Series)
df42. get( "B" )
a 1
b 4
c 7
d 10
e 13
Name: B, dtype: int32
df42. get( "B" ) . get( "a" )
1
通过属性访问,结果也是Series
df42. A
a 0
b 3
c 6
d 9
e 12
Name: A, dtype: int32
df42. A. a
0
df42. A[ : 2 ]
a 0
b 3
Name: A, dtype: int32
df42[ : 2 ]
df42. T
a b c d e A 0 3 6 9 12 B 1 4 7 10 13 C 2 5 8 11 14
df42[ : : - 1 ]
A B C e 12 13 14 d 9 10 11 c 6 7 8 b 3 4 5 a 0 1 2
四、DataFrame的统计相关操作
import numpy as np
import pandas as pd
x = np. arange( 15 ) . reshape( 5 , 3 )
df = pd. DataFrame( x, index= [ "a" , "b" , "c" , "d" , "e" ] , columns= [ "A" , "B" , "C" ] )
df
A B C a 0 1 2 b 3 4 5 c 6 7 8 d 9 10 11 e 12 13 14
查看基本信息情况
df. info( )
<class 'pandas.core.frame.DataFrame'>
Index: 5 entries, a to e
Data columns (total 3 columns):
# Column Non-Null Count Dtype
--- ------ -------------- -----
0 A 5 non-null int32
1 B 5 non-null int32
2 C 5 non-null int32
dtypes: int32(3)
memory usage: 100.0+ bytes
查看列索引信息
df. columns
Index(['A', 'B', 'C'], dtype='object')
查看行索引信息
df. index
Index(['a', 'b', 'c', 'd', 'e'], dtype='object')
获取列表的值,结果为二维数组
df. values
array([[ 0, 1, 2],
[ 3, 4, 5],
[ 6, 7, 8],
[ 9, 10, 11],
[12, 13, 14]])
查看各列的统计值(纯数据)
df. describe( )
A B C count 5.000000 5.000000 5.000000 mean 6.000000 7.000000 8.000000 std 4.743416 4.743416 4.743416 min 0.000000 1.000000 2.000000 25% 3.000000 4.000000 5.000000 50% 6.000000 7.000000 8.000000 75% 9.000000 10.000000 11.000000 max 12.000000 13.000000 14.000000
查看每列的数据数目有多少个
df. count( )
A 5
B 5
C 5
dtype: int64
查看各列的平均值
df. mean( )
A 6.0
B 7.0
C 8.0
dtype: float64
各列最大值
df. max ( )
A 12
B 13
C 14
dtype: int32
各列最小值
df. min ( )
A 0
B 1
C 2
dtype: int32
按列统计表中的空值的数量
df. isnull( ) . sum ( )
A 0
B 0
C 0
dtype: int64
按列统计 表中大于10的元素个数
df. where( df> 10 ) . count( )
A 1
B 1
C 2
dtype: int64
根据列名A属性进行分组,统计每一组的分布情况
df. groupby( "A" ) . count( )
筛选出符合条件的行显示出来
df[ df[ "A" ] > 3 ]
所有行都显示,不符合条件的显示为NaN
df. where( df[ "B" ] > 3 )
A B C a NaN NaN NaN b 3.0 4.0 5.0 c 6.0 7.0 8.0 d 9.0 10.0 11.0 e 12.0 13.0 14.0
行相关计算
df
A B C a 0 1 2 b 3 4 5 c 6 7 8 d 9 10 11 e 12 13 14
df[ "A累加计算" ] = df[ "A" ] + df[ "A" ] . shift( )
df
A B C A累加计算 a 0 1 2 NaN b 3 4 5 3.0 c 6 7 8 9.0 d 9 10 11 15.0 e 12 13 14 21.0
列相关计算,都是一一对应关系
df
A B C A累加计算 a 0 1 2 NaN b 3 4 5 3.0 c 6 7 8 9.0 d 9 10 11 15.0 e 12 13 14 21.0
df[ "A" ] = df[ "C" ] + df[ "A" ]
df
A B C A累加计算 a 2 1 2 NaN b 8 4 5 3.0 c 14 7 8 9.0 d 20 10 11 15.0 e 26 13 14 21.0
df[ "A" ] = df[ "A" ] * 3
df
A B C A累加计算 a 6 1 2 NaN b 24 4 5 3.0 c 42 7 8 9.0 d 60 10 11 15.0 e 78 13 14 21.0
df[ "D" ] = df[ "A" ] + df[ "B" ] + df[ "C" ] * 2
df
A B C A累加计算 D a 6 1 2 NaN 11 b 24 4 5 3.0 38 c 42 7 8 9.0 65 d 60 10 11 15.0 92 e 78 13 14 21.0 119
import numpy as np
import pandas as pd
x = np. arange( 15 ) . reshape( 5 , 3 )
df = pd. DataFrame( x, index= [ "a" , "b" , "c" , "d" , "e" ] , columns= [ "A" , "B" , "C" ] )
df
A B C a 0 1 2 b 3 4 5 c 6 7 8 d 9 10 11 e 12 13 14
值的算术中值(中位数)
df. median( )
A 6.0
B 7.0
C 8.0
dtype: float64
贝塞尔修正样本标准差
df. std( )
A 4.743416
B 4.743416
C 4.743416
dtype: float64
无偏方差
df. var( )
A 22.5
B 22.5
C 22.5
dtype: float64
无偏协方差(二元)
df. cov( )
A B C A 22.5 22.5 22.5 B 22.5 22.5 22.5 C 22.5 22.5 22.5
样品偏斜度(三阶矩)
df. skew( )
A 0.0
B 0.0
C 0.0
dtype: float64
样品峰度(四阶矩)
df. kurt( )
A -1.2
B -1.2
C -1.2
dtype: float64
样本分位数(百分位上的值)
df. quantile( 0.75 )
A 9.0
B 10.0
C 11.0
Name: 0.75, dtype: float64
相关性计算,计算相关性时用到的方法有:
pearson:标准相关系数(默认) kendall:Kendall Tau相关系数 Spearman:Spearman等级相关
df. corr( method= "pearson" )
A B C A 1.0 1.0 1.0 B 1.0 1.0 1.0 C 1.0 1.0 1.0
rank 函数求出数据的排名顺序,排序方法有:
average:组的平均排名 min:该组中的最低排名 max:该组中最高的排名 first:按排列顺序出现在数组中 dense:类似于“最小”,但组之间的排名始终增加1
df
A B C a 0 1 2 b 3 4 5 c 6 7 8 d 9 10 11 e 12 13 14
df. B. c = 33
df. B. a = 25
df. B. rank( method= "min" )
a 4.0
b 1.0
c 5.0
d 2.0
e 3.0
Name: B, dtype: float64
有时需要对不同窗口的中数据进行一个统计,通过 rolling 我们可以实现,设置 window=2 来保证窗口长度为 2,设置 on=“A” 来保证这一列来滑动窗口(默认不设置,表示根据索引来欢动)。有些结果是缺失值,导致这个结果的原因是因为在计算时,窗口中默认需要的最小数据个数与窗口长度一致,这里可以设置 min_periods=1 来修改下。
df
A B C a 0 1 2 b 3 4 5 c 6 7 8 d 9 10 11 e 12 13 14
df. rolling( window= 2 , on= "A" ) . sum ( )
A B C a 0 NaN NaN b 3 5.0 7.0 c 6 11.0 13.0 d 9 17.0 19.0 e 12 23.0 25.0
df. rolling( window= 2 , on= "A" , min_periods= 1 ) . sum ( )
A B C a 0 1.0 2.0 b 3 5.0 7.0 c 6 11.0 13.0 d 9 17.0 19.0 e 12 23.0 25.0
df. expanding( min_periods= 1 ) [ "A" , "B" ] . sum ( )
A B a 0.0 1.0 b 3.0 5.0 c 9.0 12.0 d 18.0 22.0 e 30.0 35.0
上面的方式只能生成一个结果,有时候想要同时求出多个结果(如求和与均值),则可利用agg方法:
df. rolling( window= 2 , min_periods= 1 ) [ "A" ] . agg( [ np. sum , np. mean, np. std] )
sum mean std a 0.0 0.0 NaN b 3.0 1.5 2.12132 c 9.0 4.5 2.12132 d 15.0 7.5 2.12132 e 21.0 10.5 2.12132
df. rolling( window= 2 , min_periods= 1 ) [ "A" ] . agg( { "A_sum" : np. sum , "A_mean" : np. mean, "A_std" : np. std} )
A_sum A_mean A_std a 0.0 0.0 NaN b 3.0 1.5 2.12132 c 9.0 4.5 2.12132 d 15.0 7.5 2.12132 e 21.0 10.5 2.12132