Pandas concat() 函数
Pandas 常用函数pd.concat() 是 Pandas 库中用于连接（拼接）多个序列（Series）或数据框（DataFrame）的函数。它可以在行方向或列方向上将多个对象合并成一个新的对象。
这是数据处理中最常用的合并操作之一，无论是纵向追加数据还是横向合并字段，pd.concat() 都能胜任。
单词释义： concat 是 "concatenate"（连接、串联）的缩写，意思是把多个东西首尾相连。
基本语法与参数
pd.concat() 是 Pandas 库的顶级函数，用于沿指定轴将多个 Series 或 DataFrame 对象拼接在一起。
语法格式
pd.concat(objs, axis=0, join='outer', ignore_index=False, keys=None, levels=None, names=None, verify_integrity=False, sort=False)
参数说明
- 参数：
objs- 类型： Series、DataFrame 或它们的列表。
- 描述： 要连接的一个或多个 Series/DataFrame 对象。可以是单个对象、列表或字典。
- 参数：
axis- 类型： 整数（0 或 1）。
- 描述： 指定拼接的轴向。
0表示按行拼接（纵向追加），1表示按列拼接（横向合并）。默认为0。
- 参数：
join- 类型： 字符串（'outer' 或 'inner'）。
- 描述： 当拼接方向上的索引不一致时的处理方式。
'outer'表示取并集（保留所有索引），'inner'表示取交集（只保留共同索引）。默认为'outer'。
- 参数：
ignore_index- 类型： 布尔值。
- 描述> 如果为
True，拼接后不使用原来的索引，而是创建新的整数索引。默认为False。
- 参数：
keys- 类型> 序列。
- 描述： 用于在拼接后创建多层索引，标识每个原始对象的来源。默认为
None。
函数说明
- 返回值： 返回拼接后的 Series 或 DataFrame 对象。类型与输入对象一致。
- 效果： 沿指定轴将多个对象合并为一个对象。
实例
让我们通过一系列从简单到复杂的例子，彻底掌握 pd.concat() 的用法。
示例 1：基础用法 - 纵向拼接 Series
实例
import pandas as pd
# 1. 创建两个 Series
s1 = pd.Series(['Alice', 'Bob', 'Charlie'], name='name')
s2 = pd.Series(['Diana', 'Eve', 'Frank'], name='name')
print("=== 原始 Series ===")
print("s1:", s1.tolist())
print("s2:", s2.tolist())
# 2. 使用 pd.concat() 纵向拼接（默认 axis=0）
result = pd.concat([s1, s2])
print("\n=== pd.concat([s1, s2]) 纵向拼接结果 ===")
print(result)
# 3. 忽略原有索引，创建新的整数索引
result_ignore = pd.concat([s1, s2], ignore_index=True)
print("\n=== ignore_index=True 结果 ===")
print(result_ignore)
# 1. 创建两个 Series
s1 = pd.Series(['Alice', 'Bob', 'Charlie'], name='name')
s2 = pd.Series(['Diana', 'Eve', 'Frank'], name='name')
print("=== 原始 Series ===")
print("s1:", s1.tolist())
print("s2:", s2.tolist())
# 2. 使用 pd.concat() 纵向拼接（默认 axis=0）
result = pd.concat([s1, s2])
print("\n=== pd.concat([s1, s2]) 纵向拼接结果 ===")
print(result)
# 3. 忽略原有索引，创建新的整数索引
result_ignore = pd.concat([s1, s2], ignore_index=True)
print("\n=== ignore_index=True 结果 ===")
print(result_ignore)
运行结果预期:
=== 原始 Series === s1: ['Alice', 'Bob', 'Charlie'] s2: ['Diana', 'Eve', 'Frank'] === pd.concat([s1, s2]) 纵向拼接结果 === 0 Alice 1 Bob 2 Charlie 0 Diana 1 Eve 2 Frank dtype: object === ignore_index=True 结果 === 0 Alice 1 Bob 2 Charlie 3 Diana 4 Eve 5 Frank dtype: object
代码解析:
pd.concat([s1, s2])将两个 Series 纵向拼接为一个更长的 Series。- 默认情况下，保留原始索引，所以会有重复的索引值 0, 1, 2。
- 设置
ignore_index=True可以重新生成连续的数字索引。
示例 2：横向拼接 DataFrame
使用 axis=1 可以将多个 DataFrame 按列拼接，这在需要合并不同字段时非常有用。
实例
import pandas as pd
# 1. 创建两个 DataFrame
df1 = pd.DataFrame({
'name': ['Alice', 'Bob', 'Charlie'],
'age': [25, 30, 35]
})
df2 = pd.DataFrame({
'city': ['Beijing', 'Shanghai', 'Guangzhou'],
'score': [85, 90, 95]
})
print("=== 原始 DataFrame ===")
print("df1:")
print(df1)
print("\ndf2:")
print(df2)
# 2. 横向拼接（axis=1）
result = pd.concat([df1, df2], axis=1)
print("\n=== pd.concat([df1, df2], axis=1) 横向拼接 ===")
print(result)
# 1. 创建两个 DataFrame
df1 = pd.DataFrame({
'name': ['Alice', 'Bob', 'Charlie'],
'age': [25, 30, 35]
})
df2 = pd.DataFrame({
'city': ['Beijing', 'Shanghai', 'Guangzhou'],
'score': [85, 90, 95]
})
print("=== 原始 DataFrame ===")
print("df1:")
print(df1)
print("\ndf2:")
print(df2)
# 2. 横向拼接（axis=1）
result = pd.concat([df1, df2], axis=1)
print("\n=== pd.concat([df1, df2], axis=1) 横向拼接 ===")
print(result)
运行结果预期:
=== 原始 DataFrame ===
df1:
name age
0 Alice 25
1 Bob 30
2 Charlie 35
df2:
city score
0 Beijing 85
1 Shanghai 90
2 Guangzhou 95
=== pd.concat([df1, df2], axis=1) 横向拼接 ===
name age city score
0 Alice 25 Beijing 85
1 Bob 30 Shanghai 90
2 Charlie 35 Guangzhou 95
代码解析:
- 使用
axis=1将两个 DataFrame 按列拼接。 - 横向拼接要求两个 DataFrame 具有相同的行数（索引对齐）。
- 拼接后的 DataFrame 包含两个对象的所有列。
示例 3：使用 keys 参数创建层次化索引
keys 参数可以帮助我们标识数据来源，这在合并来自不同数据集的内容时非常有用。
实例
import pandas as pd
# 1. 创建一个包含多个 Series 的字典
data = {
'group_a': pd.Series([1, 2, 3, 4]),
'group_b': pd.Series([5, 6, 7, 8]),
'group_c': pd.Series([9, 10, 11, 12])
}
print("=== 使用 keys 参数拼接 ===")
# 2. 使用 keys 参数创建层次化索引
result = pd.concat(data, keys=['第一组', '第二组', '第三组'])
print(result)
# 3. 访问特定层级的数据
print("\n=== 访问 '第一组' 的数据 ===")
print(result['第一组'])
# 1. 创建一个包含多个 Series 的字典
data = {
'group_a': pd.Series([1, 2, 3, 4]),
'group_b': pd.Series([5, 6, 7, 8]),
'group_c': pd.Series([9, 10, 11, 12])
}
print("=== 使用 keys 参数拼接 ===")
# 2. 使用 keys 参数创建层次化索引
result = pd.concat(data, keys=['第一组', '第二组', '第三组'])
print(result)
# 3. 访问特定层级的数据
print("\n=== 访问 '第一组' 的数据 ===")
print(result['第一组'])
运行结果预期:
=== 使用 keys 参数拼接 ===
第一组 group_a 1
group_b 2
group_c 3
group_a 4
第二组 group_a 5
group_b 6
group_c 7
group_a 8
第二组 group_b 9
...
代码解析:
keys参数为拼接结果创建了多层索引（层次化索引），第一层标识数据来源的组别。- 可以通过
result['第一组']访问特定组别的数据。
示例 4：处理不同列的 DataFrame（join 参数）
当要拼接的 DataFrame 具有不同的列时，可以使用 join 参数控制处理方式。
实例
import pandas as pd
# 1. 创建具有不同列的 DataFrame
df1 = pd.DataFrame({
'name': ['Alice', 'Bob'],
'age': [25, 30]
})
df2 = pd.DataFrame({
'name': ['Charlie', 'Diana'],
'score': [85, 90]
})
print("=== 原始 DataFrame ===")
print("df1:")
print(df1)
print("\ndf2:")
print(df2)
# 2. 外连接（默认）- 保留所有列
print("\n=== join='outer' (外连接) ===")
print(pd.concat([df1, df2], join='outer'))
# 3. 内连接 - 只保留共同列
print("\n=== join='inner' (内连接) ===")
print(pd.concat([df1, df2], join='inner'))
# 1. 创建具有不同列的 DataFrame
df1 = pd.DataFrame({
'name': ['Alice', 'Bob'],
'age': [25, 30]
})
df2 = pd.DataFrame({
'name': ['Charlie', 'Diana'],
'score': [85, 90]
})
print("=== 原始 DataFrame ===")
print("df1:")
print(df1)
print("\ndf2:")
print(df2)
# 2. 外连接（默认）- 保留所有列
print("\n=== join='outer' (外连接) ===")
print(pd.concat([df1, df2], join='outer'))
# 3. 内连接 - 只保留共同列
print("\n=== join='inner' (内连接) ===")
print(pd.concat([df1, df2], join='inner'))
运行结果预期:
=== 原始 DataFrame ===
df1:
name age
0 Alice 25
1 Bob 30
df2:
name score
0 Charlie 85
1 Diana 90
=== join='outer' (外连接) ===
name age score
0 Alice 25.0 NaN
1 Bob 30.0 NaN
0 Charlie NaN 85.0
1 Diana NaN 90.0
=== join='inner' (内连接) ===
name
0 Alice
1 Bob
0 Charlie
1 Diana
代码解析:
join='outer'（默认）保留所有列，不存在的列填充为NaN。join='inner'只保留两个 DataFrame 共有的列（这里是name）。
提示：
pd.concat()适合简单的拼接操作。如果需要更复杂的合并（如基于列值的匹配），请参考pd.merge()函数。