程序员经验分享-hwhale

np.max()、np.argmax()、np.maximum()、np.min()、np.argmin()、np.minimum()、np.sum()

2023-05-16

numpy专题——最值、求和

  • 最大值
    • np.max()
    • np.argmax()
    • np.maximum()
  • 求和
    • np.sum

网上已经有很多对于这几个函数的讲解资料，但总感觉讲得有些乱，特别是对于高维数组，如果指定了某个轴，就会变得很复杂。这篇文章根据”拆分“原理，对numpy数据的这几个函数进行简单而又详细地讲解。

拆分原理：指定哪个轴，就对哪个轴进行拆分，以得到多个数组，然后对这些数组进行对应元素操作。即
假设三维numpy数组array1的shape为(c, m, n)，其中axis=0对应“c”，axis=1对应“m”，axis=2对应“n”。
若指定轴0（axis = 0），则对轴0进行拆分，得到c个shape为(m, n)的ndarray：array1[0, :, :]、array1[1, :, :]、… 、array1[c-1, :, :]，然后对array1[0, :, :]、array1[1, :, :]、… 、array1[c-1, :, :]进行对应元素操作，得到输出结果，其shape为(m, n)。其他轴类似。

如果您还没明白，请继续往下看。

最大值

np.max()、np.argmax()、np.maximum()和np.min()、np.argmin()、np.minimum()一一对应，前一组与”最大“有关，后一组与”最小“有关，所以这里只讲”最大“

np.max()

函数形式

np.max(array, axis=None, out=None, keepdims=False)

ndarray的形状是从左往右的，即由外往里计算，这和list是一样。
keepdims默认为False，如果keepdims=True，则输出的ndarray与原nadarray具有相同的形状。

  • 一维ndarray
import numpy as np

array1 = np.array([1, 3, 2, 8, 5])
print(array1)
print(np.max(array1))  # 返回array1的最大值
print(np.max(array1, axis=0))  # 指定0轴（即array1本身，输出结果一样）

输出结果：

[1 3 2 8 5]
8
8
  • 二维ndarray
    假设二维numpy数组array1的shape为(3, 4)，其中axis=0对应“3”，axis=1对应“4”
    （1）指定轴0：axis=0
    np.max(array1, axis=0)的意思就是：按第一个维度（即，行）对array1进行拆分，得到array1[0, :]、array1[1, :]、array1[2, :]，然后对array1[0, :]、array1[1, :]、array1[2, :]的对应元素进行逐位比较，并取其最大者，构成新的ndarray。
array1 = np.reshape(list(range(12)), (3, 4))
print('array1 =', array1)
print('array1[0, :] =', array1[0, :])
print('array1[1, :] =', array1[1, :])
print('array1[2, :] =', array1[2, :])
print('np.max(array1, axis=0)=', np.max(array1, axis=0))

输出结果：

array1= [[0  1  2  3]
         [4  5  6  7]
         [8  9 10 11]]
array1[0, :] = [0 1 2 3]
array1[1, :] = [4 5 6 7]
array1[2, :] = [8 9 10 11]
np.max(array1, axis=0) = [8 9 10 11]

（2）指定轴1：axis=1
np.max(array1, axis=1)的意思就是：按第二个维度（即，列）对array1进行拆分，得到array1[:, 0]、array1[:, 1]、array1[:, 2]、array1[:, 3]，然后对array1[:, 0]、array1[:, 1]、array1[:, 2]、array1[:, 3]的对应元素进行逐位比较，并取其最大者，构成新的ndarray。

import numpy as np

array1 = np.reshape(list(range(12)), (3, 4))
print('array1 =', array1)
print('array1[:, 0] =', array1[:, 0])
print('array1[:, 1] =', array1[:, 1])
print('array1[:, 2] =', array1[:, 2])
print('array1[:, 3] =', array1[:, 3])
print('np.max(array1, axis=1) =', np.max(array1, axis=1))

输出结果：

array1 = [[0  1  2  3]
          [4  5  6  7]
          [8  9 10 11]]
array1[:, 0] = [0 4 8]
array1[:, 1] = [1 5 9]
array1[:, 2] = [2 6 10]
array1[:, 3] = [3 7 11]
np.max(array1, axis=1) = [3 7 11]
  • 三维ndarray
    假设三维numpy数组array1的shape为(2, 3, 4)，其中axis=0对应“2”，axis=1对应“3”，axis=2对应“4”。
    （1）指定轴0：axis=0
    np.max(array1, axis=0)的意思就是：按第一个维度对array1进行拆分，得到array1[0, :, :]、array1[1, :, :]，然后对array1[0, :, :]、array1[1, :, :]的对应元素进行逐位比较，并取其最大者，构成新的ndarray。
import numpy as np

array1 = np.reshape(list(range(24)), (2, 3, 4))
print('array1 =', array1)
print('array1[0, :, :] =', array1[0, :, :])
print('array1[1, :, :] =', array1[1, :, :])
print('np.max(array1, axis=0) =', np.max(array1, axis=0))

输出结果：

array1 = [[[0  1  2  3]
           [4  5  6  7]
           [8  9 10 11]]

          [[12 13 14 15]
           [16 17 18 19]
           [20 21 22 23]]]
array1[0, :, :] = [[0  1  2  3]
                   [4  5  6  7]
                   [8  9 10 11]]
array1[1, :, :] = [[12 13 14 15]
                   [16 17 18 19]
                   [20 21 22 23]]
np.max(array1, axis=0) = [[12 13 14 15]
                          [16 17 18 19]
                          [20 21 22 23]]

（2）指定轴1：axis=1
np.max(array1, axis=1)的意思就是：按第二个维度对array1进行拆分，得到array1[:, 0, :]、array1[:, 1, :]、array1[:, 2, :]，然后对array1[:, 0, :]、array1[:, 1, :]、array1[:, 2, :]的对应元素进行逐位比较，并取其最大者，构成新的ndarray。

import numpy as np

array1 = np.reshape(list(range(24)), (2, 3, 4))
print('array1 =', array1)
print('array1[:, 0, :] =', array1[:, 0, :])
print('array1[:, 1, :] =', array1[:, 1, :])
print('array1[:, 2, :] =', array1[:, 2, :])
print('np.max(array1, axis=1) =', np.max(array1, axis=1))

输出结果：

array1 = [[[0  1  2  3]
           [4  5  6  7]
           [8  9 10 11]]

          [[12 13 14 15]
           [16 17 18 19]
           [20 21 22 23]]]
array1[:, 0, :] = [[ 0  1  2  3]
                   [12 13 14 15]]
array1[:, 1, :] = [[ 4  5  6  7]
                   [16 17 18 19]]
array1[:, 2, :] = [[ 8  9 10 11]
                   [20 21 22 23]]
np.max(array1, axis=1) = [[ 8  9 10 11]
                          [20 21 22 23]]

（3）指定轴2：axis=2
np.max(array1, axis=2)的意思就是：按第三个维度对array1进行拆分，得到array1[:, :, 0]、array1[:, :, 1]、array1[:, :, 2]、array1[:, :, 3]，然后对array1[:, :, 0]、array1[:, :, 1]、array1[:, :, 2]、array1[:, :, 3]的对应元素进行逐位比较，并取其最大者，构成新的ndarray。

import numpy as np

array1 = np.reshape(list(range(24)), (2, 3, 4))
print('array1 =', array1)
print('array1[:, :, 0] =', array1[:, :, 0])
print('array1[:, :, 1] =', array1[:, :, 1])
print('array1[:, :, 2] =', array1[:, :, 2])
print('array1[:, :, 3] =', array1[:, :, 3])
print('np.max(array1, axis=2) =', np.max(array1, axis=2))

输出结果：

array1 = [[[0  1  2  3]
 		   [4  5  6  7]
		   [8  9 10 11]]

 		  [[12 13 14 15]
           [16 17 18 19]
           [20 21 22 23]]]
array1[:, :, 0] = [[ 0  4  8]
                   [12 16 20]]
array1[:, :, 1] = [[ 1  5  9]
                   [13 17 21]]
array1[:, :, 2] = [[ 2  6 10]
                   [14 18 22]]
array1[:, :, 3] = [[ 3  7 11]
                   [15 19 23]]
np.max(array1, axis=2) = [[ 3  7 11]
                          [15 19 23]]

np.argmax()

np.argmax()与np.max()类似：np.max()返回指定轴的最大值，而np.argmax()返回指定轴的最大值对应的索引，指定哪个轴，就按哪个轴进行拆分。

  • 一维ndarray
import numpy as np

array1 = np.array([1, 3, 2, 8, 5])
print(array1)
print(np.argmax(array1))  # 返回array1的最大值对应的索引
print(np.argmax(array1, axis=0))  # 指定0轴（即array1本身，输出结果一样）

输出结果：

[1 3 2 8 5]
3
3
  • 二维ndarray
    假设二维numpy数组array1的shape为(3, 4)，其中axis=0对应“3”，axis=1对应“4”
    （1）指定轴0：axis=0
    np.argmax(array1, axis=0)的意思就是：按第一个维度（即，行）对array1进行拆分，得到array1[0, :]、array1[1, :]、array1[2, :]，然后对array1[0, :]、array1[1, :]、array1[2, :]的对应元素进行逐位比较，并取其最大者所在的数组的索引（即，若某一对应元素的最大值在array1[0, :]，则返回索引0,；若某一对应元素的最大值在array1[1, :]，则返回索引1；依此类推），构成新的ndarray。
import numpy as np

array1 = np.reshape(list(range(12)), (3, 4))
print('array1 =', array1)
print('array1[0, :] =', array1[0, :])
print('array1[1, :] =', array1[1, :])
print('array1[2, :] =', array1[2, :])
print('np.max(array1, axis=0)=', np.max(array1, axis=0))

输出结果：

array1= [[0  1  2  3]
         [4  5  6  7]
         [8  9 10 11]]
array1[0, :] = [0 1 2 3]
array1[1, :] = [4 5 6 7]
array1[2, :] = [8 9 10 11]
np.argmax(array1, axis=0)= [2 2 2 2]

（2）指定轴1：axis=1
np.arg(array1, axis=1)的意思就是：按第二个维度（即，列）对array1进行拆分，得到array1[:, 0]、array1[:, 1]、array1[:, 2]、array1[:, 3]，然后对array1[:, 0]、array1[:, 1]、array1[:, 2]、array1[:, 3]的对应元素进行逐位比较，并取其最大者所在的数组的索引（即，若某一对应元素的最大值在array1[:, 0]，则返回索引0,；若某一对应元素的最大值在array1[:, 1]，则返回索引1；依此类推），构成新的ndarray。

import numpy as np

array1 = np.reshape(list(range(12)), (3, 4))
print('array1 =', array1)
print('array1[:, 0] =', array1[:, 0])
print('array1[:, 1] =', array1[:, 1])
print('array1[:, 2] =', array1[:, 2])
print('array1[:, 3] =', array1[:, 3])
print('np.argmax(array1, axis=1) =', np.argmax(array1, axis=1))

输出结果：

array1 = [[0  1  2  3]
          [4  5  6  7]
          [8  9 10 11]]
array1[:, 0] = [0 4 8]
array1[:, 1] = [1 5 9]
array1[:, 2] = [2 6 10]
array1[:, 3] = [3 7 11]
np.argmax(array1, axis=1) = [3 3 3]

（3）没有指定任何轴

import numpy as np

array1 = np.reshape(list(range(12)), (3, 4))
array1[2, 3] = 1
print('array1 =', array1)
print('np.argmax(array1) =', np.argmax(array1))

输出结果：

array1 = [[ 0  1  2  3]
          [ 4  5  6  7]
          [ 8  9 10  1]]
np.argmax(array1) = 10

由于Numpy是按维度大小的顺序由最底层开始存储的，所以 m × n m \times n m×n 的ndarray最大值的索引是：(np.argmax(array1) // n, np.argmax(array1) % n)。

  • 三维ndarray
    假设三维numpy数组array1的shape为(2, 3, 4)，其中axis=0对应“2”，axis=1对应“3”，axis=2对应“4”。
    （1）指定轴0：axis=0
    np.argmax(array1, axis=0)的意思就是：按第一个维度对array1进行拆分，得到array1[0, :, :]、array1[1, :, :]，然后对array1[0, :, :]、array1[1, :, :]的对应元素进行逐位比较，并取其最大者所在的数组的索引（即，若某一对应元素的最大值在array1[0, :, :]，则返回索引0,；若某一对应元素的最大值在[1, :, :]，则返回索引1；依此类推），构成新的ndarray。
import numpy as np

array1 = np.reshape(list(range(24)), (2, 3, 4))
print('array1 =', array1)
print('array1[0, :, :] =', array1[0, :, :])
print('array1[1, :, :] =', array1[1, :, :])
print('np.argmax(array1, axis=0) =', np.argmax(array1, axis=0))

输出结果：

array1 = [[[0  1  2  3]
           [4  5  6  7]
           [8  9 10 11]]

          [[12 13 14 15]
           [16 17 18 19]
           [20 21 22 23]]]
array1[0, :, :] = [[0  1  2  3]
                   [4  5  6  7]
                   [8  9 10 11]]
array1[1, :, :] = [[12 13 14 15]
                   [16 17 18 19]
                   [20 21 22 23]]
np.argmax(array1, axis=0) = [[1 1 1 1]
 							 [1 1 1 1]
 							 [1 1 1 1]]

（2）指定轴1：axis=1
np.argmax(array1, axis=1)的意思就是：按第二个维度对array1进行拆分，得到array1[:, 0, :]、array1[:, 1, :]、array1[:, 2, :]，然后对array1[:, 0, :]、array1[:, 1, :]、array1[:, 2, :]的对应元素进行逐位比较，并取其最大者所在的数组的索引（即，若某一对应元素的最大值在array1array1[:, 0, :]，则返回索引0,；若某一对应元素的最大值在[:, 1, :]，则返回索引1；依此类推），构成新的ndarray。

import numpy as np

array1 = np.reshape(list(range(24)), (2, 3, 4))
print('array1 =', array1)
print('array1[:, 0, :] =', array1[:, 0, :])
print('array1[:, 1, :] =', array1[:, 1, :])
print('array1[:, 2, :] =', array1[:, 2, :])
print('np.argmax(array1, axis=1) =', np.argmax(array1, axis=1))

输出结果：

array1 = [[[0  1  2  3]
           [4  5  6  7]
           [8  9 10 11]]

          [[12 13 14 15]
           [16 17 18 19]
           [20 21 22 23]]]
array1[:, 0, :] = [[ 0  1  2  3]
                   [12 13 14 15]]
array1[:, 1, :] = [[ 4  5  6  7]
                   [16 17 18 19]]
array1[:, 2, :] = [[ 8  9 10 11]
                   [20 21 22 23]]
np.argmax(array1, axis=1) = [[2 2 2 2]
           					 [2 2 2 2]]

（3）指定轴2：axis=2
np.argmax(array1, axis=2)的意思就是：按第三个维度对array1进行拆分，得到array1[:, :, 0]、array1[:, :, 1]、array1[:, :, 2]、array1[:, :, 3]，然后对array1[:, :, 0]、array1[:, :, 1]、array1[:, :, 2]、array1[:, :, 3]的对应元素进行逐位比较，并取其最大者所在的数组的索引（即，若某一对应元素的最大值在array1array1[:, :, 0]，则返回索引0,；若某一对应元素的最大值在[:, :, 1]，则返回索引1；依此类推），构成新的ndarray。

import numpy as np

array1 = np.reshape(list(range(24)), (2, 3, 4))
print('array1 =', array1)
print('array1[:, :, 0] =', array1[:, :, 0])
print('array1[:, :, 1] =', array1[:, :, 1])
print('array1[:, :, 2] =', array1[:, :, 2])
print('array1[:, :, 3] =', array1[:, :, 3])
print('np.argmax(array1, axis=2) =', np.argmax(array1, axis=2))

输出结果：

array1 = [[[0  1  2  3]
 		   [4  5  6  7]
		   [8  9 10 11]]

 		  [[12 13 14 15]
           [16 17 18 19]
           [20 21 22 23]]]
array1[:, :, 0] = [[ 0  4  8]
                   [12 16 20]]
array1[:, :, 1] = [[ 1  5  9]
                   [13 17 21]]
array1[:, :, 2] = [[ 2  6 10]
                   [14 18 22]]
array1[:, :, 3] = [[ 3  7 11]
                   [15 19 23]]
np.argmax(array1, axis=2) = [[3 3 3]
                             [3 3 3]]

np.maximum()

np.maximum(array1, array2)：逐位比较array1和array2，并输出两者的最大值。

  • 如果array1和array2的形状相同，则输出结果的形状与array1和array2的形状相同。
  • 如果array1和array2的形状不同（允许只有一个维度不同），则会用到numpy的broadcast机制。
  • 如果用于比较的ndarray有一个是标量，则另一个ndarray可以是任何形状，这同样用到了broadcast机制
import numpy as np

array1 = np.array([[2, 5, 8], [3, 4, 6]])
array2 = np.array([[3, 4, 9], [2, 1, 6]])
array3 = np.array([1, 6, 7])
print('array1 =', array1)
print('array2 =', array2)
print('array3 =', array3)
print('np.maximum(array1, array2) =', np.maximum(array1, array2))
print('np.maximum(array1, array3) =', np.maximum(array1, array3))  # numpy的broadcast机制
print('np.maximum(array1, 4) =', np.maximum(array1, 4))  # numpy的broadcast机制

输出结果：

array1 = [[2 5 8]
          [3 4 6]]
array2 = [[3 4 9]
          [2 1 6]]
array3 = [1 6 7]
np.maximum(array1, array2) = [[3 5 9]
                              [3 4 6]]
np.maximum(array1, array3) = [[2 6 8]
							  [3 6 7]]
np.maximum(array1, 4) = [[4 5 8]
 						 [4 4 6]]

求和

np.sum

  1. 一维ndarray
    对所有元素求和（无论多少维的ndarray，只要没有指定axis，就表示对所有元素进行求和）。
import numpy as np

array1 = np.array([1, 3, 2, 8, 5])
print(array1)
print(np.sum(array1))  # 返回对array1的所有元素进行求和
print(np.sum(array1, axis=0))  # 指定0轴（即array1本身，输出结果一样）
  1. 二维ndarray
    假设二维numpy数组array1的shape为(3, 4)，其中axis=0对应“3”，axis=1对应“4”
    （1）指定轴0：axis=0
    np.sum(array1, axis=0)的意思就是：按第一个维度（即，行）对array1进行拆分，得到array1[0, :]、array1[1, :]、array1[2, :]，然后对array1[0, :]、array1[1, :]、array1[2, :]的对应元素进行逐位相加，构成新的ndarray。即
    np.sum(array1, axis=0) = array1[0, :] + array1[1, :] + array1[2, :]
import numpy as np

array1 = np.reshape(list(range(12)), (3, 4))
print('array1 =', array1)
print('array1[0, :] =', array1[0, :])
print('array1[1, :] =', array1[1, :])
print('array1[2, :] =', array1[2, :])
print('np.sum(array1, axis=0)=', np.sum(array1, axis=0))

输出结果：

array1= [[0  1  2  3]
         [4  5  6  7]
         [8  9 10 11]]
array1[0, :] = [0 1 2 3]
array1[1, :] = [4 5 6 7]
array1[2, :] = [8 9 10 11]
np.sum(array1, axis=0)= [12 15 18 21]

（2）指定轴1：axis=1
np.sum(array1, axis=1)的意思就是：按第二个维度（即，列）对array1进行拆分，得到array1[:, 0]、array1[:, 1]、array1[:, 2]、array1[:, 3]，然后对array1[:, 0]、array1[:, 1]、array1[:, 2]、array1[:, 3]的对应元素进行逐位相加，构成新的ndarray。即
np.sum(array1, axis=1) = array1[:, 0] + array1[:, 1] + array1[:, 2] + array1[:, 3]

import numpy as np

array1 = np.reshape(list(range(12)), (3, 4))
print('array1 =', array1)
print('array1[:, 0] =', array1[:, 0])
print('array1[:, 1] =', array1[:, 1])
print('array1[:, 2] =', array1[:, 2])
print('array1[:, 3] =', array1[:, 3])
print('np.sum(array1, axis=1) =', np.sum(array1, axis=1))

输出结果：

array1 = [[0  1  2  3]
          [4  5  6  7]
          [8  9 10 11]]
array1[:, 0] = [0 4 8]
array1[:, 1] = [1 5 9]
array1[:, 2] = [2 6 10]
array1[:, 3] = [3 7 11]
np.sum(array1, axis=1) = [6 22 38]
  1. 三维ndarray
    假设三维numpy数组array1的shape为(2, 3, 4)，其中axis=0对应“2”，axis=1对应“3”，axis=2对应“4”。
    （1）指定轴0：axis=0
    np.sum(array1, axis=0)的意思就是：按第一个维度对array1进行拆分，得到array1[0, :, :]、array1[1, :, :]，然后对array1[0, :, :]、array1[1, :, :]的对应元素进行逐位相加，构成新的ndarray，即
    np.sum(array1, axis=0) = array1[0, :, :] + array1[1, :, :]
import numpy as np

array1 = np.reshape(list(range(24)), (2, 3, 4))
print('array1 =', array1)
print('array1[0, :, :] =', array1[0, :, :])
print('array1[1, :, :] =', array1[1, :, :])
print('np.sum(array1, axis=0) =', np.sum(array1, axis=0))

输出结果：

array1 = [[[0  1  2  3]
           [4  5  6  7]
           [8  9 10 11]]

          [[12 13 14 15]
           [16 17 18 19]
           [20 21 22 23]]]
array1[0, :, :] = [[0  1  2  3]
                   [4  5  6  7]
                   [8  9 10 11]]
array1[1, :, :] = [[12 13 14 15]
                   [16 17 18 19]
                   [20 21 22 23]]
np.sum(array1, axis=0) = [[12 14 16 18]
                          [20 22 24 26]
                          [28 30 32 34]]

（2）指定轴1：axis=1
npsum(array1, axis=1)的意思就是：按第二个维度对array1进行拆分，得到array1[:, 0, :]、array1[:, 1, :]、array1[:, 2, :]，然后对array1[:, 0, :]、array1[:, 1, :]、array1[:, 2, :]的对应元素进行逐位相加，构成新的ndarray，即
np.sum(array1, axis=1) = array1[:, 0, :] + array1[:, 1, :] + array1[:, 2, :]

import numpy as np

array1 = np.reshape(list(range(24)), (2, 3, 4))
print('array1 =', array1)
print('array1[:, 0, :] =', array1[:, 0, :])
print('array1[:, 1, :] =', array1[:, 1, :])
print('array1[:, 2, :] =', array1[:, 2, :])
print('np.sum(array1, axis=1) =', np.sum(array1, axis=1))

输出结果：

array1 = [[[0  1  2  3]
           [4  5  6  7]
           [8  9 10 11]]

          [[12 13 14 15]
           [16 17 18 19]
           [20 21 22 23]]]
array1[:, 0, :] = [[ 0  1  2  3]
                   [12 13 14 15]]
array1[:, 1, :] = [[ 4  5  6  7]
                   [16 17 18 19]]
array1[:, 2, :] = [[ 8  9 10 11]
                   [20 21 22 23]]
np.sum(array1, axis=1) = [[12 15 18 21]
 				          [48 51 54 57]]

（3）指定轴2：axis=2
np.sum(array1, axis=2)的意思就是：按第三个维度对array1进行拆分，得到array1[:, :, 0]、array1[:, :, 1]、array1[:, :, 2]、array1[:, :, 3]，然后对array1[:, :, 0]、array1[:, :, 1]、array1[:, :, 2]、array1[:, :, 3]的对应元素进行逐位相加，构成新的ndarray，即
np.sum(array1, axis=2) = array1[:, :, 0] + array1[:, :, 1] + array1[:, :, 2] + array1[:, :, 3]

import numpy as np

array1 = np.reshape(list(range(24)), (2, 3, 4))
print('array1 =', array1)
print('array1[:, :, 0] =', array1[:, :, 0])
print('array1[:, :, 1] =', array1[:, :, 1])
print('array1[:, :, 2] =', array1[:, :, 2])
print('array1[:, :, 3] =', array1[:, :, 3])
print('np.sum(array1, axis=2) =', np.sum(array1, axis=2))

输出结果：

array1 = [[[0  1  2  3]
 		   [4  5  6  7]
		   [8  9 10 11]]

 		  [[12 13 14 15]
           [16 17 18 19]
           [20 21 22 23]]]
array1[:, :, 0] = [[ 0  4  8]
                   [12 16 20]]
array1[:, :, 1] = [[ 1  5  9]
                   [13 17 21]]
array1[:, :, 2] = [[ 2  6 10]
                   [14 18 22]]
array1[:, :, 3] = [[ 3  7 11]
                   [15 19 23]]
np.sum(array1, axis=2) = [[ 6 22 38]
                          [54 70 86]]
本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有涉嫌抄袭侵权的内容，请联系:hwhale#tublm.com(使用前将#替换为@)

max

argmax

Maximum

min

argmin

np.max()、np.argmax()、np.maximum()、np.min()、np.argmin()、np.minimum()、np.sum() 的相关文章

  • 如何返回列表切片的最大元素

    我想最大限度地简化这个功能 我该怎么办 def eleMax items start 0 end None if end is None end len items return max items start end 我想到了 def e

  • 获取表的最大 ID 行

    我的问题是如何获取表的最大 id 行 我正在使用 max 函数 但给我一个错误 这是我的代码 public static long getLastIdQuotaAdded Context context long id Cursor cur

  • Python：获取列表中最常见的项目

    给定一个元组列表 我希望获得最常出现的元组 但如果存在 联合获胜者 它应该在它们之间随机选择 tups 1 2 3 4 5 6 1 2 3 4 上面的列表应该返回 1 2 or 3 4 上面的列表是随机的 Use collections C

  • 包含聚合的更新语句在 SQL Server 中不起作用

    我希望有人可以在这里帮助我的语法 我有两张桌子ansicache encounters and ansicache x refclaim Table The encounters表有一个encounter匹配的列patacctnumber栏

  • Groupby 与 min 结合，同时保留整个数据帧[重复]

    这个问题在这里已经有答案了 我想结合 groupby 和 min 但保留整个数据框 如果我使用下面的方法 我最终只会得到 2 列 即 col1 和 col2 对于这个 df col1 col2 col3 1 1 A 1 0 B 2 2 C

  • Excel公式查找其他单元格使用的引用

    有没有办法找出Excel中另一个单元格引用的单元格的地址 例如 单元格 C1 包含公式 max A A 并返回值 10 该值实际上引用单元格 A10 我可以在单元格 B 中使用返回 A10 的公式吗 不 我根本不想使用 VBA 假设您的条目

  • 如何在 MATLAB 中找到数组中的最大值及其索引？

    假设我有一个数组 a 2 5 4 7 返回最大值及其索引的函数是什么 例如 在我的例子中 该函数应返回 7 作为最大值 4 作为索引 函数是max 要获得第一个最大值 您应该这样做 val idx max a val是最大值并且idx是它的

  • Android Sqlite 字符串的最大长度？

    关于这个问题 Android 上的 SQLite 如何处理长字符串 https stackoverflow com questions 3068180 how sqlite on android handles long strings 它

  • 如何仅在筛选记录上使用 power bi 中的 MAX 函数？

    我试图选择具有最新日期的记录 数据库中的所有记录都有这些基本列 AssetNumber WorkOrderNumber ScheduledEndDate Department 我想查找特定部门中每项资产的所有最新工单 日期 我有一个基本的措

  • 寻找最大最小值集合

    我正在尝试编写一个 天真的或半天真的 程序 给定一组元素和许多玩家将其划分为这个数量的玩家 并且对于每个这样的划分取最小值 按总和 子集 然后 我想计算所有这些最小除法的最大值 这被称为https en wikipedia org wiki

  • 无法向 Kafka 发送大消息

    我想从生产者向 Kafka 发送一条大消息 因此我更改了以下属性 代理 服务器 属性 replica fetch max bytes 317344026 message max bytes 317344026 max message byt

  • Java 数组中的最小值和最大值

    我的代码没有给出错误 但它没有显示最小值和最大值 代码是 Scanner input new Scanner System in int array new int 10 System out println Enter the numbe

  • SQL 数据范围最小值最大值类别

    我想确定 2 个类别的范围 A 类和 B 类 A 从 1 到 15 开始 B 从 16 到 31 开始 然后 A 再次从 32 到 40 开始 现在如果运行此查询 select min range max range from table

  • opencv形态扩张滤波器作为最大滤波器

    就像中值滤波器的定义一样 我可以将 最大滤波器 定义为局部窗口 例如dst x y max 3x3 局部窗口像素 但我在opencv中找不到这样的过滤器 最接近的是 dilate 函数 然后我使用 dilate 函数的默认配置 但结果不正确

  • 获取字母数字值的 Max()

    我有一个包含字母数字 ID 的字典 例如 a10a10 和 d10a9 我想要其中最大的 ID 意思是 9 当我使用以下代码时 d10a9 是 MAX 因为 9 排在 10 之前 var lsd new Dictionary

  • hive sql查找最新记录

    该表是 create table test id string name string age string modified string 像这样的数据 id name age modifed 1 a 10 2011 11 11 11 1

  • codeigniter，获取mysql表列中的最大值

    我正在使用 codeigniter 2 我有一个 mysql 表列 存储每个学生所用的时间 例如 1 2327 0 6547 1 9876 我想获得最大值 值该列 这是我的代码 this gt db gt select max time t

  • 获取包含矩阵行内最大值的列名称，该矩阵在数组内包含单独的最大值

    例如给出 dim1 lt c P PO C T dim2 lt c LL RR R Y dim3 lt c Jerry1 Jerry2 Jerry3 Q lt array 1 48 c 4 4 3 dimnames list dim1 di

  • 对象中的最高值（如果有更多最大值并且它们相同，则更多）

    假设我有这样的对象 var obj a 5 b 10 c 15 d 20 e 20 f 25 我想获得前 3 个最高值 请注意d and e键具有相同的值 我也需要获取键 所以它看起来像 最高值 f 25日 20e 20 另外 如果有六个值

  • 仅选择 SQL 关系中的最大值？

    我有以下两个关系 Game id name year Devs pid gid role 其中 Game id 是主键 Devs gid 是 Game id 的外键 我想编写一个 SQL 查询来查找参与该游戏的人数最多的游戏 我写了以下查询

随机推荐

热门标签