NumPy - 数组连接

上一页
下一页

NumPy 中的数组连接

NumPy 中的数组连接是指将两个或多个数组组合成单个数组的过程。结果可能因数组的维度和连接数组的轴而异。

NumPy 提供了多个函数用于沿不同轴连接数组，它们是：

  • np.concatenate() 函数
  • np.stack() 函数
  • np.hstack() 函数
  • np.vstack() 函数

使用 concatenate() 函数

NumPy 的 concatenate() 函数沿指定的轴连接一系列数组。除了要连接的轴对应的维度外，这些数组必须具有相同的形状。以下是基本语法：

np.concatenate((array1, array2, ...), axis=0)

其中，

  • array1, array2, ... − 要连接的数组序列。除了由 axis 指定的一个轴外，这些数组沿所有轴都应该具有相同的形状。
  • axis − 沿其连接数组的轴。默认值为 0，表示沿行连接数组（对于二维数组）。

示例：连接一维数组

在下面的示例中，我们沿默认轴（axis 0）连接两个一维数组“array1”和“array2”：

import numpy as np

# Create two 1D arrays
array1 = np.array([1, 2, 3])
array2 = np.array([4, 5, 6])

# Concatenate along the default axis (axis=0)
result = np.concatenate((array1, array2))

print("Concatenated Array:", result)

生成的数组是一个包含两个输入数组所有元素的单个一维数组：

Concatenated Array: [1 2 3 4 5 6]

示例：沿不同轴连接二维数组

在这里，我们使用 concatenate() 函数沿不同的轴连接两个二维数组：

import numpy as np

# Create two 2D arrays
array1 = np.array([[1, 2], [3, 4]])
array2 = np.array([[5, 6], [7, 8]])

# Concatenate along axis 0 (row-wise)
result_axis_0 = np.concatenate((array1, array2), axis=0)

print("Concatenated along Axis 0:\n", result_axis_0)

# Concatenate along axis 1 (column-wise)
result_axis_1 = np.concatenate((array1, array2), axis=1)

print("Concatenated along Axis 1:\n", result_axis_1)

获得的输出如下：

Concatenated along Axis 0:
[[1 2]
 [3 4]
 [5 6]
 [7 8]]
Concatenated along Axis 1:
 [[1 2 5 6]
 [3 4 7 8]]

示例：连接不同维度的数组

在这里，我们将一维数组“array1”重塑为具有给定形状的二维数组，使其能够沿轴“0”与二维数组“array2”连接：

import numpy as np

# Create a 1D and a 2D array
array1 = np.array([1, 2, 3])
array2 = np.array([[4, 5, 6], [7, 8, 9]])

# Reshape array1 to make it 2D for concatenation along axis 0
array1_reshaped = array1.reshape(1, -1)

# Concatenate along axis 0
result = np.concatenate((array1_reshaped, array2), axis=0)

print("Concatenated Array:\n", result)

这将产生以下结果：

Concatenated Array:
[[1 2 3]
 [4 5 6]
 [7 8 9]]

使用 stack() 函数堆叠数组

NumPy 的 stack() 函数沿一个新的轴连接一系列数组，这个轴由你指定。当需要保留数组的原始维度同时添加一个新轴进行堆叠时，此函数非常有用。以下是语法：

np.stack((array1, array2, ...), axis=0)

其中，

  • array1, array2, ... − 要堆叠的数组序列。这些数组必须具有相同的形状。
  • axis − 沿其堆叠数组的轴。默认值为 0，表示沿新的第一个轴堆叠数组。

示例：堆叠二维数组

在下面的示例中，我们沿新的第三轴堆叠两个二维数组。这将创建一个具有特定形状的三维数组：

import numpy as np

# Create two 2D arrays
array1 = np.array([[1, 2], [3, 4]])
array2 = np.array([[5, 6], [7, 8]])

# Stack along a new third axis (axis 2)
stacked_array = np.stack((array1, array2), axis=2)

print("Stacked Array along Axis 2:\n", stacked_array)
print("Shape of Stacked Array:", stacked_array.shape)

新维度表示数组的深度，其中来自原始数组的对应元素堆叠在一起：

Stacked Array along Axis 2:
[[[1 5]
  [2 6]]

 [[3 7]
  [4 8]]]
Shape of Stacked Array: (2, 2, 2)

示例：堆叠多个数组

在这个例子中，三个一维数组使用 stack() 函数沿新的第一个轴堆叠：

import numpy as np

# Create three 1D arrays
array1 = np.array([1, 2, 3])
array2 = np.array([4, 5, 6])
array3 = np.array([7, 8, 9])

# Stack along the first axis (new axis 0)
stacked_array = np.stack((array1, array2, array3), axis=0)

print("Stacked Array:\n", stacked_array)
print("Shape of Stacked Array:", stacked_array.shape)

结果是一个二维数组，其中每个原始数组构成新数组中的一行：

Stacked Array:
[[1 2 3]
 [4 5 6]
 [7 8 9]]
Shape of Stacked Array: (3, 3)

使用 hstack() 函数进行水平堆叠

NumPy 的 hstack() 函数按顺序水平（列式）堆叠数组。这意味着数组沿它们的第二维（二维数组的 axis 1）连接。对于一维数组，它们只是沿着单个可用轴连接。

以下是语法：

np.hstack((array1, array2, ...))

其中，array1, array2, ... 是要水平堆叠的数组序列。所有数组除了第二个轴外，沿所有轴都必须具有相同的形状。

示例

在下面的示例中，我们将两个二维数组“array1”和“array2”水平堆叠，得到一个新数组，其中“array2”的列放在“array1”的列右侧：

import numpy as np

# Create two 2D arrays
array1 = np.array([[1, 2, 3],
                   [4, 5, 6]])
array2 = np.array([[7, 8, 9],
                   [10, 11, 12]])

# Horizontally stack the arrays
hstacked_array = np.hstack((array1, array2))

print("Horizontally Stacked 2D Array:\n", hstacked_array)

以上代码的输出如下：

Horizontally Stacked 2D Array:
 [[ 1  2  3  7  8  9]
  [ 4  5  6 10 11 12]]

使用 vstack() 函数进行垂直堆叠

NumPy 的 vstack() 函数按顺序垂直（行式）堆叠数组。这意味着数组沿它们的第一个维度（二维数组的 axis 0）连接。对于一维数组，它们被视为行并彼此堆叠，从而产生一个二维数组。

以下是语法：

np.vstack((array1, array2, ...))

其中，array1, array2, ... 是要垂直堆叠的数组序列。所有数组除了第一个轴外，沿所有轴都必须具有相同的形状。

示例

在下面的示例中，我们将两个二维数组“array1”和“array2”垂直堆叠，得到一个新数组，其中“array2”的行放在“array1”的行下方：

import numpy as np

# Create two 2D arrays
array1 = np.array([[1, 2, 3],
                   [4, 5, 6]])
array2 = np.array([[7, 8, 9],
                   [10, 11, 12]])

# Vertically stack the arrays
vstacked_array = np.vstack((array1, array2))

print("Vertically Stacked 2D Array:\n", vstacked_array)

获得的输出如下所示：

Vertically Stacked 2D Array:
 [[ 1  2  3]
  [ 4  5  6]
  [ 7  8  9]
  [10 11 12]]

连接后分割数组

连接数组后，您可能希望将其分割回原始部分或不同形状的部分。NumPy 提供了多个用于分割数组的函数：

  • np.split() 函数 − 根据索引或部分将数组分割成多个子数组。
  • np.array_split() 函数 − 类似于 np.split() 函数，但允许分割成不相等的子数组。
  • np.hsplit() 函数 − 水平（列式）分割数组。
  • np.vsplit() 函数 − 垂直（行式）分割数组。
  • np.dsplit() 函数 − 沿第三轴（深度方向）分割数组，用于三维数组。
数组分割是将数组分成多个子数组的过程。此操作是数组连接的反向操作。

示例

在下面的示例中，我们使用 np.vsplit() 函数将垂直堆叠的数组分成两等份，有效地反转了垂直堆叠操作：

import numpy as np

# Vertically stack two arrays
array1 = np.array([[1, 2, 3],
                   [4, 5, 6]])
array2 = np.array([[7, 8, 9],
                   [10, 11, 12]])

vstacked_array = np.vstack((array1, array2))

# Split the array back into the original arrays
split_arrays = np.vsplit(vstacked_array, 2)

print("Split Arrays:")
for arr in split_arrays:
   print(arr)

执行上述代码后，我们得到以下输出：

Split Arrays:
[[1 2 3]
 [4 5 6]]
[[ 7  8  9]
 [10 11 12]]
打印页面
上一页
下一页
广告