---

个人昵称：lxw-pro
个人主页：欢迎关注 我的主页
个人感悟： “失败乃成功之母”，这是不变的道理，在失败中总结，在失败中成长，才能成为IT界的一代宗师。

# -*- coding = utf-8 -*-
# @Time : 2022/7/28 9:10
# @Author : lxw_pro
# @File : Numpy统计函数-下.py
# @Software : PyCharm

import numpy as np
1
2
3
4
5
6
7

Numpy 学习（续）

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

运行结果：

原数组为：
 [[1 2 3]
 [4 5 6]
 [7 8 9]]
1
2
3
4

---

print()
pjz = np.mean(lxw)
print(f"数组中元素的算术平均值为：{pjz}")
1
2
3

运行结果：

数组中元素的算术平均值为：5.0
1

---

print()
# 按纵列获取其算术平均值：
print(np.mean(lxw, axis=0))
1
2
3

运行结果：

[4. 5. 6.]
1

---

# 按横行获取其算术平均值
print(np.mean(lxw, axis=1))
1
2

运行结果：

[2. 5. 8.]
1

---

numpy.average()

numpy.average() 函数根据在另一个数组中给出的各自的权重计算数组中元素的加权平均值。

加权平均值即将各数值乘以相应的权数，然后加总求和得到总体值，再除以总的单位数。

比如：有数组[1, 2, 3]和相对应的权重[3, 2, 1],他们的权重值=(13+22+3*1)/(1+2+3)

lxw2 = np.array([1, 2, 3])
print("lxw2原数组为：\n", lxw2)
1
2

运行结果：

lxw2原数组为：
 [1 2 3]
1
2

---

# 调用average()函数
print(np.average(lxw2))
1
2

运行结果：

2.0
1

---

me = np.array([3, 2, 1])
# 再次调用average()函数
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
2
3
4
5
6
7

运行结果：

1.6667
权重的和为：[1.6667 6.    ]
1
2

---

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))
1
2
3
4
5
6
7
8
9
10
11

运行结果：

原数组为：
 [[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.]))

1
2
3
4
5
6
7
8
9
10
11
12
13

---

标准差

标准差是一组数据平均值分散程度的一种度量。

标准差是方差的算术平方根。

标准差公式如下：

std = sqrt(mean((x - x.mean())**2))
1

lxw4 = np.array([1, 2, 3])
print(np.std(lxw4))

'''
如果数组是 [1，2，3]，则其平均值为 2。 
所以，差的平方是 [1,0,1]，且再求其平均值的平方根除以 3，即 sqrt(2/3) ，
运行结果为 0.816496580927726

'''
1
2
3
4
5
6
7
8
9

运行结果：

0.816496580927726
1

方差

统计中的方差（样本方差）是每个样本值与全体样本值的平均数之差的平方值的平均数，即 mean((x - x.mean())** 2)

可以说，标准差是方差的平方根

lxw5 = np.array([1, 2, 3])
print(np.var(lxw5))
1
2

运行结果：

0.6666666666666666
1

————————————————————————————————————————————

# -*- coding = utf-8 -*-
# @Time : 2022/7/28 13:52
# @Author : lxw_pro
# @File : Numpy 排序.py
# @Software : PyCharm
1
2
3
4
5

NumPy 排序、条件刷选函数

NumPy 提供了多种排序的方法。 这些排序函数实现不同的排序算法，分别有快速排序、
归并排序和堆排序，其中归并排序占有工作空间，稳定性较好，执行速度居中。
每个排序算法的特征在于执行速度，最坏情况性能，所需的工作空间和算法的稳定性

numpy.sort()

'''
numpy.sort()
numpy.sort() 函数返回输入数组的排序副本。函数格式如下：
numpy.sort(a, axis, kind, order)

复杂参数说明：

kind: 默认为'quicksort'（快速排序）
order: 若数组包含字段，则是要排序的字段

注：axis=0 按列排序，axis=1 按行排序
'''
1
2
3
4
5
6
7
8
9
10
11
12

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)

# 在sort函数中排序字段：
dty = np.dtype([('name', 'S08'), ('age', int)])
lxw2 = np.array([
    ('lxw-pro', 21), ('cw', 23), ('tzs', 22), ('ltw', 18)
], dtype=dty)

print("排序字段后的数组为：\n", lxw2)

# 按 name 排序后的数组为：
print(np.sort(lxw2, order='name'))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

运行结果为：

原数组为：
 [[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)]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

---

numpy.argsort()

# 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=' ')
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

运行结果为：

原数组为：
 [8 6 9]
调用argsort函数后的元组：
 [1 0 2]
以排序后的顺序重构原数组：
 [6 8 9]
6 8 9 
1
2
3
4
5
6
7

---

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)}")

# 沿轴0返回最大元素的索引值
yz0 = np.argmax(lxw4, axis=0)
print(f"沿轴0返回最大元素的索引值为：{yz0}")

# 沿轴1返回最大元素的索引值
yz1 = np.argmax(lxw4, axis=1)
print(f"沿轴0返回最大元素的索引值为：{yz1}")

print()
# 展开数组
zk = lxw4.flatten()
print("展开后的数组：\n", zk)

print("展开后的数组中的最大值：", zk[np.argmax(lxw4)])
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

运行结果为：

[[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

1
2
3
4
5
6
7
8
9
10

---

numpy.argmin()

print()
print("="*20)
# 沿给定轴返回最小元素的索引值
print(f"沿给定轴返回最小元素的索引值为：{np.argmin(lxw4)}")

print()
# 沿轴0返回最小元素的索引值
yz0 = np.argmin(lxw4, axis=0)
print(f"沿轴0返回最小元素的索引值为：{yz0}")

# 沿轴1返回最小元素的索引值
yz1 = np.argmin(lxw4, axis=1)
print(f"沿轴0返回最小元素的索引值为：{yz1}")

print()
# 展开数组
zk = lxw4.flatten()
print("展开后的数组：\n", zk)

print("展开后的数组中的最小值：", zk[np.argmin(lxw4)])
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

运行结果为：

====================
沿给定轴返回最小元素的索引值为：0
沿轴0返回最小元素的索引值为：[0 1 0]
沿轴0返回最小元素的索引值为：[0 1 0]
展开后的数组：
 [16 86 26 66 36 56 46 96 76]
展开后的数组中的最小值： 16
1
2
3
4
5
6
7

---

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)
1
2
3
4
5
6
7
8
9
10
11
12
13

运行结果为：

原数组为：
 [[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]
1
2
3
4
5
6
7
8

---

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)
1
2
3
4
5
6
7
8
9
10

运行结果为：

原数组为：
 [[0 1 2]
 [3 4 5]
 [6 7 8]]
判断数组其中的奇数元素：
 [[False  True False]
 [ True False  True]
 [False  True False]]
提取的元素有：
 [1 3 5 7]
1
2
3
4
5
6
7
8
9
10

---

每日一言：

我一直喜欢下午的阳光，它让我相信这个世界任何事情都会有转机，相信命运的宽厚和美好！

---

持续更新中…

点赞，你的认可是我创作的动力！
收藏，你的青睐是我努力的方向！
评论，你的意见是我进步的财富！
关注，你的喜欢是我长久的坚持！

欢迎关注微信公众号【程序人生6】，一起探讨学习哦！！！