python大数据之dataframe常用操作

详细讲解了dataframe的常用操作，包含创建，增删改查，算数运算，逻辑运算，常用聚合函数以及lamda函数的使用等

addict_jun

9623人浏览 · 2022-09-15 10:04:38

addict_jun · 2022-09-15 10:04:38 发布

文章目录

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]

Operation	Syntax	Result
选择列	`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      0
1   b      1
2   b      2
df_1
  key  data
0   a     0
1   b     1
2   c     2
pd.merge(df_2,df_1) # 默认为inner
  key  data1  data
0   a      0     0
1   b      1     1
2   b      2     1

pd.merge(df_1,df_2,how='left')  # 左连接，无数据补空，同outer
  key  data  data1
0   a     0    0.0
1   b     1    1.0
2   b     1    2.0
3   c     2    NaN
pd.merge(df_1,df_2,how='right') # 同inner
  key  data  data1
0   a     0      0
1   b     1      1
2   b     1      2

#  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     0     1      0  

# 列名不同合并
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     1       1     a      0         1

Join()

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

left.join(right, on=key_or_keys)

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

特点

按照行对数据进行拼接，两个df可以是不同的长度，拼接后和左边的数据长度保持一直。
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
0   1  11.0
1   2  22.0
2  34   NaN

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

append()

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

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

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)

# 与函数进行结合
def fun(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: return int(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)

#这里是将函数中的体积模块，分成长，宽，高以及他们的乘积和