python大数据之dataframe常用操作

文章目录

1. 文件操作

主要是三种文件，txt，csv，xlsx；

txt暂无

csv

'''CSV读取'''
df = pd.read_csv("文件名",encoding='utf_8_sig')#读取文件，同时需要进行解码，避免出现乱码情况del df_train['Unnamed: 0']#常用语删除无用的索引行'''CSV保存'''
df = pd.to_csv("文件名",header=True)//保存时常常会把列索引保存进去

xlsx

'''CSV读取'''
df = pd.read_excel("文件名",encoding='utf_8_sig')#读取文件，同时需要进行解码，避免出现乱码情况del df_train['Unnamed: 0']#常用语删除无用的索引行'''CSV保存'''
df = pd.to_xlsx("文件名")//保存时常常会报列索引保存进去

2.dataframe属性和方法

df.index    #访问索引
df.columns   #访问列名
df.T    #转置

Dataframe创建操作

'''列表创建'''
pd.DataFrame(columns=list, index=list)#空列表
pd.DataFrame(columns=list, index=list，data=list（list）)//带数据的结构

'''字典创建'''
pd.DataFrame(dict,index=None)#字典key默认为列名'''Series创建'''
pd.DataFrame(dict("列名",pd.Series),index=None)#键值默认为列名'''二维数组创建'''
pd.DataFrame(arr, index=None, columns=None)'''字典组成列表'''
pd.DataFrame(list(dict),index=None, columns=None)#键值默认为列名'''字典组成字典'''
pd.DataFrame(dict(dict))#最外面的是列名，里面是index

查找

'''按列读取'''
df.列名
df['列名']
df[list].iloc[:,colNo1:colNo2]'''按列号读取'''
df.iloc[:1]#读取第一列
df.iloc[:,1:3]#读取第一列到第三列，没有左开右闭
df.iloc[:,2:]#读取第2列之后的数据'''按行名读取'''.loc['行标签'].loc[list]'''按行号读取'''.loc[list]#存整形'''按单元格读取'''
df['列']['行']
df.列['行']'''读取一行多列'''
df.loc[行][列：列]#list为列'''读取多行一列'''
df.loc[list][列]'''读取多行多列'''
df.loc[list][list]

OperationSyntaxResult选择列

df[col]

Series按索引选择行

df.loc[label]

Series按数字索引选择行

df.iloc[loc]

Series使用切片选择行

df[5:10]

DataFrame用表达式筛选行

df[bool_vec]

DataFrame

赋值

'''按列赋值’''
df.A = [1,2,3,4,5,6]      #列表的值要跟行的值相同

'''按行赋值'''
df.loc[row]=list
df.loc[list,list]=list(list)

插入

'''插入一列'''
df.insert(ioc, column,list)#list为结果值'''插入一行'''
row =dict()
df.loc[1]= row

'''指定填充值'''
df.fillna('我是无效值')

删除

drop(labels=list, axis=0, level=None, inplace=False)#labels表示要删除的数据， axis：0表示行，1表示列，  # inplace表示当前df中执行的操作

drop_duplicates()#删除行# 还可以指定要判断的列，比如我们要删除A，B，C重复的行：
df.drop_duplicates(['A','B','C'])

拼接

merge()

可以根据一个或多个健 将不同DataFrame中的行连接起来，类似于数据库中的join方法。

merge(left, right, how='inner', on=None, left_on=None, right_on=None,
      left_index=False, right_index=False, sort=True,
      suffixes=('_x','_y'), copy=True, indicator=False)
      
left,right：需要拼接的两个数据
how：拼接方式，inner(内连接),left(左外连接),right(右外连接),outer(全外连接);默认为inner

on:用于连接列索引名称
left_on：左则DataFrame中用作连接键的列名;这个参数中左右列名不相同，但代表的含义相同时非常有用。

right_on：右则DataFrame中用作 连接键的列名

left_index：使用左则DataFrame中的行索引做为连接键，用到这个参数时，就有点类似于接下来要说的JOIN函数了。

right_index：使用右则DataFrame中的行索引做为连接键

sort：默认为True，将合并的数据进行排序。在大多数情况下设置为False可以提高性能

suffixes：字符串值组成的元组，用于指定当左右DataFrame存在相同列名时在列名后面附加的后缀名称，默认为('_x','_y')

copy：默认为True,总是将数据复制到数据结构中；大多数情况下设置为False可以提高性能

indicator：在 0.17.0中还增加了一个显示合并数据中来源情况；如只来自己于左边(left_only)、两者(both)

特点：

默认以重叠列名当做连接健。

默认是INNER JOIN。

可以多健连接，‘on’参数后传入多健列表即可。

如果两个对象的列表不同，可以用left_on，right _on指定。

也可以用行索引当连接健，使用参数left_index，但是这种情况最好用JOIN

df_2 = pd.DataFrame({'key':['a','b','b'],'data1':range(3)})
df_1 = pd.DataFrame({'key':['a','b','c'],'data':range(3)})
df_2
  key  data1
0   a      01   b      12   b      2
df_1
  key  data
0   a     01   b     12   c     2
pd.merge(df_2,df_1)# 默认为inner
  key  data1  data
0   a      001   b      112   b      21

pd.merge(df_1,df_2,how='left')# 左连接，无数据补空，同outer
  key  data  data1
0   a     00.01   b     11.02   b     12.03   c     2    NaN
pd.merge(df_1,df_2,how='right')# 同inner
  key  data  data1
0   a     001   b     112   b     12#  merge 多个键连接
df_1['key1']=[1,1,2]
df_2['key1']=[1,3,3]
pd.merge(df_1,df_2,on=['key1','key'])#按照key1和key的值合并
  key  data  key1  data1  
0   a     010# 列名不同合并
pd.merge(df_1,df_2,left_on='data',right_on='key1')# 相同重复类的名字加 _x 和_y 后缀
  key_x  data  key1_x key_y  data1    key1_y
0     b     11     a      01

Join()

join连接主要是列索引上的合并，join默认为左连接，只能操作DataFrame，Series没有该方法

left.join(right, on=key_or_keys)

1. df1.join(df2):列名没有重复，可以直接使用
2. df1.join(df2,lsuffix=’_l’, rsuffix=’_r’):列名重复时需要指定lsuffix和rsuffix
3. on 可以多列设置

特点

1. 按照行对数据进行拼接，两个df可以是不同的长度，拼接后和左边的数据长度保持一直。
2. df1和df2合并的列名不同，但是值相同：df1.join(df2.set_index('列名’of df2),on=df1的‘列名’)

例子1：# 左侧长度为3
df = pd.DataFrame({'a':[1,2,34]})
dff = df.join(pd.DataFrame({'b':[11,22]}))
dff
Out[11]: 
    a     b
0111.01222.0234   NaN

例子2：# 左侧长度为2
df = pd.DataFrame({'a':[1,2]})
dff = df.join(pd.DataFrame({'b':[11,22,33]}))
dff
Out[14]: 
   a   b
01111222

append()

append相当于concat的简易操作，行上的拼接（axis=0），需要列的名称相同

df_3 = pd.DataFrame({'a':range(3),'b':range(3),'c':range(3)})
df_3
   a  b  c
000011112222
df_4 = pd.DataFrame({'a':range(3),'b':range(3),'c':range(3)})
df_4
   a  b  c
000011112222
df_4.index=[4,5,6]
df_4
   a  b  c
400051116222
df_3.append(df_4)# 列名相同，直接行拼接
   a  b  c
000011112222400051116222

concat()

pd.concat(objs, axis=0, join='outer', join_axes=None, ignore_index=False,
          keys=None, levels=None, names=None, verify_integrity=False,
          copy=True)1、aixs=0 行拼接，效果与obj1.append(obj2)是相同的
2、ignore_index=False 是否忽略索引而重建
3、join  “inner”：列的交集 “outer”：列的并集

concat是轴向链接，关键在与axis，axis=0表示列操作，axis=1 行操作，默认为0

df = pd.concat([df1,df2],axis=1),[df1,df2,df3]可以一次实现多个df合并。

pd.concat([df1, df2], axis=0, ignore_index=True)：行合并，ignore_index=True，重新设置行索引。列合并ignore_index=True，columns重新排序。默认为False

备注：列合并需要index相同，行合并需要columns相同。

3.算术运算

运算符操作函数注释+add()加法-sub()减法*mul()乘法/div()除法//floordiv()取整**pow()乘方%mod()取余
dataframe与标量

• , - , * , /可以用于直接运算，如果是标量，则直接全加，类似点乘。列加也是一样的。

add(100， fill_value=100) 可以给缺失值+上1000 # 上面的100也可以使用dataframe来代替

sub(y, fill_value=100)

dataframe与dataframe之间

• , - , * , / 可以在两个dataframe之间进行运算，属于一对一的计算。

4.逻辑运算

逻辑运算符号< , > , |, &

• 逻辑运算类型：>, >=, <, <= , ==, !=
• 复合逻辑运算：&，|， ~（与或非）

5.常用聚合函数

• max()：最大值
• min()：最小值
• mean()：平均值
• median()：算术平均值
• sum()：求和
• count(axis=0)：列计数
• value_counts()：统计某列不不同值出现的频数

也可以用来统计缺省值

6.lamda函数使用

pandas的元素级操作是对每个元素进行相同的操作，比如格式转换，判断是否为空等

df = DataFrame(np.arange(12).reshape(3,4))# 判断为空
df.isnull()# 对每个元素转字符串
df.applymap(lambda s:str(s))# 执行数学操作
df.applymap(lambda s:s**2)
df.apply(lambda s:s**2)# 与函数进行结合deffun(val,n):try:
        a,b,c = val.split('*')except ValueError:return val
    if n ==1:return a
    elif n ==2:return b
    elif n ==3:return c
    else:returnint(a)*int(b)*int(c)

f1['16']= f1.apply(lambda x:fun(x['12'],2),axis=1)
f1['17']= f1.apply(lambda x:fun(x['12'],3),axis=1)
f1['18']= f1.apply(lambda x:fun(x['12'],4),axis=1)
f1['12']= f1.apply(lambda x:fun(x['12'],1),axis=1)#这里是将函数中的体积模块，分成长，宽，高以及他们的乘积和