NumPy 数组重塑指南

The NumPyPython 中的库提供了强大的功能来重塑数组的维度，这就是我们将在本教程中深入探讨的内容。

在整个教程中，我们将介绍 NumPy 数组重塑的含义及其重要性，然后再深入研究如何重塑不同维度的数组的细节。

在本教程结束时，您将熟练地重塑 NumPy 数组并了解如何将这些技术应用于现实世界的数据操作任务。

为什么重塑功能至关重要？

在 NumPy 中重塑数组是一项关键操作，尤其是在数据科学和机器学习领域。

它允许您重组数据以适应可能需要特定维度或形状输入的不同算法。值得注意的是，reshape函数不会改变数组的原始数据，保证了数据的完整性。
例如，某些机器学习模型可能要求输入位于二维数组中，即使只有一个特征。

在这种情况下，重塑允许您将一维数组转换为二维数组。

它通常返回原始数组的视图，这意味着它不会复制数据，而是提供一种新的索引方式。

这使您可以有效地处理大型数据集，而无需担心内存使用情况。

numpy.reshape() 函数

The reshape()NumPy 中的函数用于更改数组的形状。它将您要为数组指定的新形状作为其第一个参数，该形状应与原始数组的形状兼容。

这意味着原始数组中的元素总数应与重构数组中的元素总数相同。
这是一个简单的例子：

import numpy as np

# original array
arr = np.array([0, 1, 2, 3, 4, 5])
print("Original Array: ", arr)

# reshaping the array
reshaped_arr = np.reshape(arr, (3, 2))
print("Reshaped Array: \n", reshaped_arr)
  

Output:

Original Array:  [0 1 2 3 4 5]
Reshaped Array: 
 [[0 1]
 [2 3]
 [4 5]]
  

在上面的例子中，我们使用了np.reshape改变一维数组形状的方法arr到二维数组。

新的数组，reshaped_arr，是一个形状为 (3, 2) 的二维数组，这意味着它有 3 行和 2 列。这np.reshape方法将要重塑的数组作为其第一个参数，并将新形状作为其第二个参数。
重构后的数组仍然引用内存中与原始数组相同的数据，这意味着对原始数组的更改将反映在重构后的数组中，反之亦然。

NumPy 重塑顺序（索引顺序）

在重塑数组时，NumPy 以不同顺序或重新排列元素的方式提供灵活性。最常用的是“C”、“F”和“A”顺序。

• ‘C’顺序，或C风格顺序，意味着以C语言风格进行行上升操作。
• “F”顺序，或 Fortran 风格的顺序，意味着操作是按列进行的。
• “A”顺序也称为保留顺序，表示如果数组在内存中是 Fortran 连续的，则使用“F”，否则使用“C”。

它们的工作原理如下：

import numpy as np

# original array
arr = np.array([[1, 2, 3], [4, 5, 6]])
print("Original Array: \n", arr)

# using reshape with C order
reshaped_c_arr = np.reshape(arr, (3, 2), order='C')
print("Reshaped Array in C order: \n", reshaped_c_arr)

# using reshape with F order
reshaped_f_arr = np.reshape(arr, (3, 2), order='F')
print("Reshaped Array in F order: \n", reshaped_f_arr)

# Using reshape with A order
reshaped_a_arr = arr.reshape(3, 2, order='A')
print("Reshaped Array in A order: \n", reshaped_a_arr)
  

Output:

Original Array: 
[[1 2 3]
[4 5 6]]
Reshaped Array in C order: 
[[1 2]
[3 4]
[5 6]]
Reshaped Array in F order: 
[[1 3]
[5 2]
[4 6]]
Reshaped Array in A order: 
[[1 2]
[3 4]
[5 6]]
  

在此示例中，原始二维数组arr使用 C 和 F 阶将其重塑为 3×2 数组。以 C 顺序重塑时 (reshaped_c_arr），数组按行读取，就像从左到右，然后从上到下读取英文文本一样。

另一方面，当按 F 阶重塑时 (reshaped_f_arr），数组按列读取，从第一列开始，然后继续下一列。

在 reshape 函数中指定 order 参数允许您决定从原始数组中取出元素并在新数组中排列的逻​​辑。

使用 numpy.ndarray.reshape()

The numpy.ndarray.reshape()方法是一个实例方法，其行为类似于numpy.reshape()功能。
让我们看看它是如何工作的：

import numpy as np

# original array
arr = np.array([1, 2, 3, 4, 5, 6, 7, 8])
print("Original Array: ", arr)

# reshaped array
reshaped_arr = arr.reshape(2, 4)
print("Reshaped Array: \n", reshaped_arr)
  

Output:

Original Array:  [1 2 3 4 5 6 7 8]
Reshaped Array: 
 [[1 2 3 4]
 [5 6 7 8]]
  

这里，原始的一维数组arr被重塑为二维数组reshaped_arr通过使用 ndarray 的 reshape 方法。

重构后的数组reshaped_arr现在有两行和四列。新形状 (2, 4) 直接传递给 reshape 方法，无需包含在元组中，这在使用 ndarray 的 reshape 方法进行重塑时是允许的。

numpy.ndarray.reshape() 与 numpy.reshape()

它们的功能本质上是相同的，但用法略有不同。

The numpy.ndarray.reshape是 ndarray 类的一个方法，这意味着它是每个 ndarray 对象都拥有并且可以使用的函数。它不是一个独立的函数，而是在一个数组对象上调用。这是一个例子：

import numpy as np
a = np.array([1, 2, 3, 4, 5, 6])
b = a.reshape((2, 3))  

因此，它们之间的区别实际上只是在于您如何称呼它们。

numpy.reshape被调用为一个以数组为参数的函数，并且numpy.ndarray.reshape作为数组对象上的方法调用。

将一维数组重塑为二维数组

您可以使用 reshape 方法将一维数组重塑为二维数组。操作方法如下：

import numpy as np

# original 1d array
arr_1d = np.array([1, 2, 3, 4, 5, 6])
print("Original 1d Array: ", arr_1d)

# reshaping to 2d array
arr_2d = arr_1d.reshape((3, 2))
print("Reshaped 2d Array: \n", arr_2d)
  

Output:

Original 1d Array:  [1 2 3 4 5 6]
Reshaped 2d Array: 
 [[1 2]
 [3 4]
 [5 6]]
  

在这里，我们已经转换了一维数组，arr_1d，进入二维数组，arr_2d，通过使用重塑方法。

我们传递一个元组(3, 2)作为 reshape 方法的参数，表明我们要将数组转换为 3 行 2 列的二维数组。得到的数组，arr_2d，体现了新的形状。

将 2-D 数组重塑为 3-D 数组

现在让我们看一下将 2 维数组重塑为 3 维数组。当处理更复杂的数据（例如图像或多变量时间序列数据）时，这非常有用。

import numpy as np

# original 2d array
arr_2d = np.array([[1, 2, 3], [4, 5, 6]])
print("Original 2d Array: \n", arr_2d)

# reshaping to 3d array
arr_3d = arr_2d.reshape((2, 1, 3))
print("Reshaped 3d Array: \n", arr_3d)
  

Output:

Original 2d Array: 
 [[1 2 3]
 [4 5 6]]
Reshaped 3d Array: 
 [[[1 2 3]]
 [[4 5 6]]]
  

在这个例子中，我们重塑了一个二维数组，arr_2d，进入 3 维数组，arr_3d。我们传递了一个元组(2, 1, 3)到 reshape 方法，它表示我们要将数组转换为三维数组，其中第一维有 2 个元素，第二维有 1 个元素，第三维有 3 个元素。这会产生一个 3d 数组，arr_3d.

将一维数组重塑为多维数组

还可以将一维数组重塑为多维数组。例如，一维数组可以重塑为 3 维数组，如下例所示：

import numpy as np

# original 1d array
arr_1d = np.array([1, 2, 3, 4, 5, 6])
print("Original 1d Array: ", arr_1d)

# reshaping to 3d array
arr_3d = arr_1d.reshape((2, 1, 3))
print("Reshaped 3d Array: \n", arr_3d)
  

Output:

Original 1d Array:  [1 2 3 4 5 6]
Reshaped 3d Array: 
 [[[1 2 3]]
 [[4 5 6]]]
  

在上面的例子中，一维数组arr_1d被重塑为 3 维数组arr_3d。 reshape 方法需要一个元组(2, 1, 3)指定新数组所需的形状。

重构后的数组arr_3d现在有两个块，每个块包含一行三个元素。

使用 -1 重塑（未知尺寸）

重塑数组时，您可以使用-1在您指定的新形状中，这让 NumPy 自动计算该尺寸的大小-1.

当您知道某些维度的形状并希望 NumPy 计算出剩余维度时，这会很方便。
这是一个例子：

import numpy as np

# original 1d array
arr_1d = np.array([1, 2, 3, 4, 5, 6])
print("Original 1d Array: ", arr_1d)

# reshaping with -1
arr_2d = arr_1d.reshape((3, -1))
print("Reshaped 2d Array: \n", arr_2d)
  

Output:

Original 1d Array:  [1 2 3 4 5 6]
Reshaped 2d Array: 
 [[1 2]
 [3 4]
 [5 6]]
  

在这种情况下，原始数组arr_1d被重塑为二维数组arr_2d using -1。传递元组时(3, -1)对于 reshape 方法，我们指定希望新数组具有三行，并让 NumPy 计算保留原始数组中元素数量所需的列数（在本例中为 2）。

将 4 维数组重塑为 2 维数组

从 4 维数组重塑为 2 维数组也很常见，特别是在处理图像数据时，我们经常处理批量的多个图像。

import numpy as np

# Create a 4-D array of shape (2, 2, 3, 3)
arr_4d = np.random.randint(10, size=(2, 2, 3, 3))
print("Original 4-D Array: \n", arr_4d)

# Reshape 4-D array to 2-D array
arr_2d = arr_4d.reshape(-1, arr_4d.shape[-1])
print("\nReshaped 2-D Array: \n", arr_2d)
  

Output:

Original 4-D Array: 
 [[[[8 2 9]
   [8 6 5]
   [7 8 0]]

  [[6 0 0]
   [5 2 4]
   [2 1 9]]]


 [[[4 9 2]
   [4 5 1]
   [2 3 9]]

  [[2 3 3]
   [6 9 1]
   [8 1 3]]]]

Reshaped 2-D Array: 
 [[8 2 9]
 [8 6 5]
 [7 8 0]
 [6 0 0]
 [5 2 4]
 [2 1 9]
 [4 9 2]
 [4 5 1]
 [2 3 9]
 [2 3 3]
 [6 9 1]
 [8 1 3]]
  

原始数组的形状为 (2, 2, 3, 3)，我们希望将其重塑为二维数组，并保持最后一个维度不变。

因此，我们使用了-1对于新形状的第一个维度，以及arr_4d.shape[-1]对于第二个维度。

结果是一个二维数组，其中第一个维度由 NumPy 推断，第二个维度与原始数组的最后一个维度相同。

NumPy 数组重塑的真实示例

NumPy 数组重塑是数据处理和机器学习中的基本操作。例如：

• 图像处理：Python 中加载的图像会变成 NumPy 数组，并且通常需要重新整形。例如，形状（宽度、高度、3）的彩色图像在输入神经网络进行训练之前可能需要重新整形为一维数组。
• 神经网络：神经网络的输入层通常需要特定形状的数据。因此，重塑允许以一定大小的批次馈送数据。

这是图像处理中重塑的一个简单示例：

from PIL import Image
import numpy as np
img = Image.open('image.jpg')

# Convert image to a NumPy array
img_arr = np.array(img)
print("Original Image Shape: ", img_arr.shape)

# Reshape the image array
reshaped_img_arr = np.reshape(img_arr, -1)
print("Reshaped Image Array Shape: ", reshaped_img_arr.shape)
  

Output:

Original Image Shape: (800, 800, 3)
Reshaped Image Array Shape: (1920000,)  

在此示例中，我们使用 PIL 库打开图像并将其转换为 NumPy 数组img_arr.

原来的形状是img_arr将为（高度、宽度、通道），其中通道表示 RGB 值。

然后使用以下命令重塑图像阵列numpy.reshape()函数转换为一维数组reshaped_img_arr，然后可以用作机器学习算法的输入。

F.A.Q

问：如何将一维 numpy 数组重塑为二维数组？

答：您可以使用 numpy reshape() 函数将一维数组转换为二维数组。该函数用于改变数组的形状而不改变其数据。

例如，如果您有一个包含 8 个元素的数组，则可以使用 reshape(2,4) 将其转换为两行四列的二维数组。

问：numpy reshape() 函数中数组形状参数的作用是什么？

答：numpy reshape 函数中的数组形状参数指定要将数组重塑为的新形状。

具体来说，它是一个元组，指示新数组每个维度的元素数量。新形状中的元素总数应与原始形状兼容。

问：如何使用 numpy reshape 将二维数组转换为一维数组？

答：您可以使用 reshape() 函数将二维数组转换为一维 numpy 数组，并将 -1 作为新的形状参数。

这告诉 NumPy 根据原始数组大小计算尽可能大的维度大小，以容纳数组的所有元素。

问：在重塑 NumPy 数组时，类 C 和类 Fortran 索引顺序意味着什么？

答：类 C（“C”顺序或以 C 编程语言命名）意味着数组按行重新整形。这也称为行主序。这是 NumPy 中的默认顺序。

类似 Fortran（“F”顺序或以 Fortran 编程语言命名）意味着数组按列重新整形。您可以使用 order 参数在 numpy reshape 中指示这些选项。

问：我可以使用 numpy reshape 添加或删除维度吗？

答：是的，您可以使用 numpy reshape 添加或删除数组的维度。例如，您可以将 3D 数组转换为 2D 数组（删除维度）。

问：我有一个 3 维数组，我想将其转换为 2 维数组。我应该考虑什么？

答：使用 numpy reshape 将 3 维数组转换为 2 维数组时，需要确保 2 维数组中的元素总数与 3 维数组中的元素总数相同。例如，如果您有一个形状为 (2, 3, 4) 的 3 维 numpy 数组，则可以将其重塑为形状为 (6, 4) 的二维数组。

问：重塑 ndarray 时数组索引如何工作？

答：数组索引基于 ndarray 的形状进行工作。当您使用 reshape 更改 NumPy 数组的形状时，数组中的原始数据将根据新形状重新对齐，但数组中元素及其索引之间的映射将被保留。这是根据“C”或 Fortran 内存布局完成的，具体取决于您指定的内容。

问：当我们说新形状“与原始形状兼容”时，是什么意思？

答：当我们重塑 NumPy 数组时，与原始形状兼容意味着新形状的元素总数与原始数组中的元素总数相匹配。

例如，如果您有一个包含 8 个元素的数组，则它与也包含 8 个元素的任何其他形状兼容（例如 (2,4)、(4,2) 或 (8,1)）。

问：在 reshape NumPy 数组中，他们提到了 reshape(-1, 1) 的使用。那有什么作用？

答：NumPy 中的 reshape(-1, 1) 用于将数组转换为具有一列和所需行数的 2D numpy 数组。

-1 是一个特殊值，它告诉 NumPy 计算尽可能大的维度大小以容纳数组的所有元素。

进一步阅读

https://numpy.org/doc/stable/reference/ generated/numpy.reshape.html

https://numpy.org/doc/stable/reference/ generated/numpy.ndarray.reshape.html