NumPy中数组的拼接(Concatenation)的使用

一、数组拼接的核心定义

说白了，数组拼接就是把多个形状兼容的数组，沿着指定的轴（axis）合并成一个新数组。这个过程在数据处理中太常见了，无论是把几组实验数据堆在一起，还是给特征矩阵添加新维度，都离不开它。

• 轴（axis）：就是拼接的方向。二维数组里，axis=0代表按行拼接，也就是垂直方向堆叠；axis=1代表按列拼接，水平方向延伸。
• 形状兼容：除了拼接轴，其他维度的大小必须一模一样。比如按行拼接，所有数组的列数得一致；按列拼接，行数得相同。
• 核心函数：np.concatenate()是通用工具，np.vstack()（垂直拼接）、np.hstack()（水平拼接）、np.dstack()（深度拼接）则是它的“快捷方式”，语义更直观。

二、核心拼接函数（分类讲解）

NumPy 提供了好几套拼接函数，np.concatenate()是底层通用的那个，而vstack/hstack是它的简化版，好处是不用记axis参数。

1. 通用拼接：np.concatenate ()（核心）

语法长这样：

np.concatenate((arr1, arr2, ...), axis=0, out=None) 

• (arr1, arr2, ...)：所有要拼接的数组得用元组或列表包起来，不能直接扔进去好几个数组。
• axis：拼接轴，默认是0。一维数组只能选axis=0，没有别的选项。
• out：可以指定输出数组，一般用不上。
• 返回值：拼接后的新数组，独立内存，不会影响原数组的数据。

示例 1：一维数组合并（最基础）

先拿两个一维数组试试，模拟两个班级的分数：

import numpy as np
class1 = np.array([85, 92, 78, 90])
class2 = np.array([88, 76, 95, 81])
all_scores = np.concatenate((class1, class2))
print("拼接后一维数组：", all_scores)  # [85 92 78 90 88 76 95 81]
print("拼接后形状：", all_scores.shape)  # (8,)

示例 2：二维数组按行拼接（axis=0）

按行拼接要求所有数组的列数一致，不然会报错：

import numpy as np
arr1 = np.array([[1, 2, 3], [4, 5, 6]])  # 2行3列
arr2 = np.array([[7, 8, 9], [10, 11, 12]])  # 2行3列
arr_v = np.concatenate((arr1, arr2), axis=0)
print("按行拼接结果：\n", arr_v)
print("拼接后形状：", arr_v.shape)  # (4, 3)

输出：

按行拼接结果：

[[ 1 2 3]

[ 4 5 6]

[ 7 8 9]

[10 11 12]]

拼接后形状： (4, 3)

示例 3：二维数组按列拼接（axis=1）

按列拼接则要求行数一致：

import numpy as np
arr1 = np.array([[1, 2], [3, 4]])  # 2行2列
arr2 = np.array([[5, 6], [7, 8]])  # 2行2列
arr3 = np.array([[9], [10]])       # 2行1列
arr_h = np.concatenate((arr1, arr2, arr3), axis=1)
print("按列拼接结果：\n", arr_h)
print("拼接后形状：", arr_h.shape)  # (2, 5)

输出：

按列拼接结果：

[[ 1 2 5 6 9]

[ 3 4 7 8 10]]

拼接后形状： (2, 5)

2. 简化拼接函数（更直观）

如果不想记axis，NumPy提供了几个语义更清晰的函数：

示例：vstack/hstack 简化操作

import numpy as np
arr1 = np.array([[1,2],[3,4]])
arr2 = np.array([[5,6],[7,8]])
arr_v = np.vstack((arr1, arr2))
print("vstack结果：\n", arr_v)  # 4行2列
arr_h = np.hstack((arr1, arr2))
print("hstack结果：\n", arr_h)  # 2行4列

示例：一维数组的 hstack/vstack 特殊处理

一维数组用hstack和vstack会自动调整维度，这一点要留意：

import numpy as np
a = np.array([1,2,3])  # 形状(3,)
b = np.array([4,5,6])  # 形状(3,)
# vstack：一维数组合并为二维（按行）→ (2,3)
v_arr = np.vstack((a, b))
print("vstack一维数组：\n", v_arr)
print("形状：", v_arr.shape)  # (2,3)
# hstack：一维数组合并为更长的一维 → (6,)
h_arr = np.hstack((a, b))
print("hstack一维数组：", h_arr)
print("形状：", h_arr.shape)  # (6,)

3. 深度拼接：np.dstack ()（三维数组）

按第三个维度拼接，常用于图像处理或三维数据：

import numpy as np
arr1 = np.array([[1,2,3],[4,5,6]])
arr2 = np.array([[7,8,9],[10,11,12]])
d_arr = np.dstack((arr1, arr2))
print("dstack结果形状：", d_arr.shape)  # (2,3,2)
print("dstack结果[0,0,:]：", d_arr[0,0,:])  # [1,7]

三、高维数组拼接（进阶）

处理高维数组时，关键是把轴的编号搞清楚。维度编号从0开始，三维数组形状(a,b,c)，轴0=a、轴1=b、轴2=c。拼接时，除了拼接轴，其他维度大小必须一致，这个铁律不会变。

示例：三维数组拼接

import numpy as np
arr1 = np.arange(24).reshape(2,3,4)
arr2 = np.arange(24,48).reshape(2,3,4)
# 按轴0拼接 → 形状(4,3,4)
concat0 = np.concatenate((arr1, arr2), axis=0)
print("按轴0拼接形状：", concat0.shape)  # (4,3,4)
# 按轴1拼接 → 形状(2,6,4)
concat1 = np.concatenate((arr1, arr2), axis=1)
print("按轴1拼接形状：", concat1.shape)  # (2,6,4)
# 按轴2拼接 → 形状(2,3,8)
concat2 = np.concatenate((arr1, arr2), axis=2)
print("按轴2拼接形状：", concat2.shape)  # (2,3,8)

四、拼接的兼容性规则（核心避坑！）

拼接失败，十有八九是因为形状不兼容。记住这一条铁律就够了：

除拼接轴外，其他所有维度的大小必须完全一致。

示例：不兼容的拼接（报错）

import numpy as np
# 错误1：按行拼接但列数不同
arr1 = np.array([[1,2],[3,4]])  # 2行2列
arr2 = np.array([[5,6,7],[8,9,10]])  # 2行3列
try:
    np.concatenate((arr1, arr2), axis=0)
except ValueError as e:
    print("报错1：", e)
# 错误2：按列拼接但行数不同
arr3 = np.array([[1,2],[3,4]])  # 2行2列
arr4 = np.array([[5,6]])        # 1行2列
try:
    np.concatenate((arr3, arr4), axis=1)
except ValueError as e:
    print("报错2：", e)

解决方法：调整数组形状（reshape/expand_dims）

当形状不匹配时，可以通过reshape或np.expand_dims来手动调整：

import numpy as np
arr3 = np.array([[1,2],[3,4]])
arr4 = np.array([[5,6]])
# 方法1：给arr4添加一行
arr4_exp = np.vstack((arr4, [[0,0]]))
concat_ok = np.concatenate((arr3, arr4_exp), axis=1)
print("调整后拼接结果：\n", concat_ok)
# 方法2：扩展维度
a = np.array([1,2,3])  # (3,)
b = np.array([[4,5,6]]) # (1,3)
a_2d = np.expand_dims(a, axis=0)  # (1,3)
concat_a_b = np.concatenate((a_2d, b), axis=0)
print("一维转二维后拼接：\n", concat_a_b)

五、常见应用场景

场景 1：合并多组数据（机器学习数据集）

假设有三组特征数据，每组10个样本、5个特征，要合并成一个30个样本的数据集：

import numpy as np
feat1 = np.random.rand(10,5)
feat2 = np.random.rand(10,5)
feat3 = np.random.rand(10,5)
all_feat = np.concatenate((feat1, feat2, feat3), axis=0)
print("合并后数据集形状：", all_feat.shape)  # (30,5)
# 再添加一个新特征列
new_feat = np.random.rand(30,1)
all_feat_new = np.hstack((all_feat, new_feat))
print("添加新特征后形状：", all_feat_new.shape)  # (30,6)

场景 2：合并时间序列数据（温度数据）

模拟3月和4月的温度数据（各31天×24小时和30天×24小时），合并成春季温度数据：

import numpy as np
march_temp = np.random.normal(5,6,(31,24)).round(1)
april_temp = np.random.normal(15,5,(30,24)).round(1)
spring_temp = np.vstack((march_temp, april_temp))
print("春季温度数据形状：", spring_temp.shape)  # (61,24)

场景 3：批量拼接多个数组

生成10个一维数组，每个数组包含5个元素，然后一次性拼起来：

import numpy as np
arr_list = [np.random.randint(0,10,5) for _ in range(10)]
all_arr = np.concatenate(arr_list, axis=0)
print("批量拼接后形状：", all_arr.shape)  # (50,)

六、避坑点与最佳实践

1. 核心避坑点

• ❌ 直接传多个数组给concatenate是不行的，必须用元组或列表包起来。
• ❌ 一维数组别用axis=1，它只有一个轴，用axis=1会报错。
• ❌ 二维数组里axis=0是行、axis=1是列，容易记反，这可能是最常见的错误。
• ❌ vstack对一维数组会转成二维，而concatenate保持一维，这个差异容易被忽略。

2. 最佳实践

• ✅ 简单拼接优先用vstack/hstack，语义清晰，不用记axis。
• ✅ 高维数组用np.concatenate，明确指定axis。
• ✅ 拼接前养成好习惯，用arr.shape检查形状。
• ✅ 需要批量拼接多个数组时，先放到列表里，再传给concatenate。
• ✅ 如果频繁拼接，最好先预分配数组（用np.empty），然后填充，比多次拼接效率高很多。

总结

1. NumPy数组拼接的核心是np.concatenate()，vstack/hstack是它的简化版，分别对应axis=0和axis=1。
2. 拼接规则很明确：除拼接轴外，其他维度大小必须完全一致，否则就等着报错吧。
3. 维度说明：
   • 一维数组：只能按axis=0拼接，hstack会合并成更长的数组，vstack会自动变成二维。
   • 二维数组：axis=0按行拼接，axis=1按列拼接，记住“行数一致、列数一致”就好。
4. 避坑关键：拼接前检查形状兼容性，一维数组需要转二维时用np.expand_dims。
5. 常用场景：合并数据集、添加特征列、合并时间序列数据，实际中碰到这些需求直接套用就行。