本文详细介绍Pandas库的使用，涵盖Series与DataFrame的创建、索引、数据获取、文件操作、统计方法、时间序列处理、表合并、分组聚合等功能，是进行高效数据分析的必备指南。
pandas引入
from pandas import Series, DataFrame
import pandas as pd
Series：一种类似于一维数组的对象，是由一组数据(各种NumPy数据类型)以及一组与之相关的数据标签(即索引)组成。仅由一组数据也可产生简单的Series对象。注意：Series中的索引值是可以重复的。
DataFrame：一个表格型的数据结构，包含有一组有序的列，每列可以是不同的值类型(数值、字符串、布尔型等)，DataFrame即有行索引也有列索引，可以被看做是由Series组成的字典。
Series创建
1，一维数组创建
通过数组创建Series的时候，如果没有为数据指定索引的话，会自动创建一个从0到N-1的整数索引，当Series对象创建好后，可以通过inde修改索引值
arr=[87,90,89]
series=Series(arr)
series.index=[u'语文',u'数学',u'英语']
series=Series(data=[89,90,34],dtype=np.float,index=[u'语文',u'数学',u'英语'])
series.name=u'语文' #索引具有一个name属性，默认为null,根据需要进行赋值操作
series.index.name=u"考试成绩"
#series.head()返回前n行
#series.tail()返回最后n行
print(series)
考试成绩
语文 89.0
数学 90.0
英语 34.0
Name: 语文, dtype: float64
2，通过字典的方式创建
字典中的key组成Series中的索引，字典中的values组成Series的value
dict={'a':1,'b':2,'c':3,'d':4}
series=Series(dict)
Series获取
1，通过中括号+索引（[x]）的方式获取对应索引的数据
print(series['语文'])
2，通过中括号+下标值（冒号：同切片）的方式读取对应下标值的数据
print(series[0:1])
Series缺失值检测
pandas中的isnull和notnull两个函数可以用于在Series中检测缺失值，这两个函数的返回时一个布尔类型的Series，
arr=np.array([1,3,4,np.nan,10])
print(arr[pd.isnull(arr)]) #nan
DataFrame 创建
通过二位数组创建，即数据以行和列的表格方式排列。通过列表创建，可以自定义行列
arr=np.array([['tom',76],['grrry',98],['john',86]])
df=DataFrame(arr,index=['one','two','three'],columns=['name','score'])
print(df)
name score
one tom 76
two grrry 98
three john 86
采用字典创建 arrays must all be same length
dict={
'name':['joe','anne','black'],
'age':[16,19,20],
'sex':['m','f','m'],
'class':1
}
df=pd.DataFrame(dict,index=['one','two','three'])
#df.columns=list('abcd') 重置列索引 age class name sex
print(df)
age class name sex
one 16 1 joe m
two 19 1 anne f
three 20 1 black m
DataFrame索引
分层索引 DataFrame.set_index(index) 指定index分层
还原索引 DataFrame.reset_index()
DataFrame数据获取
列的获取
#df使用前面创建的df 下同
df['salary']=['1k','2k','3k'] #列添加
del(df03['salary']) || df03.pop('b') #列删除
df['name']=['zhangsan','laowang','xiaozhang'] #列修改,修改1,2,3行数据
df[indexname] df['name'] #列选择，
行的获取 loc,iloc[index]
df.loc['four']=[11,2,'green','m'] #行新增
delDf=df.drop('four') #删除行
df.loc['four','name']='greeen' #行更新
dfselectMulti=df.loc[['one','three']] #行选择，选择one,three两行
dfIselectMulti=df.iloc[[0,2]] #这边的 i 我觉得代表index，比较好记点。此处等同于 dfselectMulti
pandas文件操作
文件读取 read_xxx相关的函数可以读取文件中的数据，并形成DataFrame
#csv
df=pd.read_csv("dta.csv",seq=":",header=None)#header=None 列名转化成数据
#excel
df=pd.read_excel("data.xlsx",header=None,names=['a','b','c'])
文件存储
df.to_csv("data.csv",sep=":",header=None)
NaN处理方法
df.isnull() # 返回一个含有布尔值的对象，这些布尔值表示那些值是缺失值NA notnull 相反
df.dropna() # 删除只要包含NAN的行
df.dropna(axis=1) # 删除只要包含NAN的列
df.dropna(how="all",axis=1) # 删除所有的 元素为NAN的行或列
dfFill=df.fillna("0") #指定值替换nan
dfFill=df.fillna({"classs":"0.0","sex":"1.0"}) #替换指定列中的nan值
dfReplace=df.replace({np.nan:'hehe'})
pandas统计方法
df.describe() #计算列总统计值
A B C D E
count 4.000000 4.00 4.000000 4.000000 4.00000
mean 7.250000 4.25 5.250000 3.500000 4.00000
std 0.957427 2.50 0.957427 2.886751 2.94392
min 6.000000 1.00 4.000000 1.000000 1.00000
25% 6.750000 3.25 4.750000 1.000000 2.50000
50% 7.500000 4.50 5.500000 3.500000 3.50000
75% 8.000000 5.50 6.000000 6.000000 5.00000
max 8.000000 7.00 6.000000 6.000000 8.00000
df.count() #列中计算非na值的数量
df.min()/max() # 列中最小值，最大值
df.idmin()/idxmax() #列中最小值，最大值行索引
df.mean() #列中平均数
df.quantile() #列中分位数
df.median() #列中中位数
df.sum() #列中值的总和
df.std() # 列中变准差
df.var() # 列中方差
#行的话，axis=1
df.max(axis=1)
pandas:相关系数与协方差
协方差 ：如果有X,Y两个变量，每个时刻的“X值与其均值之差”乘以“Y值与其均值之差”得到一个乘积，再对这每时刻的乘积求和并求出均值。
如果协方差为正，说明X，Y同向变化，协方差越大说明同向程度越高；如果协方差为负，说明X，Y反向运动，协方差越小说明反向程度越高。
df=DataFrame({'dw':[1,2,3,4,5,6],'kill':[10,3,5,8,3,1]})
df['dw'].cov(df['kill'])
相关系数:corr()
就是用X、Y的协方差除以X的标准差和Y的标准差。所以，相关系数也可以看成协方差：一种剔除了两个变量量纲影响、标准化后的特殊协方差。
当相关系数为1的时候两者相识度最大，同向正相关
当相关系数为0的时候两者没有任何相似度，两个变量无关
当相关系数为-1的时候两者变化的反向相似度最大，完全反向负相关
层次索引
ser=Series([1,2,3,4,5],index=[['2015','2015','2015','2016','2016'],['a','b','c','a','b']])
print(ser)
2015 a 1
b 2
c 3
2016 a 4
b 5
dtype: int64
swap=ser.swaplevel()#交换分层索引
df = DataFrame({
'year':[2011,2012,2011,2013,2013,2012,2014],
'fruit':['apple','apple','banana','orange','orange','leon','leon'],
'name':['jack1','jack2','jack3','jack4','jack5','jack6','jack7'],
'score':[211,12,11,20,13,201,14],
'profits':[111,222,333,444,555,666,777]
})
df01=df.set_index(['fruit','year']) #分层索引
dfsum=df01.sum(level='fruit') #按照index='fruit'索引进行求和操作
dfProfitsMean=df01['profits'].mean(level='year') #按照index='year'索引进行求均值操作
unstack() 把最内层的行索引还原成了列索引, stack()是将原来的列索引转成了最内层的行索引
deep_Series = pd.Series([89, 99, 56, 44, 33, 56], index=[
['2015', '2015', '2015', '2016', '2016', '2016'],
list('CMECME')])
data_frame = deep_Series.unstack() #unstack() 把最内层的行索引还原成了列索引
#data_frame = deep_Series.unstack(level='0') 把level对应的行索引还原成了列索引
2015 C 89
M 99
E 56
2016 C 44
M 33
E 56
dtype: int64
C E M
2015 89 56 99
2016 44 56 33
排序之sort_
#sort_index Series
series=pd.Series(np.arange(0,4),index=['b','c','d','a'])
seriesSort=series.sort_index(ascending=True) #ascending=True正常排序，False倒序排序。缺省正序排列
#sort_index DataFrame
df1=pd.DataFrame(np.random.randint(1,9,(4,4)),columns=['b','c','a','d'],index=['B','D','A','C'])
df2=df1.sort_index(axis=1,ascending=False)#通过列索引进行排序
d c b a
B 1 6 8 8
D 8 2 5 7
A 8 5 5 1
C 2 4 6 8
#sort_values
#对Series按值进行排序, 排序时，任何缺失值默认都会被放到Series的末尾。
dfSort0=df1.sort_values(by=['a'],ascending=False)#默认axis=0 ，值按“a”列进行排序，此处倒序
b c a d
B 8 6 8 1
C 6 4 8 2
D 5 2 7 8
A 5 5 1 8
dfSort1=df1.sort_values(by=['A','B'],ascending=True,axis=1) #值按"A","B"行排序,此处升序
排序之rank
跟排序关系密切， 且它会增设一个排名值（从1开始， 一直到数组中有效数据的数量）
method为average，即排序是在相等分组中，为各个值分配平均排名，默认值
ser=Series([5,6,5,7,8],index=list('bdcae'))
serRank=ser.rank(method='average')#method:'min', 'max','first'
b 1.5
d 3.0
c 1.5
a 4.0
e 5.0
dtype: float64
时间序列
#M月，D天，H时,T分,S秒
date_range=pd.date_range(start='2017-01-01 08:10:50',periods=11,freq='2D')
DatetimeIndex(['2017-01-01 08:10:50', '2017-01-03 08:10:50',
'2017-01-05 08:10:50', '2017-01-07 08:10:50',
'2017-01-09 08:10:50', '2017-01-11 08:10:50',
'2017-01-13 08:10:50', '2017-01-15 08:10:50',
'2017-01-17 08:10:50', '2017-01-19 08:10:50',
'2017-01-21 08:10:50'],
dtype='datetime64[ns]', freq='2D')
表合并
pandas.merge 可根据一个或多个键将不同 DataFrame 中的行连接起来。
dic={'data1':[1,2,3,4],'key':['a','b','c','m']}
df1=DataFrame(dic)
dic2={'data2':[11,22,33,44],'key':['a','b','c','n']}
df2=DataFrame(dic2)
#默认按照相同的列名或者通过on指定列名
dataFmerge=pd.merge(df1,df2,on='key',how='outer')#指定连接方式。outer并集，默认交集
dataFmerge=pd.merge(df1,df2,left_on='key1',right_on='key2')#没有相同的列名，分别指定列名
data1 key data2
0 1.0 a 11.0
1 2.0 b 22.0
2 3.0 c 33.0
3 4.0 m NaN
4 NaN n 44.0
pandas.concat 可以沿着一条轴将多个对象堆叠到一起
dic={'data':[1,2,3,4],'key1':['a','b','c','m']}
df1=DataFrame(dic)
dic2={'data':[11,22,33,44],'key2':['a','b','c','n']}
df2=DataFrame(dic2)
dataf2=pd.concat([df1,df2],axis=0,join='outer') #join连接的方式 outer并集；
data key1 key2
0 1 a NaN
1 2 b NaN
2 3 c NaN
3 4 m NaN
0 11 NaN a
1 22 NaN b
2 33 NaN c
3 44 NaN n
Pandas 分组和聚合
分组：groupby 对DataFrame进行数据分组
聚合：GroupBy对象sum()/mean()/max()等方法
dfMean=df.groupby('sex')['money'].mean()
Pandas聚合之apply
df1=pd.DataFrame(np.random.randint(1,9,(4,4)),columns=list('abcd'))
def sums(x):
return x.sum()
df2=df1.apply(sums,axis=1)#默认axis=0列
a b c d
0 7 5 1 8
1 3 1 5 6
2 1 4 6 5
3 5 5 3 2
0 21
1 15
2 16
3 15
#自定义字符串拼接操作
def type_name(x,suffixs,suffix2):
return str(x)+suffixs+suffix2
df2=df1['c'].apply(type_name,args=('班','级'))
0 1班级
1 5班级
2 6班级
3 3班级
Pandas聚合之数据透视
df1 = pd.DataFrame({
'score':[70,60,50,80,99],
'grade':['one','two','one','two','one'],
'class':['lib','sci','lib','lib','sci']
})
df2=df1.pivot_table(values='score',index='grade',aggfunc=np.sum)
df3=df1.pivot_table(values='score',index='grade',columns='class',aggfunc=np.sum)
grade
one 219
two 140
Name: score, dtype: int64
class lib sci
grade
one 120 99
two 80 60
扫一扫
854
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
