Pandas —— 合并、连接、比较

于 2024-04-18 16:45:51 发布
阅读量701 收藏 18
点赞数 20
文章标签： pandas
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Jesse_chao122/article/details/137914953
版权
本文主要讲解了Pandas中合并数据的方法，如concat函数用于连接对象，merge和join用于基于索引或列的连接，以及DataFrame的compare功能用于比较差异。还提供了具体的代码示例以展示这些操作的应用。
摘要由CSDN通过智能技术生成

1.合并（concat）

        concat（）函数沿一个轴连接任意数量的Series或DataFrame对象，同时在其他轴上执行索引的可选集逻辑（并集或交集）。与numpy.contenate一样，concat（）获取一个同质类型对象的列表或dict，并将它们连接起来。

pandas.concat(objs, *, axis=0, join='outer', 
                ignore_index=False, keys=None, 
                levels=None, names=None, verify_integrity=False, 
                sort=False, copy=None)

参数说明：

参数名说明
objs

Series或DataFrame对象的序列或映射

axis

{0/’index’, 1/’columns’}, default 0

join{‘inner’, ‘outer’}, default ‘outer’
ignore_indexbool, default False
keyssequence, default None
levelslist of sequences, default None
nameslist, default None

verify_integrity

bool, default False
sortbool, default False
copybool, default True

返回值：object, type of objs

具体用法见示例：

import pandas as pd
import numpy as np

# Series与DataFrame声明
df1 = pd.DataFrame([
    np.random.randint(1, 10, size=3),
    np.random.randint(1, 10, size=3),
    np.random.randint(1, 10, size=3),
])
df2= pd.DataFrame([
    np.random.randint(1, 10, size=3),
    np.random.randint(1, 10, size=3),
    np.random.randint(1, 10, size=3),
])
df3 = pd.DataFrame([
    np.random.randint(1, 10, size=3),
    np.random.randint(1, 10, size=3),
    np.random.randint(1, 10, size=3),
])

df4 = pd.DataFrame([
    np.random.randint(1, 10, size=4),
    np.random.randint(1, 10, size=4),
    np.random.randint(1, 10, size=4),
])

series = pd.Series(np.random.randint(1, 10, size=3))

# 基础用法
df = pd.concat([df1, df2, df3])
# 数据输出
按index合并后的DataFrame：
   0  1  2
0  6  5  7
1  3  5  9
2  8  6  8
0  4  5  4
1  4  9  5
2  1  3  2
0  2  4  8
1  4  8  1
2  1  9  2

# 参数ignore_index的用法：重置索引(index)
df = pd.concat([df1, df2, df3], ignore_index=True)
# 数据输出
合并后的DataFrame：
   0  1  2
0  5  3  5
1  3  6  1
2  4  8  2
3  9  4  3
4  8  3  4
5  7  6  3
6  2  6  8
7  6  3  5
8  4  8  6

# DataFrame与Series的合并
# (对参数axis的理解，以index为轴则意味着在行的方向递增数据，columns同理)
df = pd.concat([df1, series], axis=0, ignore_index=True)
# 数据输出
合并后的DataFrame：
   0    1    2
0  4  7.0  9.0
1  9  6.0  4.0
2  1  5.0  3.0
3  7  NaN  NaN
4  5  NaN  NaN
5  1  NaN  NaN
df = pd.concat([df1, series], axis=1, ignore_index=True)
# 数据输出
合并后的DataFrame：
   0  1  2  3
0  1  1  3  1
1  1  8  4  7
2  8  7  5  4

# 参数join的用法:指定合并方式inner or outer
df = pd.concat([df1, df4, df3], join='outer', ignore_index=True)
# 数据输出
合并后的DataFrame：
   0  1  2    3
0  7  4  1  NaN
1  7  5  1  NaN
2  9  5  5  NaN
3  6  5  1  3.0
4  2  1  2  1.0
5  7  5  8  2.0
6  3  6  5  NaN
7  6  4  3  NaN
8  6  1  8  NaN
# 参数join的用法:指定合并方式inner or outer
df = pd.concat([df1, df4, df3], join='inner', ignore_index=True)
# 数据输出
合并后的DataFrame：
   0  1  2
0  9  8  3
1  6  3  4
2  5  5  6
3  9  2  5
4  3  5  9
5  3  7  5
6  6  5  9
7  5  2  3
8  9  8  9

2.连接（merge、join）

   join可以使用join（）或merge（）来执行。默认情况下，join（）将连接其索引上的DataFrames。每个方法都有参数，允许您指定要执行的联接类型（LEFT、RIGHT、INNER、FULL）或要联接的列（列名或索引）。

        如果两个键列都包含键为null值的行，则这些行将相互匹配。这与通常的SQL联接行为不同，可能会导致意外的结果。

2.2.1 merge()

pandas.merge(left, right, how='inner', on=None, 
            left_on=None, right_on=None, left_index=False, 
            right_index=False, sort=False, suffixes=('_x', '_y'), 
            copy=None, indicator=False, validate=None)

参数说明：

参数名说明
leftDataFrame or named Series
rightDataFrame or named Series
how{‘left’, ‘right’, ‘outer’, ‘inner’, ‘cross’}, default ‘inner’
on

label or list

要连接的列或索引级别名称。这些必须在两个 DataFrame 中找到。如果on为 None 并且不合并索引，则默认为两个 DataFrame 中列的交集。

left_on

label or list

要连接到左侧 DataFrame 的列或索引级别名称。也可以是左侧 DataFrame 长度的数组或数组列表。这些数组被视为列。

right_on

label or list

要连接到右侧 DataFrame 中的列或索引级别名称。也可以是正确 DataFrame 长度的数组或数组列表。这些数组被视为列。

left_index

bool, 默认 False

使用左侧 DataFrame 的索引作为连接键。如果它是 MultiIndex，则其他 DataFrame 中的键数（索引或列数）必须与级别数匹配。

right_index

bool, 默认 False

使用右侧 DataFrame 的索引作为连接键。如果它是 MultiIndex，则其他 DataFrame 中的键数（索引或列数）必须与级别数匹配。

sort

bool，默认 False

在结果 DataFrame 中按字典顺序对连接键进行排序。如果为 False，则连接键的顺序取决于连接类型（how 关键字）。

suffixes

列表，默认为（“_x”，“_y”）

长度为 2 的序列，其中每个元素都可以是一个字符串，指示分别添加到左侧和右侧重叠列名称的后缀 。传递None值而不是字符串，以指示左侧或 右侧的列名称应保持原样，不带后缀。至少其中一个值不得为 None。

copy

bool，默认 True

如果为 False，请尽可能避免复制

indicator

bool 或 str，默认 False

如果为 True，则向输出 DataFrame 添加一列名为“_merge”的列，其中包含有关每行源的信息。可以通过提供字符串参数来为该列指定不同的名称。该列将具有分类类型，对于合并键仅出现在左侧 DataFrame 中的观察，值为“left_only”；对于合并键仅出现在右侧 DataFrame 中的观察，值为“right_only”；如果观察的合并键为“both”在两个 DataFrame 中都可以找到。

validate

str，可选

如果指定，则检查合并是否属于指定类型。

  • “one_to_one”或“1:1”：检查合并键在左右数据集中是否唯一。

  • “one_to_many”或“1:m”：检查合并键在左侧数据集中是否唯一。

  • “many_to_one”或“m:1”：检查合并键在正确的数据集中是否唯一。

  • “many_to_many”或“m:m”：允许，但不会导致检查。

返回值：两个合并对象的DataFrame

import pandas as pd
import numpy as np

data1 = {
    "id":[1,2,3,4,5,6],
    "age":np.random.randint(15, 20, size=6),
    "class":np.random.randint(1, 4, size=6)
}

df1 = pd.DataFrame(data1)

data2 = {
    "id": [1, 2, 4, 5, 6],
    "name": ["John", "Smith", "Jesse", "Neal", "Bob"],
}

df2 = pd.DataFrame(data2)
df_left = pd.merge(df1, df2, on="id", how="left")
df_right = pd.merge(df1, df2, on="id", how="right")
df_inner = pd.merge(df1, df2, on="id", how="inner")
df_outer = pd.merge(df1, df2, on="id", how="outer")
df_cross = pd.merge(df1, df2, how="cross")
print(f'左连接结果：\n{df_left}')
print(f'右连接结果：\n{df_right}')
print(f'内连接结果：\n{df_inner}')
print(f'外连接结果：\n{df_outer}')
print(f'笛卡尔积结果：\n{df_cross}')
----------------------------------------------------
左连接结果：
   id  age  class   name
0   1   18      2   John
1   2   15      2  Smith
2   3   15      2    NaN
3   4   15      1  Jesse
4   5   18      2   Neal
5   6   19      2    Bob
右连接结果：
   id  age  class   name
0   1   18      2   John
1   2   15      2  Smith
2   4   15      1  Jesse
3   5   18      2   Neal
4   6   19      2    Bob
内连接结果：
   id  age  class   name
0   1   18      2   John
1   2   15      2  Smith
2   4   15      1  Jesse
3   5   18      2   Neal
4   6   19      2    Bob
外连接结果：
   id  age  class   name
0   1   18      2   John
1   2   15      2  Smith
2   3   15      2    NaN
3   4   15      1  Jesse
4   5   18      2   Neal
5   6   19      2    Bob
笛卡尔积结果：
    id_x  age  class  id_y   name
0      1   18      2     1   John
1      1   18      2     2  Smith
2      1   18      2     4  Jesse
3      1   18      2     5   Neal
4      1   18      2     6    Bob
5      2   15      2     1   John
6      2   15      2     2  Smith
7      2   15      2     4  Jesse
8      2   15      2     5   Neal
9      2   15      2     6    Bob
10     3   15      2     1   John
11     3   15      2     2  Smith
12     3   15      2     4  Jesse
13     3   15      2     5   Neal
14     3   15      2     6    Bob
15     4   15      1     1   John
16     4   15      1     2  Smith
17     4   15      1     4  Jesse
18     4   15      1     5   Neal
19     4   15      1     6    Bob
20     5   18      2     1   John
21     5   18      2     2  Smith
22     5   18      2     4  Jesse
23     5   18      2     5   Neal
24     5   18      2     6    Bob
25     6   19      2     1   John
26     6   19      2     2  Smith
27     6   19      2     4  Jesse
28     6   19      2     5   Neal
29     6   19      2     6    Bob

2.2.2 join()

DataFrame.join(other, on=None, how='left', 
               lsuffix='', rsuffix='', sort=False, 
               validate=None)

参数说明：

参数名说明
other

DataFrame、Series 或包含它们任意组合的列表。

索引应该类似于这一列中的一列。如果传递了 Series，则必须设置其 name 属性，该属性将用作生成的连接 DataFrame 中的列名称。

on

str、str 列表或类似数组上，可选

调用者中要连接到other中的索引的列或索引级别名称，否则连接索引上的索引。如果给定多个值，则另一个DataFrame 必须具有 MultiIndex。如果调用 DataFrame 中尚未包含数组，则可以传递数组作为连接键。类似于 Excel VLOOKUP 运算。

how

{'left', 'right', 'outer', 'inner', 'cross'}, 默认'left'

如何处理两个对象的操作。

  • 左：使用调用帧的索引（或列，如果指定了）

  • 右：使用别人的索引。

  • 外部：将调用框架的索引（如果指定了则为列）与其他框架的索引形成并集，并按字典顺序排序。

  • 内部：形成调用帧的索引（或列，如果指定了 on）与其他索引的交集，保留调用帧的顺序。

  • cross：从两个帧创建笛卡尔积，保留左键的顺序。

lsuffix

str，默认 ''

从左框架的重叠列使用的后缀。

rsuffix

str，默认 ''

从右框架的重叠列使用的后缀。

sort

bool，默认 False

通过连接键按字典顺序对结果 DataFrame 进行排序。如果为 False，则连接键的顺序取决于连接类型（how 关键字）。

validate

str，可选

如果指定，则检查连接是否属于指定类型。

  • “one_to_one”或“1:1”：检查连接键在左右数据集中是否唯一。

  • “one_to_many”或“1:m”：检查连接键在左侧数据集中是否唯一。

  • “many_to_one”或“m:1”：检查连接键在正确的数据集中是否唯一。

  • “many_to_many”或“m:m”：允许，但不会导致检查。

返回值：数据框，包含来自调用方和其他方的列的数据框。

import pandas as pd
import numpy as np

data1 = {
    "id":[1,2,3,4,5,6],
    "age":np.random.randint(15, 20, size=6),
    "class":np.random.randint(1, 4, size=6)
}

df1 = pd.DataFrame(data1)

data2 = {

    "name": ["John", "Smith", "Jesse", "Neal", "Bob"],
}

df2 = pd.DataFrame(data2)
df_left = df1.join(df2, how="left", rsuffix="_right", lsuffix="_left")
df_right = df1.join(df2, how="right", rsuffix="_right", lsuffix="_left")
df_inner = df1.join(df2, how="inner", rsuffix="_right", lsuffix="_left")
df_outer = df1.join(df2, how="outer", rsuffix="_right", lsuffix="_left")
df_cross = df1.join(df2, how="cross", rsuffix="_right", lsuffix="_left")
print(f'左连接结果：\n{df_left}')
print(f'右连接结果：\n{df_right}')
print(f'内连接结果：\n{df_inner}')
print(f'外连接结果：\n{df_outer}')
print(f'笛卡尔积结果：\n{df_cross}')
---------------------------------------------------------
左连接结果：
   id  age  class   name
0   1   16      3   John
1   2   19      1  Smith
2   3   16      3  Jesse
3   4   19      1   Neal
4   5   16      3    Bob
5   6   19      1    NaN
右连接结果：
   id  age  class   name
0   1   16      3   John
1   2   19      1  Smith
2   3   16      3  Jesse
3   4   19      1   Neal
4   5   16      3    Bob
内连接结果：
   id  age  class   name
0   1   16      3   John
1   2   19      1  Smith
2   3   16      3  Jesse
3   4   19      1   Neal
4   5   16      3    Bob
外连接结果：
   id  age  class   name
0   1   16      3   John
1   2   19      1  Smith
2   3   16      3  Jesse
3   4   19      1   Neal
4   5   16      3    Bob
5   6   19      1    NaN
笛卡尔积结果：
    id  age  class   name
0    1   16      3   John
1    1   16      3  Smith
2    1   16      3  Jesse
3    1   16      3   Neal
4    1   16      3    Bob
5    2   19      1   John
6    2   19      1  Smith
7    2   19      1  Jesse
8    2   19      1   Neal
9    2   19      1    Bob
10   3   16      3   John
11   3   16      3  Smith
12   3   16      3  Jesse
13   3   16      3   Neal
14   3   16      3    Bob
15   4   19      1   John
16   4   19      1  Smith
17   4   19      1  Jesse
18   4   19      1   Neal
19   4   19      1    Bob
20   5   16      3   John
21   5   16      3  Smith
22   5   16      3  Jesse
23   5   16      3   Neal
24   5   16      3    Bob
25   6   19      1   John
26   6   19      1  Smith
27   6   19      1  Jesse
28   6   19      1   Neal
29   6   19      1    Bob

3. 比较（compare）

3.1 Series.compare

3.2 DataFrame.compare

        与另一个DataFrame进行比较并显示差异        

DataFrame.compare(other, align_axis=1, 
                  keep_shape=False, keep_equal=False, 
                  result_names=('self', 'other'))

参数说明：

参数名说明
otherDataFrame
align_axis

{0 or ‘index’, 1 or ‘columns’}, default 1

确定在哪个轴上对齐比较。

0或'index'结果差异垂直堆叠，其中从自身和他人交替地绘制行。

1，或“列”结果差异水平对齐，其中列从自身和他人交替绘制

keep_shape

bool, default False

如果为true，则保留所有行和列。否则，只保留具有不同值的值。

keep_equal

bool, default False

如果为true，则结果将保持相等的值。否则，相等的值显示为NaN。

result_names

tuple, default (‘self’, ‘other’)

设置比较的数据帧名称。

返回值：DataFrame

import pandas as pd
import numpy as np


df1 = pd.DataFrame([
    np.random.randint(1, 10, size=3),
    np.random.randint(1, 10, size=3),
    np.random.randint(1, 10, size=3),
])
df2= pd.DataFrame([
    np.random.randint(1, 10, size=3),
    np.random.randint(1, 10, size=3),
    np.random.randint(1, 10, size=3),
])

df = df1.compare(df2, align_axis=0)
# 数据输出
print(f'比较结果：\n{df}')
比较结果：
         0  1    2
0 self   6  8  9.0
  other  7  9  8.0
1 self   1  4  4.0
  other  7  7  5.0
2 self   3  8  NaN
  other  4  3  NaN

Jesse_chao122
关注
  • 20
    点赞
  • 踩
  • 18
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Pandas数据合并与拼接的5种方法
m0_37932764的博客
11-24 2万+
Pandas数据合并与拼接的5种方法。必须存在于左右两个DataFrame中，如果没有指定且其他参数也没有指定，则以两个DataFrame列名交集作为连接键；suffixes：字符串值组成的元组，用于指定当左右DataFrame存在相同列名时在列名后面附加的后缀名称，默认为('_x', '_y')；left_on：左侧DataFrame中用于连接键的列名，这个参数左右列名不同但代表的含义相同时非常的有用；没有指定连接键，默认用重叠列名，没有指定连接方式，默认inner内连接（取key的交集）
Python：利用pandas对两个dataframe数据进行左联接/左关联(以左边为主体)、右联接/右关联(以右边为主体)、内联接(取交集)、外联接(取并集)操作案例实现代码
近期请国内外头部出版社可尽快私信博主！——心比天高，仗剑走天涯，保持热爱，奔赴向梦想！低调，谦虚，自律，反思，成长，还算是比较正能量的博主，公益免费传播……内心特别想在AI界做出一些可以推进历史进程影响力的东西(兴趣使然，有点小情怀，也有点使命感呀)…
03-08 4429
​ Python：利用pandas对两个dataframe数据进行左联接/左关联(以左边为主体)、右联接/右关联(以右边为主体)、内联接(取交集)、外联接(取并集)操作案例实现代码 目录 join、left join和right join之间区别 左联接/左关联(以左边为主体)、右联接/右关联(以右边为主体)、内联接(取交集)、外联接(取并集)操作案例 join、left join和right join之间区别 Database之SQLSever：SQL命令实现查询之多表查询、嵌套查询、分页复杂
数据合并--Pandas
chongbaikaishi的博客
07-08 1151
合并DataFrame或者命名的Series，命名的Series被视为单列的DataFrame。
Python 教学 | Pandas 数据合并（含目录文件合并案例）
weixin_55633225的博客
07-13 3491
本期文章我们就学习如何使用 Pandas 的数据合并函数。
pandas合并操作
前景
07-20 5091
pandas合并操作
Pandas——练习题一：在校生饮酒消费数据分析
07-25
在本实践练习中，我们将深入探索使用Pandas库对在校...这只是一个基础练习，实际上Pandas的功能远不止这些，包括时间序列分析、数据重塑、合并、连接、条件选择等，都能帮助我们在实际项目中进行复杂的数据操作和挖掘。
python——pandas总结1
07-18
- **关系型运算**：支持常见的数据库操作，如合并（merge）、连接（join）等，类似于 SQL 查询。 #### 三、Pandas 数据结构介绍 Pandas 主要有两种核心的数据结构： 1. **Series** - **定义**：Series 是一种...
详解pandas数据合并与重塑（pd.concat篇）
09-19
本篇文章将重点讲解Pandas中的数据合并方法——`pd.concat`，它可以帮助我们将多个DataFrame对象按照特定轴进行合并。 `pd.concat`函数是Pandas库提供的用于合并数据的主要方法。其基本语法如下： ```python pd....
Python数据分析神器——pandas（进阶教程）
12-21
本文将深入探讨pandas的一些高级特性，包括数据合并、索引合并、轴向连接、数据重塑、数据转换以及重复数据的处理。 **1. 合并数据集** pandas提供了多种数据合并方法。`pandas.merge`允许根据一个或多个键将不同...
pandas资料.zip
08-09
Pandas提供了多种合并和连接数据的方法，如`concat()`、`merge()`和`join()`，它们分别用于堆叠、横向合并、纵向合并以及基于特定键的合并。 8. 数据透视与统计分析 `pivot_table()`函数允许我们创建类似电子表格...
数据分析之Pandas合并操作总结
Datawhale
06-30 6866
↑↑↑关注后"星标"Datawhale每日干货 &每月组队学习，不错过 Datawhale干货 作者：耿远昊，Datawhale成员，华东师范大学 pand...
Pandas pd.merge 函数使用 交集、并集、左连接、右连接
Ghjkku的博客
02-24 11万+
取交集：print(pd.merge(df1,df2,on=['name', 'age', 'sex'])) 取并集：print(pd.merge(df1,df2,on=['name', 'age', 'sex'], how='outer'))
python数据分析之pandas数据合并
柳小葱的博客
10-12 6873
🌷这一章节来介绍pandas中的DateFrame实现数据合并的操作，类似于SQL中的内连接、外连接的操作.
R语言使用dplyr包右连接两个dataframe数据（right join）
statistics+insight+vista+power
11-03 209
R语言使用dplyr包右连接两个dataframe数据（right join）
【pandas】[3] DataFrame 数据合并，连接（merge,join,concat)
热门推荐
LiangHC
05-25 34万+
作者：lianghc 连接：http://blog.csdn.net/zutsoft/article/details/51498026 merge  通过键拼接列 pandas提供了一个类似于关系数据库的连接(join)操作的方法merage,可以根据一个或多个键将不同DataFrame中的行连接起来 语法如下： merge(left, right, how='inner', on=No...
Spark DataFrame中的join类型
anjingwunai的专栏
07-17 4万+
欢迎使用Markdown编辑器写博客本Markdown编辑器使用StackEdit修改而来，用它写博客，将会带来全新的体验哦：www hello 百度 Markdown和扩展Markdown简洁的语法 代码块高亮 图片链接和图片上传 LaTex数学公式 UML序列图和流程图 离线写博客 导入导出Markdown文件 丰富的快捷键 sdfa sdsd* sd *快捷键 加粗 Ctrl +
pandas之数据合并
qq_42413820的博客
06-23 1万+
       在数据处理中，不免会遇到数据之间的合并。学过关系数据库的童鞋应该都清楚数据表之间的连接。今天要说的数据合并其实和数据表之间的连接有很多相似之处。由于 pandas 库在数据分析中比较方便而且用者较多，我们就说pandas中的数据合并方式。     pandas 中数据合并常用的方法有三种：pandas.merge(), pandas.concat(), 以及实例方法 combine_...
Pandas 合并数据集
CV前沿
04-13 6万+
在数据挖掘过程中，经常会有不同表格的数据需要进行合并操作。今天介绍通过python下的pandas库下的merge方法和concat方法来实现数据集的合并。1.mergemerge 函数通过一个或多个键来将数据集的行连接起来。该函数的主要 应用场景是针对同一个主键存在两张包含不同特征的表，通过该主键的连接，将两张表进行合并。合并之后，两张表的行数没有增加，列数是两张表的列数之和减一。 函数的具体参
5个必知必会的 Python 数据合并技巧
Python学习与数据挖掘
03-27 8917
大家好，前不久在我们技术交流群有群友提到最近他面试阿里70万总包的数据岗位，对方问Pandas的5种数据合并的函数，结果他只答出了2个。 那么，究竟是哪五个呢？今天，我们就来带大家了解一下！想加技术交流群的，文末获取 目录： 1. concat 2. append 3. merge 4. join 5. combine 总结 1. concat concat是pandas中专门用于数据连接合并的函数，功能非常强大，支持纵向合并和横向合并，默认情况下是纵向合并，具体可以通过参数进
pandas 文件合并
最新发布
10-05
Pandas提供了多种方法来合并文件，其中两个...此外，Pandas还提供了其他一些用于合并数据的函数，例如merge()函数和join()函数，它们提供了更灵活和复杂的合并方式，可以根据指定的键将不同数据集中的行连接在一起。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值