pandas -- 基础操作(四): dataFrame 数据拼接merge、join、concat、append

系列文章目录

基础操作(四): dataFrame 数据拼接merge、join、concat、append

---

---

前言

Pandas.DataFrame操作表连接有三种方式：merge, join, concat，append，
下面详细解释这几个方法的使用。

---

dataFrame 数据拼接的方法:

1. merge()

df.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)

特点：

1. 默认以重叠列名当做链接键
2. 默认是INNER JOIN。
3. 可以多键连接，'on’参数后传入多键列表即可
4. 如果两个对象的列表不同，可以用left_on, right_on指定。
5. 也可以用行索引当连接键，使用参数left_index=True, right_index=True. 但是这种情况下最好用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 

2. 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 可以多列设置

特点:
4. 按照行对数据进行拼接，两个df可以是不同的长度，拼接后和左边的数据长度保持一直。
5. 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

3.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

4. 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相同。

总结

本文主要介绍了dataFrame 数据合并的操作，其中包括merge、join、concat和append。其中join和append 使用的场景相对较窄，多使用merge和concat。