Numpy基础（二）
11.数组元素的增删改查
11.1resize
| 函数名 | 参数 |
|---|---|
| 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]]
resize 后数组：
[[0 1 2 3]
[4 5 0 1]
[2 3 4 5]]
"""
11.2insert
| 函数名称 | 参数 | 说明 |
|---|---|---|
| insert(arr, obj, values, axis) | arr：输入的数组 obj：表示索引值，在该索引值之前插入 值 values：要插入的值 axis：默认为 None，返回的是一维数组；当 axis =0 时，追加的值会被添加到行，而列数保持不变，若 axis=1 则与其恰好相反 |
沿规定的轴将元素值插入到指定的元素前 |
import numpy as np
def insert_test():
arr01 = np.arange(6).reshape(2, 3)
print('原数组：\n', arr01)
arr02 = np.insert(arr01, 1, [6], axis=None)
print('insert 后数组 axis=None：\n', arr02)
# 在索引为1的行插入[6],并自动广播
arr03 = np.insert(arr01, 1, [6], axis=0)
print('insert 后数组 axis=0：\n', arr03)
# 在索引为1的列插入[6],并自动广播
arr03 = np.insert(arr01, 1, [6], axis=1)
print('insert 后数组 axis=1：\n', arr03)
arr04 = np.insert(arr01, 1, [6, 7], axis=1)
print('insert 后数组 axis=1：\n', arr04)
if __name__ == '__main__':
insert_test()
运行结果
原数组：
[[0 1 2]
[3 4 5]]
insert 后数组 axis=None：
[0 6 1 2 3 4 5]
insert 后数组 axis=0：
[[0 1 2]
[6 6 6]
[3 4 5]]
insert 后数组 axis=1：
[[0 6 1 2]
[3 6 4 5]]
insert 后数组 axis=1：
[[0 6 1 2]
[3 7 4 5]]
11.3delete
| 函数名称 | 参数 | 说明 |
|---|---|---|
| delete(arr, obj, axis) | arr：输入的数组 obj：表示索引值，要删除数据的索引 axis：默认为 None，返回的是一维数组；当 axis =0 时，删除指定的行，若 axis=1 则与其恰好相反 |
删掉某个轴上的子数组，并返回删除后的新数组 |
import numpy as np
def delete_test():
# 创建一个 NumPy 数组
arr = np.array([1, 2, 3, 4, 5, 6])
# 删除索引为 2 和 4 的元素
new_arr = np.delete(arr, [2, 4])
print("一维数组[1, 2, 3, 4, 5, 6]delete后\n",new_arr)
#二维数组
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)
if __name__ == '__main__':
delete_test()
运行结果
一维数组[1, 2, 3, 4, 5, 6]delete后
[1 2 4 6]
原数组：
[[0 1 2]
[3 4 5]]
delete 后数组 axis=None：
[0 2 3 4 5]
delete 后数组 axis=0：
[[0 1 2]]
delete 后数组 axis=1：
[[0 2]
[3 5]]
11.4argwhere
返回数组中非 0 元素的索引，若是多维数组则返回行、列索引组成的索引坐标
import numpy as np
def argwhere_test():
arr01 = np.arange(6).reshape(2,3)
print('原数组：\n', arr01)
print('argwhere 返回非0元素索引：\n', np.argwhere(arr01))
print('argwhere 返回所有大于 1 的元素索引：\n', np.argwhere(arr01 > 1))
if __name__ == '__main__':
argwhere_test()
运行结果
原数组：
[[0 1 2]
[3 4 5]]
argwhere 返回非0元素索引：
[[0 1]
[0 2]
[1 0]
[1 1]
[1 2]]
argwhere 返回所有大于 1 的元素索引：
[[0 2]
[1 0]
[1 1]
[1 2]]
11.5 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)
# 运行结果
# [1 2 3 4 5]
# [0 1 3 4 6]
案例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)
#[1 2 3]
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))
输出：
原数组元素：
[[ 1 23 4 5 6]
[ 1 2 333 4 5]]
原数组水平方向最小值：
[1 1]
按1轴求最小值，表示在最内层轴中（每列中）分别找最小值；按1轴求最小值表示在最外层轴中（所有行中按列）找最小值。求最大值类似。
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，如果未指定，则数组被展开为一维数组。
加权平均值 = ∑ i = 1 n ( x i ⋅ w i ) ∑ i = 1 n w i 加权平均值=\dfrac{∑_{i=1}^n(x_i⋅w_i)}{∑_{i=1}^nw_i} 加权平均值=∑i=1nwi∑i=1n(xi⋅wi)
其中 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 = 1 N ∑ i = 1 N ( x i − μ ) 2 σ^2=\dfrac{1}{N}∑_{i=1}^N(x_i−μ)^2 σ2=N1i=1∑N(xi−μ)2
其中：
- N是总体数据点的总数。
- μ是总体的均值。
# 创建一个数组
arr = np.array([1, 2, 3, 4, 5])
# 计算方差
variance = np.var(arr)
print(variance)
#输出：2
样本方差：
对于一个样本数据集 X={x1,x2,…,xn}，样本方差 的计算公式为：
s 2 = 1 n − 1 ∑ i = 1 n ( x i − x ‾ ) 2 s^2=\dfrac{1}{n−1}∑_{i=1}^n(x_i−\overline x)^2 s2=n−11i=1∑n(xi−x)2
其中：
- n是样本数据点的总数。
- xˉ是样本的均值。
在样本数据中，样本均值的估计会引入一定的偏差。通过使用 n−1作为分母，可以校正这种偏差，得到更准确的总体方差估计。
# 创建一个数组
arr = np.array([1, 2, 3, 4, 5])
# 计算方差
variance = np.var(arr, ddof=1)
print(variance)
#输出：2.5
8、std()
标准差是方差的算术平方根，用来描述一组数据平均值的分散程度。若一组数据的标准差较大，说明大部分的数值和其平均值之间差异较大；若标准差较小，则代表这组数值比较接近平均值
import numpy as np
# 创建一个数组
arr = np.array([1, 2, 3, 4, 2, 2, 5])
# 计算标准差
std_dev = np.std(arr)
print(std_dev)
# 输出：1.2777531299998799