Python包——numpy2
9.迭代数组
nditer 是 NumPy 中的一个强大的迭代器对象，用于高效地遍历多维数组。nditer 提供了多种选项和控制参数，使得数组的迭代更加灵活和高效。
控制参数
nditer 提供了多种控制参数，用于控制迭代的行为。
主要参数
- op：要迭代的数组或数组序列。可以是单个数组或多个数组组成的列表或元组。
- flags：控制迭代器行为的标志。常用标志包括：
'external_loop'：使迭代器返回数组的外部维度（如二维数组的行）作为一维数组，而不是单个元素。'c_index'：通过迭代器的index属性跟踪 C 顺序（行优先）的索引。'f_index'：通过迭代器的index属性跟踪 Fortran 顺序（列优先）的索引。'multi_index'：通过迭代器的multi_index属性获取当前元素的完整索引（多维索引）。- op_flags：控制操作数组时的读写模式。常用值包括：
['readwrite']：允许在迭代过程中读写数组元素。['writeonly']：只允许在迭代过程中写入数组元素（不常用）。- 默认为只读模式。
- order：控制遍历数组元素的顺序。常用值包括：
'C'：C 顺序，即行优先（默认）。'F'：Fortran 顺序，即列优先。'K'：保持数组元素在内存中的顺序。'A'：与'F'顺序相同（遗留选项）。- casting：控制数据类型转换的策略。常用值包括
'safe'（仅进行安全转换）和'same_kind'（进行相似类型的转换）。
# 创建一个三维数组 arr = np.array([[[1, 2], [3, 4]], [[5, 6], [7, 8]]]) # 使用 nditer 遍历数组并获取多维索引 it = np.nditer(arr, flags=['multi_index']) for x in it: print(f"Element: {x}, Index: {it.multi_index}") # 输出： # Element: 1, Index: (0, 0, 0) # Element: 2, Index: (0, 0, 1) # Element: 3, Index: (0, 1, 0) # Element: 4, Index: (0, 1, 1) # Element: 5, Index: (1, 0, 0) # Element: 6, Index: (1, 0, 1) # Element: 7, Index: (1, 1, 0) # Element: 8, Index: (1, 1, 1) # 创建一个二维数组 arr = np.array([[1, 2, 3], [4, 5, 6]]) # 使用外部循环遍历数组 for x in np.nditer(arr, flags=['external_loop'], order='F'): print(x) # 输出: # [1 4] # [2 5] # [3 6]
10.数组操作
10.1数组变维
函数名称 函数介绍 reshape 在不改变数组元素的条件下，修改数组的形状 flat 返回是一个迭代器，可以用 for 循环遍历其中的每一个元素 flatten 以一维数组的形式返回一份数组的副本，对副本的操作不会影响到原数组 ravel 返回一个连续的扁平数组（即展开的一维数组），与 flatten不同，它返回的是数组视图（修改视图会影响原数组）
10.1.1 flat
返回一个一维迭代器，用于遍历数组中的所有元素。无论数组的维度如何，ndarray.flat属性都会将数组视为一个扁平化的一维数组，按行优先的顺序遍历所有元素。
import numpy as np def flat_test(): array_one = np.arange(4).reshape(2,2) print("原数组元素：") for i in array_one: print(i,end=" ") print() print("使用flat属性，遍历数组：") for i in array_one.flat: print(i,end=" ")
10.1.2 flatten()
用于将多维数组转换为一维数组。flatten() 返回的是原数组的一个拷贝，因此对返回的数组进行修改不会影响原数组。
参数
order: 指定数组的展开顺序。
'C'：按行优先顺序展开（默认）。
'F'：按列优先顺序展开。
'A'：如果原数组是 Fortran 连续的，则按列优先顺序展开；否则按行优先顺序展开。
'K'：按元素在内存中的顺序展开。
import numpy as np # 创建一个二维数组 arr = np.array([[1, 2, 3], [4, 5, 6]]) # 使用 flatten 方法按行优先顺序展开 flat_arr = arr.flatten(order='C') print(flat_arr) # 输出: # [1 2 3 4 5 6]
10.1.3 ravel()
用于将多维数组转换为一维数组。与 flatten() 不同，ravel() 返回的是原数组的一个视图（view），而不是拷贝。因此，对返回的数组进行修改会影响原数组。
参数
order: 指定数组的展开顺序。
'C'：按行优先顺序展开（默认）。
'F'：按列优先顺序展开。
'A'：如果原数组是 Fortran 连续的，则按列优先顺序展开；否则按行优先顺序展开。
'K'：按元素在内存中的顺序展开。
import numpy as np # 创建一个二维数组 arr = np.array([[1, 2, 3], [4, 5, 6]]) # 使用 ravel 方法按行优先顺序展开 ravel_arr = arr.ravel() print(ravel_arr) # 输出: # [1 2 3 4 5 6] ravel_arr[-1] = 7 print(arr) # 输出: # [[1 2 3] # [4 5 7]]
10.2 数组转置
函数名称 说明 transpose 将数组的维度值进行对换，比如二维数组维度(2,4)使用该方法后为(4,2) ndarray.T 与 transpose 方法相同
import numpy as np def transpose_test(): array_one = np.arange(12).reshape(3, 4) print("原数组：") print(array_one) print("使用transpose()函数后的数组：") print(np.transpose(array_one)) def T_test(): array_one = np.arange(12).reshape(3, 4) print("原数组：") print(array_one) print("数组转置：") print(array_one.T)
10.3 修改数组维度
多维数组（也称为 ndarray）的维度（或轴）是从外向内编号的。这意味着最外层的维度是轴0，然后是轴1，依此类推。
函数名称 参数 说明 expand_dims(arr, axis) arr：输入数组 axis：新轴插入的位置 在指定位置插入新的轴(相对于结果数组而言)，从而扩展数组的维度 squeeze(arr, axis) arr：输入数的组 axis：取值为整数或整数元组，用于指定需要删除的维度所在轴，指定的维度值必须为 1 ，否则将会报错，若为 None，则删除数组维度中所有为 1 的项 删除数组中维度为 1 的项
10.3.1numpy.expand_dims(a, axis)
a：输入的数组。axis：指定在哪个轴上插入新的维度。轴的编号从0开始，负值表示从最后一个轴开始计数（例如，-1表示最后一个轴）。如果axis的值大于或等于输入数组的轴数，那么新的维度将被添加到数组的末尾。- 返回值是一个新数组，其形状与输入数组相同，但在指定的轴上增加了一个大小为1的维度。
import numpy as np # 创建一个一维数组 arr = np.array([1, 2, 3]) # 在轴0上增加维度（变为列向量） arr_expanded_axis0 = np.expand_dims(arr, axis=0) print("Expanded on axis 0:\n", arr_expanded_axis0) # 输出: # [[1 2 3]] # 在轴1上增加维度（变为行向量） arr_expanded_axis1 = np.expand_dims(arr, axis=1) print("Expanded on axis 1:\n", arr_expanded_axis1) # 输出: # [[1] # [2] # [3]] # 创建一个二维数组 arr_2d = np.array([[1, 2], [3, 4]]) # 在轴2上增加维度（变为三维数组，最后一个维度大小为1） arr_expanded_axis2 = np.expand_dims(arr_2d, axis=2) print("Expanded on axis 2:\n", arr_expanded_axis2) # 输出: # [[[1] # [2]] # # [[3] # [4]]]
10.3.2squeeze(arr, axis)
a：输入的数组。axis：用于指定需要被压缩的轴的编号。如果为None（默认值），则所有大小为1的轴都将被压缩。如果指定了axis，则只有该轴（或其负值对应的轴，表示从最后一个轴开始计数）在大小为1时才会被压缩。如果指定的轴上大小不为1，则该操作不会改变数组的形状。- 返回值是一个新数组，其形状是输入数组形状中移除了所有（或指定）大小为1的维度后的结果。
import numpy as np # 创建一个三维数组，其中一个维度大小为1 arr = np.array([[[1], [2]], [[3], [4]]]) # 移除所有大小为1的维度 arr_squeezed = np.squeeze(arr) print("Squeezed all single dimensions:\n", arr_squeezed) # 输出: # [[1 2] # [3 4]] # 创建一个二维数组，没有大小为1的维度 arr_2d = np.array([[1, 2], [3, 4]]) # 尝试移除（但因为没有大小为1的维度，所以形状不变） arr_2d_squeezed = np.squeeze(arr_2d) print("Squeezed 2D array (no change):\n", arr_2d_squeezed) # 输出: # [[1 2] # [3 4]] # 创建一个三维数组，并指定只移除第二个维度（大小为1的维度） arr_with_middle_dim = np.array([[[1, 2]], [[3, 4]]]) arr_squeezed_middle = np.squeeze(arr_with_middle_dim, axis=1) print("Squeezed middle dimension:\n", arr_squeezed_middle) # 输出: # [[[1 2]] # # [[3 4]]] # 注意：这里第二个维度（axis=1）被移除了，但因为第一个和最后一个维度仍然不是1，所以它们保留了下来。 # 然而，这个特定的例子可能有些误导，因为通常我们期望squeeze能够移除所有大小为1的维度。 # 在这个例子中，如果我们想要移除所有大小为1的维度，我们应该不指定axis参数。 # 更正上面的误解，如果我们想要移除arr_with_middle_dim中所有大小为1的维度： arr_fully_squeezed = np.squeeze(arr_with_middle_dim) print("Fully squeezed array:\n", arr_fully_squeezed) # 输出: # [[1 2] # [3 4]]
10.4 连接数组
函数名称 参数 说明 hstack(tup) tup：可以是元组，列表，或者numpy数组，返回结果为numpy的数组 按水平顺序堆叠序列中数组（列方向） vstack(tup) tup：可以是元组，列表，或者numpy数组，返回结果为numpy的数组 按垂直方向堆叠序列中数组（行方向）
- hstack函数要求堆叠的数组在垂直方向（行）上具有相同的形状。如果行数不一致，hstack() 将无法执行，并会抛出 ValueError 异常。
- hstack() 要求堆叠的数组在垂直方向（行）上具有相同的形状。如果列数不一致，将无法执行堆叠操作。
- vstack() 和 hstack() 要求堆叠的数组在某些维度上具有相同的形状。如果维度不一致，将无法执行堆叠操作。
import numpy as np # 创建两个形状不同的数组 arr1 = np.array([[1, 2], [3, 4]]) arr2 = np.array([[5], [6]]) print(arr1.shape) # (2, 2) print(arr2.shape) # (2, 1) # 使用 hstack 水平堆叠数组 result = np.hstack((arr1, arr2)) print(result) # 输出： # [[1 2 5] # [3 4 6]]
# 创建两个一维数组 arr1 = np.array([1, 2, 3]) arr2 = np.array([4, 5, 6]) # 使用 vstack 垂直堆叠数组 result = np.vstack((arr1, arr2)) print(result) # 输出: # [[1 2 3] # [4 5 6]]
10.5 分割数组
函数名称 参数 说明 hsplit(ary, indices_or_sections) ary：原数组 indices_or_sections：按列分割的索引位置 将一个数组水平分割为多个子数组（按列） vsplit(ary, indices_or_sections) ary：原数组 indices_or_sections：按列分割的索引位置 将一个数组垂直分割为多个子数组（按行）
import numpy as np # 创建一个二维数组 arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]) result = np.hsplit(arr, [1, 3]) # 查看结果 print("第一个子数组:\n", result[0]) # 输出包含第0列的子数组 print("第二个子数组:\n", result[1]) # 输出包含第1列和第2列的子数组 print("第三个子数组:\n", result[2]) # 输出包含第3列的子数组 array_one = np.arange(12).reshape(2,6) print('array_one 原数组：\n', array_one) array_two = np.vsplit(array_one,[1]) print('vsplit 之后的数组：\n', array_two)
11.数组元素的增删改查
11.1 resize
函数名称 参数 说明 resize(a, new_shape) a：操作的数组 new_shape：返回的数组的形状，如果元素数量不够，重复数组元素来填充新的形状 返回指定形状的
import numpy as np array_one = np.arange(6).reshape(2, 3) print(array_one) print('resize 后数组：\n', np.resize(array_one, (3, 4))) # 输出： # [[0 1 2 3] # [4 5 0 1] # [2 3 4 5]]
11.2 append
函数名称 参数 说明 append(arr, values, axis=None) arr：输入的数组 values：向 arr 数组中添加的值，需要和 arr 数组的形状保持一致 axis：默认为 None，返回的是一维数组；当 axis =0 时，追加的值会被添加到行，而列数保持不变，若 axis=1 则与其恰好相反 在数组的末尾添加值，返回一个一维数组
import numpy as np # 示例 1：向一维数组末尾添加单个值 arr_1d = np.array([1, 2, 3]) new_arr_1d = np.append(arr_1d, 4) print(new_arr_1d) # 输出: [1 2 3 4] # 示例 2：向一维数组末尾添加数组 arr_1d = np.array([1, 2, 3]) values_to_add = np.array([4, 5]) new_arr_1d = np.append(arr_1d, values_to_add) print(new_arr_1d) # 输出: [1 2 3 4 5] # 示例 3：向二维数组沿指定轴添加值 arr_2d = np.array([[1, 2], [3, 4]]) values_to_add = np.array([[5, 6]]) # 注意这里的形状 new_arr_2d = np.append(arr_2d, values_to_add, axis=0) # 沿着行（axis=0）添加 print(new_arr_2d) # 输出: # [[1 2] # [3 4] # [5 6]] # 如果尝试沿着列（axis=1）添加不同形状的数组，将会出错： # values_to_add = np.array([5, 6]) # 这是一个一维数组 # new_arr_2d = np.append(arr_2d, values_to_add, axis=1) # 这将引发错误
11.3 insert
函数名称 参数 说明 insert(arr, obj, values, axis) arr：输入的数组 obj：表示索引值，在该索引值之前插入 values 值 values：要插入的值 axis：默认为 None，返回的是一维数组；当 axis =0 时，追加的值会被添加到行，而列数保持不变，若 axis=1 则与其恰好相反
import numpy as np # 示例 1：向一维数组指定索引前插入单个值 arr_1d = np.array([1, 2, 4, 5]) new_arr_1d = np.insert(arr_1d, 2, 3) # 在索引2之前插入值3 print(new_arr_1d) # 输出: [1 2 3 4 5] # 示例 2：向一维数组指定索引前插入数组 arr_1d = np.array([1, 2, 4, 5]) values_to_insert = np.array([3, 30]) # 注意这里的形状 # 由于我们只想在索引2之前插入一个值，我们需要选择values_to_insert中的一个元素 # 或者调整arr_1d和values_to_insert的形状以匹配 # 这里我们简单选择values_to_insert的第一个元素 new_arr_1d = np.insert(arr_1d, 2, values_to_insert[0]) print(new_arr_1d) # 输出: [1 2 3 4 5] # 如果想插入整个数组，需要调整arr_1d的形状或选择另一个插入策略 # 示例 3：向二维数组指定轴和索引前插入值 arr_2d = np.array([[1, 2], [4, 5]]) values_to_insert = np.array([3]) # 单个值，将被广播到适当的形状 new_arr_2d = np.insert(arr_2d, 1, values_to_insert, axis=0) # 沿着行（axis=0）在索引1之前插入 print(new_arr_2d) # 注意，由于values_to_insert是标量，它会被广播到与arr_2d的一行相同的形状 # 输出: # [[1 2] # [3 3] # 这里3被广播到了整行，但通常我们期望插入的是与原始行形状相同的数组 # [4 5]] # 正确的做法应该是提供一个与arr_2d一行形状相同的数组作为values_to_insert # 正确的二维数组插入示例 values_to_insert_correct = np.array([[3, 3]]) # 与arr_2d的一行形状相同 new_arr_2d_correct = np.insert(arr_2d, 1, values_to_insert_correct, axis=0) print(new_arr_2d_correct) # 输出: # [[1 2] # [3 3] # [4 5]]
11.4 delete
函数名称 参数 说明 delete(arr, obj, axis) arr：输入的数组 obj：表示索引值，在该索引值之前插入 values 值 axis：默认为 None，返回的是一维数组；当 axis =0 时，删除指定的行，若 axis=1 则与其恰好相反 删掉某个轴上的子数组，并返回删除后的新数组
import numpy as np # 示例 1：从一维数组中删除指定索引的元素 arr_1d = np.array([1, 2, 3, 4, 5]) new_arr_1d = np.delete(arr_1d, 2) # 删除索引为2的元素（值为3） print(new_arr_1d) # 输出: [1 2 4 5] # 示例 2：从一维数组中删除多个指定索引的元素 arr_1d = np.array([1, 2, 3, 4, 5]) new_arr_1d = np.delete(arr_1d, [1, 3]) # 删除索引为1和3的元素（值为2和4） print(new_arr_1d) # 输出: [1 3 5] # 示例 3：从二维数组中删除指定轴和索引的子数组 arr_2d = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) new_arr_2d = np.delete(arr_2d, 1, axis=0) # 沿着行（axis=0）删除索引为1的子数组（值为[4, 5, 6]） print(new_arr_2d) # 输出: # [[1 2 3] # [7 8 9]] # 从二维数组中删除指定轴和索引的列 new_arr_2d = np.delete(arr_2d, 1, axis=1) # 沿着列（axis=1）删除索引为1的列（值为[2, 5, 8]） print(new_arr_2d) # 输出: # [[1 3] # [4 6] # [7 9]]
11.5 argwhere
返回数组中非 0 元素的索引，若是多维数组则返回行、列索引组成的索引坐标
import numpy as np # 示例 1：查找所有非零元素的索引 arr = np.array([[1, 0, 2], [0, 3, 0], [4, 0, 5]]) indices = np.argwhere(arr) print(indices) # 输出: # [[0 0] # [0 2] # [1 1] # [2 0] # [2 2]] # 示例 2：查找大于2的元素的索引 arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) indices = np.argwhere(arr > 2) print(indices) # 输出: # [[0 2] # [1 0] # [1 1] # [1 2] # [2 0] # [2 1] # [2 2]]
11.6 unique
函数名称 参数 说明 unique(ar, return_index=False, return_inverse=False, return_counts=False, axis=None) ar：输入的数组 return_index：如果为 True，则返回新数组元素在原数组中的位置（索引） return_inverse：如果为 True，则返回原数组元素在新数组中的位置（逆索引） return_counts：如果为 True，则返回去重后的数组元素在原数组中出现的次数 删掉某个轴上的子数组，并返回删除后的新数组
import numpy as np # 示例 1：基本用法 arr = np.array([1, 2, 2, 3, 4, 4, 5]) unique_vals = np.unique(arr) print(unique_vals) # 输出: [1 2 3 4 5] # 示例 2：返回唯一值在原始数组中的索引 arr = np.array([[1, 1], [2, 3], [2, 1]]) unique_vals, indices = np.unique(arr, return_index=True, axis=0) print(unique_vals) # 输出: [[1 1] # [2 3] # [2 1]] 中的唯一行 print(indices) # 输出: [0 1 0] 这些是唯一行在原始数组中的索引（沿着行轴） # 示例 3：返回逆索引和出现次数 arr = np.array([1, 2, 2, 3, 4, 4, 5]) unique_vals, inverse_indices, counts = np.unique(arr, return_inverse=True, return_counts=True) print(unique_vals) # 输出: [1 2 3 4 5] print(inverse_indices) # 输出: [0 1 1 2 3 3 4] 可以使用这个数组来重构原始数组 print(counts) # 输出: [1 2 1 2 1] 每个唯一值出现的次数
12.统计函数
12.1 amin() 和 amax()
amin()
numpy.amin(a, axis=None, out=None, keepdims=<no value>, initial=<no value>, where=<no value>)
a：输入数组。axis：指定沿哪个轴计算最小值。默认是None，表示计算整个数组的最小值。如果是一个整数，表示沿该轴计算；如果是元组，表示沿多个轴计算。out：可选参数，用于存储结果的数组。keepdims：如果为True，则保持输出的维度与输入相同。initial：用于计算最小值的初始值。where：可选参数，布尔数组，指定哪些元素参与计算。
import numpy as np arr = np.array([[1, 2, 3], [4, 5, 6]]) # 计算整个数组的最小值 min_val_all = np.amin(arr) print("整个数组的最小值:", min_val_all) # 输出: 整个数组的最小值: 1 # 沿着行计算最小值 min_val_axis0 = np.amin(arr, axis=0) print("沿着行计算的最小值:", min_val_axis0) # 输出: 沿着行计算的最小值: [1 2 3] # 沿着列计算最小值 min_val_axis1 = np.amin(arr, axis=1) print("沿着列计算的最小值:", min_val_axis1) # 输出: 沿着列计算的最小值: [1 4]
numpy.amax():参数与numpy.amin()相同，只是功能相反，计算的是最大值。import numpy as np arr = np.array([[1, 2, 3], [4, 5, 6]]) # 计算整个数组的最大值 max_val_all = np.amax(arr) print("整个数组的最大值:", max_val_all) # 输出: 整个数组的最大值: 6 # 沿着行计算最大值 max_val_axis0 = np.amax(arr, axis=0) print("沿着列计算的最大值:", max_val_axis0) # 输出: 沿着行计算的最大值: [4 5 6] # 沿着列计算最大值 max_val_axis1 = np.amax(arr, axis=1) print("沿着行计算的最大值:", max_val_axis1) # 输出: 沿着列计算的最大值: [3 6]
12.2 ptp()
在 NumPy 中，ptp() 函数用于计算数组元素沿指定轴的最大值与最小值之差（即峰值到峰值，peak-to-peak）。如果不指定轴，则默认在整个数组上计算。
import numpy as np # 创建一个二维数组 arr = np.array([[1, 10, 3], [5, 6, 9], [2, 8, 7]]) # 在整个数组上计算 ptp（最大值与最小值之差） print("整个数组的 ptp:", arr.ptp()) # 沿着列（axis=0）计算 ptp # 这将返回每一列的最大值与最小值之差 print("沿着列的 ptp:", arr.ptp(axis=0)) # 沿着行（axis=1）计算 ptp # 这将返回每一行的最大值与最小值之差 print("沿着行的 ptp:", arr.ptp(axis=1))
12.3 median()
在 NumPy 中，median() 函数用于计算数组元素的中位数。中位数是将一组数据从小到大排序后，位于中间位置的数值。如果数据量是奇数，则中位数是中间那个数；如果数据量是偶数，则中位数是中间两个数的平均值。对于一维数组，median() 函数直接返回整个数组的中位数。对于二维或更高维度的数组，你可以通过指定 axis 参数来计算沿某个轴的中位数。
import numpy as np # 创建一个一维数组 arr1 = np.array([1, 3, 5, 7, 9]) print("一维数组的中位数:", arr1.median()) # 创建一个二维数组 arr2 = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) # 计算整个二维数组的中位数（将所有元素视为一个一维数组） print("整个二维数组的中位数:", np.median(arr2)) # 沿着列（axis=0）计算中位数 print("沿着列的中位数:", np.median(arr2, axis=0)) # 沿着行（axis=1）计算中位数 print("沿着行的中位数:", np.median(arr2, axis=1)) #一维数组的中位数: 5.0 #整个二维数组的中位数: 5.0 #沿着列的中位数: [4. 5. 6.] #沿着行的中位数: [2. 5. 8.]
12.4 mean()
在 NumPy 中，mean() 函数用于计算数组元素的平均值（或均值）。对于一维数组，它返回整个数组元素的平均值；对于二维或更高维度的数组，你可以通过指定 axis 参数来计算沿某个轴的平均值。
import numpy as np # 创建一个一维数组 arr1 = np.array([1, 2, 3, 4, 5]) print("一维数组的平均值:", arr1.mean()) # 创建一个二维数组 arr2 = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) # 计算整个二维数组的平均值（将所有元素视为一个一维数组） print("整个二维数组的平均值:", np.mean(arr2)) # 沿着列（axis=0）计算平均值 print("沿着列的平均值:", np.mean(arr2, axis=0)) # 沿着行（axis=1）计算平均值 print("沿着行的平均值:", np.mean(arr2, axis=1)) #一维数组的平均值: 3.0 #整个二维数组的平均值: 5.0 #沿着列的平均值: [4. 5. 6.] #沿着行的平均值: [2. 5. 8.]
12.5average()
NumPy 提供了一个 numpy.average() 函数，它用于计算数组元素的加权平均值。与 mean() 函数不同，average() 函数允许你指定一个权重数组来计算加权平均值。
import numpy as np # 创建一个一维数组 arr = np.array([1, 2, 3, 4, 5]) # 计算整个数组的平均值（与 mean() 相同，因为没有指定权重） avg_value = np.average(arr) print("整个数组的平均值:", avg_value) # 创建一个权重数组 weights = np.array([0.1, 0.2, 0.3, 0.4, 0.0]) # 计算加权平均值 weighted_avg_value = np.average(arr, weights=weights) print("加权平均值:", weighted_avg_value) #整个数组的平均值: 3.0 #加权平均值: 2.6
12.6var()
在 NumPy 中，计算方差时使用的是统计学中的方差公式，而不是概率论中的方差公式，主要是因为 NumPy 的设计目标是处理实际数据集，而不是概率分布。np.var 函数默认计算的是总体方差（Population Variance），而不是样本方差（Sample Variance）。
import numpy as np data = np.array([1, 2, 3, 4, 5]) # 计算方差，默认计算样本方差（ddof=1） variance = np.var(data) print("方差:", variance) # 如果要计算总体方差，可以设置 ddof=0 population_variance = np.var(data, ddof=0) print("总体方差:", population_variance)
12.7std()
标准差是方差的算术平方根，用来描述一组数据平均值的分散程度。若一组数据的标准差较大，说明大部分的数值和其平均值之间差异较大；若标准差较小，则代表这组数值比较接近平均值
import numpy as np data = np.array([1, 2, 3, 4, 5]) # 计算标准差，默认计算样本标准差（ddof=1） std_dev = np.std(data) print("标准差:", std_dev) # 如果要计算总体标准差，可以设置 ddof=0 population_std_dev = np.std(data, ddof=0) print("总体标准差:", population_std_dev)