当前位置：首页 > news >正文

在NumPy中合并两个一维数组的多种方法

news 2025/10/17 10:48:48

在科学计算和数据分析中，经常需要将多个一维数组合并成一个新的数组。NumPy作为Python中最重要的数值计算库，提供了多种灵活高效的方法来实现这一操作。本文将深入探讨这些方法，分析它们的底层原理和适用场景。

基础方法：直接连接

`np.concatenate()` - 最通用的连接方法

np.concatenate() 是NumPy中最基础的数组连接函数，它沿着指定轴连接数组序列。对于一维数组，默认沿着第0轴（行方向）连接。

import numpy as np# 创建两个示例一维数组
arr1 = np.linspace(0, 4, 5)  # 生成[0,1,2,3,4]
arr2 = np.linspace(5, 9, 5)  # 生成[5,6,7,8,9]# 使用concatenate连接数组
merged = np.concatenate([arr1, arr2])print("合并后的数组:", merged)
print("数组形状:", merged.shape)

输出结果：

合并后的数组: [0. 1. 2. 3. 4. 5. 6. 7. 8. 9.]
数组形状: (10,)

底层原理：
np.concatenate() 在内存中创建一个新的连续数组，将输入数组的元素按顺序复制到新数组中。时间复杂度为 $O (n)$ ，其中 $n$ 是总元素数量。

优势：

支持任意维度的数组连接
可以一次性连接多个数组
内存效率高（直接操作底层缓冲区）

`np.hstack()` - 水平堆叠

np.hstack() 是水平堆叠函数的简称，专门用于沿水平方向（列方向）连接数组。对于一维数组，效果与 concatenate 相同。

import numpy as nparr1 = np.linspace(0, 4, 5)
arr2 = np.linspace(5, 9, 5)# 使用hstack连接数组
merged = np.hstack((arr1, arr2))print("水平堆叠结果:", merged)

输出结果：

水平堆叠结果: [0. 1. 2. 3. 4. 5. 6. 7. 8. 9.]

适用场景：
当需要明确表达"水平连接"的意图时，使用 hstack 可以使代码更易读。对于二维数组，hstack 会沿列方向连接，保持行数不变。

简洁语法：NumPy的快捷方式

`np.r_` - 切片语法连接

NumPy提供了特殊的对象 r_，它使用切片语法实现数组连接，代码更加简洁。

import numpy as nparr1 = np.linspace(0, 4, 5)
arr2 = np.linspace(5, 9, 5)# 使用r_连接数组
merged = np.r_[arr1, arr2]print("r_连接结果:", merged)

输出结果：

r_连接结果: [0. 1. 2. 3. 4. 5. 6. 7. 8. 9.]

高级用法：
r_ 支持更复杂的切片语法，例如可以插入特定值：

# 在数组间插入0
merged_with_zero = np.r_[arr1, 0, arr2]
print("带插入值的连接:", merged_with_zero)

输出结果：

带插入值的连接: [0. 1. 2. 3. 4. 0. 5. 6. 7. 8. 9.]

原理分析：
np.r_ 实际上是 np.concatenate 的语法糖，但在底层实现上，它会先创建一个索引数组，然后通过索引构建新数组，效率略低于直接使用 concatenate。

创建二维数组的合并方法

`np.vstack()` - 垂直堆叠

np.vstack() 将数组沿垂直方向（行方向）堆叠，对于一维数组，会先将它们转换为二维行向量再堆叠。

import numpy as nparr1 = np.linspace(0, 4, 5)
arr2 = np.linspace(5, 9, 5)# 使用vstack垂直堆叠
stacked = np.vstack((arr1, arr2))print("垂直堆叠结果:\n", stacked)
print("数组形状:", stacked.shape)

输出结果：

垂直堆叠结果:[[0. 1. 2. 3. 4.][5. 6. 7. 8. 9.]]
数组形状: (2, 5)

数学表示：
垂直堆叠可以表示为：
$\text{stacked} = \begin{bmatrix} \text{arr1} \\ \text{arr2} \end{bmatrix}$

`np.column_stack()` - 列方向堆叠

np.column_stack() 将一维数组作为列向量堆叠，形成二维数组。

import numpy as nparr1 = np.linspace(0, 4, 5)
arr2 = np.linspace(5, 9, 5)# 使用column_stack堆叠
column_stacked = np.column_stack((arr1, arr2))print("列堆叠结果:\n", column_stacked)
print("数组形状:", column_stacked.shape)

输出结果：

列堆叠结果:[[0. 5.][1. 6.][2. 7.][3. 8.][4. 9.]]
数组形状: (5, 2)

数学表示：
列堆叠可以表示为：
$column_stacked=[arr10arr20arr11arr21⋮⋮arr1narr2n] \text{column\_stacked} = \begin{bmatrix} \text{arr1}_0 & \text{arr2}_0 \\ \text{arr1}_1 & \text{arr2}_1 \\ \vdots & \vdots \\ \text{arr1}_n & \text{arr2}_n \end{bmatrix}$

性能比较与最佳实践

性能对比

不同方法在性能上有细微差别，特别是处理大型数组时：

import numpy as np
import timeit# 创建大型数组
large_arr1 = np.linspace(0, 1_000_000, 1_000_000)
large_arr2 = np.linspace(1_000_001, 2_000_000, 1_000_000)# 测试concatenate性能
concatenate_time = timeit.timeit(lambda: np.concatenate([large_arr1, large_arr2]),number=100
)# 测试hstack性能
hstack_time = timeit.timeit(lambda: np.hstack((large_arr1, large_arr2)),number=100
)# 测试r_性能
r_time = timeit.timeit(lambda: np.r_[large_arr1, large_arr2],number=100
)print(f"concatenate 耗时: {concatenate_time:.4f} 秒")
print(f"hstack 耗时: {hstack_time:.4f} 秒")
print(f"r_ 耗时: {r_time:.4f} 秒")

典型输出：

concatenate 耗时: 0.1254 秒
hstack 耗时: 0.1268 秒
r_ 耗时: 0.1892 秒

最佳实践建议

简单连接首选 np.concatenate()
对于大多数情况，concatenate 是最佳选择，因为它直接、高效且功能全面。
需要代码可读性时用 np.hstack()
当明确表示水平连接意图时，使用 hstack 可以提高代码可读性。
避免在性能关键代码中使用 np.r_
虽然 r_ 语法简洁，但其性能略低于其他方法，不适合处理大型数组。
创建二维结构时使用专用函数
如果需要将一维数组转换为二维结构：
- 使用 vstack 创建多行数据
- 使用 column_stack 创建多列数据
处理多个数组
所有方法都支持一次连接多个数组：

import numpy as nparr1 = np.linspace(0, 2, 3)
arr2 = np.linspace(3, 5, 3)
arr3 = np.linspace(6, 8, 3)# 连接三个数组
multi_merged = np.concatenate([arr1, arr2, arr3])
print("多数组连接:", multi_merged)