import numpy as np
numpy.mean()
numpy.mean() 函数返回数组中元素的算术平均值
算术平均值是沿轴的元素的总和除以元素的数量。
lxw = np.array([
[1, 2, 3],
[4, 5, 6],
[7, 8, 9]
])
print("原数组为：\n", lxw)
运行结果：
原数组为：
[[1 2 3]
[4 5 6]
[7 8 9]]
print()
pjz = np.mean(lxw)
print(f"数组中元素的算术平均值为：{pjz}")
运行结果：
数组中元素的算术平均值为：5.0
print()
print(np.mean(lxw, axis=0))
运行结果：
[4. 5. 6.]
print(np.mean(lxw, axis=1))
运行结果：
[2. 5. 8.]
numpy.average()
numpy.average() 函数根据在另一个数组中给出的各自的权重计算数组中元素的加权平均值。
_加权平均值_即将各数值乘以相应的权数，然后加总求和得到总体值，再除以总的单位数。
比如：有数组[1, 2, 3]和相对应的权重[3, 2, 1],他们的 权重值=(1 _3+2_2+3*1)/(1+2+3)
lxw2 = np.array([1, 2, 3])
print("lxw2原数组为：\n", lxw2)
运行结果：
lxw2原数组为：
[1 2 3]
print(np.average(lxw2))
运行结果：
2.0
me = np.array([3, 2, 1])
zc = np.average(lxw2, weights=me)
print(np.around(zc, 4))
he = np.average([1, 2, 3], weights=[3, 2, 1], returned=True)
print("权重的和为：{}".format(np.round(he, 4)))
运行结果：
1.6667
权重的和为：[1.6667 6. ]
print()
lxw3 = np.arange(9).reshape(3, 3)
print("原数组为：\n", lxw3)
xgh = np.array([5, 2, 6])
print("修改后的数组为：\n", np.average(lxw3, axis=0, weights=xgh))
print("修改后的数组为：\n", np.average(lxw3, axis=1, weights=xgh))
print("权重的和：\n", np.average(lxw3, axis=0, weights=xgh, returned=True))
print("权重的和：\n", np.average(lxw3, axis=1, weights=xgh, returned=True))
运行结果：
原数组为：
[[0 1 2]
[3 4 5]
[6 7 8]]
修改后的数组为：
[3.23076923 4.23076923 5.23076923]
修改后的数组为：
[1.07692308 4.07692308 7.07692308]
权重的和：
(array([3.23076923, 4.23076923, 5.23076923]), array([13., 13., 13.]))
权重的和：
(array([1.07692308, 4.07692308, 7.07692308]), array([13., 13., 13.]))
标准差
标准差是一组数据平均值分散程度的一种度量。
标准差是方差的算术平方根。
标准差公式如下：
std = sqrt(mean((x - x.mean())**2))
lxw4 = np.array([1, 2, 3])
print(np.std(lxw4))
'''
如果数组是 [1，2，3]，则其平均值为 2。
所以，差的平方是 [1,0,1]，且再求其平均值的平方根除以 3，即 sqrt(2/3) ，
运行结果为 0.816496580927726
'''
运行结果：
0.816496580927726
统计中的方差（样本方差）是每个样本值与全体样本值的平均数之差的平方值的平均数，即
mean((x - x.mean())** 2)
可以说， 标准差是方差的平方根
lxw5 = np.array([1, 2, 3])
print(np.var(lxw5))
运行结果：
0.6666666666666666
————————————————————————————————————————————
NumPy 提供了多种排序的方法。 这些排序函数实现不同的排序算法，分别有快速排序、
归并排序和堆排序，其中 归并排序占有工作空间，稳定性较好，执行速度居中。
每个排序算法的特征在于执行速度，最坏情况性能，所需的工作空间和算法的稳定性
numpy.sort()
'''
numpy.sort()
numpy.sort() 函数返回输入数组的排序副本。函数格式如下：
numpy.sort(a, axis, kind, order)
复杂参数说明：
kind: 默认为'quicksort'（快速排序）
order: 若数组包含字段，则是要排序的字段
注：axis=0 按列排序，axis=1 按行排序
'''
import numpy as np
lxw = np.array([
[3, 5, 2],
[8, 2, 6],
[9, 4, 1]
])
print("原数组为：\n", lxw)
print()
ah = np.sort(lxw)
print("按行排列：\n", ah)
print()
al = np.sort(lxw, axis=0)
print("按列排列：\n", al)
dty = np.dtype([('name', 'S08'), ('age', int)])
lxw2 = np.array([
('lxw-pro', 21), ('cw', 23), ('tzs', 22), ('ltw', 18)
], dtype=dty)
print("排序字段后的数组为：\n", lxw2)
print(np.sort(lxw2, order='name'))
原数组为：
[[3 5 2]
[8 2 6]
[9 4 1]]
按行排列：
[[2 3 5]
[2 6 8]
[1 4 9]]
按列排列：
[[3 2 1]
[8 4 2]
[9 5 6]]
排序字段后的数组为：
[(b'lxw-pro', 21) (b'cw', 23) (b'tzs', 22) (b'ltw', 18)]
[(b'cw', 23) (b'ltw', 18) (b'lxw-pro', 21) (b'tzs', 22)]
numpy.argsort()
lxw3 = np.array([8, 6, 9])
print("原数组为：\n", lxw3)
arg = np.argsort(lxw3)
print("调用argsort函数后的元组：\n", arg)
cg = lxw3[arg]
print("以排序后的顺序重构原数组：\n", cg)
print()
for i in arg:
cg2 = lxw3[i]
print(cg2, end=' ')
原数组为：
[8 6 9]
调用argsort函数后的元组：
[1 0 2]
以排序后的顺序重构原数组：
[6 8 9]
6 8 9
numpy.argmax()
numpy.argmax() 和 numpy.argmin()函数分别沿给定轴返回最大和最小元素的索引
lxw4 = np.array([
[16, 86, 26],
[66, 36, 56],
[46, 96, 76]
])
print(lxw4)
print()
print(f"沿给定轴返回最大元素的索引值为：{np.argmax(lxw4)}")
yz0 = np.argmax(lxw4, axis=0)
print(f"沿轴0返回最大元素的索引值为：{yz0}")
yz1 = np.argmax(lxw4, axis=1)
print(f"沿轴0返回最大元素的索引值为：{yz1}")
print()
zk = lxw4.flatten()
print("展开后的数组：\n", zk)
print("展开后的数组中的最大值：", zk[np.argmax(lxw4)])
[[16 86 26]
[66 36 56]
[46 96 76]]
沿给定轴返回最大元素的索引值为：7
沿轴0返回最大元素的索引值为：[1 2 2]
沿轴0返回最大元素的索引值为：[1 0 1]
展开后的数组：
[16 86 26 66 36 56 46 96 76]
展开后的数组中的最大值： 96
numpy.argmin()
print()
print("="*20)
print(f"沿给定轴返回最小元素的索引值为：{np.argmin(lxw4)}")
print()
yz0 = np.argmin(lxw4, axis=0)
print(f"沿轴0返回最小元素的索引值为：{yz0}")
yz1 = np.argmin(lxw4, axis=1)
print(f"沿轴0返回最小元素的索引值为：{yz1}")
print()
zk = lxw4.flatten()
print("展开后的数组：\n", zk)
print("展开后的数组中的最小值：", zk[np.argmin(lxw4)])
====================
沿给定轴返回最小元素的索引值为：0
沿轴0返回最小元素的索引值为：[0 1 0]
沿轴0返回最小元素的索引值为：[0 1 0]
展开后的数组：
[16 86 26 66 36 56 46 96 76]
展开后的数组中的最小值： 16
numpy.where()
numpy.where() 函数返回输入数组中满足给定条件的元素的索引
lxw5 = np.array([
[3, 6, 9],
[2, 9, 4],
[8, 6, 2]
])
print("原数组为：\n", lxw5)
dy = np.where(lxw5 >= 6)
print("大于6的元素索引有：\n", dy)
hq = lxw5[dy]
print("获取其元素：\n", hq)
原数组为：
[[3 6 9]
[2 9 4]
[8 6 2]]
大于6的元素索引有：
(array([0, 0, 1, 2, 2], dtype=int64), array([1, 2, 1, 0, 1], dtype=int64))
获取其元素：
[6 9 9 8 6]
numpy.extract()
numpy.extract() 函数根据某个条件从数组中抽取元素，返回满条件的元素
lxw6 = np.arange(9).reshape(3, 3)
print("原数组为：\n", lxw6)
jsh = np.mod(lxw6, 2) != 0
print("判断数组其中的奇数元素：\n", jsh)
tq = np.extract(jsh, lxw6)
print("提取的元素有：\n", tq)
原数组为：
[[0 1 2]
[3 4 5]
[6 7 8]]
判断数组其中的奇数元素：
[[False True False]
[ True False True]
[False True False]]
提取的元素有：
[1 3 5 7]
每日一言：
我一直喜欢下午的阳光，它让我相信这个世界任何事情都会有转机，相信命运的宽厚和美好！
点赞，你的认可是我创作的
动力！
收藏，你的青睐是我努力的方向！
评论，你的意见是我进步的财富！
关注，你的喜欢是我长久的坚持！
Original: https://blog.csdn.net/m0_66318554/article/details/125857264
Author: lxw-pro
Title: 【数据处理必备Numpy~python】
原创文章受到原创版权保护。转载请注明出处：https://www.johngo689.com/614174/
转载文章受原作者版权保护。转载请注明原作者出处！