Pandas数据连接和合并

在实际的数据处理工作中，我们常常会遇到需要将多个数据集进行连接或合并的情况。比如，在分析公司销售数据时，可能需要将不同地区、不同时间段的销售数据整合在一起；在进行用户行为分析时，可能需要将用户的基本信息、浏览记录、购买记录等多个数据集合并，以便进行更全面的分析。而 Pandas 库提供的数据连接和合并功能，正是解决这些问题的利器,接下来，就让我们深入探索 Pandas 库的数据连接和合并功能。

数据合并大揭秘：merge 函数

在 Pandas 库中，merge函数是实现数据合并的核心工具，它就像是一位神奇的 “数据融合大师”，能够根据指定的规则将两个或多个DataFrame巧妙地合并在一起，为数据分析提供更全面、更丰富的数据基础。接下来，让我们深入了解merge函数的强大功能。

merge函数

merge函数的基本语法如下:

函数参数详解

开始前先建两个DataFrame供下面的介绍使用。

import pandas as pd
# 创建第一个DataFrame
data1 = {
'id': [1, 2, 3, 4],
'name': ['Alice', 'Bob', 'Charlie', 'David'],
'age': [25, 30, 35, 40]
}
df1 = pd.DataFrame(data1)
# 创建第二个DataFrame
data2 = {
'id': [3, 4, 5, 6],
'city': ['New York', 'Los Angeles', 'Chicago', 'Houston'],
'salary': [5000, 6000, 7000, 8000]
}
df2 = pd.DataFrame(data2)

left和right

分别表示要合并的左侧和右侧DataFrame；

how

参数指定合并的方式，包括内连接、外连接、左连接和右连接，每种连接方式都有其独特的含义和使用场景，默认为内连接（inner）。

• 内连接（inner join）：内连接是merge函数的默认合并方式，它只保留两个DataFrame中连接键相同的行，就像是两个集合的交集。

下面通过一个简单的示例来展示如何使用merge函数根据指定键合并两个DataFrame：

# 使用merge函数根据'id'列合并两个DataFrame
merged_df = pd.merge(df1, df2, on='id')
print(merged_df)

运行上述代码，输出结果如下：

  id name   age  city      salary
0 3 Charlie 35  New York   5000
1 4 David   40 Los Angeles 6000

从结果中可以看出，merge函数根据id列将两个DataFrame进行了合并，只保留了id列相同的行。

• 外连接（outer join）：外连接会保留两个DataFrame中的所有行，如果某一行在其中一个DataFrame中不存在，则对应的列会填充为NaN，类似于两个集合的并集。将上述示例中的合并方式改为外连接：

merged_df = pd.merge(df1, df2, on='id', how='outer')
print(merged_df)

输出结果为：

  id  name    age    city       salary
0 1.0 Alice   25.0   NaN         NaN
1 2.0 Bob     30.0   NaN         NaN
2 3.0 Charlie 35.0 New York     5000.0
3 4.0 David   40.0 Los Angeles  6000.0
4 NaN NaN     NaN   Chicago     7000.0
5 NaN NaN     NaN   Houston     8000.0

可以看到，外连接保留了两个DataFrame中的所有行，对于在另一个DataFrame中没有匹配的行，相应的列填充为NaN。

• 左连接（left join）：左连接会保留左侧DataFrame中的所有行，右侧DataFrame中匹配的行则进行合并，如果没有匹配的行，右侧对应的列会填充为NaN，即以左表为主。代码如下：

merged_df = pd.merge(df1, df2, on='id', how='left')
print(merged_df)

输出结果：

  id name   age city        salary
0 1 Alice   25.0 NaN         NaN
1 2 Bob     30.0 NaN         NaN
2 3 Charlie 35.0 New York    5000.0
3 4 David   40.0 Los Angeles 6000.0

左连接保留了df1中的所有行，对于df1中id为1和2的行，由于在df2中没有匹配的id，所以city和salary列填充为NaN。

• 右连接（right join）：右连接与左连接相反，它会保留右侧DataFrame中的所有行，左侧DataFrame中匹配的行进行合并，没有匹配的行，左侧对应的列填充为NaN，即以右表为主。示例代码如下：

merged_df = pd.merge(df1, df2, on='id', how='right')
print(merged_df)

输出结果：

  id name   age  city        salary
0 3 Charlie 35.0 New York    5000.0
1 4 David   40.0 Los Angeles 6000.0
2 5 NaN     NaN Chicago      7000.0
3 6 NaN     NaN Houston      8000.0

右连接保留了df2中的所有行，对于df2中id为5和6的行，由于在df1中没有匹配的id，所以name和age列填充为NaN。

on

用于指定合并的列名，当两个DataFrame中有相同的列名时，可以直接使用该参数指定合并键。

在下面的示例中我们使用on='city'指定根据city列进行合并。

merged_df = pd.merge(df1, df2, on='city')
print(merged_df)

输出结果：

  id_x name   city    age id_y salary
0 1    Alice  New York 25  3    5000
1 2    Bob Los Angeles 30  4    6000
2 3    Charlie Chicago 35  5    7000

left_on和right_on

当两个DataFrame中用于合并的列名不同时，可以使用left_on指定左侧DataFrame中用于合并的列名，right_on指定右侧DataFrame中用于合并的列名。例如：

merged_df = pd.merge(df1, df2, left_on='user_id', right_on='customer_id', 
                     how='inner')
print(merged_df)

输出结果：

 user_id name   age customer_id city     salary
0  3    Charlie 35     3        New York   5000
1  4    David   40     4       Los Angeles 6000

这里使用left_on='user_id'和right_on='customer_id'指定了不同的列名进行合并。

left_index和right_index

如果为True，则使用左侧或右侧DataFrame的索引进行合并。例如：

df1 = pd.DataFrame({'value': [1, 2, 3]}, index=['A', 'B', 'C'])
df2 = pd.DataFrame({'value2': [4, 5, 6]}, index=['A', 'B', 'D'])
merged_df = pd.merge(df1, df2, left_index=True, right_index=True, how='outer')
print(merged_df)

输出结果：

value value2
A 1.0 4.0
B 2.0 5.0
C 3.0 NaN
D NaN 6.0

此示例中，通过设置left_index=True和right_index=True，使用索引进行合并。

suffixes

当两个DataFrame中有相同的列名，但不是合并键时，可以使用suffixes参数指定后缀，以区分这些列。例如：

merged_df = pd.merge(df1, df2, on='id', suffixes=('_left', '_right'))
print(merged_df)

输出结果：

  id name_left age name_right city
0 3   Charlie   35 Eve       New York
1 4    David    40 Frank    Los Angeles

这里使用suffixes=('_left', '_right')为重复的name列添加了不同的后缀，以便区分。

通过深入理解和灵活运用merge函数的各种参数和合并方式，我们能够根据不同的业务需求，高效地对数据进行合并和整合，为后续的数据分析和挖掘工作奠定坚实的基础。

数据连接的魔法：concat 函数

在 Pandas 库中，除了强大的merge函数用于数据合并外，concat函数则是实现数据连接的得力助手。它能够沿着指定的轴将多个DataFrame或Series连接在一起，为数据的整合提供了一种简洁而高效的方式。下面，让我们一起揭开concat函数的神秘面纱。

concat 函数基础

concat函数的基本语法如下：

参数详解

objs

含义：传入一个序列或映射，其中序列可以是列表、元组等，元素通常为Series 或DataFrame；映射一般是字典，键为对象的标识，值为 Series 或 DataFrame。

示例：

import pandas as pd
df1 = pd.DataFrame({'A': [1, 2], 'B': [3, 4]})
df2 = pd.DataFrame({'A': [5, 6], 'B': [7, 8]})
result = pd.concat([df1, df2])
print(result)

这里 objs 就是 [df1, df2] 这个列表。

输出结果：

  A B
0 1 3
1 2 4
0 5 7
1 6 8

axis

含义：按行连接（axis=0）和按列连接（axis=1）

示例；

1. 按行连接（axis=0）

按行连接是concat函数的默认行为，它将多个DataFrame或Series沿着垂直方向（行）进行堆叠。这种连接方式适用于将具有相同列结构的数据进行合并，例如将不同时间段的销售数据按时间顺序连接起来，或者将不同地区的用户数据合并成一个完整的用户数据集。

import pandas as pd
# 创建第一个DataFrame
data1 = { 'name': ['Alice', 'Bob'],'age': [25, 30]}
df1 = pd.DataFrame(data1)
# 创建第二个DataFrame
data2 = { 'name': ['Charlie', 'David'], 'age': [35, 40]}
df2 = pd.DataFrame(data2)
# 按行连接两个DataFrame
result = pd.concat([df1, df2])
print(result)

输出结果：

  name    age
0 Alice   25
1 Bob     30
0 Charlie 35
1 David   40

在这个例子中，df1和df2具有相同的列结构，通过pd.concat([df1, df2])将它们按行连接起来，形成了一个包含所有数据的新DataFrame。可以看到，索引并没有重新排列，而是保留了原始的索引值。

1. 按列连接（axis=1）：

按列连接则是将多个DataFrame或Series沿着水平方向（列）进行拼接。这种连接方式适用于将具有相同行索引的数据进行合并，例如将用户的基本信息、购买记录和评价信息等不同维度的数据按列连接在一起，以便进行更全面的分析。

import pandas as pd
# 创建第一个DataFrame
data1 = { 'name': ['Alice', 'Bob'],'age': [25, 30]}
df1 = pd.DataFrame(data1)
# 创建第二个DataFrame
data2 = { 'city': ['New York', 'Los Angeles'], 'salary': [5000, 6000]}
df2 = pd.DataFrame(data2)
# 按列连接两个DataFrame
result = pd.concat([df1, df2], axis=1)
print(result)

输出结果：

  name age city       salary
0 Alice 25 New York    5000
1 Bob   30 Los Angeles 6000

在这个例子中，df1和df2具有相同的行索引，通过pd.concat([df1, df2], axis=1)将它们按列连接起来，新的DataFrame包含了来自两个原始DataFrame的所有列。

join

含义：join参数指定连接时如何处理其他轴上的索引，可选值为'outer'（默认值）和'inner'。'outer'表示对所有索引进行并集操作，缺失值用NaN填充；'inner'表示对所有索引进行交集操作，只保留共同索引。

示例：

import pandas as pd
# 创建第一个DataFrame
data1 = {
'name': ['Alice', 'Bob'],
'age': [25, 30]
}
df1 = pd.DataFrame(data1, index=['a', 'b'])
# 创建第二个DataFrame
data2 = {
'city': ['New York', 'Los Angeles'],
'salary': [5000, 6000]
}
df2 = pd.DataFrame(data2, index=['b', 'c'])
# 按列连接，使用outer连接方式
result_outer = pd.concat([df1, df2], axis=1, join='outer')
print("Outer join:")
print(result_outer)
# 按列连接，使用inner连接方式
result_inner = pd.concat([df1, df2], axis=1, join='inner')
print("\nInner join:")
print(result_inner)

输出结果：

Outer join:
  name age  city       salary
a Alice 25  NaN         NaN
b Bob   30  New York    5000
c NaN   NaN Los Angeles 6000
Inner join:
  name age city    salary
b Bob   30 New York 5000

在这个例子中，df1和df2的索引不完全相同。使用join='outer'时，结果包含了两个DataFrame的所有索引，缺失值用NaN填充；使用join='inner'时，结果只保留了共同索引b。

ignore_index

含义：ignore_index参数用于指定是否忽略连接后的索引，默认为False。如果设置为True，则会重新生成一个新的整数索引，而不保留原始索引。

示例：

import pandas as pd
# 创建第一个DataFrame
data1 = {
'name': ['Alice', 'Bob'],
'age': [25, 30]
}
df1 = pd.DataFrame(data1)
# 创建第二个DataFrame
data2 = {
'name': ['Charlie', 'David'],
'age': [35, 40]
}
df2 = pd.DataFrame(data2)
# 按行连接，忽略索引
result = pd.concat([df1, df2], ignore_index=True)
print(result)

输出结果：

  name    age
0 Alice   25
1 Bob     30
2 Charlie 35
3 David   40

在这个例子中，通过设置ignore_index=True，连接后的DataFrame重新生成了从 0 开始的连续整数索引。

keys

含义：keys参数用于创建层次化索引，方便区分不同的连接对象。如果传入列表或数组，这些键将被用作最外层级别的索引。

示例：

import pandas as pd
# 创建第一个DataFrame
data1 = {
'name': ['Alice', 'Bob'],
'age': [25, 30]
}
df1 = pd.DataFrame(data1)
# 创建第二个DataFrame
data2 = {
'name': ['Charlie', 'David'],
'age': [35, 40]
}
df2 = pd.DataFrame(data2)
# 按行连接，添加keys
result = pd.concat([df1, df2], keys=['group1', 'group2'])
print(result)

输出结果：

         name age
group1 0 Alice 25
       1 Bob 30
group2 0 Charlie 35
       1 David 40

在这个例子中，通过设置keys=['group1', 'group2']，为连接后的DataFrame创建了层次化索引，第一级索引为group1和group2，方便区分数据来源。

levels

含义：通常与 keys 配合使用，用于指定层次化索引的级别。如果不指定，Pandas 会自动根据 keys 生成合适的级别。

示例：

#接着上面keys的示例，添加levels参数

result = pd.concat([df1, df2], keys=['group1', 'group2'],
                   levels=['group1', 'group2']])

names

含义：为层次化索引的各级别指定名称。如果使用了 keys创建了层次化索引，可通过 names 为这些索引级别命名。

示例：

#接着上面keys的示例，添加names参数

result=pd.concat([df1,df2],keys=['group1','group2'],
                 names=['DataFrame', 'Row'])

verify_integrity

含义：布尔值，默认值为 False。如果设置为 True，则在连接过程中会检查结果对象的索引是否存在重复值，若存在则会抛出 ValueError 异常。

示例：

try:
result_verify=pd.concat([df1,df2],verify_integrity=True)
except ValueError as e:
print(e)

sort

含义：布尔值，默认值为 False。如果 join='outer'且 axis=1，设置为 True 会对列名进行排序。

示例：

result_sort = pd.concat([df3, df4], axis=1, join='outer', sort=True)

copy

含义：布尔值，默认值为 True。如果设置为 True，会复制数据；如果设置为 False，则尽量避免复制数据，但可能会影响原始对象。

示例：

result_no_copy = pd.concat([df1, df2], copy=False)

通过灵活运用这些参数，你可以根据具体需求对多个 Series或 DataFrame 进行各种方式的连接操作。

常见问题与解决方法

在使用 Pandas 进行数据连接和合并时，常常会遇到一些问题，这些问题如果不及时解决，可能会影响数据分析的准确性和效率。下面将讨论一些常见问题，并提供相应的解决方法。

键不匹配问题

在合并和连接数据时，键不匹配是一个常见的问题。当使用merge函数进行合并时，如果两个DataFrame中用于连接的键（列）的值不完全匹配，可能会导致数据丢失或合并结果不符合预期。例如，在一个销售数据集中，一个表中的商品 ID 使用数字表示，而另一个表中相同含义的商品 ID 使用字符串表示，这种情况下直接进行合并就会出现键不匹配问题。

解决键不匹配问题的方法有多种。首先，在合并前，需要仔细检查两个DataFrame中用于连接的键的数据类型和值，确保它们一致。如果数据类型不一致，可以使用astype()方法将其转换为相同的数据类型。比如：

import pandas as pd
# 创建两个示例DataFrame
data1 = {
'id': [1, 2, 3, 4],
'name': ['Alice', 'Bob', 'Charlie', 'David']
}
df1 = pd.DataFrame(data1)
data2 = {
'id': ['1', '2', '5', '6'],
'city': ['New York', 'Los Angeles', 'Chicago', 'Houston']
}
df2 = pd.DataFrame(data2)
# 将df2中的id列转换为整数类型
df2['id'] = df2['id'].astype(int)
# 进行合并
merged_df = pd.merge(df1, df2, on='id')
print(merged_df)

在这个例子中，df2中的id列是字符串类型，通过astype(int)将其转换为整数类型后，再进行合并，就可以避免键不匹配问题。

数据类型不一致

数据类型不一致也是数据连接和合并中常见的问题之一，它会对连接和合并操作产生重大影响。在 Pandas 中，每个列都有其特定的数据类型，如整数、浮点数、字符串等。当进行连接或合并时，如果参与操作的列的数据类型不一致，可能会导致数据转换错误或结果不符合预期。

解决数据类型不一致问题的方法如下：在连接或合并之前，先检查数据类型，并使用astype()方法将其转换为一致的数据类型。例如：

import pandas as pd
# 创建两个示例DataFrame
data1 = {
'age': [25, 30, 35],
'salary': [5000, 6000, 7000]
}
df1 = pd.DataFrame(data1)
data2 = {
'age': ['28', '32', '36'],
'salary': [5500, 6500, 7500]
}
df2 = pd.DataFrame(data2)
# 将df2中的age列转换为整数类型
df2['age'] = df2['age'].astype(int)
# 按列连接两个DataFrame
result = pd.concat([df1, df2], axis=1)
print(result)

在这个示例中，df2中的age列是字符串类型，通过astype(int)将其转换为整数类型后，再进行按列连接，就可以得到正确的结果。

重复列名处理

在合并数据时，有时会出现重复列名的情况，这会给后续的数据处理和分析带来不便。例如，当两个DataFrame中有相同的列名，但不是合并键时，合并后会出现重复列名。

Pandas 提供了suffixes参数来处理重复列名问题。suffixes参数是一个包含两个字符串的元组，分别表示左侧DataFrame和右侧DataFrame中重复列名的后缀。通过指定不同的后缀，可以避免列名冲突。例如：

import pandas as pd
# 创建两个示例DataFrame
data1 = {
'id': [1, 2, 3],
'name': ['Alice', 'Bob', 'Charlie'],
'age': [25, 30, 35]
}
df1 = pd.DataFrame(data1)
data2 = {
'id': [3, 4, 5],
'name': ['David', 'Eve', 'Frank'],
'city': ['New York', 'Los Angeles', 'Chicago']
}
df2 = pd.DataFrame(data2)
# 使用suffixes参数处理重复列名
merged_df = pd.merge(df1, df2, on='id', suffixes=('_left', '_right'))
print(merged_df)

在这个例子中，df1和df2中都有name列，通过suffixes=('_left', '_right')为重复的name列添加了不同的后缀，这样在合并后的DataFrame中就可以区分这两个列。

除了使用suffixes参数外，还可以在合并后手动删除不需要的重复列。例如：

# 合并后删除重复列（假设保留left的name列，删除right的name列）
merged_df = merged_df.drop('name_right', axis=1)
print(merged_df)

通过这种方式，可以根据实际需求灵活处理合并后出现的重复列名问题，确保数据的整洁和易于处理。

共勉： 东汉·班固《汉书·枚乘传》：“泰山之管穿石，单极之绠断干。水非石之钻，索非木之锯，渐靡使之然也。”

-----指水滴不断地滴，可以滴穿石头；

-----比喻坚持不懈，集细微的力量也能成就难能的功劳。

----感谢读者的阅读和学习，谢谢大家。