【Task 6】连接

最新推荐文章于 2024-07-12 19:06:42 发布

decade、

最新推荐文章于 2024-07-12 19:06:42 发布

阅读量209

点赞数

分类专栏： # Pandas 文章标签： python

本文链接：https://blog.csdn.net/weixin_44369102/article/details/111870559

版权

Pandas 专栏收录该内容

6 篇文章 0 订阅

订阅专栏

一、关系型连接

1. 连接的基本概念

连接的两个重要要素：

键：用 on 参数表示，在关系型连接中，把两张相关的表按照某一个或某一组键连接起来是一种常见操作。
连接的形式：在 pandas 中的关系型连接函数 merge 和 join 中提供了 how 参数来代表连接形式，分为：

左连接 left
右连接 right
内连接 inner
外连接 outer

用示意图表示它们的区别：

左连接：即以左边的键为准，如果右边表中的键于左边存在，那么就添加到左边，否则则处理为缺失值，右连接类似处理。

内连接：只负责合并两边同时出现的键，而外连接则会在内连接的基础上包含只在左边出现以及只在右边出现的值，因此外连接又叫全连接。

同一个表中的键出现重复的情况，只需把握一个原则，即只要两边同时出现的值，就以笛卡尔积的方式加入，如果单边出现则根据连接形式进行处理。

笛卡尔积的说明：

设左表中键 张三 出现两次，右表中的 张三 也出现两次，那么逐个进行匹配，最后产生的表必然包含 2*2 个姓名为 张三 的行。

2. 值连接

merge 函数可以通过几列值的组合进行连接。

# 根据 姓名 进行张三和李四信息的 左连接
df1 = pd.DataFrame({'Name':['San Zhang','Si Li'],
                     'Age':[20,30]})
 

df2 = pd.DataFrame({'Name':['Si Li','Wu Wang'],
                     'Gender':['F','M']})
 

df1.merge(df2, on='Name', how='left')
## 输出
        Name  Age Gender
0  San Zhang   20    NaN
1      Si Li   30      F

如果两个表中想要连接的列不具备相同的列名，可以通过 left_on 和 right_on 指定：

df1 = pd.DataFrame({'df1_name':['San Zhang','Si Li'],
                     'Age':[20,30]})
 

df2 = pd.DataFrame({'df2_name':['Si Li','Wu Wang'],
                     'Gender':['F','M']})
 

df1.merge(df2, left_on='df1_name', right_on='df2_name', how='left')
## 输出
    df1_name  Age df2_name Gender
0  San Zhang   20      NaN    NaN
1      Si Li   30    Si Li      F

如果两个表中的列出现了重复的列名，那么可以通过 suffixes 参数指定。

# 合并考试成绩的时候，第一个表记录了语文成绩，第二个是数学成绩
df1 = pd.DataFrame({'Name':['San Zhang'],'Grade':[70]})

df2 = pd.DataFrame({'Name':['San Zhang'],'Grade':[80]})

df1.merge(df2, on='Name', how='left', suffixes=['_Chinese','_Math'])
## 输出 
        Name  Grade_Chinese  Grade_Math
0  San Zhang             70          80

指定 on 参数为多个列使得正确连接，能解决出现重复元素：

# 两位同学来自不同的班级，但是姓名相同，使用 on参数 正确连接
df1 = pd.DataFrame({'Name':['San Zhang', 'San Zhang'],
                    'Age':[20, 21],
                    'Class':['one', 'two']})
 

df2 = pd.DataFrame({'Name':['San Zhang', 'San Zhang'],
                     'Gender':['F', 'M'],
                     'Class':['two', 'one']})
 
df1
## 输出
        Name  Age Class
0  San Zhang   20   one
1  San Zhang   21   two

df2
## 输出
        Name Gender Class
0  San Zhang      F   two
1  San Zhang      M   one

df1.merge(df2, on='Name', how='left') # 错误的结果
## 输出 
        Name  Age Class_x Gender Class_y
0  San Zhang   20     one      F     two
1  San Zhang   20     one      M     one
2  San Zhang   21     two      F     two
3  San Zhang   21     two      M     one

df1.merge(df2, on=['Name', 'Class'], how='left') # 正确的结果
## 输出 
        Name  Age Class Gender
0  San Zhang   20   one      M
1  San Zhang   21   two      F

要保证唯一性，除了用 duplicated 检查是否重复外， merge 中也提供了 validate 参数来检查连接的唯一性模式。这里共有三种模式：

一对一连接 1:1 ：指左右表的键都是唯一的
一对多连接 1:m ：指左表键唯一
多对一连接 m:1 ：指右表键唯一

3. 索引连接

索引连接：把索引当作键，这和值连接本质上没有区别。

pandas 中利用 join 函数来处理索引连接，它的参数选择要少于 merge ，除了必须的 on 和 how 之外，可以对重复的列指定左右后缀 lsuffix 和 rsuffix 。其中， on 参数指索引名，单层索引时省略参数表示按照当前索引连接。

df1 = pd.DataFrame({'Age':[20,30]},
                     index=pd.Series(
                     ['San Zhang','Si Li'],name='Name'))
 

df2 = pd.DataFrame({'Gender':['F','M']},
                     index=pd.Series(
                     ['Si Li','Wu Wang'],name='Name'))
 

df1.join(df2, how='left')
## 输出 
           Age Gender
Name                 
San Zhang   20    NaN
Si Li       30      F

使用 join 让语文和数学分数合并：

df1 = pd.DataFrame({'Grade':[70]},
                     index=pd.Series(['San Zhang'],
                     name='Name'))
 

df2 = pd.DataFrame({'Grade':[80]},
                     index=pd.Series(['San Zhang'],
                     name='Name'))
 

df1.join(df2, how='left', lsuffix='_Chinese', rsuffix='_Math')
## 输出 
           Grade_Chinese  Grade_Math
Name                                
San Zhang             70          80

join 使用多级索引，类似于 merge 中以多列为键的操作：

df1 = pd.DataFrame({'Age':[20,21]},
                     index=pd.MultiIndex.from_arrays(
                     [['San Zhang', 'San Zhang'],['one', 'two']],
                     names=('Name','Class')))
 

df2 = pd.DataFrame({'Gender':['F', 'M']},
                     index=pd.MultiIndex.from_arrays(
                     [['San Zhang', 'San Zhang'],['two', 'one']],
                     names=('Name','Class')))
 

 df1
## 输出 
                 Age
Name      Class     
San Zhang one     20
          two     21

df2
## 输出
                Gender
Name      Class       
San Zhang two        F
          one        M

df1.join(df2)
## 输出
                 Age Gender
Name      Class            
San Zhang one     20      M
          two     21      F

二、方向连接

1. concat

关系型连接，以某一列或者多列为键来合并，其中最重要的参数是 on 和 how 。但有时候把两个表或者多个表按照纵向或横向拼接，pandas 中提供了 concat 函数来实现。

在 concat 中，最常用的有三个参数：

axis ：表示拼接方向，在默认状态下的 axis=0 ，表示纵向拼接多个表，常用于多个样本的拼接；而 axis=1 表示横向拼接多个表，常用于多个字段或特征的拼接
join ：表示连接形式
keys : 表示在新表中指示来自于哪一张旧表的名字

注意： 这里的join 和 keys 与上面的 join 函数和键的概念没有任何关系。

# 纵向合并各表中人的信息
df1 = pd.DataFrame({'Name':['San Zhang','Si Li'],
                     'Age':[20,30]})
 

df2 = pd.DataFrame({'Name':['Wu Wang'], 'Age':[40]})

pd.concat([df1, df2])
## 输出 
        Name  Age
0  San Zhang   20
1      Si Li   30
0    Wu Wang   40

# 横向合并各表中的字段
df2 = pd.DataFrame({'Grade':[80, 90]})

df3 = pd.DataFrame({'Gender':['M', 'F']})

pd.concat([df1, df2, df3], 1)
## 输出
        Name  Age  Grade Gender
0  San Zhang   20     80      M
1      Si Li   30     90      F

concat 是关于索引进行连接的。纵向拼接会根据列索引对其，默认状态下 join=outer ，表示保留所有的列，并将不存在的值设为缺失； join=inner ，表示保留两个表都出现过的列。横向拼接则根据行索引对齐， join 参数可以类似设置。

df2 = pd.DataFrame({'Name':['Wu Wang'], 'Gender':['M']})

pd.concat([df1, df2])
## 输出 
        Name   Age Gender
0  San Zhang  20.0    NaN
1      Si Li  30.0    NaN
0    Wu Wang   NaN      M

df2 = pd.DataFrame({'Grade':[80, 90]}, index=[1, 2])

pd.concat([df1, df2], 1)
## 输出
        Name   Age  Grade
0  San Zhang  20.0    NaN
1      Si Li  30.0   80.0
2        NaN   NaN   90.0

pd.concat([df1, df2], axis=1, join='inner')
## 输出
    Name  Age  Grade
1  Si Li   30     80

注意：

确认要使用多表直接的方向合并时，尤其是横向的合并，可以先用 reset_index 方法恢复默认整数索引再进行合并，防止出现由索引的误对齐和重复索引的笛卡尔积带来的错误结果。

keys 参数的使用场景在于多个表合并后，用户仍然想要知道新表中的数据来自于哪个原表，这时可以通过 keys 参数产生多级索引进行标记。

# 第一个表中都是一班的同学，而第二个表中都是二班的同学，可以使用这种方式合并
df1 = pd.DataFrame({'Name':['San Zhang','Si Li'],
                     'Age':[20,21]})
 

df2 = pd.DataFrame({'Name':['Wu Wang'],'Age':[21]})

pd.concat([df1, df2], keys=['one', 'two'])
## 输出
            Name  Age
one 0  San Zhang   20
    1      Si Li   21
two 0    Wu Wang   21

2. 序列与表的合并

把一个序列追加到表的行末或者列末，则可以分别使用 append 和 assign 方法。在 append 中，如果原表是默认整数序列的索引，那么可以使用 ignore_index=True 对新序列对应索引的自动标号，否则必须对 Series 指定 name 属性。

s = pd.Series(['Wu Wang', 21], index = df1.columns)

df1.append(s, ignore_index=True)
## 输出 
        Name  Age
0  San Zhang   20
1      Si Li   21
2    Wu Wang   21

assign 通过 df['new_col'] = ... 的形式可以等价地添加新列。同时，使用 [] 修改的缺点是它会直接在原表上进行改动，而 assign 返回的是一个临时副本：

s = pd.Series([80, 90])

df1.assign(Grade=s)
## 输出 
        Name  Age  Grade
0  San Zhang   20     80
1      Si Li   21     90

df1['Grade'] = s

df1
## 输出
        Name  Age  Grade
0  San Zhang   20     80
1      Si Li   21     90

三、类连接操作

一些函数能够对两个表进行某些操作，把它们统称为类连接操作。

1. 比较

compare 能够比较两个表或者序列的不同处并将其汇总展示：

df1 = pd.DataFrame({'Name':['San Zhang', 'Si Li', 'Wu Wang'],
                         'Age':[20, 21 ,21],
                         'Class':['one', 'two', 'three']})
 

df2 = pd.DataFrame({'Name':['San Zhang', 'Li Si', 'Wu Wang'],
                         'Age':[20, 21 ,21],
                         'Class':['one', 'two', 'Three']})
 

df1.compare(df2)
## 输出
    Name         Class       
    self  other   self  other
1  Si Li  Li Si    NaN    NaN
2    NaN    NaN  three  Three

结果中返回了不同值所在的行列，如果相同则会被填充为缺失值 NaN ，其中：

other ：指代传入的参数表
self ：指代被调用的表自身

设置 keep_shape=True ，可以完整显示表中所有元素的比较情况：

df1.compare(df2, keep_shape=True)
## 输出
    Name         Age        Class       
    self  other self other   self  other
0    NaN    NaN  NaN   NaN    NaN    NaN
1  Si Li  Li Si  NaN   NaN    NaN    NaN
2    NaN    NaN  NaN   NaN  three  Three

2. 组合

combine 函数能够让两张表按照一定的规则进行组合，在进行规则比较时会自动进行列索引的对齐。

对于传入的函数而言，每一次操作中输入的参数是来自两个表的同名 Series ，依次传入的列是两个表列名的并集。

设置 overtwrite 参数为 False 可以保留被调用表中未出现在传入的参数表中的列，而不会设置未缺失值。

注意：

除了 combine 之外， pandas 中还有一个 combine_first 方法，其功能是在对两张表组合时，若第二张表中的值在第一张表中对应索引位置的值不是缺失状态，那么就使用第一张表的值填充。

decade、

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
【Task 6】连接

一、关系型连接1. 连接的基本概念连接的两个重要要素：键：用on参数表示，在关系型连接中，把两张相关的表按照某一个或某一组键连接起来是一种常见操作。连接的形式：在pandas中的关系型连接函数merge和join中提供了how参数来代表连接形式，分为：左连接left 右连接right 内连接inner 外连接outer用示意图表示它们的区别：左连接：即以左边的键为准，如果右边表中的键于左边存在，那么就添加到左边，否则则处理为缺失值，右连接...
复制链接

扫一扫