python数据处理

numpy 数据类型一样（相当于R中的array）

• 数据生成
  从0开始为索引 reshape按行进行填充得到形状,order='C’表示按行，'F’表示按列

import numpy as np
a=np.arange(6).reshape(3,2)
print(a)
b=a.reshape(2,3)
print(b)
#条件过滤
print(a[a[:,1]>2,])
#转置
print(a.T)
#展开（降维成一纬）  flatten不改变原矩阵
a.flatten()
a.ravel()

#数组排序  a.sort()或np.sort(array,axis,order=排序字段)直接改变原数组 sorted不改变原数组
#axis=0表示按列排序，axis=1表示按行排序
#argsort返回升序对应下标
#降序需要为a[np.argsort(-a)]
import numpy as np
a=np.array([2,4,1,5])
b=sorted(a)
print(b)
print(a.argsort())
print(a)

a=np.array([[1,4,3],[2,3,4],[2,3,1]])
a.sort(axis=0)
print('最大值',np.argmax(a))
#多条件排序（首先根据a排序，再根据b排序，返回索引值）
a = [1,5,1,4,3,4,4] # First column
b = [9,4,0,4,0,2,1] # Second column
ind = np.lexsort((b,a)) # Sort by a, then by b
print(ind)
#numpy.argmax() 返回最大值索引
#numpy.where(a>3) 返回满足条件的索引

• 数组组合

#水平组合 垂直组合 深度组合 列组合 行组合
import numpy as np
a=np.arange(6).reshape(3,2)
b=np.arange(2,8).reshape(3,2)
c=np.concatenate((a,b),axis=1)
print(c)
c=np.concatenate((a,b))
print(c)

#统计函数
import numpy as np
a=np.arange(6).reshape(3,2)
np.mean(a)
np.median(a)
np.max(a)

---

pandas三种数据类型 （数据类型可以不一样，但是每列数据类型要一样）

1. Series 一维数据（带有索引的一维数组）
2. Dataframe 二维数据
3. Panel 三维或可变维数据

---

1. Series

import pandas as pd
s=pd.Series([1,2,3,4],index=['a','b','c','d'])
print(s.index)
print(s.values)

2. dataframe

• 创建数据框（三种方法）与切片（loc,iloc）

#按行组合成为数据框 df[]直接引用后面只能是列名
#loc后面用name iloc用数组索引（并且iloc中0:2不包含2）
#创建dataframe
import pandas as pd
df=pd.DataFrame([[1,2,3],[2,3,4]],columns=['x','y','z'])
df1=pd.DataFrame(dict(X=range(6),Y=range(1,7),Z=range(2,8)))
df2=pd.DataFrame({'x':range(2),'y':range(1,3)},index=['a','b'])
print(df1)
print(df.loc[0,])
print(df.loc[[0,1],'x']) #使用loc列要用名字搜索
#多重索引
df1=df1.set_index(['X','Y'])
print(df1.loc[(3,4),'Z'])
#对0级索引进行筛选，但不对1级索引筛选
print(df1.loc[(3,slice(None)),'Z'])
#想象x是横向放，y是纵向放，生成一个大网格
x=['a','b','c','d']
y=range(4)
X,Y=np.meshgrid(x,y)
print(X,Y)
df_grid=pd.DataFrame({'x':X.flatten(),'y':Y.flatten()})
print(df_grid)

• numpy分类数据

  是一种类似于列表但又不是列表的形式，是一种数据类型，不是数据结构（R 中的factor）

import numpy as np
import pandas as pd

cut='c s d a s r a d'.split(sep=' ')
#分类变量
cut_factor=pd.Categorical(cut)
print(type(cut_factor))

#桉顺序排好分类变量(有序变量)
cut_factor2=pd.Categorical(cut,categories=['a','c','d','r','s'],ordered=True)
#可以放进数据框
df=pd.DataFrame({'num':list(range(8)),'type':cut_factor2})

• 表格变化

#表格变换
#宽数据变长数据 melt函数使用与R类似
import pandas as pd
df=pd.DataFrame({'x':['A','B','C'],'2010':[1,3,4],'2011':[3,5,2]})
df_melt=pd.melt(df,id_vars='x',var_name='year',value_name='value')
print(df_melt)
#长变宽    columns是要进行拆分的列，calues是对应的值
df_pivot=df_melt.pivot_table(index='x',columns='year',values='value')
df_pivot=df_pivot.reset_index()
print(df_pivot)

• 变量变换

import pandas as pd
#创建新列
df=pd.DataFrame({'x':['A','B','C'],'2010':[1,3,4],'2011':[3,5,2]})
df['value']=df['2011']*2
print(df)
#apply函数 遍历每行或每列，进行指定函数操作
df['value']=df.apply(lambda x:x['2011']*2 if x['2011']==1 else x['2011'],axis=1)
#列表排序  ascending=True表示升序
dat_sort1=df_melt.sort_values(by='value',ascending=True)
dat_sort3=df_melt.sort_values(by=['value','year'],ascending=True)

• 列表拼接

#列表拼接与融合
import pandas as pd
df1=pd.DataFrame(dict(x=['a','b','c'],y=range(1,4)))
df2=pd.DataFrame(dict(z=['B','D','H'],g=[2,5,3]))
df3=pd.DataFrame(dict(x=['g','d'],y=[2,5]))

dat_cbind=pd.concat([df1,df2],axis=1)
dat_rbind=pd.concat([df1,df3],axis=0)
print(dat_cbind)
print(dat_rbind)

#删除某列 (inpalce决定是否改变原数据)
df1.drop(labels='y',axis=1,inplace=True)

#表格融合
#how参数有left，right，inner,outer，决定保留那部分全部信息，on表示匹配哪些列（要求列名字相同），left_on,right_on（列名不相同进行匹配）
dat_merge1=pd.merge(left=df1,right=df3,how='left',on='x')
dat_merge2=pd.merge(left=df1,right=df2,how='left',left_on='y',right_on='g')
print(dat_merge1)
print(dat_merge2)

• 列表分组操作

gruopby函数

import pandas as pd
import numpy as np
df=pd.DataFrame({'x':'A B C A D'.split(sep=' '),'2010':[1,3,4,4,3],'2011':[3,5,2,8,9]})
df_melt=pd.melt(df,id_vars='x',var_name='year',value_name='value')
#将某列的值形式转换
df_melt['year']=df_melt['year'].astype(int)
#求和
df_rowsum=df[['2010','2011']].apply(lambda x:x.sum(),axis=1)
df_colsum=df[['2010','2011']].apply(lambda x:x.sum(),axis=0)
df['2010_2011']=df.apply(lambda x:x['2010']+2*x['2011'],axis=1)
print(df_colsum)

#分组操作
df_group_mean1=df_melt.groupby('year').mean()
#as_index参数决定是否将两列变为大小索引展示
df_group_mean2=df_melt.groupby(['year','x'],as_index=False).mean()
df_group_mean3=df_melt.groupby(['year','x']).mean()
print(df_group_mean1,df_group_mean2)

• 数据导入导出

建议录入数据时采用一维列表

#读取函数pd.read_xxx,导出函数df.to_xxx
#1、excel
import pandas as pd
#header表示列名是在哪一行,inex_col指定哪一列作为行索引
df=pd.read_excel(r'E:\书籍\大三下\商务统计学\数据集\statistics for business and economics 11e Data Files\Absent.xlsx',
                 header=0,index_col=None)
print(df)

#缺失值
df.dropna()
df.fillna()
df.isnull()
df.isna()