9.迭代数组
nditer 是 NumPy 中的一个强大的迭代器对象,用于高效地遍历多维数组。nditer 提供了多种选项和控制参数,使得数组的迭代更加灵活和高效。
控制参数
nditer 提供了多种控制参数,用于控制迭代的行为。
1.order 参数
order 参数用于指定数组的遍历顺序。默认情况下,nditer 按照 C 风格(行优先)遍历数组。
-
C 风格(行优先): order='C'
-
Fortran 风格(列优先): order='F'
# 创建一个二维数组 arr = np.array([[1, 2, 3], [4, 5, 6]]) # 使用 C 风格遍历数组 for x in np.nditer(arr, order='C'): print(x) # 输出: # 1 # 2 # 3 # 4 # 5 # 6 # 使用 Fortran 风格遍历数组 for x in np.nditer(arr, order='F'): print(x) # 输出: # 1 # 4 # 2 # 5 # 3 # 6
2.flags 参数
flags 参数用于指定迭代器的额外行为。
-
multi_index: 返回每个元素的多维索引。
-
external_loop: 返回一维数组而不是单个元素,减少函数调用的次数,从而提高性能。
# 创建一个三维数组 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]
3.op_flags 参数
op_flags 参数用于指定操作数的行为。
-
readonly: 只读操作数。
-
readwrite: 读写操作数。
-
writeonly: 只写操作数。
# 创建一个二维数组 arr = np.array([[1, 2, 3], [4, 5, 6]]) # 使用读写操作数遍历数组 for x in np.nditer(arr, op_flags=['readwrite']): x[...] = 2 * x print(arr) # 输出: # [[ 2 4 6] # [ 8 10 12]]
10.数组操作
10.1 数组变维
函数名称 | 函数介绍 |
---|---|
reshape | 在不改变数组元素的条件下,修改数组的形状 |
flat | 返回是一个迭代器,可以用 for 循环遍历其中的每一个元素 |
flatten | 以一维数组的形式返回一份数组的副本,对副本的操作不会影响到原数组 |
ravel | 返回一个连续的扁平数组(即展开的一维数组),与 flatten不同,它返回的是数组视图(修改视图会影响原数组) |
10.1.1 flat
返回一个一维迭代器,用于遍历数组中的所有元素。无论数组的维度如何,ndarray.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() 返回的是原数组的一个拷贝,因此对返回的数组进行修改不会影响原数组。
语法:
ndarray.flatten(order='C')
参数
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]
1.3 ravel()
用于将多维数组转换为一维数组。与 flatten() 不同,ravel() 返回的是原数组的一个视图(view),而不是拷贝。因此,对返回的数组进行修改会影响原数组。
语法:
ndarray.ravel()
参数
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 的项 |
案例:
import numpy as np def expand_dims_test(): array_one = np.arange(4).reshape(2,2) print('原数组:\n', array_one) print('原数组维度情况:\n', array_one.shape) # 在 1 轴处插入新的轴 array_two = np.expand_dims(array_one, axis=1) print('在 1 轴处插入新的轴后的数组:\n', array_two) print('在 1 轴处插入新的轴后的数组维度情况:\n', array_two.shape) def squeeze_test(): array_one = np.arange(6).reshape(2,1,3) print('原数组:\n', array_one) print('原数组维度情况:\n', array_one.shape) # 删除 array_two = np.squeeze(array_one,1) print('从数组的形状中删除一维项后的数组:\n', array_two) print('从数组的形状中删除一维项后的数组维度情况:\n', array_two.shape)
10.4 连接数组
函数名称 | 参数 | 说明 |
---|---|---|
hstack(tup) | tup:可以是元组,列表,或者numpy数组,返回结果为numpy的数组 | 按水平顺序堆叠序列中数组(列方向) |
vstack(tup) | tup:可以是元组,列表,或者numpy数组,返回结果为numpy的数组 | 按垂直方向堆叠序列中数组(行方向) |
hstack函数要求堆叠的数组在垂直方向(行)上具有相同的形状。如果行数不一致,hstack() 将无法执行,并会抛出 ValueError 异常。
hstack() 要求堆叠的数组在垂直方向(行)上具有相同的形状。如果列数不一致,将无法执行堆叠操作。
vstack() 和 hstack() 要求堆叠的数组在某些维度上具有相同的形状。如果维度不一致,将无法执行堆叠操作。
案例:
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, 4]]) arr2 = np.array([[5], [6], [7]]) print(arr1.shape) # (2, 2) print(arr2.shape) # (3, 1) # 使用 hstack 水平堆叠数组 result = np.hstack((arr1, arr2)) print(result) # ValueError: all the input array dimensions except for the concatenation axis must match exactly # 第一个数组在第0维有2个元素,而第二个数组在第0维有3个元素,因此无法直接连接。
vstack:
# 创建两个一维数组 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]]
# 创建两个形状不同的数组 arr1 = np.array([[1, 2], [3, 4]]) arr2 = np.array([[5, 6, 7], [8, 9, 10]]) # 使用 vstack 垂直堆叠数组 result = np.vstack((arr1, arr2)) print(result) # ValueError: all the input array dimensions except for the concatenation axis must match exactly # 第一个数组在第1维有2个元素,而第二个数组在第1维有3个元素,因此无法直接连接。
10.5 分割数组
函数名称 | 参数 | 说明 |
---|---|---|
hsplit(ary, indices_or_sections) | ary:原数组 indices_or_sections:按列分割的索引位置 | 将一个数组水平分割为多个子数组(按列) |
vsplit(ary, indices_or_sections) | ary:原数组 indices_or_sections:按列分割的索引位置 | 将一个数组垂直分割为多个子数组(按行) |
案例:
import numpy as np ''' hsplit 函数: 1、将一个数组水平分割为多个子数组(按列) 2、ary:原数组 3、indices_or_sections:按列分割的索引位置 ''' # 创建一个二维数组 arr = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]]) # 使用 np.hsplit 将数组分割成三个子数组 # 分割点在索引1和3处,这意味着: # 第一个子数组将包含从第0列到索引1(不包括索引1)的列,即第0列。 # 第二个子数组将包含从索引1(包括索引1)到索引3(不包括索引3)的列,即第1列到第2列。 # 第三个子数组将包含从索引3(包括索引3)到末尾的列,即第3列。 result = np.hsplit(arr, [1, 3]) # 查看结果 print("第一个子数组:\n", result[0]) # 输出包含第0列的子数组 print("第二个子数组:\n", result[1]) # 输出包含第1列和第2列的子数组 print("第三个子数组:\n", result[2]) # 输出包含第3列的子数组 ''' vsplit 函数: 1、将一个数组垂直分割为多个子数组(按行) 2、ary:原数组 3、indices_or_sections:按列分割的索引位置 ''' 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]]
最后一行代码将数组形状修改为(3, 4),原数组的元素数量不够,则重复原数组的元素填充。
11.2 append
函数名称 | 参数 | 说明 |
---|---|---|
append(arr, values, axis=None) | arr:输入的数组 values:向 arr 数组中添加的值,需要和 arr 数组的形状保持一致 axis:默认为 None,返回的是一维数组;当 axis =0 时,追加的值会被添加到行,而列数保持不变,若 axis=1 则与其恰好相反 | 在数组的末尾添加值,返回一个一维数组 |
案例:
''' append(arr, values, axis=None) 函数: 1、将元素值添加到数组的末尾,返回一个一维数组 2、arr:输入的数组 3、values:向 arr 数组中添加的值,需要和 arr 数组的形状保持一致 4、axis:默认为 None,返回的是一维数组;当 axis =0 时,追加的值会被添加到行,而列数保持不变,若 axis=1 则与其恰好相反 ''' def append_test(): array_one = np.arange(6).reshape(2,3) print('原数组:\n', array_one) array_two = np.append(array_one,[[1,1,1],[1,1,1]],axis=None) print('append 后数组 axis=None:\n', array_two) array_three = np.append(array_one, [[1, 1, 1], [1, 1, 1]], axis=0) print('append 后数组 axis=0:\n', array_three) array_three = np.append(array_one, [[1, 1, 1], [1, 1, 1]], axis=1) print('append 后数组 axis=1:\n', array_three)
11.3 insert
函数名称 | 参数 | 说明 |
---|---|---|
insert(arr, obj, values, axis) | arr:输入的数组 obj:表示索引值,在该索引值之前插入 values 值 values:要插入的值 axis:默认为 None,返回的是一维数组;当 axis =0 时,追加的值会被添加到行,而列数保持不变,若 axis=1 则与其恰好相反 | 沿规定的轴将元素值插入到指定的元素前 |
案例:
import numpy as np def insert_test(): array_one = np.arange(6).reshape(2,3) print('原数组:\n', array_one) array_two = np.insert(array_one, 1, [6],axis=None) print('insert 后数组 axis=None:\n', array_two) array_three = np.insert(array_one,1, [6], axis=0) print('insert 后数组 axis=0:\n', array_three) array_three = np.insert(array_one, 1, [6,7], axis=1) print('insert 后数组 axis=1:\n', array_three)
如果obj为-1,表示插入在倒数第一个元素之前。
11.4 delete
函数名称 | 参数 | 说明 |
---|---|---|
delete(arr, obj, axis) | arr:输入的数组 obj:表示索引值,在该索引值之前插入 values 值 axis:默认为 None,返回的是一维数组;当 axis =0 时,删除指定的行,若 axis=1 则与其恰好相反 | 删掉某个轴上的子数组,并返回删除后的新数组 |
案例:
一维数组:
import numpy as np # 创建一个 NumPy 数组 arr = np.array([1, 2, 3, 4, 5, 6]) # 删除索引为 2 和 4 的元素 new_arr = np.delete(arr, [2, 4]) print(new_arr)
二维数组:
import numpy as np def delete_test(): array_one = np.arange(6).reshape(2,3) print('原数组:\n', array_one) array_two = np.delete(array_one,1,axis=None) print('delete 后数组 axis=None:\n', array_two) array_three = np.delete(array_one,1, axis=0) print('delete 后数组 axis=0:\n', array_three) array_three = np.delete(array_one, 1, axis=1) print('delete 后数组 axis=1:\n', array_three)
11.5 argwhere
返回数组中非 0 元素的索引,若是多维数组则返回行、列索引组成的索引坐标
案例:
import numpy as np ''' argwhere(a) 函数: 1、返回数组中非 0 元素的索引,若是多维数组则返回行、列索引组成的索引坐标 ''' def argwhere_test(): array_one = np.arange(6).reshape(2,3) print('原数组:\n', array_one) print('argwhere 返回非0元素索引:\n', np.argwhere(array_one)) print('argwhere 返回所有大于 1 的元素索引:\n', np.argwhere(array_one > 1))
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,则返回去重后的数组元素在原数组中出现的次数 | 删掉某个轴上的子数组,并返回删除后的新数组 |
案例1:返回唯一元素的索引
import numpy as np # 创建一个 NumPy 数组 arr = np.array([1, 2, 2, 3, 4, 4, 5]) unique_elements, indices = np.unique(arr, return_index=True) print(unique_elements) print(indices)
案例2:返回唯一元素及其逆索引
mport numpy as np # 创建一个一维数组 arr = np.array([1, 2, 2, 3, 3, 3, 4, 4, 4, 4]) # 使用 np.unique 查找唯一元素及其逆索引 unique_elements, inverse_indices = np.unique(arr, return_inverse=True) print(unique_elements) # 输出: # [1 2 3 4] print(inverse_indices) # 输出: # [0 1 1 2 2 2 3 3 3 3] # 逆索引数组,表示原始数组中的每个元素在唯一元素数组中的位置。
案例3:返回唯一元素的计数
import numpy as np # 创建一个一维数组 arr = np.array([1, 2, 2, 3, 3, 3, 4, 4, 4, 4]) # 使用 np.unique 查找唯一元素及其计数 unique_elements, counts = np.unique(arr, return_counts=True) print(unique_elements) # 输出: # [1 2 3 4] print(counts) # 输出: # [1 2 3 4]
对于多维数组,unique 函数同样适用。默认情况下,unique 函数会将多维数组展平为一维数组,然后查找唯一元素。
arr = np.array([[1, 2], [2, 3], [1, 2]]) # 查找数组中的唯一元素 unique_elements = np.unique(arr) print(unique_elements)
12.统计函数
12.1 amin() 和 amax()
-
计算数组沿指定轴的最小值与最大值,并以数组形式返回
-
对于二维数组来说,axis=1 表示沿着水平方向,axis=0 表示沿着垂直方向
案例:
''' numpy.amin() 和 numpy.amax() 函数: 1、计算数组沿指定轴的最小值与最大值,并以数组形式返回 2、对于二维数组来说,axis=1 表示沿着水平方向,axis=0 表示沿着垂直方向 ''' def amin_amax_test(): array_one = np.array([[1,23,4,5,6],[1,2,333,4,5]]) print('原数组元素:\n', array_one) print('原数组水平方向最小值:\n', np.amin(array_one, axis=1)) print('原数组水平方向最大值:\n', np.amax(array_one, axis=1)) print('原数组垂直方向最小值:\n', np.amin(array_one, axis=0)) print('原数组垂直方向最大值:\n', np.amax(array_one, axis=0))
输出:
原数组元素: [[ 1 23 4 5 6] [ 1 2 333 4 5]] 原数组水平方向最小值: [1 1] 原数组水平方向最大值: [ 23 333] 原数组垂直方向最小值: [1 2 4 4 5] 原数组垂直方向最大值: [ 1 23 333 5 6]
按1轴求最小值,表示在最内层轴中(每列中)分别找最小值;按0轴求最小值表示在最外层轴中(所有行中按列)找最小值。求最大值类似。
12.2 ptp()
-
计算数组元素中最值之差值,即最大值 - 最小值
-
对于二维数组来说,axis=1 表示沿着水平方向,axis=0 表示沿着垂直方向
# 创建一个二维数组 arr = np.array([[1, 2, 3], [4, 5, 6]]) # 使用 np.ptp 计算峰峰值 ptp_value = np.ptp(arr) print(ptp_value) # 输出: # 5 # 使用 np.ptp 按行计算峰峰值 ptp_values_row = np.ptp(arr, axis=1) # 使用 np.ptp 按列计算峰峰值 ptp_values_col = np.ptp(arr, axis=0) print(ptp_values_row) # 输出: # [2 2] print(ptp_values_col) # 输出: # [3 3 3]
12.3 median()
用于计算中位数,中位数是指将数组中的数据按从小到大的顺序排列后,位于中间位置的值。如果数组的长度是偶数,则中位数是中间两个数的平均值。
# 创建一个二维数组 arr = np.array([[1, 2, 3], [4, 5, 6]]) # 使用 np.median 计算中位数 median_value = np.median(arr,axis=None) print(median_value) # 输出: # 3.5 # 使用 np.median 按行计算中位数 median_values_row = np.median(arr, axis=1) # 使用 np.median 按列计算中位数 median_values_col = np.median(arr, axis=0) print(median_values_row) # 输出: # [2. 5.] print(median_values_col) # 输出: # [2.5 3.5 4.5]
12.4 mean()
沿指定的轴,计算数组中元素的算术平均值(即元素之总和除以元素数量)
# 创建一个一维数组 arr = np.array([1, 2, 3, 4, 5]) # 使用 np.mean 计算平均值 mean_value = np.mean(arr) print(mean_value) # 输出: # 3.0 # 创建一个二维数组 arr = np.array([[1, 2, 3], [4, 5, 6]]) # 使用 np.mean 计算平均值 mean_value = np.mean(arr) print(mean_value) # 输出: # 3.5 # 使用 np.mean 按行计算平均值 mean_values_row = np.mean(arr, axis=1) # 使用 np.mean 按列计算平均值 mean_values_col = np.mean(arr, axis=0) print(mean_values_row) # 输出: # [2. 5.] print(mean_values_col) # 输出: # [2.5 3.5 4.5]
6、average()
加权平均值是将数组中各数值乘以相应的权数,然后再对权重值求总和,最后以权重的总和除以总的单位数(即因子个数);根据在数组中给出的权重,计算数组元素的加权平均值。该函数可以接受一个轴参数 axis,如果未指定,则数组被展开为一维数组。
$$
加权平均值=\dfrac{∑_{i=1}^n(x_i⋅w_i)}{∑_{i=1}^nw_i}
$$
其中 xi是数组中的元素,wi是对应的权重。
如果所有元素的权重之和等于1,则表示为数学中的期望值。
# 创建一个一维数组 arr = np.array([1, 2, 3, 4, 5]) # 创建权重数组 weights = np.array([0.1, 0.2, 0.3, 0.2, 0.2]) # 使用 np.average 计算加权平均值 average_value = np.average(arr, weights=weights) print(average_value) # 输出: # 3.2
7、var()
在 NumPy 中,计算方差时使用的是统计学中的方差公式,而不是概率论中的方差公式,主要是因为 NumPy 的设计目标是处理实际数据集,而不是概率分布。
np.var 函数默认计算的是总体方差(Population Variance),而不是样本方差(Sample Variance)。
总体方差:
对于一个总体数据集 X={x1,x2,…,xN},总体方差的计算公式为:
$$
σ^2=\dfrac{1}{N}∑_{i=1}^N(x_i−μ)^2
$$
其中:
-
N是总体数据点的总数。
-
μ是总体的均值。
# 创建一个数组 arr = np.array([1, 2, 3, 4, 5]) # 计算方差 variance = np.var(arr) print(variance) #输出:2
样本方差:
对于一个样本数据集 X={x1,x2,…,xn},样本方差 的计算公式为:
$$
s^2=\dfrac{1}{n−1}∑_{i=1}^n(x_i−\overline x)^2
$$
其中:
-
n是样本数据点的总数。
-
xˉ是样本的均值。
在样本数据中,样本均值的估计会引入一定的偏差。通过使用 n−1n−1 作为分母,可以校正这种偏差,得到更准确的总体方差估计。
# 创建一个数组 arr = np.array([1, 2, 3, 4, 5]) # 计算方差 variance = np.var(arr, ddof=1) print(variance) #输出:2.5
8、std()
标准差是方差的算术平方根,用来描述一组数据平均值的分散程度。若一组数据的标准差较大,说明大部分的数值和其平均值之间差异较大;若标准差较小,则代表这组数值比较接近平均值
# 创建一个数组 arr = np.array([1, 2, 3, 4, 5]) # 计算标准差 std_dev = np.std(arr) print(std_dev) # 输出:1.4142135623730951