如何reshape numpy数组以添加新轴？

你可以使用reshape()，但np.expand_dims()或np.newaxis在添加单个维度时更简洁。例如，arr[np.newaxis, :]添加一个行轴，arr[:, np.newaxis]添加一个列轴。

NumPy Reshape：如何在Python中改变数组形状

Q: numpy reshape(-1)做什么？

调用array.reshape(-1)将数组展平为一维。-1告诉NumPy自动计算元素总数。它等同于array.ravel()或array.flatten()，不过reshape(-1)在可能时返回视图，而flatten()总是返回副本。

Q: numpy reshape会改变原始数组吗？

不会。reshape()返回一个新的数组对象。但是，如果返回的数组是视图（通常如此），修改reshape后的数组也会修改原始数组，因为它们共享相同的内存。要避免这种情况，对结果调用.copy()。

Q: numpy reshape和flatten有什么区别？

reshape()可以将数组转换为任何兼容的形状。flatten()总是转换为1D数组并总是返回副本。ravel()也转换为1D，但在可能时返回视图，类似于reshape(-1)。

Q: 我可以用numpy reshape来reshape pandas DataFrame吗？

不能直接reshape。你首先需要使用df.values或df.to_numpy()提取底层的NumPy数组，然后再reshape。对于DataFrame特定的reshape操作，使用pandas方法如pivot()、melt()、stack()或unstack()。

Name: Soren Atelier

Updated on 2026/2/9

你有一个包含10,000个像素值的扁平列表，而神经网络期望一个100x100的图像矩阵。或者scikit-learn正在报错，因为你的特征数组是一维的，而它需要一个列向量。这些不是边缘情况——它们是每个使用Python处理数值数据的人每天都会遇到的障碍。解决这些问题的函数就是numpy.reshape()，正确理解它可以节省数小时的调试时间。

📚

numpy reshape做什么？

numpy.reshape()在不改变数据的情况下改变数组的形状。它取相同的元素并将它们重新排列成新的维度组合。一个有12个元素的一维数组可以变成3x4矩阵、2x6矩阵、4x3矩阵，甚至是2x2x3的三维数组。唯一的规则是元素总数必须保持不变。

import numpy as np
 
a = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12])
print(a.shape)
# (12,)
 
b = a.reshape(3, 4)
print(b)
# [[ 1  2  3  4]
#  [ 5  6  7  8]
#  [ 9 10 11 12]]
 
print(b.shape)
# (3, 4)

原始数组a仍然以其原始形状存在。reshape后的数组b是同一数据的新视图（关于视图与副本的更多内容稍后介绍）。

基本语法和参数

在NumPy中有两种方式来reshape数组：

# 方法1：作为函数
np.reshape(array, newshape, order='C')
 
# 方法2：作为数组方法
array.reshape(newshape, order='C')

参数	类型	描述
`array`	ndarray	要reshape的数组（仅用于`np.reshape()`函数形式）
`newshape`	int或int元组	目标形状。一个维度可以设为-1，它会自动计算。
`order`	`'C'`、`'F'`或`'A'`	元素的读写顺序。`'C'` = 行优先（默认），`'F'` = 列优先，`'A'` = 如果数组是Fortran连续的则用Fortran顺序，否则用C顺序。

两种形式产生相同的结果。方法形式（array.reshape()）更常用，因为它在代码中读起来更自然。

将1D数组reshape为2D数组

这是最常见的reshape操作。你从一个扁平数组开始，需要一个矩阵。

import numpy as np
 
# 有8个元素的1D数组
data = np.array([10, 20, 30, 40, 50, 60, 70, 80])
 
# reshape为2行4列
matrix_2x4 = data.reshape(2, 4)
print(matrix_2x4)
# [[10 20 30 40]
#  [50 60 70 80]]
 
# reshape为4行2列
matrix_4x2 = data.reshape(4, 2)
print(matrix_4x2)
# [[10 20]
#  [30 40]
#  [50 60]
#  [70 80]]
 
# reshape为单列向量（8行，1列）
column_vector = data.reshape(8, 1)
print(column_vector)
# [[10]
#  [20]
#  [30]
#  [40]
#  [50]
#  [60]
#  [70]
#  [80]]
 
print(column_vector.shape)
# (8, 1)

列向量reshape（n, 1）特别重要。许多scikit-learn函数即使对于单个特征也需要2D输入。如果你传入1D数组，会得到错误Expected 2D array, got 1D array instead。解决方法是.reshape(-1, 1)。

从2D reshape为3D（用于机器学习和深度学习）

像TensorFlow和PyTorch这样的深度学习框架通常需要3D或4D输入张量。例如，一批灰度图像需要形状(batch_size, height, width)，一批彩色图像需要(batch_size, height, width, channels)。

import numpy as np
 
# 模拟4张3x3灰度图像，存储为2D数组中的行
images_2d = np.arange(36).reshape(4, 9)
print(images_2d.shape)
# (4, 9)
 
# reshape为（批次，高度，宽度）
images_3d = images_2d.reshape(4, 3, 3)
print(images_3d.shape)
# (4, 3, 3)
 
print(images_3d[0])
# [[0 1 2]
#  [3 4 5]
#  [6 7 8]]

对于3通道（RGB）彩色图像：

import numpy as np
 
# 2张彩色图像，每张4x4带3个通道，扁平存储
flat_data = np.arange(96)  # 2 * 4 * 4 * 3 = 96
 
images = flat_data.reshape(2, 4, 4, 3)
print(images.shape)
# (2, 4, 4, 3)

-1技巧：自动计算一个维度

当你将一个维度设为-1时，NumPy会根据元素总数和你指定的其他维度自动计算它。这是reshape最有用的功能之一。

import numpy as np
 
arr = np.arange(12)
 
# "给我3行，自动计算列数"
print(arr.reshape(3, -1))
# [[ 0  1  2  3]
#  [ 4  5  6  7]
#  [ 8  9 10 11]]
# 形状: (3, 4) -- NumPy计算出4列
 
# "给我2列，自动计算行数"
print(arr.reshape(-1, 2))
# [[ 0  1]
#  [ 2  3]
#  [ 4  5]
#  [ 6  7]
#  [ 8  9]
#  [10 11]]
# 形状: (6, 2) -- NumPy计算出6行
 
# 展平为1D
print(arr.reshape(-1))
# [ 0  1  2  3  4  5  6  7  8  9 10 11]
# 形状: (12,)
 
# 列向量
print(arr.reshape(-1, 1).shape)
# (12, 1)

-1只能用于一个维度。对两个或更多维度使用会引发错误，因为计算变得模糊不清。

import numpy as np
 
arr = np.arange(12)
 
# 这会失败：
# arr.reshape(-1, -1)
# ValueError: can only specify one unknown dimension

reshape()与resize()的区别：关键差异

两个函数都能改变数组形状，但行为非常不同。

特性	`reshape()`	`resize()`
返回值	新数组（视图或副本）	原地修改数组（方法）或返回新数组（函数）
大小必须匹配	是——元素总数必须相同	否——用零填充或截断
原始数组	不变	被修改（使用`ndarray.resize()`时）
安全性	大小不匹配时抛出错误	静默填充或截断
常见用途	重新排列维度	改变数组大小

import numpy as np
 
arr = np.array([1, 2, 3, 4, 5, 6])
 
# reshape：必须保持相同的元素总数
reshaped = arr.reshape(2, 3)
print(reshaped)
# [[1 2 3]
#  [4 5 6]]
 
# np.resize（函数形式）：如果新大小更大，通过重复来填充
resized = np.resize(arr, (3, 3))
print(resized)
# [[1 2 3]
#  [4 5 6]
#  [1 2 3]]   <-- 从头开始重复
 
# np.resize：如果新大小更小，则截断
resized_small = np.resize(arr, (2, 2))
print(resized_small)
# [[1 2]
#  [3 4]]

当你想在不改变数据的情况下重新排列维度时，使用reshape()。仅当你确实需要改变元素数量时，才使用resize()。

order参数：C与F与A

order参数控制如何从原始数组读取元素并将其放入新形状。当你处理来自不同编程语言或存储格式的数据时，这一点很重要。

import numpy as np
 
arr = np.array([1, 2, 3, 4, 5, 6])
 
# C顺序（行优先）：逐行填充——这是默认值
c_order = arr.reshape(2, 3, order='C')
print("C顺序:")
print(c_order)
# [[1 2 3]
#  [4 5 6]]
 
# F顺序（列优先）：逐列填充
f_order = arr.reshape(2, 3, order='F')
print("F顺序:")
print(f_order)
# [[1 3 5]
#  [2 4 6]]

Order	名称	填充方式	使用场景
`'C'`	C风格 / 行优先	逐行（最后一个索引变化最快）	Python/C/C++默认内存布局
`'F'`	Fortran风格 / 列优先	逐列（第一个索引变化最快）	MATLAB、Fortran、R数据
`'A'`	自动	如果数组是Fortran连续的则用F，否则用C	保留现有内存布局

大多数情况下你会使用默认的'C'顺序。当加载从MATLAB或Fortran导出的数据时需要'F'顺序，因为这些环境中矩阵是按列存储的。

视图与副本：reshape何时返回视图

一个关键细节：reshape()尽可能返回原始数组的视图。视图共享相同的底层内存。修改视图会修改原始数组，反之亦然。

import numpy as np
 
original = np.arange(6)
reshaped = original.reshape(2, 3)
 
# 修改reshape后的视图
reshaped[0, 0] = 999
 
print(original)
# [999   1   2   3   4   5]   <-- 原始数组也改变了！

如果NumPy无法创建视图（例如，当内存布局与新形状不兼容时），它会返回副本。你可以显式地强制创建副本：

import numpy as np
 
original = np.arange(6)
reshaped_copy = original.reshape(2, 3).copy()
 
reshaped_copy[0, 0] = 999
print(original)
# [0 1 2 3 4 5]   <-- 原始数组不受影响

要检查reshape返回的是视图还是副本，检查base属性：

import numpy as np
 
arr = np.arange(6)
view = arr.reshape(2, 3)
copy = arr.reshape(2, 3).copy()
 
print(view.base is arr)   # True -- 是视图
print(copy.base is arr)   # False -- 是副本

常见错误及解决方法

错误："cannot reshape array of size X into shape Y"

这是最常见的reshape错误。当元素总数与目标形状不匹配时发生。

import numpy as np
 
arr = np.arange(10)
 
# 这会失败，因为 10 != 3 * 4 = 12
# arr.reshape(3, 4)
# ValueError: cannot reshape array of size 10 into shape (3,4)

解决方法：

检查你的计算。 确保所有目标维度的乘积等于arr.size。

import numpy as np
 
arr = np.arange(10)
print(arr.size)  # 10
 
# 10个元素的有效形状: (2,5), (5,2), (1,10), (10,1), (10,)
print(arr.reshape(2, 5))
# [[0 1 2 3 4]
#  [5 6 7 8 9]]

填充或裁剪数组，如果你确实需要一个不能整除的形状。

import numpy as np
 
arr = np.arange(10)
 
# 填充到12个元素，然后reshape为(3, 4)
padded = np.pad(arr, (0, 2), constant_values=0)
print(padded.reshape(3, 4))
# [[0 1 2 3]
#  [4 5 6 7]
#  [8 9 0 0]]

使用-1让NumPy为你计算一个维度，避免手动计算错误。

import numpy as np
 
arr = np.arange(10)
print(arr.reshape(-1, 2))
# [[0 1]
#  [2 3]
#  [4 5]
#  [6 7]
#  [8 9]]

错误："Expected 2D array, got 1D array instead"

当你传入1D特征数组时，会出现这个scikit-learn错误。修复方法很直接：

import numpy as np
 
features = np.array([1.5, 2.3, 3.1, 4.7, 5.0])
 
# 转换为列向量
features_2d = features.reshape(-1, 1)
print(features_2d.shape)
# (5, 1)

实际示例

为Scikit-Learn准备数据

scikit-learn期望形状为(n_samples, n_features)的特征矩阵。以下是如何正确reshape数据用于简单线性回归：

import numpy as np
 
# 单一特征：房屋面积（平方英尺）
sizes = np.array([850, 1200, 1500, 1800, 2100, 2400, 2800])
 
# 为sklearn reshape为(n_samples, 1)
X = sizes.reshape(-1, 1)
print(X.shape)
# (7, 1)
 
# 目标变量（价格）已经是1D的，sklearn接受这种格式
y = np.array([150000, 220000, 275000, 320000, 380000, 430000, 510000])
 
# 现在X和y已经准备好用于sklearn了
# from sklearn.linear_model import LinearRegression
# model = LinearRegression().fit(X, y)

reshape图像数据

处理图像数据集经常需要在扁平向量和空间维度之间进行reshape：

import numpy as np
 
# 模拟将28x28灰度图像作为扁平数组加载（如MNIST）
flat_image = np.random.randint(0, 256, size=784)
print(flat_image.shape)
# (784,)
 
# reshape为2D图像
image_2d = flat_image.reshape(28, 28)
print(image_2d.shape)
# (28, 28)
 
# 为神经网络输入reshape一批100张图像
batch_flat = np.random.randint(0, 256, size=(100, 784))
batch_images = batch_flat.reshape(100, 28, 28, 1)  # 添加通道维度
print(batch_images.shape)
# (100, 28, 28, 1)

用reshape转置（以及为什么不应该这样做）

一个常见的错误是使用reshape来"转置"矩阵。reshape按内存顺序重新排列元素，这与转置不同。

import numpy as np
 
matrix = np.array([[1, 2, 3],
                   [4, 5, 6]])
 
# 错误：reshape(3, 2)不是转置
wrong = matrix.reshape(3, 2)
print("reshape(3,2):")
print(wrong)
# [[1 2]
#  [3 4]
#  [5 6]]
 
# 正确：使用.T或np.transpose()
correct = matrix.T
print("转置:")
print(correct)
# [[1 4]
#  [2 5]
#  [3 6]]

在RunCell中使用NumPy Reshape

如果你经常reshape数组并希望工作流程更快，RunCell (opens in a new tab)是一个在Jupyter笔记本中运行的AI代理。它专为每天编写NumPy、pandas和scikit-learn代码的数据科学家而构建。

RunCell可以通过多种方式帮助reshape操作：

即时形状调试。 当你遇到形状不匹配错误时，RunCell读取回溯信息并建议正确的reshape调用，包括正确的维度和order参数。
自动生成样板代码。 用自然语言描述你需要的内容——"将这个扁平数组reshape成3通道的32x32图像批次"——RunCell就会编写代码。
探索替代方案。 RunCell可以根据你的具体情况，告诉你应该使用reshape、np.expand_dims、np.newaxis还是np.squeeze。

由于RunCell直接在你的Jupyter环境中运行，你可以完全控制你的数据和代码，同时在需要的地方获得AI辅助建议。

FAQ

numpy reshape(-1)做什么？

调用array.reshape(-1)将数组展平为一维。-1告诉NumPy自动计算元素总数。它等同于array.ravel()或array.flatten()，不过reshape(-1)在可能时返回视图，而flatten()总是返回副本。

numpy reshape会改变原始数组吗？

不会。reshape()返回一个新的数组对象。但是，如果返回的数组是视图（通常如此），修改reshape后的数组也会修改原始数组，因为它们共享相同的内存。要避免这种情况，对结果调用.copy()。

reshape和flatten有什么区别？

reshape()可以将数组转换为任何兼容的形状。flatten()总是转换为1D数组并总是返回副本。ravel()也转换为1D，但在可能时返回视图，类似于reshape(-1)。

我可以用numpy reshape来reshape pandas DataFrame吗？

不能直接reshape。你首先需要使用df.values或df.to_numpy()提取底层的NumPy数组，然后再reshape。对于DataFrame特定的reshape操作，使用pandas方法如pivot()、melt()、stack()或unstack()。

如何reshape数组以添加新轴？

你可以使用reshape()，但np.expand_dims()或np.newaxis在添加单个维度时更简洁：

import numpy as np
 
arr = np.array([1, 2, 3])
 
# 使用reshape
print(arr.reshape(1, 3).shape)   # (1, 3)
print(arr.reshape(3, 1).shape)   # (3, 1)
 
# 使用np.newaxis（更易读）
print(arr[np.newaxis, :].shape)  # (1, 3)
print(arr[:, np.newaxis].shape)  # (3, 1)

总结

numpy.reshape()是NumPy库中最常用的函数之一。它允许你在1D、2D、3D和更高维数组之间进行转换，而无需复制数据（在大多数情况下）。需要记住的关键点：

元素总数在reshape前后必须保持不变。
对一个维度使用-1让NumPy自动计算。
reshape()通常返回视图，而非副本。对视图的更改会影响原始数组。
默认的order='C'逐行填充元素。对于来自MATLAB或Fortran的列优先数据，使用order='F'。
当scikit-learn抱怨1D数组时，.reshape(-1, 1)就是你的解决方案。

掌握这些模式，无论是为机器学习准备表格数据还是为深度学习reshape图像张量，你都能自信地处理形状不匹配问题。

📚

NumPy Reshape: How to Change Array Shapes in Python NumPy vs Pandas: Explain the Difference in Plain English