扫码加入数据分析学习群

1. s=Series(['a',4,5,None,np.nan])
   

   

2.s.isnull() #缺失值的判断

s.notnull()
3. data1=[[1, 2, None],[4, 5, np.nan],[7, 8, 9]] #二维列表创建,二维元组
d1=DataFrame(data1)

4. df = pd.DataFrame(np.random.rand(4, 5))
df.index = ['a', 'b', 'c', 'd']
df.columns = ['value1','value2','value3','value4','value5']
df.iloc[0:3,1]=np.nan
df #先产生有缺失值的数据

5. df.dropna(axis=0) #沿着0轴方向看，是否有缺失，删除的是行

6. df.dropna(axis=1) #沿着1轴方向看，是否有缺失，删除的是列

7. df.dropna(axis=0,thresh=5) # 删除非nan的数量小于5的行，阈值，保留非空的数量大于等于5的行

8.df.dropna(axis=1,thresh=2) #阈值，保留非空的数量大于等于2的列

9. df.dropna(how='all',axis=0) #删除的是行，全部为nan才删除

10. df.dropna(how='any',axis=0) #删除的是行，只要有nan就删除

11. df.dropna(how='any',axis=1) #删除的是列，只要为nan就删除

12. df.loc['e']=[1,2,3,4,5]
df.loc['f']=[1,2,3,4,5]
df.loc['g']=[1,2,2,3,3]
df #生成数据

13. df.drop_duplicates(keep='first') #删除行，所有的列相同认为是重复

14. df.drop_duplicates(['value1','value2'],keep='first') #value1和value2相同则去重复

15. df.drop_duplicates(['value1'],keep='last')
16. df1=df.reset_index()

17. df2=df1.drop_duplicates(['index'],keep='last')

18. 数据的填充和替换

19. df = pd.DataFrame([
['小ming', 18],
['小强', 19],
['小丽', np.NaN],
['小花', np.NaN]
],columns=['name', 'age'], index=['a','b','c','d'])
df.replace('小ming','小明') #新生成，替换

df.replace('小ming','小明',inplace=True) #原地修改

20. df=pd.read_clipboard(header=None)

缺失值的填充

21. a = [[1, 2, 2],[3,None,6],[3, 7, None],[5,None,7]]
df = DataFrame(a)

df.fillna(0) #用常数进行填充

df.fillna({1:0,2:100}) #用不同的值填充不同的列 1,2为列名

df.fillna(method='ffill') #前向填充，同一列的前一行，默认axis=0

df.fillna(method='bfill') #后向填充

df.fillna(df.mean()) #用均值填充，按照列进行 max，min

df.fillna(df[0].mean()) #用某一列的均值进行填充

df.groupby('年级')['age'].apply(lambda x: x.fillna(x.mean()))

算数运算和对齐

22. #序列运算
s1=Series([4,2,-5,3],index=['d','b','a','e'])
s2=Series([4,2,-5,3,6,7],index=['d','b','a','c','f','g']) #自动对齐索引，缺失值会在运算中传播
s1+s2

s1.add(s2,fill_value=0) #调用方法,空值用0填充

df1.apply(np.mean,axis=0) #np.mean,std,sum,max numpy系统带的一些函数

df1.apply(np.mean,axis=1) #需要特别指定

#扩展性很强，可以写复杂函数
def f(x):
if x<5:
return x
else:
return x*x
for i in df1.columns:
df1[i]=df1[i].map(f) #

排序

序列的排序

#序列
s=pd.Series([3,4,1,6],index=['b','a','d','c'])

s.sort_index() #按索引排序

s.sort_values() #按值的大小,从小大

s.sort_values(ascending=False,inplace=True) #ascending=False 降序

d1=pd.DataFrame([[2,4,1,5],[3,1,4,5],[5,1,4,2]],columns=['b','a','d','c'],index=['one','two','four'])

d1.sort_index(axis=0,ascending=True) #默认,升序

d1.sort_index(axis=1,ascending=True) #默认

d1.sort_values(by='a',ascending=True) #默认按照列排序

d1.sort_values(by='two',ascending=False,axis=1) #按照行排序，需要指定轴

设置索引再排序

df1=df.set_index(['位置']) #重新设置索引
df1.sort_index(axis=0,ascending=False) #默认

#多层排序
df2=df.set_index(['位置','价格']) #重新设置索引

df2.sort_index(level=0).head(20)#0为位置，1为价格

df1.reset_index().head() #恢复默认索引

多重排序

df.sort_values(['位置','价格'],ascending=[True,False]).set_index(['位置','价格'])

df.sort_values(['价格','成交量'],ascending=[True,False])

统计和描述

a = [[1,np.nan,9],[2,8,3],[3,5,np.nan]]
data = DataFrame(a,index=["a","b","c"],columns=["one","two","three"])
data

data.sum() #按列进行统计

data.mean()

data.sum(axis=1)

data.idxmax() #每一列中最大值的行索引

data.idxmax(axis=1) #每一行中最大值的列索引

data.count() #非空的数量

data.describe() #描述

更换列的顺序

a = [[1,np.nan,9],[2,8,3],[3,5,np.nan]]
data = DataFrame(a,index=["a","b","c"],columns=["one","two","three"])
data

方法一：

data[['three','two','one']]

方法二：针对列数比较多的情况

df_id=data['three'] #选择要调整的那一列

data = data.drop('three',axis=1) #对原数据，删除那一列

data.insert(0,'three',df_id) #在默认列索引的地方插入three这个列索引，

数据的合并和重塑

拼接

df1 = DataFrame(np.ones((2,4))*2, index=['one','two'],columns=['a','b','c','d'])
df2 = DataFrame(np.ones((3,3))*1, index=['one','two','three'],columns=['b','d','e'])

pd.concat([df1,df2],axis=1,join='outer') #横着拼接，外连接

pd.concat([df1,df2],axis=1,join='inner') #横着拼接，内连接

pd.concat([df1,df2],axis=0,join='outer') #纵向拼接，外连接

pd.concat([df1,df2],axis=0,join='inner') #内连接

pd.concat([df1,df2],axis=0,join='inner',ignore_index=True) #重新设置索引

#append,只有纵向
df1.append(df2,ignore_index=True)

主键合并

left = pd.DataFrame({'key': ['K0', 'K1', 'K2', 'K3'],
'A': ['A0', 'A1', 'A2', 'A3'],
'B': ['B0', 'B1', 'B2', 'B3']})
right = pd.DataFrame({'key': ['K0', 'K1', 'K2', 'K4'],
'C': ['C0', 'C1', 'C2', 'C3'],
'D': ['D0', 'D1', 'D2', 'D3']})

pd.merge(left,right,on='key',how='outer') #外连接

pd.merge(left,right,on='key',how='inner') #内连接

pd.merge(left,right,on='key',how='left') #以左边为准

pd.merge(left,right,on=['key1','key2']) #inner

pd.merge(left,right,on=['key1','key2'],how='outer') #out方式

pd.merge(left,right,on=['key1','key2'],how='left') #以左测为准

pd.merge(left,right,on=['key1','key2'],how='right') #以右测为准

df = DataFrame({'水果种类':['苹果','苹果','梨','梨','草莓','草莓'],
'信息':['价格','数量','价格','数量','价格','数量'],
'值':[4,3,5,4,6,5]})

df.pivot('水果种类','信息','值')

分组运算 #groupby

df = DataFrame({'类别':['水果','水果','水果','蔬菜','蔬菜','肉类','肉类'],
'产地':['美国','中国','中国','中国','新西兰','新西兰','美国'],
'种类':['苹果','梨','草莓','番茄','黄瓜','羊肉','牛肉'],
'数量':[5,5,9,3,2,10,8],
'价格':[5,5,10,3,3,13,20]})

df[['类别','价格']].groupby('类别').mean() #std,var,min,max,sum

df[['类别','数量']].groupby('类别').sum() #std,var,min,max,sum

df[['类别','价格','产地']].groupby(['产地','类别']).mean() #std,var,min,max,sum

df[['类别','数量','产地']].groupby(['产地','类别']).size() #统计记录条数

df[['类别','数量','产地']].groupby(['产地','类别']).size().values #将记录条数以数组呈现

df[['类别','数量','产地']].groupby(['产地','类别']).count() #统计记录条数

淘宝数据分析

df = pd.read_csv('taobao_data.txt')
df.head(5)

哪个地方成交量最多

df[['位置','成交量']].groupby('位置').sum().sort_values('成交量',ascending=False)

哪个卖家成交量最多

df[['卖家','成交量']].groupby('卖家').sum().sort_values('成交量',ascending=False).head()

哪个商家的成交额最多

df['成交额']=df['价格']*df['成交量']

df[['卖家','成交额']].groupby('卖家').sum().sort_values('成交额',ascending=False).head()

可以通过字典或者序列进行分组

people=DataFrame(np.random.randn(5,5),columns=['a','b','c','d','e'],index=['joe','steve','wes','jim','travis'])
people.loc[['wes'],['b','c']]=np.nan
people

mapping={'joe':'1','steve':'2','wes':'1','jim':'2','travis':'3'}#通过字典进行映射
people.groupby(mapping).sum()

mapping={'a':'red','b':'red','c':'blue','d':'blue','e':'red'}#通过字典进行映射
people.groupby(mapping,axis=1).sum()

数据聚合

df=DataFrame({'key1':['a','a','b','b','a'],'key2':['one','two','one','two','one'],'data1':np.random.randn(5),'data2':np.random.randn(5)})

传入标准函数

df.groupby(['key1']).agg([np.mean]) #标准的函数，std，var，min,max

def ptp(arr):
return arr.max()-arr.min()
df.groupby(['key1']).agg([ptp])

df.groupby(['key1']).agg([np.mean,ptp]) #可以调用多个聚合函数

不同的列用不同的聚合函数

df = DataFrame({'类别':['水果','水果','水果','蔬菜','蔬菜','肉类','肉类'],
'产地':['美国','中国','中国','中国','新西兰','新西兰','美国'],
'种类':['苹果','梨','草莓','番茄','黄瓜','羊肉','牛肉'],
'数量':[5,5,9,3,2,10,8],
'价格':[5,5,10,3,3,13,20]})

def ptp(arr):
return arr.max()-arr.min()

#不同的列用不同的聚合函数
mapping={'数量':np.sum,'价格':np.mean} #
df.groupby('类别').agg(mapping)

分组运算和转换

df[['类别','价格']].groupby('类别').transform(lambda x:x-x.mean())

透视表和交叉表

df = DataFrame({'类别':['水果','水果','水果','蔬菜','蔬菜','肉类','肉类'],
'产地':['美国','中国','中国','中国','新西兰','新西兰','美国'],
'种类':['苹果','梨','草莓','番茄','黄瓜','羊肉','牛肉'],
'数量':[5,5,9,3,2,10,8],
'价格':[5,5,10,3,3,13,20]})

df.pivot_table(index=['类别']) #先对类别groupby，再求mean

df.pivot_table(index=['产地','类别']) #先对类别groupby，再求mean

df.pivot_table(index=['产地','类别'],aggfunc=np.sum) #使用定义的聚合函数

pd.crosstab(df['类别'],df['产地']) #统计的是分组的频率