Pandas —— 合并、连接、比较

于 2024-04-18 16:45:51 发布
阅读量684 收藏 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的交集）
数据合并--Pandas
chongbaikaishi的博客
07-08 1130
合并DataFrame或者命名的Series，命名的Series被视为单列的DataFrame。
Python：利用pandas对两个dataframe数据进行左联接/左关联(以左边为主体)、右联接/右关联(以右边为主体)、内联接(取交集)、外联接(取并集)操作案例实现代码
近期请国内外头部出版社可尽快私信博主！——心比天高，仗剑走天涯，保持热爱，奔赴向梦想！低调，谦虚，自律，反思，成长，还算是比较正能量的博主，公益免费传播……内心特别想在AI界做出一些可以推进历史进程影响力的东西(兴趣使然，有点小情怀，也有点使命感呀)…
03-08 4372
​ Python：利用pandas对两个dataframe数据进行左联接/左关联(以左边为主体)、右联接/右关联(以右边为主体)、内联接(取交集)、外联接(取并集)操作案例实现代码 目录 join、left join和right join之间区别 左联接/左关联(以左边为主体)、右联接/右关联(以右边为主体)、内联接(取交集)、外联接(取并集)操作案例 join、left join和right join之间区别 Database之SQLSever：SQL命令实现查询之多表查询、嵌套查询、分页复杂
Python 教学 | Pandas 数据合并（含目录文件合并案例）
weixin_55633225的博客
07-13 3354
本期文章我们就学习如何使用 Pandas 的数据合并函数。
pandas合并操作
前景
07-20 5078
pandas合并操作
Pandas——练习题一：在校生饮酒消费数据分析
07-25
在本实践练习中，我们将深入探索使用Pandas库对在校...这只是一个基础练习，实际上Pandas的功能远不止这些，包括时间序列分析、数据重塑、合并、连接、条件选择等，都能帮助我们在实际项目中进行复杂的数据操作和挖掘。
详解pandas数据合并与重塑（pd.concat篇）
09-19
本篇文章将重点讲解Pandas中的数据合并方法——`pd.concat`，它可以帮助我们将多个DataFrame对象按照特定轴进行合并。 `pd.concat`函数是Pandas库提供的用于合并数据的主要方法。其基本语法如下： ```python pd....
Python数据分析神器——pandas（进阶教程）
12-21
文章目录合并数据集索引的合并轴向连接合并重叠数据重塑和轴向旋转重塑层次化索引将“长格式”旋转为“宽格式”数据转换移除重复数据利用函数或映射进行数据转换替换值重命名轴索引离散化和面元划分 合并数据集 ...
pandas资料.zip
08-09
Pandas提供了多种合并和连接数据的方法，如`concat()`、`merge()`和`join()`，它们分别用于堆叠、横向合并、纵向合并以及基于特定键的合并。 8. 数据透视与统计分析 `pivot_table()`函数允许我们创建类似电子表格...
Mastering Pandas_pandas_
10-01
8. **数据合并与连接**: `merge()`, `concat()`, `join()`等函数用于合并多个DataFrame。`merge()`类似SQL中的JOIN操作，`concat()`用于垂直或水平堆叠数据。 9. **数据排序**: `sort_values()`用于按指定列排序，...
数据分析之Pandas合并操作总结
Datawhale
06-30 6852
↑↑↑关注后"星标"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 6826
🌷这一章节来介绍pandas中的DateFrame实现数据合并的操作，类似于SQL中的内连接、外连接的操作.
R语言使用dplyr包右连接两个dataframe数据（right join）
statistics+insight+vista+power
11-03 207
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...
pandas 进阶 --- 去重 合并 与实战
王冠hurt的博客
04-12 2万+
1.去重1.1 groupbygroupby用于对pandas数据进行分组，使用示例如下：card_group=card_df.groupby(['id','how'])['amount'].sum()首先我们根据id和how两列对数据进行分组，并对分组结果中的amount列进行求和运算，返回最后的结果。1.2 pivot_tablepivot_table是pandas提供的透视表函数，它根据一个...
pandas 表的合并 merge/join/contact
很吵请安静
01-09 8438
最近做比赛的特征工程时，经常用到表的合并，对上述三种操作总是不是熟练的使用，弄不清其中的区别与联系。所以花点时间弄清他们。 merge操作 merge通过一个或者多个键将两张表合并在一起，api如下 merge(left,right,how='inner',on=None,left_on=None,right_on=None, left_index=False,right_index=False,...
Pandas-D5合并
weixin_50888378的博客
12-02 420
目录一、append与assign1.append方法2.assign方法二、combine与updata1.combine方法2.updata方法三、contact方法四、merge与join1.merge函数 import numpy as np import pandas as pd df = pd.read_csv('data/table.csv') df.head() 一、append与assign 1.append方法 a)利用序列添加行（必须制定name） df_append = df.lo
pandas 文件合并
最新发布
10-05
Pandas提供了多种方法来合并文件，其中两个...此外，Pandas还提供了其他一些用于合并数据的函数，例如merge()函数和join()函数，它们提供了更灵活和复杂的合并方式，可以根据指定的键将不同数据集中的行连接在一起。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值