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
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
import numpy as np

# 1、读取文件数据
pk10 = np.genfromtxt("../pk10.txt",delimiter="	",dtype="str")  # 读取文件数据，并且指定“	”为分隔符
print(type(pk10))
print(pk10)
print(help(np.genfromtxt))   # 查看函数的帮助文档
"""
<class "numpy.ndarray">
[["2017-12-15" "656198" "5,1,8,2,9,3,10,4,7,6"]
 ["2017-12-15" "656197" "5,9,10,4,2,7,3,6,8,1"]
 ["2017-12-15" "656196" "4,9,7,2,3,6,1,5,10,8"]
 ...,
 ["2012-01-01" "274575" "3,7,10,4,8,6,9,5,1,2"]
 ["2012-01-01" "274574" "2,5,4,7,6,10,8,1,9,3"]
 ["2012-01-01" "274573" "8,4,6,3,2,9,5,10,1,7"]]
"""

# 2、创建矩阵
a1 = np.array([1,2,3])             # 创建一维矩阵
a2 = np.array([[1,2,3],[1,2,3]])   # 创建一个二维矩阵
print(a1.shape)                   # 查看矩阵的结构 (3,)  3行1列
print(a2.shape)                   # 查看矩阵的结构 (2,3) 2行3列

# 3、类型转换
## numpy array传入的值必须同一类型，不然会自动转换成为较少数量的数值类型
b1 = np.array([1,2,3,4])
b2 = np.array([1,2,3,4.])
b3 = np.array([1,2,3,"4"])
print(b1.dtype)                   # int32
print(b2.dtype)                   # float64
print(b3.dtype)                   # <U11

# 4、选取数据
## 和python使用方法一样
c1 = np.genfromtxt("../pk10.txt",delimiter="	",dtype="str")
print(c1[1,2])                    # 5,9,10,4,2,7,3,6,8,1
print(c1[2,1])                    # 656196

# 5、切片
d1 = np.array([5,10,15,20])
print(d1[0:3])                    #  [5,10,15] 切片切取0到3的数据 不包括3
d2 = np.array([
    [5,10,15],
    [20,25,30],
    [30,35,40]
])
print(d2[:,1])                    # [10 25 35] 切片切取整个数据结构的下标为1的列

# 6、对Numpy结构一次操作会同步给每一个
e1 = np.array([5,10,15,20])
## 如进行一个判断操作，就可以对每个对象进行相同操作，就不用for循环
print(e1 == 10)                      # array([False,  True, False, False], dtype=bool)
e2 = np.array([
    [5,10,15],
    [20,25,30],
    [30,35,40]
])
print(e2 == 10)
"""
array([[False,  True, False],
       [False, False, False],
       [False, False, False]], dtype=bool)
"""
## 将判断的布尔值作为参数传入数据对象
e3 = (e1 == 10)
print(e1[e3])                     # [10]
e4 = (e2[:,1] == 25)
print(e2[e4,:])                   # [[20,25,30]]

# 7、或 与 操作
f1 = np.array([5,10,15,20])
f2 = (f1 == 10) & (f1 == 5)        # 与 操作 array([False, False, False, False], dtype=bool)
f3 = (f1 == 10) | (f1 == 5)        # 或 操作 array([ True,  True, False, False], dtype=bool)

# 8、改变numpy.array的数据类型
g1 = np.array(["1","2","3"])
g2 = g1.astype(float)
print(g1.dtype)                    #  <U1
print(g2.dtype)                    #  float64
print(g2)                          #  array([ 1.,  2.,  3.])

# 9、最小值最大值
h1 = np.array([5,10,15,20])
print(h1.max())                     # 5
print(h1.min())                     # 20
## 了解更多属性  print(help(np.array))

# 10、指定维度计算
i1 = np.array([
    [5,10,15],
    [20,25,30],
    [30,35,40]
])
i2 = i1.sum(axis = 1)                    # array([ 30,  75, 105]) 若axis=1 则按行计算每一行的和
i3 = i1.sum(axis = 0)                    # array([55, 70, 85])    若axis=0 则按列计算每一列的和

# 11、数据结构变换
j1 = np.arange(15)                       # np.aramge 创建出来的是向量格式
j2 = j1.reshape(3,5)                     # reshape 是将向量转换成指定格式的矩阵
"""
array([[ 0,  1,  2,  3,  4],
       [ 5,  6,  7,  8,  9],
       [10, 11, 12, 13, 14]])
"""
j2.shape                                 # 矩阵结构 (3,5)
j2.ndim                                  # 矩阵维度  2
j2.dtype.name                            # 矩阵数据类型 "int32"
j2.size                                  # 矩阵长度  15

# 12、初始化一个矩阵，值都是0
k1 = np.zeros((3,4))                     # 初始化矩阵结构为 (3,4)
"""
array([[ 0.,  0.,  0.,  0.],
       [ 0.,  0.,  0.,  0.],
       [ 0.,  0.,  0.,  0.]])
"""

# 13、初始化一个矩阵，值都是1
k2 = np.ones((2,3,4),dtype=np.int32)     # 初始化矩阵结构为 (2,3,4) 且数据是int32
"""
array([[[1, 1, 1, 1],
        [1, 1, 1, 1],
        [1, 1, 1, 1]],

       [[1, 1, 1, 1],
        [1, 1, 1, 1],
        [1, 1, 1, 1]]])
"""

# 14、arange数据间隔
k3 = np.arange( 10,30,5 )                 #  array([10, 15, 20, 25])
# 介绍 np.arange(start,end,skip) 开始，结束，跳过  且不包含end值
k4 = np.arange(12).reshape(4,3)
"""
array([[ 0,  1,  2],
       [ 3,  4,  5],
       [ 6,  7,  8],
       [ 9, 10, 11]])
"""

# 15、随机数的使用
l1 = np.random.random((2,3))              # 随机数返回的是矩阵，这里设置矩阵结构
"""
array([[ 0.25731809,  0.14592857,  0.1125052 ],
       [ 0.94415331,  0.46446762,  0.26658256]])
"""
from numpy import pi
l2 = np.linspace( 0, 2*pi, 100)           # np.linspace(start,end,total)
## linspace生成的是从start到end中平均取total个数据

# 16、数学算术  对应位置进行操作
m1 = np.array( [20,30,40,50] )             # array([20, 30, 40, 50])
m2 = np.array( 4 )                         # array(4)
m3 = m1 - m2                               # array([16, 26, 36, 46])
m4 = m3 - 1                                # array([15, 25, 35, 45])
m5 = m2 ** 2                               # 16
m6 = m1 < 35                               # array([ True,  True, False, False], dtype=bool)

# 17、矩阵乘法
n1 = np.array([[1,1],[0,1]])
n2 = np.array([[2,0],[3,4]])
n3 = n1 * n2                                # 直接相乘： 对应位置数值相乘
"""
array([[2, 0],
       [0, 4]])
"""
n4 = n1.dot(n2)                              # 矩阵乘法1
"""
array([[5, 4],
       [3, 4]])
"""
n5 = np.dot(n1,n2)                            # 矩阵乘法2
"""
array([[5, 4],
       [3, 4]])
"""

# 18、计算e
o1 = np.arange(3)                             # array([0, 1, 2])
print(np.exp(o1))                            # 求幂,如求e的n次方是0 -> 1  e的n次方是1 -> 2.71828183     [ 1.   2.71828183  7.3890561 ]
print(np.sqrt(o1))                           # 求平方根,如求多少的根号为0->0 多少的根号为1->1   [ 0.   1.          1.41421356]

# 19、矩阵的操作
p1 = np.floor(10*np.random.random((3,4)))
"""
array([[ 2.,  4.,  0.,  1.],
       [ 1.,  2.,  7.,  1.],
       [ 0.,  5.,  5.,  6.]])
"""
p2 = p1.ravel()                               # p1.ravel()  方法是将矩阵拉成一维数组
"""
array([ 2.,  4.,  0.,  1.,  1.,  2.,  7.,  1.,  0.,  5.,  5.,  6.])
"""
p2.shape = (6,2)
### 也可以使用 p2.reshaoe = (6,-1)  -1: 代表让系统自动计算列数
"""
array([[ 2.,  4.],
       [ 0.,  1.],
       [ 1.,  2.],
       [ 7.,  1.],
       [ 0.,  5.],
       [ 5.,  6.]])
"""
p2.T
"""
array([[ 2.,  0.,  1.,  7.,  0.,  5.],
       [ 4.,  1.,  2.,  1.,  5.,  6.]])
"""

## 矩阵拼接
p3 = np.floor(10*np.random.random((2,2)))
"""
array([[ 9.,  7.],
       [ 9.,  8.]])
"""
p4 = np.floor(10*np.random.random((2,2)))
"""
array([[ 1.,  9.],
       [ 0.,  6.]])
"""
p5 = np.hstack((p3,p4))            # hstack 横着拼接
"""
array([[ 9.,  7.,  1.,  9.],
       [ 9.,  8.,  0.,  6.]])
"""
p6 = np.vstack((p3,p4))            # vstack 纵着拼接
"""
array([[ 9.,  7.],
       [ 9.,  8.],
       [ 1.,  9.],
       [ 0.,  6.]])
 """

## 矩阵分割
p7 = np.floor(10*np.random.random((2,12)))
"""
array([[ 1.,  7.,  2.,  2.,  6.,  1.,  8.,  9.,  4.,  8.,  3.,  4.],
       [ 9.,  0.,  2.,  3.,  7.,  2.,  9.,  4.,  3.,  6.,  3.,  4.]])
"""
p8 = np.hsplit(p7,3)                # hsplit()横向切割  平均分成3份
"""
[array([[ 1.,  7.,  2.,  2.],
       [ 9.,  0.,  2.,  3.]]), array([[ 6.,  1.,  8.,  9.],
       [ 7.,  2.,  9.,  4.]]), array([[ 4.,  8.,  3.,  4.],
       [ 3.,  6.,  3.,  4.]])]
"""
p8 = np.hsplit(p7,(3,4))            # 指定切分的位置( 3,4 )

p9 = np.floor(10*np.random.random((12,2)))
p10 = np.vsplit(p9,3)                # vsplit()纵向切割  平均分成3份


# 20、 复制的三种方法
## 第一种 深拷贝 只是名字不同 实质指向完全一样 id相同 一起变化
q1 = np.arange(12)
q2 = q1
print(q2 is p1)                    # False
q2.shape = 3,4
print(q1.shape)                    # (3, 4)
print(id(q1))                      # id是机器分配的唯一值  1410862548912
print(id(q2))                      # 1410862548912

## 第二种 浅拷贝 id不同 但同时改变(共用)
q3 = q1.view()
print(q3 is q1)                    # False
q3.shape = 2,6
print(q1.shape)                    # (3, 4)
q3[0,4] = 1234
print(q1)
"""
array([[   0,    1,    2,    3, 1234,    5],
       [   6,    7,    8,    9,   10,   11]])
"""
print(id(q1))                      # 1410862548912
print(id(q3))                      # 1502044416

## 第三种 深拷贝 即id不同 又不同时改变
p4 = p1.copy()
print(p4 is p1)                    # False
p4[0,0] = 9999
print(p4)
"""
[[  9.99900000e+03   4.00000000e+00   0.00000000e+00   1.00000000e+00]
 [  1.00000000e+00   2.00000000e+00   7.00000000e+00   1.00000000e+00]
 [  0.00000000e+00   5.00000000e+00   5.00000000e+00   6.00000000e+00]]
"""
print(p1)
"""
[[ 2.  4.  0.  1.]
 [ 1.  2.  7.  1.]
 [ 0.  5.  5.  6.]]
"""

# 21、排序和索引
## 索引
q1 = np.sin(np.arange(20)).reshape(5,4)
"""
array([[ 0.        ,  0.84147098,  0.90929743,  0.14112001],
       [-0.7568025 , -0.95892427, -0.2794155 ,  0.6569866 ],
       [ 0.98935825,  0.41211849, -0.54402111, -0.99999021],
       [-0.53657292,  0.42016704,  0.99060736,  0.65028784],
       [-0.28790332, -0.96139749, -0.75098725,  0.14987721]])
"""
in1 = q1.argmax(axis = 0)     # 指定axis=0即第0列中，获取索引值最大的索引
# array([2, 0, 3, 1], dtype=int64)
q2 = q1[in1, range(q1.shape[1])]    # 使用索引去获取值
# array([ 0.98935825,  0.84147098,  0.99060736,  0.6569866 ])

# 拓展 np.tile(data , (x倍数, y倍数))
q3 = np.arange(0, 40, 10)
"""
array([ 0, 10, 20, 30])
"""
q4 = np.tile( q3, (2,2))
"""
array([[ 0, 10, 20, 30,  0, 10, 20, 30],
       [ 0, 10, 20, 30,  0, 10, 20, 30]])
"""
q5 = np.tile( q3, (3,2))
"""
array([[ 0, 10, 20, 30,  0, 10, 20, 30],
       [ 0, 10, 20, 30,  0, 10, 20, 30],
       [ 0, 10, 20, 30,  0, 10, 20, 30]])
"""

# 排序
q6 = np.array([[4, 3, 5],[1, 2, 1]])
"""
array([[4, 3, 5],
       [1, 2, 1]])
"""
q7 = np.sort(q6, axis=1)
"""
array([[3, 4, 5],
       [1, 1, 2]])
"""
q8 = np.array([4, 3, 1, 2])
q9 = np.argsort(q8)     # 从小到大 返回排序后的索引值
"""
array([2, 3, 1, 0], dtype=int64)
"""