Numpy简述

  1 import numpy as np
  2 
  3 #关于创建数组  以及生成常见的数组
  4 if 0:
  5     #进行类型转换
  6     if 0:  #可以这样  它起到了注释的作用
  7         arr = np.array([1, 3, 4, 5, 5], dtype=int)
  8         arr = arr.astype('float')  #将原有数据类型改为float
  9         arr.fill(2.5)
 10 
 11         print(arr)
 12         print("arr的里面存放的数据类型：>>>")
 13         print(arr.dtype)
 14 
 15     #除了上面的用np.array() 生成数组以外，
 16     #下面用np.arange()生成
 17 
 18 
 19     #01生成整数序列：
 20     if 0:
 21         arr = np.arange(10)
 22         print(arr)  #[0 1 2 3 4 5 6 7 8 9]
 23 
 24         arr2 = np.arange(1,10,3)  #1-10 3 为步长
 25         print(arr2)   #[1 4 7]
 26     #02 生成等差数列
 27     elif 0:
 28         arr = np.linspace(1,10,num=5)
 29         print(arr)  #[ 1.    3.25  5.5   7.75 10.  ]
 30 
 31         arr2 = np.linspace(1,10,5)
 32         print(arr2)   #[ 1.    3.25  5.5   7.75 10.  ]
 33 
 34         arr3 = np.linspace(1,10,endpoint=False) #endpoint 表示不包含最后一个
 35         print(arr3)
 36         # [1.   1.18 1.36 1.54 1.72 1.9  2.08 2.26 2.44 2.62 2.8  2.98 3.16 3.34
 37         #  3.52 3.7  3.88 4.06 4.24 4.42 4.6  4.78 4.96 5.14 5.32 5.5  5.68 5.86
 38         #  6.04 6.22 6.4  6.58 6.76 6.94 7.12 7.3  7.48 7.66 7.84 8.02 8.2  8.38
 39         #  8.56 8.74 8.92 9.1  9.28 9.46 9.64 9.82]
 40         #注意：此时没有写要生成几个，默认是生成50 个
 41 
 42         arr4 = np.linspace(1,10,num=5,retstep=True) #retstep 是是否返回公差
 43         #如果要返回公差的话此时返回的是个元组
 44         print(arr4) #(array([ 1.  ,  3.25,  5.5 ,  7.75, 10.  ]), 2.25)
 45     #03 生成随机数
 46     elif 1:
 47         arr = np.random.rand(10)  #使用np.random下的函数rand()来生成10 个【0，1） 的随机数
 48         print(arr)
 49 
 50         arr2 = np.random.randn(10) #10 个服从标准正太分布的随机数
 51         print(arr2)
 52 
 53         arr3  = np.random.randint(1,10,5) #生成5个 【1，10） 的随机整数
 54         print(arr3)
 55 
 56 
 57 
 58 
 59 
 60 
 61 
 62         pass
 63 
 64     else:
 65         pass
 66 
 67 #数组属性
 68 if 0:
 69     #查看类型
 70     if 0:
 71 
 72         a = np.array([1,3,4])
 73         print(type(a)) #<class 'numpy.ndarray'>
 74         pass
 75 
 76     #查看数组中的数据类型
 77     elif 0:
 78 
 79         a = np.array([1,3,4])
 80         print(a.dtype) #int32
 81 
 82         pass
 83 
 84     #查看形状 ，会返回一个元组,每个元素代表这一维 的元素数目
 85     elif 0:
 86         a = np.array([1,3,4])
 87         print(a.shape) #(3,)
 88 
 89         b = np.arange(10).reshape(2,5)
 90         print(b.shape) #(2, 5)
 91 
 92         c = np.arange(12).reshape(2,2,3)
 93         print(c)
 94         print(c.shape) #(2, 2, 3)   行列分别是最后两个 2，2，3 的意思是2个2行3列
 95 
 96 
 97 
 98         pass
 99 
100     #查看数组里面元素的数目
101     elif 0:
102         arr = np.array([1,2,3,4,5])
103         print(arr.size) #5
104         pass
105     #查看数组的维度
106     elif 1:
107         arr = np.array([1,2,3,4,5])
108         print(arr.ndim)  #1   en :demensionality 维度
109         pass
110 
111 #数组的索引和切片
112 if 0:
113     #切片的案例  :根据总票房来算每天的票房
114     if 0:
115         boxOffice =np.array([1222,1550,1899,3444,5666])
116         #分析：每天的票房等于
117         #1550,1899,3444,5666 -
118         # 1222, 1550, 1899, 3444
119         everyday_boxOffice = boxOffice[1:] - boxOffice[:-1]
120         print(everyday_boxOffice) # [ 328  349 1545 2222]
121     else:
122         pass
123 
124 #多维数组 及其属性
125 if 0:
126     # array 可以生成多维数组
127     if 0:
128         arr  = np.array([[1,2,3,4],[3,4,5,6]])
129         print(arr)
130         # [[1 2 3 4]
131         #  [3 4 5 6]]
132         pass
133     #查看形状
134     if 0:
135         arr = np.array([[1, 2, 3, 4], [3, 4, 5, 6]])
136         print(arr.shape) #(2, 4)
137         pass
138     #查看总的元素的个数
139     if 0:
140         arr = np.array([[1, 2, 3, 4], [3, 4, 5, 6]])
141         print(arr.size) #8
142         pass
143     #查看维数
144     if 0:
145         arr = np.array([[1, 2, 3, 4], [3, 4, 5, 6]])
146         print(arr.ndim) #2
147         pass
148     else:
149         pass
150 
151 #多维数组索引
152 if 0:
153     #对于二维数组，可以传入两个数字来索引，第一个是第一个维度，第二个是第二个维度
154     if 0:
155         arr = np.array([list(range(10)),list(range(10,20))])
156         print(arr)
157         print(arr[1,1])
158         pass
159     #对于二维数组的赋值也是类似于上面
160     if 0:
161         pass
162     #还可以使用单个索引来索引一整行的内容
163     if 0:
164         arr = np.array([list(range(10)),list(range(10,20))])
165         print(arr[1])
166         pass
167     #还可以使用单个索引来索引一整列的内容
168     if 1:
169         arr = np.array([list(range(10)),list(range(10,20))])
170         print(arr[:,1])
171         pass
172     else:
173         pass
174 
175 #注意：切片只是针对的是连续 或者登间隔的切片，要想实现任意位置的操作，要使用花式索引了
176 #多维数组的切片
177 if 0:
178     arr = np.array([list(range(5)) , list(range(5,10)) , list(range(10,15))])
179     if 1:
180         print(arr)
181         #第一行最后两个数
182         print(arr[0,3:]) # [3 4]
183         #最后两行的最后两列：
184         print(arr[-2:,-2:])
185         # [[8  9]
186         #  [13 14]]
187 
188         #得到第三列
189         print(arr[:,2]) #[ 2  7 12]
190 
191         #每一维都支持切片规则，包括负索引，包括步长
192         # [lower:upper:step]
193 
194         #取出1，3 行的奇数列
195         print(arr[::2,::2])
196 
197         pass
198     else:
199         pass
200 
201 #切片是引用：
202 # 切片在内存中使用的引用机制，Python 并没有为arr1分配新的空间来存储它的值，就是改变来原来的数组的值
203 if 0:
204     if 0:
205         arr =np.array([1,2,3,4])
206         arr1 =arr[:2]
207         print(arr1)
208 
209         arr1[0] =-1
210         print(arr)  #此时修改arr1 但是arr 的值也跟着改变 ，这样做的好处是对于大量的数组，不用复制大量的数据
211 
212     #注意；这种现象在列表中是不存在的，列表中的 切片使用的不是这种机制。
213     if 0:
214         arr2 = [1,2,3,4]
215         arr3 = arr2[:2]
216         arr3[0]= -1
217         print(arr2)
218 
219 
220     #但是，如果不想跟着改变如何变，可以用copy()方法，此时就会申请一个新的内存
221     if 1:
222         arr = np.array([1,2,3,4])
223         arr2 =arr[:2].copy()  #此时就会将 真实的切片内容申请一个新的内存空间，
224         arr2[0] =-1
225         print(arr)
226 
227         pass
228 
229 
230 # 切片只是针对的是连续 或者登间隔的切片，要想实现任意位置的操作，要使用花式索引了
231 if 0:
232     #一维花式索引
233     if 0:
234         arr = np.arange(0, 100, 10)
235         print(arr) #[ 0 10 20 30 40 50 60 70 80 90]
236 
237         #花式索引需要指定索引位置
238         if 0:
239             idx = [1,2,-3]
240             print(arr[idx])  #[10 20 70]
241         #通过布尔数组来花式索引
242         if 1:
243             mask =np.array([1,2,3,0,1,0,0,1,2,0],dtype=bool)
244             print(mask) #[ True  True  True False  True False False  True  True False]
245             print(arr[mask]) #[ 0 10 20 40 70 80]  #这就是通过布尔数组进行花式索引
246             pass
247     #二维花式索引
248     if 1:
249         #对于二维花式索引，我们要给定行和列 的值
250         arr = np.array([[1,2,3],[2,3,4],[3,4,5]])
251         print(arr)
252         if 0:
253             #获取次对角线上的数
254             print(arr[(0,1),(1,2)])  #[2 4]
255 
256             #后两行的1，3，列
257             print(arr[-2:,(0,2)])
258             # [[2 4]
259             #  [3 5]]
260             pass
261         # 还是可以用布尔数组来进行花式索引
262         if 0:
263             mask = np.array([1,0,1],dtype=bool)
264             print(arr[mask,2]) #[3 5]
265             pass
266         pass
267 
268     #与切片不同，花式索引返回的是原对象的一个复制而不是一个引用
269 
270 #“不完全”索引
271 if 0:
272     arr = np.array([[1, 2, 3, 4], [3, 4, 5, 6],[1, 2, 3, 4], [3, 4, 5, 6]])
273     print(arr)
274     # 只给出行索引时，返回整行
275     if 0:
276         print(arr[:3])
277     #这时候也可以使用花式索引取出0，2，3 行
278     if 1:
279         print(arr[np.array([1,0,1,1],dtype=bool)])
280         pass
281     pass
282 
283 #where 语句
284 #where 函数会返回所有的非0 元素的索引
285 if 0:
286     #一维数组
287     if 1:
288         arr = np.array([1,2,3,4,5,9])
289         #判断数组中的元素是否大于5
290         print(arr>5) #[False False False False False  True]
291 
292         #数组中所有大于3的元素的索引位置
293         #这时可以用where 函数了
294         print(np.where(arr>3))    #(array([3, 4, 5], dtype=int32),)
295 
296         #也可以直接数组操作
297         print(arr[arr>3])  #[4 5 9]
298         #下面也可以
299         print(arr[np.where(arr>3)])  #[4 5 9]
300         pass
301 
302     pass
303 
304 
305 #数组类型
306 if 0:
307     #类型转换
308     if 1:
309         arr = np.arange(10)
310         print(arr)
311         #使用asarray()函数
312         if 0:
313             ret = np.asarray(arr,dtype=float)
314             print(ret) #[0. 1. 2. 3. 4. 5. 6. 7. 8. 9.]
315             pass
316         #使用astype方法
317         if 1:
318             ret = arr.astype(float)
319             print(ret)   #[0. 1. 2. 3. 4. 5. 6. 7. 8. 9.]
320             pass
321         pass
322 
323 #数组操作：
324 if 0:
325     arr = np.array([1,20,2,43,1,34,34,23,34,535,45,23,2,1,64])
326     # 数组排序
327     if 0:
328         #sort（）函数
329         if 0:
330             res = np.sort(arr)
331             print(res)
332             pass
333         #argsort（）函数
334         if 1:
335             #返回元素的索引位置
336             res = np.argsort(arr)
337             print(res)
338             pass
339 
340 
341         pass
342 
343     #求和
344     if 0:
345         res = np.sum(arr)
346         print(res)
347 
348         res = arr.sum()
349         print(res)
350         pass
351 
352     #最值
353     if 0:
354         res = np.min(arr)
355         # 或用面向对象的方式书写
356         res = arr.min()
357         print(res)
358 
359         res = np.max(arr)
360         res = arr.max()
361         print(res)
362         pass
363 
364     #均值
365     if 0:
366         res = np.mean(arr)
367         res = np.average(arr)
368         res = arr.mean()
369         print(res)
370         pass
371 
372 
373     #标准差
374     if 0:
375         res  = np.std(arr)
376         res = arr.std()
377         print(res)
378         pass
379 
380     #相关系数矩阵
381     if 1:
382         arr2 = np.arange(15)
383         res = np.cov(arr,arr2 )
384         # res = print(arr.size)
385         print(res)
386         # [[17828.26666667    98.64285714]
387         #  [98.64285714    20.]]
388         pass
389     pass
390 
391 
392 #多维数组的操作
393 if 1:
394     arr = np.array([[1, 2, 3, 4], [3, 4, 5, 6],[1, 2, 3, 4], [3, 4, 5, 6]])
395     #数组形状
396     if 0:
397         #改变原来数组的形状
398         if 0:
399             arr.shape = (2,8)  #此时改变原有数组的形状
400             print(arr)
401             # [[1 2 3 4 3 4 5 6]
402             #  [1 2 3 4 3 4 5 6]]
403         #与之对应的是不改变原有数组的形状  .reshape()
404         if 0:
405             res = arr.reshape((2,8))
406             print(res)
407             print(arr)
408             pass
409         pass
410 
411     #转置
412     if 0:
413         #使用.T 属性转置
414         if 0:
415             res = arr.T
416             print(res)
417         #使用 .transpose()进行
418         if 1:
419             res = arr.transpose()
420             print(res)
421         pass
422 
423     #数组连接
424     if 0:
425         x = np.array([[1, 2, 3], [4, 5, 6]])
426         y = np.array([[10, 20, 30], [40, 50, 60]])
427         if 0:
428             res = np.concatenate((x,y))  #默认是按照axis = 0 来连接的
429             print(res)
430 
431             res2 = np.concatenate((x,y),axis=1) #沿着第二维 进行连接
432             print(res2)
433 
434             #注：因为x,y 的形状相同，ｘｙ还可以连接成一个三维的数组，但是concatenate 不提供这样的功能，可以如下方法做
435             res3 = np.array([x,y])
436             print(res3)
437 
438         #事实上，Numpy 提供了上面三种的情况的函数
439         # vstack
440         # hstack
441         # dstack
442         if 1:
443             res = np.vstack((x,y))
444             print(res)
445 
446             res2 = np.hstack((x,y))
447             print(res2)
448 
449             res3 = np.dstack((x,y))
450             print(res3)
451 
452             # res4 = np.array((x,y))
453             # print(res4)
454             pass
455         pass
456 
457 
458 
459 
460 
461     pass
462 
463 #Numpy 内置函数
464 if 1:
465     #绝对值
466     np.abs()
467     #指数
468     np.exp()
469     #中值
470     np.median()
471     #累计和
472     np.cumsum()
473 
474     #内置函数总结：
475     # https: // blog.csdn.net / nihaoxiaocui / article / details / 51992860?locationNum = 5 & fps = 1
476 
477     pass