常用操作
（一）、数组shape处理
1、数组重塑（数组总大小不变，不修改原数组）
np.reshape(a, newshape, order=‘C’)
用于给定的数组 a 重新塑形（reshape）为 newshape 指定的新形状。这个函数返回一个新的数组，它是 a 的重塑版本，而不改变数据。
- a: 输入数组。
- newshape: 一个整数的元组，表示新的维度。例如，(2, 3, 4) 表示重塑后的数组将具有 3 维，第一维大小为 2，第二维大小为 3，第三维大小为 4。
- order: 字符串，指定数组中元素的遍历顺序。‘C’ 表示按 C 语言风格的行主序（row-major order），‘F’ 表示按 Fortran 风格的列主序（column-major order）。默认值为 ‘C’。
import numpy as np
# 创建一个一维数组
a = np.arange(6)
print(a)
# [0 1 2 3 4 5]
# 将其重塑为 2x3 的二维数组
reshaped_a = np.reshape(a, (2, 3))
print(reshaped_a)
# 输出:
# [[0 1 2]
# [3 4 5]]
此处，a 是一个包含从 0 到 5 的整数的一维数组。使用 np.reshape(a, (2, 3)) 将其重塑为一个 2 行 3 列的二维数组。
注意：
- 重塑操作不会改变数组中元素的顺序，除非指定了 order=‘F’。
- newshape 中的整数乘积必须与原数组 a 的总元素数量相同。
- 如果 newshape 中包含 -1，则该维度的大小将自动计算，以便保持元素总数不变。例如，如果 a 有 12 个元素，np.reshape(a, (-1, 2)) 将返回一个 6 行 2 列的数组。
2、数组重塑（数组总大小变化，不修改原数组）
numpy.resize(a, new_shape)
用于改变数组 a 的形状为 new_shape 指定的新形状，并返回一个新的数组。与 np.reshape 不同的是，np.resize 会更改数组的总大小，如果新形状需要更多的元素，这些新元素将被添加到数组的末尾，如果需要更少的元素，数组将被截断。
- a: 输入数组。
- new_shape: 一个整数的元组，表示新的维度。
import numpy as np
# 创建一个一维数组
a = np.array([1, 2, 3, 4])
# 改变数组的形状，总元素数量不变
b = np.resize(a, (2, 2))
print(b)
# 输出:
# [[1 2]
# [3 4]]
# 改变数组的形状，增加元素数量
c = np.resize(a, (2, 3))
print(c)
# 输出:
# [[1 2 3]
# [4 1 2]]
# 改变数组的形状，减少元素数量
d = np.resize(a, (2, 2))
print(d)
# 输出:
# [[1 2]
# [3 4]]
注意事项：
- np.resize 不会就地修改原始数组 a，它总是返回一个新的数组。
- 如果新形状的总大小小于原始数组的总大小，那么数组将从尾部开始被截断。
- 如果新形状的总大小大于原始数组的总大小，那么数组将在末尾添加 0（对于整数类型）或与原始数组元素相同的新元素。
- np.resize 可用于数组的自动扩展，例如，当你需要将一个数组调整为与另一个数组具有相同的维度时。
请注意，np.resize 的行为可能会根据 NumPy 的版本和配置有所不同，特别是在处理数组扩展时添加的元素值。在某些情况下，添加的新元素可能是原始数组元素的副本，而不是默认值。
3、数组重塑（数组总大小变化，直接修改原数组）
a.resize(new_shape)
a.resize 是一个就地操作（in-place），意味着它不会创建一个新的数组，而是直接修改原数组的大小。如果数组需要扩展，新元素的值将被初始化为零（对于数值类型）或与数组数据类型对应的默认值。
- a: 输入的 NumPy 数组。
- new_shape: 一个整数的元组，表示数组的新形状。
import numpy as np
# 创建一个一维数组
a = np.array([1, 2, 3, 4])
# 调整数组的大小为 2x2
a.resize((2, 2))
print(a)
# 输出:
# [[1 2]
# [3 4]]
此处，数组 a 被调整为 2x2 的形状。由于新形状的总大小与原始数组相同，所以没有元素被添加或删除。
注意事项：
- resize 是就地操作，不返回任何值。如果你需要保留原始数组，应在调用 resize 之前对其进行备份。
- 如果新形状的总大小大于原始数组，resize 将增加数组的大小并在末尾添加新元素，这些新元素的值将初始化为零或默认值。
- 如果新形状的总大小小于原始数组，resize 将截断数组，丢弃超出新形状大小的元素。
- resize 方法不能用于减少数组的维度。例如，你不能将一个二维数组（初始就是）直接使用 resize 变为一维数组。在这种情况下，你需要先使用 np.ndarray.ravel() 或 np.ndarray.flatten() 将数组降维，然后再使用 resize。
- resize 方法对于数组的类型有要求，它不能用于将数组从一种类型转换为另一种类型。如果你需要改变数组的类型，可以使用 .astype() 方法。
4、扁平化到一维的数组
ndarray.flatten(order=‘C’)
用于将多维数组（ndarray）降维，变成一维数组。这个方法返回一个包含相同数据的新数组，该数组是原始数组的一维表示。
- order: 字符串，指定数组中元素的遍历顺序。‘C’ 表示按 C 语言风格的行主序（row-major order，即先遍历行），‘F’ 表示按 Fortran 风格的列主序（column-major order，即先遍历列）。默认值为 ‘C’。
import numpy as np
# 创建一个二维数组
a = np.array([[1, 2, 3], [4, 5, 6]])
# 将数组降维为一维数组
flattened_a = a.flatten()
print(flattened_a)
# 输出: [1 2 3 4 5 6]
此处，原始的二维数组 a 被转换成了一维数组 flattened_a。
注意事项：
- flatten() 方法返回的是原始数组数据的一个新副本，它是一维的。
- 原始数组的数据顺序可以通过 order 参数来控制。如果使用 ‘F’ 作为参数，将返回按列主序排列的一维数组。
- flatten() 不会就地修改原始数组，它总是返回一个新的数组。
5、数组转置
ndarray.T
对于一维数组（向量），其转置与原数组相同。对于二维数组（矩阵），其转置是将矩阵的行和列互换得到的新矩阵。对于多维数组，转置会交换数组的最后一个轴和第二个最后一个轴，以此类推。
import numpy as np
# 创建一个一维数组
a = np.array([1, 2, 3, 4])
print("原始数组:", a)
print("转置数组:", a.T)
# 输出:
# 原始数组: [1 2 3 4]
# 转置数组: [1 2 3 4]
# 创建一个二维数组
b = np.array([[1, 2, 3], [4, 5, 6]])
print("\n原始矩阵:\n", b)
print("转置矩阵:\n", b.T)
# 输出:
# 原始矩阵:
# [[1 2 3]
# [4 5 6]]
# 转置矩阵:
# [[1 4]
# [2 5]
# [3 6]]
注意事项：
- .T 是一个属性，不是方法，所以它后面没有括号。
- 使用 .T 并不会就地修改原始数组，它返回的是一个新的数组，这个新数组是原始数组的视图（view），这意味着它与原始数组共享数据。
- 对于二维数组，.T 等价于 np.transpose() 函数，但 np.transpose() 可以用于多维数组的任意轴的转置。
- 如果数组是一维的，.T 会返回与原数组相同的数组，因为一维数组没有行和列之分。
6、交换数组的两个轴
np.swapaxes(a, axis1, axis2)
用于交换数组 a 中的两个轴。这个函数返回一个新的数组，其中指定的轴 axis1 和 axis2 被交换。
- a: 输入数组。
- axis1: 第一个轴的索引。
- axis2: 第二个轴的索引。
import numpy as np
x = np.array([[1, 2, 3], [4, 5, 6]])
print(x)
print(x.shape) # (2, 3)
# [[1 2 3]
# [4 5 6]]
y = np.swapaxes(x, 0, 1)
print(y.shape) # (3,2)
print(y)
# [[1 4]
# [2 5]
# [3 6]]
x = np.arange(6).reshape((1, 2, 3))
print(x)
# [[[0 1 2]
# [3 4 5]]]
print(x.shape)
# (1, 2, 3)
y = np.swapaxes(x, 1, 2)
# 第二个轴（大小为2）和第三个轴（大小为3）被交换，所以新数组 y 的形状将是 (1, 3, 2)
print(y)
# [[[0 3]
# [1 4]
# [2 5]]]
print(y.shape)
# (1, 3, 2)
注意事项：
- swapaxes 函数返回一个新的数组，原始数组 a 不会被修改。
- 交换的轴必须存在，例如，在一个三维数组中，axis1 和 axis2 必须是 0、1 或 2。
- 这个函数对于理解多维数据的几何意义或在执行某些操作前重新排列轴的顺序非常有用。
7、数组shape排序
np.transpose(a, axes=None)
用于对数组 a 的轴进行重新排序。如果未指定 axes 参数，np.transpose(a) 将返回数组的简单转置，即将数组的最后一个轴放到第一个位置，其余轴的顺序向后移动一位。
- a: 输入数组。
- axes: 一个可选的序列，指定要返回的轴的顺序。例如，如果 axes 是一个元组 (1, 0, 2)，那么数组的第二轴将被放到第一个位置，第一轴放到第二个位置，第三轴放到第三个位置。
a = np.ones((2, 3, 4, 5))
print(np.transpose(a).shape) # (5, 4, 3, 2)
a = np.ones((1, 2, 3))
print(np.transpose(a, (1, 0, 2)).shape) # (2, 1, 3)
注意事项：
- np.transpose(a) 等价于 a.T，但 np.transpose 更加通用，因为它允许通过 axes 参数指定轴的新顺序。
- axes 参数接受一个轴索引的序列。轴的索引是从0开始的，表示轴的位置。
- 如果 axes 参数被省略，函数将返回数组的简单转置，即将数组的最后一个轴顺序颠倒到最前面。
- np.transpose 返回一个新的数组，原始数组 a 不会被修改。
8、数组增加维度
np.expand_dims(a, axis)
用于在数组 a 的指定位置 axis 增加维度。这个函数会返回一个新的数组，其中在指定的轴位置增加了一个新的维度，而原始数组的数据保持不变。
- a: 输入数组。
- axis: 一个整数，指定要在哪个位置增加维度。索引是从0开始的。
import numpy as np
x = np.array([1, 2])
print(x.shape) # (2,)
# 表示在索引为0（第一个维度）扩展1个维度
y = np.expand_dims(x, axis=0)
print(y.shape) # (1, 2)
# 表示在索引为1（第一个维度）扩展1个维度
y = np.expand_dims(x, axis=1)
print(y.shape) # (2, 1)
# 表示在索引为1和索引为2（维度）扩展1个维度
y = np.expand_dims(x, axis=(0, 1))
print(y.shape) # (1, 1, 2)
# 表示在索引为2和索引为0维度）扩展1个维度
y = np.expand_dims(x, axis=(2, 0))
print(y.shape) # (1, 2, 1)
注意事项：
- np.expand_dims(a, axis) 与 a[np.newaxis, :] 等效，但更清晰明了。
- 这个函数不会就地修改原始数组 a，它返回的是一个新的数组。
- 增加的维度可以是数组的任何位置，包括最左边或最右边。
- 新增加的维度大小为1，通常用于扩展数组的维度以满足某些函数对输入数组维度的要求。
9、数组减少维度
np.squeeze(a, axis=None)
用于去除数组 a 中单维度的大小为1的维度。也就是说，如果你的数组在某个轴上的大小是1，那么这个轴可以被“挤压”掉。这个函数返回一个新的数组，其中所有大小为1的轴都被移除。
- a: 输入数组。
- axis: 一个可选的序列，指定要移除的轴。如果为 None（默认值），则移除所有大小为1的轴。
import numpy as np
# 创建一个二维数组，其中第二维的大小为1
a = np.array([[1, 2, 3]])
# 使用squeeze去除第二维
b = np.squeeze(a)
print(b) # 输出: [1 2 3]
# 去除指定的轴，例如第一个轴
c = np.squeeze(a, axis=0)
print(c) # 输出: [1 2 3]
# 对于一个三维数组，去除大小为1的第二维
d = np.array([[[1, 2, 3]], [[4, 5, 6]]])
e = np.squeeze(d, axis=1)
print(e.shape) # 输出: (2, 3)
注意事项：
- np.squeeze(a) 等价于 a.squeeze()，两者都返回一个新的数组，原始数组 a 不会被修改。
- 如果指定了 axis 参数，只有这些轴（如果它们的大小为1）将被移除。例如，np.squeeze(a, axis=(1)) 只会去除第二维，如果它的大小为1。
- 如果数组中没有大小为1的轴，或者指定的轴的大小不为1，则 np.squeeze 将返回数组的一个副本，而不是原始数组本身。
（二）、数组连接处理
1、数组连接(不会增加维度)
np.concatenate((a1, a2, …), axis=0)
用于将多个数组沿指定轴连接在一起。这个函数接受一个数组序列的元组或列表，以及一个指定沿哪个轴进行连接的 axis 参数。
np.concatenate 是一个非常有用的函数，特别是在处理需要合并多个数组的情况，例如在数据处理和机器学习中准备数据集
- (a1, a2, …): 一个数组序列的元组或列表，这些数组在连接操作中会被合并。
- axis: 一个整数，指定沿哪个轴进行数组的连接。默认值为0，表示沿着第一个轴（数组的行）连接。
- 如果axis为None，则数组在使用前会被扁平化
import numpy as np
# 创建两个一维数组
a1 = np.array([1, 2, 3])
a2 = np.array([4, 5, 6])
# 沿着第一个轴（默认axis=0）连接数组
result = np.concatenate((a1, a2))
print(result) # 输出: [1 2 3 4 5 6]
# 创建两个二维数组
a1 = np.array([[1, 2], [3, 4]])
a2 = np.array([[5, 6], [7, 8]])
# 沿着第一个轴（axis=0）连接数组，即在行方向上连接
result_axis0 = np.concatenate((a1, a2), axis=0)
print(result_axis0)
# 输出: [[1 2]
# [3 4]
# [5 6]
# [7 8]]
# 沿着第二个轴（axis=1）连接数组，即在列方向上连接
result_axis1 = np.concatenate((a1, a2), axis=1)
print(result_axis1)
# 输出: [[1 2 5 6]
# [3 4 7 8]]
如果axis为None，则数组在使用前会被扁平化
import numpy as np
a = np.array([[1, 2], [3, 4]])
b = np.array([[5, 6]])
print(np.concatenate((a, b), axis=None))
# [1 2 3 4 5 6]
注意事项：
- 所有待连接的数组 a1, a2, … 必须具有相同的形状，除了沿 axis 指定的轴之外。
- 如果数组的形状不匹配，np.concatenate 将引发异常。
- np.concatenate 返回一个新的数组，原始数组不会改变。
- 除了 axis 参数外，np.concatenate 还有其他参数，如 out，可以用来指定输出数组。
2、数组堆叠(增加维度)
np.stack(arrays, axis=0, out=None)
用于沿着新轴将一系列数组堆叠（stack）起来。与 np.concatenate 类似，np.stack 也用于组合数组，但主要区别在于 np.stack 会创建一个新的维度来存放这些数组，而 np.concatenate 是将数组沿着已存在的维度进行合并。
np.stack 是一个非常有用的函数，特别是在处理需要将多个数组视为单独样本或实例的情况，例如在机器学习中准备批次数据。
- arrays: 一个数组序列，可以是列表、元组或数组的数组，这些数组将被堆叠起来。
- axis: 一个整数，指定沿着哪个轴堆叠数组。默认值为0，表示沿着数组的第一个轴堆叠。
- out: 一个可选参数，如果提供，则结果将被存储在这个数组中。
import numpy as np
# 创建一个包含5个数组的列表。每个数组都是形状为(3, 4)的二维数组，并且数组中的所有元素都是1。
arrays = [np.ones((3, 4)) for _ in range(5)]
# [... for _ in range(5)]：这是Python中的列表推导式（list
# comprehension），它用于快速生成列表。在这个例子中，它会循环5次
# 每次都创建一个形状为(3, 4)的二维数组，并将这些数组添加到列表中
print(np.stack(arrays, axis=0).shape) # 沿第一个轴（索引为0）连接这些数组，所以输出形状是(5, 3, 4)
print(np.stack(arrays, axis=1).shape) # 沿第二个轴（索引为1）连接这些数组，所以输出形状是(3, 5, 4)
print(np.stack(arrays, axis=2).shape) # 沿第三个轴（索引为2）连接这些数组，所以输出形状是(3, 4, 5)
print(np.stack(arrays, axis=-1).shape) # 沿最后一个轴（索引为-1）连接这些数组，所以输出形状是(3, 4, 5)
注意事项：
- arrays 中的所有数组必须具有相同的形状。
- np.stack 不会就地修改原始数组，它返回一个新的数组。
- 指定的 axis 将添加到结果数组的前面或后面，具体取决于 axis 参数的值。
- 如果需要沿着特定轴合并数组，但数组的形状不匹配，np.stack 会抛出错误。
3、水平堆叠生成数组
np.hstack(tup)
用于在水平方向（沿着第二个轴）堆叠数组元组 tup 中的数组。这个函数实际上是 np.concatenate 函数的一个特例，专门用于沿着第二个轴（axis=1）进行数组的合并。
- tup: 一个数组序列的元组或列表，这些数组将被水平堆叠。
import numpy as np
# 根据第二个轴进行拼接，如果是一维数据则根据第一个轴拼接
a = np.array((1, 2, 3))
b = np.array((4, 5, 6))
print(np.hstack((a, b))) # [1 2 3 4 5 6]
# 根据第二个轴进行拼接
a = np.array([[1], [2], [3]])
b = np.array([[4], [5], [6]])
print(a.shape) # (3,1)
print(np.hstack((a, b)))
# [[1 4]
# [2 5]
# [3 6]]
注意事项：
- tup 中的所有数组必须具有相同的第一个维度大小（即第一轴长度必须一致）。
- np.hstack 主要用于一维数组的水平堆叠，但也可以用于堆叠具有相同行数的二维数组。
- 如果数组的维度大于2，np.hstack 仍然只沿着第二个轴进行堆叠。
- np.hstack 返回一个新的数组，原始数组不会改变。
4、垂直堆叠生成数组
np.vstack(tup)
用于垂直堆叠数组的函数。它将输入的数组沿着新的第一轴（行）堆叠起来。这个函数是 numpy.concatenate 的一个简便形式，专门用于沿着轴0（第一个轴，即垂直方向）进行数组的合并。
- tup: 一个数组序列的元组或列表，这些数组将被垂直堆叠。
根据第一个轴进行拼接，如果是一维(N, )数据，则转成二维(1, N)数据，再根据第一个轴拼接
import numpy as np
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
print(np.vstack((a, b)))
# [[1 2 3]
# [4 5 6]]
a = np.array([[1], [2], [3]])
b = np.array([[4], [5], [6]])
print(np.vstack((a, b)))
# 此处a和b的shape都是(3, 1)
# [[1]
# [2]
# [3]
# [4]
# [5]
# [6]]
注意事项：
- tup 中的所有数组必须具有相同的列数（即第二轴的长度必须一致）。
- np.vstack 主要用于一维数组的垂直堆叠，但也可以用于堆叠具有相同列数的二维数组。
- 如果数组的维度大于2，np.vstack 仍然只沿着第一个轴进行堆叠。
- np.vstack 返回一个新的数组，原始数组不会改变。
（三）、数组元素处理
1、重复数组中的元素
np.repeat(a, repeats, axis=None)
用于重复数组 a 中的元素。你可以指定每个元素重复的次数，并且可以指定沿哪个轴进行重复。
- a: 输入数组。
- repeats: 一个整数或数组的整数序列，指定要重复每个元素的次数。如果 repeats 是一个序列，它的长度必须与 a 的 axis 参数对应的维度长度相同。
- axis: 一个整数，指定沿哪个轴重复元素。如果为 None，则在 a 的每个元素上进行重复（相当于沿着隐含的第一轴）。如果设置为 0，则沿着行方向重复；如果设置为 1，则沿着列方向重复
import numpy as np
print(np.repeat(3, 4)) # [3 3 3 3]
x = np.array([[1, 2], [3, 4]])
print(np.repeat(x, 2))
# 这个调用会将数组x展平（flatten），然后重复每个元素两次。
# 这意味着x会被转换为一维数组[1, 2, 3, 4]，然后每个元素重复两次，得到[1, 1, 2, 2, 3, 3, 4, 4]。
print(np.repeat(x, 3, axis=1))
# 这个调用会在第二个轴（列）上重复数组x的元素。数组x有两列，因此
# np.repeat会将第一列[1, 3]中的每个元素重复三次，得到[1, 1, 1, 3, 3, 3]，
# 同样地，第二列[2, 4]中的每个元素也会重复三次，得到[2, 2, 2, 4, 4, 4]。这两列再组合成一个新的二维数组。
# [[1 1 1 2 2 2]
# [3 3 3 4 4 4]]
print(np.repeat(x, [1, 2], axis=0))
# 这个调用会在第一个轴（行）上重复数组x的元素，但重复的次数由列表[1, 2]指定。
# 这意味着第一行[1, 2]将被重复1次（即保持不变），而第二行[3, 4]将被重复2次。
# [[1 2]
# [3 4]
# [3 4]]
注意事项：
- np.repeat 返回一个新的数组，原始数组 a 不会被修改。
- 如果 repeats 是一个序列，它指定了数组 a 中每个元素重复的次数，数组 a 必须有固定的大小。
- 如果 axis 是 None，则在所有元素上进行操作，相当于在隐含的第一轴上重复。
- 重复操作不会影响数组的数据类型。
2、数组元素去重并排序
np.unique(a, return_index=False, return_inverse=False, return_counts=False,axis=None)
找到数组中的唯一元素，并返回这些唯一元素组成的排序数组
- a：输入的数组
- return_index：为True时，还会返回新数组元素在旧数组中的下标
- return_inverse：为True时，还会返回旧数组元素在新数组中的下标
- return_counts：为True时，还会返回去重数组中的元素在原数组中的出现次数
- axis：指定操作的轴。没指定时，默认扁平化处理
- 返回数组中排序的唯一元素，重复元素会被去除，只保留一个
import numpy as np
# 一维数组去重
print(np.unique([3, 3, 1, 1, 2, 2]))
# [1 2 3]
# 多维数组去重
a = np.array([[1, 1], [2, 3]])
print(np.unique(a))
# [1 2 3]
获取唯一元素的索引：
import numpy as np
# 创建一个一维数组
ar = np.array([1, 2, 2, 3, 3, 3, 4])
# 获取每个唯一元素在 ar 中的索引
indices = np.unique(ar, return_index=True)
print(indices)
# 输出: (array([1, 2, 3, 4]), array([0, 1, 3, 6], dtype=int64))
获取逆索引：
import numpy as np
# 创建一个一维数组
ar = np.array([1, 2, 2, 3, 3, 3, 4])
# 获取从 ar 到唯一元素数组的逆索引
inverse_indices = np.unique(ar, return_inverse=True)
print(inverse_indices)
# 输出: (array([1, 2, 3, 4]), array([0, 1, 1, 2, 2, 2, 3], dtype=int64))
获取元素出现次数：
import numpy as np
# 创建一个一维数组
ar = np.array([1, 2, 2, 3, 3, 3, 4])
# 获取 ar 中每个唯一元素的出现次数
counts = np.unique(ar, return_counts=True)
print(counts)
# 输出: (array([1, 2, 3, 4]), array([1, 2, 3, 1]))
注意事项：
- np.unique 返回的唯一元素数组是按升序排序的。
- 如果 return_index、return_inverse 或 return_counts 为 True，则 np.unique 返回一个元组，其中包含唯一元素数组和附加信息。
- axis 参数仅适用于多维数组，如果 axis 为 None，则在所有元素中提取唯一值。
- np.unique 对于数据分析和处理非常有用，特别是在处理分类数据或需要识别数组中不同元素的场景中。
3、获取数组所有元素乘积
np.prod(a, axis=None, keepdims=np._NoValue, initial=np._NoValue)
返回给定轴上数组元素的乘积
- a: 输入数组，可以是任何维度的数组。
- axis: 指定沿哪个轴计算乘积。例如，对于二维数组，axis=0 表示按列计算乘积（即沿着行的方向），axis=1 表示按行计算乘积（即沿着列的方向）。如果 axis 是 None 或未指定，则计算整个数组所有元素的乘积。
- keepdims: 布尔值或 np._NoValue（默认值）。如果为 True，则保持输出的维度与输入数组 a 相同，但形状中在 axis 指定的维度上大小为 1。如果为 False 或未指定，则输出数组将是一个降维的数组。
- initial: 用于乘积计算的初始值。这通常不用于普通情况，但在某些特殊情况下，例如当输入数组包含 0 或当 dtype 参数指定的数据类型不支持 0 的乘法时，它可能很有用。
- np._NoValue 是一个特殊的 NumPy 值，用于表示函数参数的默认值。这意味着如果没有显式提供某个参数的值，则该函数将使用该参数的默认值。
import numpy as np
print(np.prod([1, 2, 3, 4])) # 1 * 2 * 3 * 4 = 24
print(np.prod([[1, 2], [3, 4]])) # 1 * 2 * 3 * 4 = 24
print(np.prod([1, 2, 3, 4], initial=5)) # 120
print(np.prod([[1, 2], [3, 4]], axis=0)) # [3 8]
print(np.prod([[1, 2], [3, 4]], axis=1)) # [ 2 12]
print(np.prod([[1, 2], [3, 4]], axis=1, keepdims=True))
# [[2]
# [12]]
print(np.prod([[1, 2], [3, 4]], axis=0, keepdims=True))
# [[3 8]]
4、数组元素排序
np.sort(a, axis=-1, kind=None, order=None)
用于对数组 a 进行排序。此函数会对数组中的元素进行排序，并返回一个新的数组，其中元素按升序排列。排序默认是沿着最后一个轴（axis=-1），但你可以指定不同的轴来改变排序的方向。
- a: 输入数组。
- axis: 沿着哪个轴进行排序。默认为 -1，表示沿着数组的最后一个轴。如果是 0 或 1，则分别表示沿着第一个或第二个轴排序。 如果指定为None，则数组扁平化处理。
- kind: 指定排序算法的类型。可选的值包括 quicksort（快速排序，默认）、mergesort（归并排序）、heapsort（堆排序）等。
- order: 指定根据哪个维度进行排序，仅当数组是多维时使用。
一维数组排序
import numpy as np
# 创建一个一维数组
a = np.array([3, 1, 4, 1, 5, 9, 2, 6])
# 对数组进行排序
sorted_a = np.sort(a)
print(sorted_a) # 输出: [1 1 2 3 4 5 6 9]
多维数组排序
import numpy as np
# 创建一个二维数组
a_2d = np.array([[8, 4, 7], [6, 3, 5]])
# 沿着轴 0 排序，即对每一列进行排序
sorted_axis0 = np.sort(a_2d, axis=0)
print(sorted_axis0)
# [[6 3 5]
# [8 4 7]]
# 沿着轴 1 排序，即对每一行进行排序
sorted_axis1 = np.sort(a_2d, axis=1)
print(sorted_axis1)
# [[4 7 8]
# [3 5 6]]
注意事项：
- np.sort 返回一个新的数组，原始数组 a 不会被修改。
- 你可以指定 axis 参数来控制排序的方向，这对于多维数组特别有用。
- kind 参数允许你选择不同的排序算法，这可能对性能和稳定性有所影响。
- np.sort 默认返回升序排序的结果，如果你需要降序排序，可以使用 np.sort(a)[::-1]
5、返回数组非零元素的索引
np.nonzero(a)
用于查找数组 a 中非零元素的索引。这个函数会返回一个元组，其中每个元素都是一个数组，分别表示原数组中非零元素的索引。
- a: 输入数组。
import numpy as np
x = np.array([[3, 0, 0], [0, 4, 0], [5, 6, 0]])
print(x)
# [[3 0 0]
# [0 4 0]
# [5 6 0]]
print(np.nonzero(x))
# (array([0, 1, 2, 2], dtype=int64), array([0, 1, 0, 1], dtype=int64))
'''
array([0, 1, 2, 2])是非零元素的行索引
array([0, 1, 0, 1])是非零元素的列索引
第一个非零元素（值为3）位于第0行，第0列。
第二个非零元素（值为4）位于第1行，第1列。
第三个非零元素（值为5）位于第2行，第0列。
第四个非零元素（值为6）位于第2行，第1列。
'''
print(x[np.nonzero(x)]) # [3 4 5 6]
# 使用上面得到的行和列索引来从x中选择非零元素。因此，输出是一个包含所有非零元素的一维数组。
6、返回满足条件的元素的索引
np.where(condition, x=None, y=None)
根据给定的条件返回数组中的元素。它类似于Python中的三元运算符，但可以应用于数组。
- condition: 一个布尔数组，指定哪个位置的元素应使用 x 或 y。
- x: 可选参数，当 condition 为 True 时，对应的元素值。
- y: 可选参数，当 condition 为 False 时，对应的元素值。
- x, y：array_like，要么都传参，要么都不传
- 如果传三个参数，条件成立返回x，不成立时返回y
- 如果只传第一个参数，返回符合条件的元素的索引
import numpy as np
a = np.arange(10)
print(np.where(a < 5, a, 10 * a))
# [ 0 1 2 3 4 50 60 70 80 90]
# 当where内有三个参数时，当condition成立时返回x，当condition不成立时返回y
print(np.where([[True, False], [True, True]], [[1, 2], [3, 4]], [[9, 8], [7, 6]]))
'''
这里，条件数组是 [[True, False], [True, True]]，当条件为真时的结果数组是 [[1, 2], [3, 4]]，当条件为假时的结果数组是 [[9, 8], [7, 6]]。
根据这些条件，np.where 将返回：
第一个数组的第一行第一列位置为 True，因此结果数组在该位置的值将为 1。
第一个数组的第一行第二列位置为 False，因此结果数组在该位置的值将为 8。
第二个数组的第二行第一列位置为 True，因此结果数组在该位置的值将为 3。
第二个数组的第二行第二列位置为 True，因此结果数组在该位置的值将为 4。
'''
# [[1 8]
# [3 4]]
注意事项：
- np.where 返回的数组与输入的条件数组 condition 具有相同的形状。
- 如果 x 和 y 未提供，np.where 返回满足条件的元素的索引。
- 如果提供了 x 和 y，np.where 返回一个新数组，其中满足条件的位置填充 x 的值，不满足条件的位置填充 y 的值。
- np.where 是一个非常有用的函数，特别是在需要根据条件选择数组元素或执行条件索引时。
7、返回数组非零元素的索引（同时包含行索引和列索引）
np.argwhere(a)
用于返回数组 a 中非零元素的索引。与 np.nonzero 不同，np.argwhere 返回的是一个二维数组，其中每一行包含了一个非零元素的索引。
- a: 输入数组。
import numpy as np
x = np.arange(6).reshape(2, 3)
print(x)
# [[0 1 2]
# [3 4 5]]
print(x > 1)
# [[False False True]
# [True True True]]
print(np.argwhere(x > 1))
# [[0 2]
# [1 0]
# [1 1]
# [1 2]]
'''
此处返回的索引包含所有满足条件x > 1的元素的坐标（行索引和列索引）。每个坐标对应一个大于1的元素。
例如，[0 1]表示第一行第二列的元素大于1（即元素1），[0 2]表示第一行第三列的元素大于1（即元素2），以此类推。
'''
注意事项：
- np.argwhere 返回的二维数组中，每一行都是一个索引对，表示非零元素在数组中的位置。
- 如果数组 a 中没有非零元素，np.argwhere 将返回一个空数组。
- np.argwhere 对于查找数组中的非零元素的索引非常有用，尤其是在需要根据条件筛选数据时。
8、返回数组逐个元素比较中的最大值
np.maximum(x1, x2)
用于计算两个数组 x1 和 x2 中元素的逐个最大值（element-wise maximum）。这个函数会返回一个新的数组，其中的元素是两个输入数组中对应位置元素的最大值。
np.maximum 是一个非常有用的函数，特别是在需要比较数组元素并找出较大值的场景中，例如在图像处理、信号处理或任何需要逐元素比较的数值分析中。
- x1: 第一个输入数组。
- x2: 第二个输入数组。
一维数组
import numpy as np
# 创建两个一维数组
x1 = np.array([1, 2, 3])
x2 = np.array([3, 2, 1])
# 计算逐个最大值
max_values = np.maximum(x1, x2)
print(max_values)
# 输出: [3, 2, 3]
二维数组
import numpy as np
# 创建两个二维数组
x1 = np.array([[1, 2], [3, 4]])
x2 = np.array([[4, 1], [3, 5]])
# 计算逐个最大值
max_values = np.maximum(x1, x2)
print(max_values)
# 输出: [[4, 2],
# [3, 5]]
注意事项：
- np.maximum(x1, x2) 可以处理不同形状的数组，只要它们是广播兼容的（broadcastable）。
- 如果输入数组的形状相同，函数将逐个比较相同位置的元素。
- 如果数组可以广播，函数将扩展它们以匹配最大的形状，然后逐个比较元素。
- np.maximum 可以同时接受多个数组，如 np.maximum(x1, x2, x3, …)。
9、返回数组逐个元素比较中的最小值
np.minimum(x1, x2)
用于计算两个数组 x1 和 x2 中元素的逐个最小值（element-wise minimum）。这个函数会返回一个新的数组，其中的元素是两个输入数组中对应位置元素的最小值。
- x1: 第一个输入数组。
- x2: 第二个输入数组。
一维数组
import numpy as np
# 创建两个一维数组
x1 = np.array([1, 2, 3])
x2 = np.array([3, 2, 1])
# 计算逐个最小值
min_values = np.minimum(x1, x2)
print(min_values) # 输出: [1, 2, 1]
二维数组
import numpy as np
# 创建两个二维数组
x1 = np.array([[1, 2], [3, 4]])
x2 = np.array([[4, 1], [3, 5]])
# 计算逐个最小值
min_values = np.minimum(x1, x2)
print(min_values)
# 输出: [[1, 1],
# [3, 4]]
注意事项：
- np.minimum(x1, x2) 可以处理不同形状的数组，只要它们是广播兼容的（broadcastable）。
- 如果输入数组的形状相同，函数将逐个比较相同位置的元素。
- 如果数组可以广播，函数将扩展它们以匹配最大的形状，然后逐个比较元素。
- np.minimum可以同时接受多个数组，如 np.minimum(x1, x2, x3, …)。
10、返回沿轴的最大值的索引
np.argmax(a, axis=None, out=None)
用于返回数组 a 中元素最大值的索引。如果未指定 axis，则会在数组的扁平化版本中搜索最大值。
- a: 输入数组。
- axis: 整数或None。沿着哪个轴寻找最大值。如果为None，则在扁平化的数组中寻找最大值。默认为-1，表示沿着数组的最后一个轴。
- out: 可选参数，如果提供，则结果将被存储在这个数组中。
import numpy as np
a = np.arange(6).reshape(2, 3) + 10
print(a)
# [[10 11 12]
# [13 14 15]]
# 没有指定轴，则数组扁平化处理
print(np.argmax(a))
# 5
"""
此处的5，指的是扁平化处理后的数组索引为5的元素，即15
"""
print(np.argmax(a, axis=0)) # [1 1 1]
"""
当我们指定axis = 0时，np.argmax会沿着第一个轴（即行）操作，返回每一列中最大元素的行索引。因为a的每一列的最大元素都在第二行（索引为1），所以输出是一个数组[1, 1, 1]。
"""
print(np.argmax(a, axis=1)) # [2 2]
"""
当我们指定axis = 1时，np.argmax会沿着第二个轴（即列）操作，返回每一行中最大元素的列索引。第一行的最大元素是12（索引为2），第二行的最大元素是15（索引也为2），所以输出是一个数组[2, 2]。
"""
注意事项：
- np.argmax 返回的是数组中最大元素的索引，而不是最大元素本身的值。
- 如果数组中有多个相同的最大值，np.argmax 只返回这些最大值的第一个索引。
- 对于多维数组，指定 axis 参数可以控制沿着哪个轴寻找最大值。
11、返回沿轴的最小值的索引
np.argmin(a, axis=None, out=None)
用于返回数组 a 中元素最小值的索引。与 np.argmax 类似，np.argmin 可以找到数组中最小元素的位置。
- a: 输入数组。
- axis: 整数或None。沿着哪个轴寻找最小值。如果为None，则在扁平化的数组中寻找最小值。默认为-1，表示沿着数组的最后一个轴。
- out: 可选参数，如果提供，则结果将被存储在这个数组中。
一维数组
import numpy as np
# 创建一个一维数组
a = np.array([3, 1, 2, 5, 4])
# 寻找最小值的索引
index = np.argmin(a)
print(index)
# 输出: 1
多维数组
import numpy as np
# 创建一个二维数组
a = np.array([[20, 10, 30], [40, 50, 25]])
# 沿着轴0（行）寻找最小值的索引
index_axis0 = np.argmin(a, axis=0)
print(index_axis0) # 输出: [0, 0, 1]
"""
当我们指定 axis=0 时，np.argmin 会沿着第一个轴（即行）操作，返回每一列中最小元素的行索引。
因为 a 的每一列的最小元素获（20在一行索引为0，10在第一行索引为0，25在第二行索引为1），所以输出是一个数组 [0, 0, 1]。
"""
# 沿着轴1（列）寻找最小值的索引
index_axis1 = np.argmin(a, axis=1)
print(index_axis1) # 输出: [1, 2]
"""
当我们指定 axis=1 时，np.argmin 会沿着第二个轴（即列）操作，返回每一行中最小元素的列索引。
第一行的最小元素是 10（索引为 1），第二行的最小元素是 25（索引为 2），所以输出是一个数组 [1, 2]。
"""
注意事项：
- np.argmin 返回的是数组中最小元素的索引，而不是最小元素本身的值。
- 如果数组中有多个相同的最小值，np.argmin 只返回这些最小值的第一个索引。
- 对于多维数组，指定 axis 参数可以控制沿着哪个轴寻找最小值。
957
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
