掌握 NumPy argmax：多维数组与轴(axis)操作技巧
在数据科学和机器学习的领域中，NumPy 扮演着基石般的角色，它以其高效的 N 维数组对象和丰富的数学函数库，极大地简化了数值计算。在这些功能强大的工具中，numpy.argmax 是一个看似简单却极其重要的函数。它能够帮助我们迅速定位数组中最大元素的索引，这在很多场景下都是不可或缺的，例如找出分类模型的预测类别、定位数据中的峰值、或者在图像处理中寻找最亮的像素点。
然而，argmax 的真正威力并非仅仅体现在一维数组上。当面对多维数组时，理解并熟练运用 axis 参数，是掌握 argmax 精髓的关键。本文将深入探讨 numpy.argmax 的各个方面，从基础用法到多维数组的高级技巧，再到实际应用中的考量，力求为您呈现一个全面而深入的视角。
1. numpy.argmax 概述：寻找最大值的“坐标”
numpy.argmax(a, axis=None, out=None, *, keepdims=np._NoValue)
argmax 函数返回沿指定轴 (axis) 的最大值的索引。
a: 输入数组。axis: （可选）整数或None。沿着哪个轴查找最大值。- 如果
axis为None(默认值)，则将数组展平 (flatten) 后，返回展平数组中最大值的索引。 - 如果
axis是一个整数，则沿着该轴进行操作，并返回一个包含最大值索引的新数组。
- 如果
out: （可选）输出数组。如果提供，结果将放入此数组中。必须具有正确的形状和数据类型。keepdims: （可选）布尔值。如果设置为True，则被移除的轴将保留为大小为1的维度。这使得结果数组可以与原始数组进行广播操作。
核心思想： argmax 不返回最大值本身，而是返回最大值所处的“位置”或“坐标”。如果数组中有多个最大值，它总是返回第一个出现的最大值的索引。
2. 基础用法：一维数组的 argmax
让我们从最简单的场景开始——一维数组。这有助于我们建立对 argmax 核心行为的直观理解。
“`python
import numpy as np
示例一：简单一维数组
arr1 = np.array([1, 5, 2, 8, 3, 9, 4])
index1 = np.argmax(arr1)
print(f”原始数组1: {arr1}”)
print(f”最大值的索引1: {index1}”) # 输出: 5 (因为9在索引5)
print(f”最大值: {arr1[index1]}\n”)
示例二：数组中包含多个最大值
arr2 = np.array([10, 20, 5, 20, 15])
index2 = np.argmax(arr2)
print(f”原始数组2: {arr2}”)
print(f”最大值的索引2: {index2}”) # 输出: 1 (第一个20的索引)
print(f”最大值: {arr2[index2]}\n”)
示例三：所有元素都相同
arr3 = np.array([7, 7, 7, 7])
index3 = np.argmax(arr3)
print(f”原始数组3: {arr3}”)
print(f”最大值的索引3: {index3}”) # 输出: 0 (第一个7的索引)
print(f”最大值: {arr3[index3]}\n”)
示例四：空数组 (会引发错误)
try:
arr_empty = np.array([])
np.argmax(arr_empty)
except ValueError as e:
print(f”空数组引发错误: {e}\n”)
“`
从上述例子中，我们可以清楚地看到 argmax 在一维数组上的行为：它扫描整个数组，找到最大值，并返回该最大值在数组中的零基索引。如果存在多个相同最大值，它会返回第一个出现的那个的索引。对于空数组，argmax 会抛出 ValueError，因为没有元素可供比较。
3. 多维数组与 axis=None：展平后的最大值索引
当 argmax 应用于多维数组时，如果 axis 参数保持其默认值 None，那么 NumPy 会在计算前将整个数组“展平”成一个一维数组。然后，它会像处理一维数组一样，返回展平后最大值的索引。
这个索引是一个全局索引，表示该最大值在展平数组中的位置。要将其转换回原始多维数组的坐标，需要进行额外的计算。
“`python
示例：二维数组，axis=None
matrix = np.array([
[10, 20, 30],
[40, 50, 60],
[70, 80, 90]
])
global_index = np.argmax(matrix, axis=None)
print(f”原始矩阵:\n{matrix}\n”)
print(f”展平后最大值的全局索引 (axis=None): {global_index}”) # 输出: 8
验证：矩阵展平后的样子是 [10, 20, 30, 40, 50, 60, 70, 80, 90]
索引8对应的值是90。
print(f”全局最大值: {matrix.flatten()[global_index]}”)
将全局索引转换回二维坐标 (行, 列)
使用 np.unravel_index(index, shape)
coords = np.unravel_index(global_index, matrix.shape)
print(f”全局最大值的二维坐标 (行, 列): {coords}”) # 输出: (2, 2)
print(f”验证：matrix[coords[0], coords[1]] = {matrix[coords[0], coords[1]]}\n”)
示例：三维数组，axis=None
tensor = np.arange(1, 28).reshape(3, 3, 3)
global_index_3d = np.argmax(tensor, axis=None)
print(f”原始三维张量:\n{tensor}\n”)
print(f”展平后最大值的全局索引 (axis=None): {global_index_3d}”) # 输出: 26 (对应值27)
coords_3d = np.unravel_index(global_index_3d, tensor.shape)
print(f”全局最大值的三维坐标: {coords_3d}”) # 输出: (2, 2, 2)
print(f”验证：tensor[coords_3d] = {tensor[coords_3d]}\n”)
“`
当 axis=None 时，argmax 实际上是查找整个数组中的最大元素，并返回它在展平序列中的索引。np.unravel_index 是一个非常有用的辅助函数，可以将这种一维索引转换回多维数组的元组坐标。
4. axis 参数的魔力：多维数组的维度操作
理解 axis 参数是掌握 NumPy 多维数组操作的关键，对于 argmax 来说更是如此。axis 参数指定了我们希望沿着哪个维度进行操作。你可以把 axis 想象成“你希望哪个维度被‘压缩’掉”或者“你希望在哪个维度上进行比较”。
假设我们有一个 N 维数组。当 argmax 沿着 axis=k 操作时，它会沿着第 k 个维度进行最大值索引的查找。结果数组的维度将比原始数组减少一个，因为 axis=k 被“塌缩”了。
我们通过一个二维矩阵来深入理解 axis。一个二维数组 arr 的形状通常表示为 (rows, columns)。
axis=0: 代表沿着行方向（垂直方向，即列）进行操作。它会比较每一列中的元素，并返回每一列最大值的索引。结果数组的形状将是(columns,)。axis=1: 代表沿着列方向（水平方向，即行）进行操作。它会比较每一行中的元素，并返回每一行最大值的索引。结果数组的形状将是(rows,)。
4.1 二维数组 (matrix) 的 axis 操作
“`python
matrix = np.array([
[10, 20, 30],
[40, 50, 60],
[70, 8, 9]
])
print(f”原始矩阵:\n{matrix}\n”)
沿着 axis=0 操作
想象成有3列：
列0: [10, 40, 70] -> 最大值70的索引是2
列1: [20, 50, 8] -> 最大值50的索引是1
列2: [30, 60, 9] -> 最大值60的索引是1
argmax_axis0 = np.argmax(matrix, axis=0)
print(f”沿着 axis=0 (列方向) 查找最大值索引: {argmax_axis0}”) # 输出: [2 1 1]
print(f”结果形状: {argmax_axis0.shape}\n”) # 输出: (3,)
沿着 axis=1 操作
想象成有3行：
行0: [10, 20, 30] -> 最大值30的索引是2
行1: [40, 50, 60] -> 最大值60的索引是2
行2: [70, 8, 9] -> 最大值70的索引是0
argmax_axis1 = np.argmax(matrix, axis=1)
print(f”沿着 axis=1 (行方向) 查找最大值索引: {argmax_axis1}”) # 输出: [2 2 0]
print(f”结果形状: {argmax_axis1.shape}\n”) # 输出: (3,)
“`
理解 axis 的秘诀：
当 axis=k 时，可以这样理解：
1. “固定”除 k 之外的所有轴的索引。 想象你正在“切片”数组，切片后的每一个子数组都是一维的。
2. 在被固定的子数组（沿着 axis=k 的一维序列）中寻找最大值的索引。
3. 结果数组的形状将是原始数组的形状，但 axis=k 的维度会被移除。
例如，对于形状为 (R, C) 的矩阵：
* axis=0：我们固定 C (列索引)，遍历 R (行索引)。对于每一列 c，我们得到一个一维数组 matrix[:, c]。argmax 在这个一维数组中找到最大值的索引。最终结果的形状是 (C,)。
* axis=1：我们固定 R (行索引)，遍历 C (列索引)。对于每一行 r，我们得到一个一维数组 matrix[r, :]。argmax 在这个一维数组中找到最大值的索引。最终结果的形状是 (R,)。
4.2 三维数组 (tensor) 的 axis 操作
三维数组可以想象成多层二维数组堆叠在一起，或者一个立方体。其形状通常表示为 (depth, rows, columns) 或 (batch, height, width)。
“`python
创建一个3x3x3的三维张量
tensor = np.arange(1, 28).reshape(3, 3, 3)
print(f”原始三维张量 (形状: {tensor.shape}):\n{tensor}\n”)
沿着 axis=0 操作 (深度/Z轴)
相当于在每个 (行, 列) 位置上，沿着深度方向向下看，找到最大值的索引
想象成 3×3 的平面上，每个位置有一个垂直堆叠的3个元素。
例如，tensor[:, 0, 0] 是 [1, 10, 19]。argmax(.) 结果是 2
tensor[:, 1, 2] 是 [6, 15, 24]。argmax(.) 结果是 2
argmax_axis0 = np.argmax(tensor, axis=0)
print(f”沿着 axis=0 (深度方向) 查找最大值索引:\n{argmax_axis0}”)
print(f”结果形状: {argmax_axis0.shape}\n”) # 输出: (3, 3)
沿着 axis=1 操作 (行/Y轴)
相当于在每个 (深度, 列) 位置上，沿着行方向横向看，找到最大值的索引
想象成 3个 3×3 的切片，每个切片内，沿着行找最大值索引
例如，tensor[0, :, 0] 是 [1, 4, 7]。argmax(.) 结果是 2
tensor[1, :, 2] 是 [15, 18, 21]。argmax(.) 结果是 2
argmax_axis1 = np.argmax(tensor, axis=1)
print(f”沿着 axis=1 (行方向) 查找最大值索引:\n{argmax_axis1}”)
print(f”结果形状: {argmax_axis1.shape}\n”) # 输出: (3, 3)
沿着 axis=2 操作 (列/X轴)
相当于在每个 (深度, 行) 位置上，沿着列方向横向看，找到最大值的索引
例如，tensor[0, 0, :] 是 [1, 2, 3]。argmax(.) 结果是 2
tensor[2, 1, :] 是 [22, 23, 24]。argmax(.) 结果是 2
argmax_axis2 = np.argmax(tensor, axis=2)
print(f”沿着 axis=2 (列方向) 查找最大值索引:\n{argmax_axis2}”)
print(f”结果形状: {argmax_axis2.shape}\n”) # 输出: (3, 3)
“`
通过上述三维数组的例子，我们可以更清晰地看到 axis 参数如何“塌缩”一个维度。无论沿着哪个轴操作，结果数组的维度都会比原始数组少一个，而这个被移除的维度就是我们指定的操作轴。
4.3 负数 axis：从后向前计数
NumPy 也支持负数作为 axis 值。负数轴从最后一个维度开始倒数：
* axis=-1 指的是最后一个维度。
* axis=-2 指的是倒数第二个维度，以此类推。
这在处理不确定维度的数组时非常有用，比如总是想在“最内层”或“最外层”维度上操作。
“`python
matrix = np.array([
[10, 20, 30],
[40, 50, 60],
[70, 8, 9]
])
print(f”原始矩阵 (形状: {matrix.shape}):\n{matrix}\n”)
matrix.shape 是 (2, 3)
axis=-1 等同于 axis=1 (最后一个维度)
argmax_neg1 = np.argmax(matrix, axis=-1)
print(f”沿着 axis=-1 查找最大值索引 (等同于 axis=1): {argmax_neg1}”) # 输出: [2 2 0]
axis=-2 等同于 axis=0 (倒数第二个维度)
argmax_neg2 = np.argmax(matrix, axis=-2)
print(f”沿着 axis=-2 查找最大值索引 (等同于 axis=0): {argmax_neg2}\n”) # 输出: [2 1 1]
tensor = np.arange(1, 28).reshape(3, 3, 3)
print(f”原始三维张量 (形状: {tensor.shape}):\n{tensor}\n”)
tensor.shape 是 (3, 3, 3)
axis=-1 等同于 axis=2 (最后一个维度)
argmax_tensor_neg1 = np.argmax(tensor, axis=-1)
print(f”沿着 axis=-1 (等同于 axis=2) 查找最大值索引:\n{argmax_tensor_neg1}”)
axis=-2 等同于 axis=1 (倒数第二个维度)
argmax_tensor_neg2 = np.argmax(tensor, axis=-2)
print(f”沿着 axis=-2 (等同于 axis=1) 查找最大值索引:\n{argmax_tensor_neg2}”)
axis=-3 等同于 axis=0 (倒数第三个维度)
argmax_tensor_neg3 = np.argmax(tensor, axis=-3)
print(f”沿着 axis=-3 (等同于 axis=0) 查找最大值索引:\n{argmax_tensor_neg3}”)
“`
负数轴的引入使得代码在某些情况下更具可读性和通用性，尤其是在处理可变维度数组时。
5. keepdims 参数：保持维度的一致性
keepdims 是 argmax 的一个非常有用的参数，它能够让 argmax 的结果数组保持与原始数组相同的维度数量，尽管被操作的轴会变为长度为 1 的维度。这在需要将 argmax 的结果与其他数组进行广播操作时特别方便。
当 keepdims=True 时，被 axis 参数指定为操作维度的维度，会以长度为 1 的形式保留在结果数组的形状中。
“`python
matrix = np.array([
[10, 20, 30],
[40, 50, 60],
[70, 8, 9]
])
print(f”原始矩阵 (形状: {matrix.shape}):\n{matrix}\n”)
不使用 keepdims (默认值)
argmax_axis0_default = np.argmax(matrix, axis=0)
print(f”argmax(axis=0) 结果: {argmax_axis0_default}”)
print(f”结果形状 (默认): {argmax_axis0_default.shape}\n”) # (3,)
使用 keepdims=True
argmax_axis0_keepdims = np.argmax(matrix, axis=0, keepdims=True)
print(f”argmax(axis=0, keepdims=True) 结果:\n{argmax_axis0_keepdims}”)
print(f”结果形状 (keepdims=True): {argmax_axis0_keepdims.shape}\n”) # (1, 3)
对比：默认情况下，结果形状是 (3,)
keepdims=True，结果形状是 (1, 3)
维度数量相同，但 axis=0 的维度被压缩成1
argmax_axis1_default = np.argmax(matrix, axis=1)
print(f”argmax(axis=1) 结果: {argmax_axis1_default}”)
print(f”结果形状 (默认): {argmax_axis1_default.shape}\n”) # (3,)
argmax_axis1_keepdims = np.argmax(matrix, axis=1, keepdims=True)
print(f”argmax(axis=1, keepdims=True) 结果:\n{argmax_axis1_keepdims}”)
print(f”结果形状 (keepdims=True): {argmax_axis1_keepdims.shape}\n”) # (3, 1)
广播示例：查找每列的最大值，并创建一个布尔矩阵，指示哪些元素是最大值
方法一：不使用 keepdims，需要 reshape 才能广播
max_indices_0 = np.argmax(matrix, axis=0) # shape (3,)
is_max_0 = (np.arange(matrix.shape[0]) == max_indices_0) # 广播失败，因为 np.arange(3) 是 (3,)，max_indices_0 也是 (3,)，需要 (3, 1) vs (1, 3)
print(f”不使用 keepdims 广播的常见误区:\n{np.arange(matrix.shape[0]) == max_indices_0}\n”)
正确的广播方式 (需要手动 reshape)
is_max_0_correct = (np.arange(matrix.shape[0])[:, np.newaxis] == max_indices_0[np.newaxis, :])
print(f”不使用 keepdims 但手动 reshape 后的广播结果:\n{is_max_0_correct}\n”)
方法二：使用 keepdims，直接进行广播
max_indices_0_keepdims = np.argmax(matrix, axis=0, keepdims=True) # shape (1, 3)
现在 max_indices_0_keepdims 形状是 (1, 3)，可以与 (3, 3) 的矩阵进行广播
np.arange(matrix.shape[0])[:, np.newaxis] 形状是 (3, 1)
is_max_0_broadcast = (np.arange(matrix.shape[0])[:, np.newaxis] == max_indices_0_keepdims)
print(f”使用 keepdims=True 后直接广播的结果:\n{is_max_0_broadcast}\n”)
“`
keepdims=True 的主要优势在于它能够保持维度的一致性，使得结果可以与其他相同维度的数组进行自然的广播操作，从而避免了手动 reshape 或 np.newaxis 的需要，让代码更简洁、更不易出错。
6. 实际应用场景
argmax 在许多实际场景中都扮演着关键角色：
6.1 机器学习中的分类预测
在深度学习和机器学习的分类任务中，模型的输出通常是一个概率分布向量（例如，经过 Softmax 激活函数处理后），每个元素代表样本属于某个类别的概率。argmax 可以直接找出概率最高的那个类别的索引，即预测的类别。
“`python
假设这是一个包含3个样本，每个样本有4个类别的预测概率
predictions = np.array([
[0.1, 0.8, 0.05, 0.05], # 样本0: 预测类别1
[0.7, 0.1, 0.15, 0.05], # 样本1: 预测类别0
[0.05, 0.05, 0.8, 0.1] # 样本2: 预测类别2
])
沿着 axis=1 (即每个样本的类别维度) 查找最大概率的索引
predicted_classes = np.argmax(predictions, axis=1)
print(f”预测概率:\n{predictions}\n”)
print(f”预测类别索引: {predicted_classes}”) # 输出: [1 0 2]
如果有类别标签 (例如：0: 狗, 1: 猫, 2: 鸟, 3: 鱼)
class_labels = [“狗”, “猫”, “鸟”, “鱼”]
for i, pred_class_idx in enumerate(predicted_classes):
print(f”样本 {i} 预测为: {class_labels[pred_class_idx]}”)
“`
6.2 数据分析：查找峰值位置
在时间序列数据、光谱数据或其他连续数据中，我们可能需要找出数据中的峰值点（最大值）发生在哪一个时间点或频率点。
“`python
模拟时间序列数据 (例如，传感器读数)
time_series_data = np.array([
[10, 12, 15, 13, 11], # 传感器A
[5, 8, 9, 10, 7], # 传感器B
[20, 25, 22, 28, 26] # 传感器C
])
print(f”传感器读数:\n{time_series_data}\n”)
假设每列代表一个时间点，我们需要知道每个传感器在哪个时间点达到最大值
沿着 axis=1 (时间点维度) 查找最大值索引
peak_times_idx = np.argmax(time_series_data, axis=1)
print(f”每个传感器达到峰值的索引 (时间点): {peak_times_idx}”) # 输出: [2 3 3]
传感器A在索引2 (第三个时间点)达到峰值15
传感器B在索引3 (第四个时间点)达到峰值10
传感器C在索引3 (第四个时间点)达到峰值28
“`
6.3 图像处理：定位最亮像素
对于灰度图像（二维数组）或多通道图像（三维数组），argmax 可以用来定位最亮（最大像素值）的像素点。
“`python
模拟一个灰度图像 (8×8像素)
gray_image = np.random.randint(0, 256, size=(8, 8))
gray_image[3, 5] = 255 # 设置一个特定的最大值
print(f”模拟灰度图像 (部分):\n{gray_image[2:5, 4:7]}\n”)
查找全局最亮像素的索引 (axis=None)
brightest_pixel_idx = np.argmax(gray_image, axis=None)
brightest_pixel_coords = np.unravel_index(brightest_pixel_idx, gray_image.shape)
print(f”全局最亮像素坐标: {brightest_pixel_coords}”) # 输出: (3, 5)
对于RGB图像 (例如，形状为 (H, W, C))
rgb_image = np.random.randint(0, 256, size=(10, 10, 3))
假设我们想知道每个像素点哪个颜色通道最亮 (例如，蓝色、绿色还是红色最强)
沿着 axis=2 (颜色通道维度) 查找最大值索引
brightest_channel_per_pixel = np.argmax(rgb_image, axis=2)
print(f”每个像素点最亮通道的索引 (部分结果):\n{brightest_channel_per_pixel[0:2, 0:2]}\n”) # 结果是 HxW 的矩阵，每个元素是 0, 1 或 2
“`
6.4 游戏开发/AI：寻找最佳行动
在棋盘游戏或策略游戏中，AI 可能会评估每个可能的行动，得到一个分数数组。argmax 可以用来选择分数最高的行动。
“`python
假设AI评估了5个可能的行动，每个行动有一个得分
action_scores = np.array([0.7, 0.2, 0.9, 0.4, 0.6])
best_action_index = np.argmax(action_scores)
print(f”行动得分: {action_scores}”)
print(f”最佳行动的索引: {best_action_index}”) # 输出: 2
“`
7. 性能考量
NumPy 的 argmax 函数是高度优化的，通常由底层的 C 代码实现。这意味着它在处理大型数组时非常高效。相比于使用 Python 循环遍历数组来查找最大值的索引，numpy.argmax 可以提供几个数量级的性能提升。
- 向量化操作：
argmax是一个向量化操作的典型例子。它一次性处理整个数组（或沿一个轴），而不是通过显式的 Python 循环逐个元素地处理。 - 内存访问： NumPy 数组在内存中是连续存储的，这使得
argmax能够高效地访问数据，利用 CPU 缓存，进一步提高性能。
在大多数情况下，无需担心 argmax 的性能问题。它已经是你能找到的最快方法之一。
8. 常见陷阱与最佳实践
-
处理
NaN值：argmax默认会忽略NaN值。如果数组中存在NaN且所有非NaN值都小于某个最大值（或者只有一个NaN），其行为可能不如预期。
“`python
arr_nan = np.array([1, 5, np.nan, 8, 3])
print(f”包含 NaN 的数组: {arr_nan}”)
print(f”argmax 结果: {np.argmax(arr_nan)}”) # 输出: 3 (8的索引，NaN被忽略)arr_all_nan = np.array([np.nan, np.nan])
try:
np.argmax(arr_all_nan)
except ValueError as e:
print(f”全 NaN 数组引发错误: {e}”) # 输出: ValueError: all-NaN slice encountered
如果需要不同的 `NaN` 处理行为，可以先使用 `np.nanargmax`（它会忽略 `NaN` 并返回非 `NaN` 最大值的索引）或手动过滤掉 `NaN` 值。python
* **多个最大值：** 如前所述，`argmax` 总是返回第一个出现的最大值的索引。如果你需要获取所有最大值的索引，`argmax` 就不够用了。你需要结合 `np.where` 和 `np.max`：
arr_ties = np.array([10, 20, 5, 20, 15])
max_val = np.max(arr_ties)
all_max_indices = np.where(arr_ties == max_val)
print(f”包含并列最大值的数组: {arr_ties}”)
print(f”所有最大值的索引: {all_max_indices}”) # 输出: (array([1, 3]),)
``argmax
* **空数组：**会对空数组抛出ValueError。在处理可能为空的输入时，应进行检查或使用try-except块。argmax
* **浮点数精度：** 比较浮点数时，应注意浮点数的精度问题。极小的差异可能导致返回意料之外的结果。通常这不是一个大问题，但在特定数值敏感的场景下值得注意。axis
* **维度理解：** 最常见的错误就是对参数的误解。始终牢记axis=k意味着沿着第k个维度进行操作，并且这个维度将在结果中被“塌缩”或“移除”（除非keepdims=True`）。
9. 与相关函数的比较
NumPy 提供了许多与 argmax 功能相似或互补的函数。了解它们之间的区别可以帮助你选择最适合当前任务的工具。
numpy.argmin: 与argmax完全对称，返回沿指定轴的最小值的索引。
python
arr = np.array([1, 5, 2, 8, 3])
print(f"argmin: {np.argmin(arr)}") # 输出: 0 (1的索引)numpy.max/numpy.min: 返回沿指定轴的最大值或最小值本身，而不是它们的索引。
python
matrix = np.array([[1, 2, 3], [4, 5, 6]])
print(f"max(axis=0): {np.max(matrix, axis=0)}") # 输出: [4 5 6]
print(f"argmax(axis=0): {np.argmax(matrix, axis=0)}") # 输出: [1 1 1]numpy.where: 根据条件返回满足条件的元素的索引。可以用于查找所有最大值的索引。
python
arr = np.array([10, 20, 5, 20, 15])
max_val = np.max(arr)
indices = np.where(arr == max_val)
print(f"where: {indices}") # 输出: (array([1, 3]),)numpy.argsort: 返回沿指定轴的元素从小到大排序后的索引。你可以通过argsort的结果来找到最大值的索引，但效率不如argmax。
python
arr = np.array([1, 5, 2, 8, 3])
sorted_indices = np.argsort(arr)
print(f"argsort: {sorted_indices}") # 输出: [0 2 4 1 3] (表示 1在索引0，2在索引2，3在索引4，5在索引1，8在索引3)
print(f"最大值索引 (通过 argsort): {sorted_indices[-1]}") # 输出: 3 (不是8的索引，是8的索引是3，这个表示的是8在排序后的位置)
# 正确做法是取最后一个元素的索引
print(f"最大值索引 (通过 argsort 得到): {np.argsort(arr)[-1]}") # 3, 确实是最大值8的索引
虽然argsort也能得到最大值的索引，但它做了更多不必要的工作（对整个数组进行排序），因此在只查找最大值索引时，argmax是更优的选择。
10. 结论
numpy.argmax 是一个看似简单但功能强大的 NumPy 函数，是进行数据分析、机器学习和科学计算不可或缺的工具。掌握其在多维数组上的 axis 操作技巧，是提升 NumPy 编程效率和数据处理能力的必由之路。
通过本文的详细讲解和丰富示例，我们深入探讨了 argmax 的基础用法、多维数组中的 axis=None 和不同轴的操作、负数轴的便利性、keepdims 参数在广播中的作用，以及它在实际应用中的广泛场景。同时，我们也讨论了性能考量、常见陷阱和与相关函数的比较，旨在为您提供一个全面且实用的 argmax 使用指南。
熟练运用 argmax 不仅仅是记住其语法，更重要的是建立起对多维数组维度操作的直观理解。一旦你掌握了“沿着哪个方向进行比较”和“哪个维度被塌缩”的思维模式，你将能够更自信、更高效地处理复杂的数值数据。将这些技巧融入您的日常编程实践中，无疑会极大地增强您使用 NumPy 解决实际问题的能力。