【数模之数据分析-1】

---

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

Array数组：

# 对于ndarray结构老说，里面所有的 元素必须是同一类型的，如果不是的话，会自动的向下进行转换。
import numpy as np

lxw = [1, 2, 3, 4, 5]
lxw2 = np.array([1, 2, 3, 4, 5])
print(lxw2)
print(type(lxw2))

lxw3 = lxw2 + 1
print(lxw2)
print(lxw3)
print(lxw3+lxw2)

print(lxw3[3])
print(lxw3.shape)

lxw4 = np.array([
    [1, 3, 5],
    [2, 4, 6]
])
print(lxw4)

# 类型
print(lxw4.dtype)

print(lxw4.itemsize)

# 数组个数
print(lxw4.size)

# 维度
print(lxw4.ndim)

# 以0填充
lxw4.fill(0)
print(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
28
29
30
31
32
33
34
35
36

相关程序运行如下：

[1 2 3 4 5]

[1 2 3 4 5]
[2 3 4 5 6]
[ 3  5  7  9 11]
5
(5,)
[[1 3 5]
 [2 4 6]]
int32
4
6
2
[[0 0 0]
 [0 0 0]]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

---

索引与切片：与python大同小异，还是从0开始

lxw_array = np.array(lxw)
print(lxw_array[0])

print(lxw_array[1:4])

print(lxw_array[-3:])


# 矩阵格式【即多维的形式】
lxw_array2 = np.array([
    [9, 8, 7],
    [6, 5, 4],
    [3, 2, 1]
])

print(lxw_array2)

# 几行几列
print(lxw_array2.shape)

# 数组个数
print(lxw_array2.size)

# 维度几维
print(lxw_array2.ndim)

# 取矩阵行
print(lxw_array2[1])

# 取矩阵列
print(lxw_array2[:, 1])

# 取第二行的第一二个
print(lxw_array2[1, 0:2])

# 修改矩阵最中间的数
lxw_array2[1, 1] = 20
print(lxw_array2)

# 复制矩阵
lxw_array3 = lxw_array2.copy()
print(lxw_array3)

# 修改复制矩阵最中间的数
lxw_array3[1, 1] = 52
print(lxw_array3)


gs = np.arange(0, 100, 10)
print(gs)


mask = np.array([0, 1, 1, 0, 0, 1, 0, 1, 0, 1], dtype=bool)
print(mask)

print(gs[mask])


ran_arr = np.random.rand(8)
print(ran_arr)

mask = ran_arr > 0.5
print(mask)

sz = np.array([12, 23, 34, 45, 56])
print(sz > 36)

# 大于该数的为True，反之，则是False
print(np.where(sz > 36))

# 字节个数
print(sz.nbytes)

# 整数，小数，字符同时存在
sz2 = np.array([1, 23, 6.2, 'str'], dtype=np.object)
print(sz2)
print(sz2*2)

# 转化为浮点型
sz3 = np.asarray(sz, dtype=np.float32)
print(sz3)

# 法2（上）
sz3 = sz.astype(np.float32)
print(sz3)
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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

相关程序运行如下：

1
[2 3 4]
[3 4 5]
[[9 8 7]
 [6 5 4]
 [3 2 1]]
(3, 3)
9
2
[6 5 4]
[8 5 2]
[6 5]
[[ 9  8  7]
 [ 6 20  4]
 [ 3  2  1]]
[[ 9  8  7]
 [ 6 20  4]
 [ 3  2  1]]
[[ 9  8  7]
 [ 6 52  4]
 [ 3  2  1]]
[ 0 10 20 30 40 50 60 70 80 90]
[False  True  True False False  True False  True False  True]
[10 20 50 70 90]
[0.07407331 0.46338347 0.50051622 0.89459322 0.02400678 0.10385683
 0.78564635 0.37998512]
[False False  True  True False False  True False]
[False False False  True  True]
(array([3, 4], dtype=int32),)
20
[1 23 6.2 'str']
[2 46 12.4 'strstr']
[12. 23. 34. 45. 56.]
[12. 23. 34. 45. 56.]

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
31
32
33
34
35

---

数值运算–array数组

szjs = np.array([
    [5, 2, 0],
    [1, 3, 2]
])

# 数组内全数相加
print(np.sum(szjs))

# 指定要进行的操作是沿着什么轴（维度）
# 列加：
print(np.sum(szjs, axis=0))

# 法二（同上）：
lj = szjs.sum(axis=0)
print(lj)

# 行加：
print(np.sum(szjs, axis=1))

# 法二（同上）：
hj = szjs.sum(axis=1)
print(hj)

# 列乘：
lc = szjs.prod(axis=0)
print(lc)

# 行乘：
hc = szjs.prod(axis=1)
print(hc)

# szjs当中最小值：
zxz = szjs.min()
print(zxz)

# 哪个位置的数最小
argx = szjs.argmin()
print(argx)

# 列最小值：
lzxz = szjs.min(axis=0)
print(lzxz)

# 行最小值：
hzxz = szjs.min(axis=1)
print(hzxz)

# szjs当中最大值
zdz = szjs.max()
print(zdz)

# 哪个位置的数最大
argd = szjs.argmax()
print(argd)

# 列最大值：
lzdz = szjs.max(axis=0)
print(lzdz)

# 行最大值：
hzdz = szjs.max(axis=1)
print(hzdz)

largd = szjs.argmax(axis=0)
print(largd)

hargd = szjs.argmax(axis=1)
print(hargd)


largx = szjs.argmin(axis=0)
print(largx)

largx = szjs.argmin(axis=1)
print(largx)

# 均值：
jz = szjs.mean()
print(jz)

# 列均值：
ljz = szjs.mean(axis=0)
print(ljz)

# 行均值：
hjz = szjs.mean(axis=1)
print(hjz)


# 标准差:
bzc = szjs.std()
print(bzc)

# 列标准差：
lbzc = szjs.std(axis=0)
print(lbzc)

# 行标准差：
hbzc = szjs.std(axis=1)
print(hbzc)


# 方差：
fc = szjs.var()
print(fc)

# 列方差
lfc = szjs.var(axis=0)
print(lfc)

# 行方差
hfc = szjs.var(axis=1)
print(hfc)

# 限制,大于该数的用指定最大数表示，反之也一样【在区间内的不用管】
xz = szjs.clip(0, 3)
print(xz)

# 小数四舍五入成整数
xsz = np.array([2.6, 1.46, 8.41])
print(xsz.round())

# 四舍五入中指定小数点
print(xsz.round(decimals=1))
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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

相关程序运行如下：

13
[6 5 2]
[6 5 2]
[7 6]
[7 6]
[5 6 0]
[0 6]
0
2
[1 2 0]
[0 1]
5
0
[5 3 2]
[5 3]
[0 1 1]
[0 1]
[1 0 0]
[2 0]
2.1666666666666665
[3.  2.5 1. ]
[2.33333333 2.        ]
1.5723301886761007
[2.  0.5 1. ]
[2.05480467 0.81649658]
2.4722222222222223
[4.   0.25 1.  ]
[4.22222222 0.66666667]
[[3 2 0]
 [1 3 2]]
[3. 1. 8.]
[2.6 1.5 8.4]
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
31
32

---

排序操作：

pxsz = np.array([
    [3, 8, 2],
    [9, 4, 1],
    [3, 9, 1]
])
# 默认axis=1排序
print(np.sort(pxsz))

print(np.sort(pxsz, axis=0))

# 行逆转
print(np.sort(pxsz)[::-1])

# 排序前的位置
wz = np.argsort(pxsz)
print(wz)

# 插数
pxarr = np.linspace(0, 10, 8)
print(pxarr)

xszz = np.array([5.2, 6.6, 8.9])
print(np.searchsorted(pxarr, xszz))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

相关程序运行如下：

[[2 3 8]
 [1 4 9]
 [1 3 9]]
[[3 4 1]
 [3 8 1]
 [9 9 2]]
[[1 3 9]
 [1 4 9]
 [2 3 8]]
[[2 0 1]
 [2 1 0]
 [2 0 1]]
[ 0.          1.42857143  2.85714286  4.28571429  5.71428571  7.14285714
  8.57142857 10.        ]
[4 5 7]

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

---

数组形状操作

larr = np.arange(10)
print(larr)

print(larr.shape)

larr.shape = 2, 5
print(larr)

# 仔细感受其间的区别：
res = larr.reshape(1, 10)
print(res)
print(res.shape)

res2 = res[np.newaxis, :]
print(res2)
print(res2.shape)

res3 = res[:, np.newaxis]
print(res3)
print(res3.shape)

res4 = res[:, np.newaxis, np.newaxis]
print(res4)
print(res4.shape)

# 压缩：
res5 = res4.squeeze()
print(res5)

# 转置列行：
print(larr.transpose())

# 法二（同上）：
print(larr.T)
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
31
32
33
34

相关程序运行如下：

[0 1 2 3 4 5 6 7 8 9]
(10,)
[[0 1 2 3 4]
 [5 6 7 8 9]]
[[0 1 2 3 4 5 6 7 8 9]]
(1, 10)
[[[0 1 2 3 4 5 6 7 8 9]]]
(1, 1, 10)
[[[0 1 2 3 4 5 6 7 8 9]]]
(1, 1, 10)
[[[[0 1 2 3 4 5 6 7 8 9]]]]
(1, 1, 1, 10)
[0 1 2 3 4 5 6 7 8 9]
[[0 5]
 [1 6]
 [2 7]
 [3 8]
 [4 9]]
[[0 5]
 [1 6]
 [2 7]
 [3 8]
 [4 9]]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

---

数组的连接：

lj1 = np.array([
    [213, 324, 543],
    [23, 65, 865]
])

lj2 = np.array([
    [343, 654, 234],
    [54, 75, 54]
])

# 列拼接：
llj = np.concatenate((lj1, lj2))
print(llj)

llj2 = np.vstack((lj1, lj2))
print(llj2)

# 行拼接：
hlj = np.concatenate((lj1, lj2), axis=1)
print(hlj)

hlj2 = np.hstack((lj1, lj2))
print(hlj2)

# 拉平：
lp = hlj.flatten()
print(lp)

lp2 = llj.ravel()
print(lp2)
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

相关程序运行如下：

[[213 324 543]
 [ 23  65 865]
 [343 654 234]
 [ 54  75  54]]
[[213 324 543]
 [ 23  65 865]
 [343 654 234]
 [ 54  75  54]]
[[213 324 543 343 654 234]
 [ 23  65 865  54  75  54]]
[[213 324 543 343 654 234]
 [ 23  65 865  54  75  54]]
[213 324 543 343 654 234  23  65 865  54  75  54]
[213 324 543  23  65 865 343 654 234  54  75  54]
1
2
3
4
5
6
7
8
9
10
11
12
13
14

---

数组生成–构造出来一个数组

sz1 = np.array([5, 2, 0])
print(sz1)

sz2 = np.arange(10)
print(sz2)

sz3 = np.arange(2, 20, 2)
print(sz3)

sz4 = np.arange(2, 20, 2, dtype=np.float32)
print(sz4)

# 区间内构造n个数：
gzs = np.linspace(0, 8, 20)
print(gzs)

# 默认是以10为底的
s = np.logspace(0, 1, 5)
print(s)

x = np.linspace(-10, 10, 5)
print(x)

y = np.linspace(-10, 10, 5)
print(y)

# 构造网格：
x, y = np.meshgrid(x, y)
print(x)
print(y)

hxl = np.r_[0:10:1]
print(hxl)

lxl = np.c_[0:10:1]
print(lxl)

# 更常用的zeros、ones
oo = np.zeros(3)
print(oo)

oo0 = np.zeros((3, 3))
print(oo0)

oo1 = np.ones((3, 3))
print(oo1)

oo8 = np.ones((3, 3)) * 8
print(oo8)

oo5 = np.ones((3, 3), dtype=np.float32)
print(oo5)

k = np.empty(6)
print(k)

k.fill(1)
print(k)

o = np.ones_like(sz1)
print(o)

# 构造矩阵：
print(np.identity(5))
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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64

相关程序运行如下：

[5 2 0]
[0 1 2 3 4 5 6 7 8 9]
[ 2  4  6  8 10 12 14 16 18]
[ 2.  4.  6.  8. 10. 12. 14. 16. 18.]
[0.         0.42105263 0.84210526 1.26315789 1.68421053 2.10526316
 2.52631579 2.94736842 3.36842105 3.78947368 4.21052632 4.63157895
 5.05263158 5.47368421 5.89473684 6.31578947 6.73684211 7.15789474
 7.57894737 8.        ]
[ 1.          1.77827941  3.16227766  5.62341325 10.        ]
[-10.  -5.   0.   5.  10.]
[-10.  -5.   0.   5.  10.]
[[-10.  -5.   0.   5.  10.]
 [-10.  -5.   0.   5.  10.]
 [-10.  -5.   0.   5.  10.]
 [-10.  -5.   0.   5.  10.]
 [-10.  -5.   0.   5.  10.]]
[[-10. -10. -10. -10. -10.]
 [ -5.  -5.  -5.  -5.  -5.]
 [  0.   0.   0.   0.   0.]
 [  5.   5.   5.   5.   5.]
 [ 10.  10.  10.  10.  10.]]
[0 1 2 3 4 5 6 7 8 9]
[[0]
 [1]
 [2]
 [3]
 [4]
 [5]
 [6]
 [7]
 [8]
 [9]]
[0. 0. 0.]
[[0. 0. 0.]
 [0. 0. 0.]
 [0. 0. 0.]]
[[1. 1. 1.]
 [1. 1. 1.]
 [1. 1. 1.]]
[[8. 8. 8.]
 [8. 8. 8.]
 [8. 8. 8.]]
[[1. 1. 1.]
 [1. 1. 1.]
 [1. 1. 1.]]
[2.33333333 2.33333333 2.33333333 2.         2.         2.        ]
[1. 1. 1. 1. 1. 1.]
[1 1 1]
[[1. 0. 0. 0. 0.]
 [0. 1. 0. 0. 0.]
 [0. 0. 1. 0. 0.]
 [0. 0. 0. 1. 0.]
 [0. 0. 0. 0. 1.]]

进程已结束，退出代码为 0

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
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56

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

一切都在变好的路上

1、熬夜

很多人以为熬夜只是影响作息，伤害身体。
事实上，它也在慢慢偷走你的时间。
为什么周末的时间过得这么快，
这是因为你昨晚熬夜，导致起床晚，错过了美好的早晨。
【醒来的时候都快中午了】

2、没有节制地书刷手机

现代人已经离不开手机了。路上、候车、吃饭，无论男女老少，每个人都随处可见地刷着手机。
短视频真的很精彩，在你欲罢不能时，已有大把时间从你手中溜走了。

3、相对于刷短视频

沉迷于游戏更可怕。
因为丢掉的不止是时间，
它可能已经同时影响到了你的工作或学习。

4、不断地缅怀过去

纠结过去的某件错事，
在脑海中一遍遍地批判自己。
时间长了，思想负担。
像滚雪球一样越滚越大。
要尝试放过自己，
别用现在的标准来要求以前的自己，
过去的就让它过去吧，
每一天都是崭新的，
做人就应该要往前看。

5、反复拖延

今天的事推明天，明天的推到后天。
72小时定律告诉我们，
当你决定做一件事，
如果72小时内没有做，
那你做这件事的几率趋近于零。
拖延症是破坏我们计划的最大敌人，
但实际上它又是一场与自己的博弈。
所以我们需要培养自己的执行力，
每一次果断，每一次行动，
都是打败那个在干扰你的敌人。

6、不懂得拒绝

这类人有一个明显得特征，
不知道自己时间的宝贵，
对别人有求必应。
平时帮别人做一些小事，
结果往往不但没有落得好名声，
还费力不讨好。

7、为了合群而合群

盲目地区融入不适合自己的圈子。
看似成群结队，受人欢迎了，
其实是在浪费时间，
放弃提升自己的机会。
千万别等着别人过上理想生活时，
才后悔 为什么没有早点努力！

8、尽量“解决”以上“问题”…

---

每日一言：

把寄予他人的希望收回来放在自己身上，倒也温馨。

---

持续更新中…

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

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