NumPy快速入门指南

简介

NumPy系统是Python的一种开源的数值计算扩展。这种工具可用来存储和处理大型矩阵。

参考:https://docs.scipy.org/doc/numpy/user/quickstart.html
100 numpy exercises:http://www.labri.fr/perso/nrougier/teaching/numpy.100/
试验性的Numpy教程:http://reverland.org/python/2012/08/22/numpy
From Python to Numpy:http://www.labri.fr/perso/nrougier/from-python-to-numpy/

快速入门指南

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
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
# -*- coding: utf-8 -*-
import numpy as np
from numpy import pi
from numpy import newaxis

'''
[[ 0 1 2 3 4]
[ 5 6 7 8 9]
[10 11 12 13 14]]
<class 'numpy.ndarray'>
2
(3, 5)
15
int32
4
<memory at 0x000001D910BB6DC8>
'''
def numpyBasic():
a = np.arange(15).reshape(3, 5)
print(a)
# 当数组包含的元素太多时, 会省略中间的元素, 只打印角落的元素
# 如果想禁用这个行为, 强制打印所有的元素, 可以开启set_printoptions选项: np.set_printoptions(threshold=np.nan)
# 还原成省略效果: np.set_printoptions(threshold=1000)
# 设置打印浮点数的小数位数: np.set_printoptions(precision=4) # 设置打印浮点数的小数位数,默认是8位
print(type(a))
print(a.ndim) # 数组的轴数(即rank)
print(a.shape) # 数组的维度,返回的是一个元组,元组的长度值刚好是ndim
print(a.size) # 数组元素的个数
print(a.dtype) # 数组元素的类型
print(a.itemsize) # 数组元素的字节大小
print(a.data) # 数组包含的实际数据(一般情况下不会用到这个属性,都是通过索引来访问元素)


def numpyCreateArray():
# 可以从普通的python列表或元组来创建
a1 = np.array([2, 3, 4])
print(a1)
print(a1.dtype)
a2 = np.array([1.2, 3.5, 5.1])
print(a2.dtype)
a3 = np.array([(1.5, 2.3), (4, 5, 6)])
print(a3)
print(a3.dtype)
# 在创建数组的时候, 指定数据类型
a4 = np.array([[1, 2], [3, 4]], dtype=complex)
print(a4)
# zeros函数创建初始值为0的数组
a5 = np.zeros((3, 4))
print(a5)
# ones创建初始值为1的数组
a6 = np.ones((3, 4))
print(a6)
# empty创建未初始化的随机数组
a7 = np.empty((2, 5))
print(a7)
# 为了创建序列函数, Numpy也提供了类似range函数的方法
a8 = np.arange(10, 30, 5)
print(a8)
a9 = np.arange(0, 2, 0.3)
print(a9)
a10 = np.linspace(0, 2, 9)
print(a10)
x = np.linspace(0, 2 * pi, 100)
f = np.sin(x)

# 数组的算术运算会自动作用于每个元素,并返回一个新的数组
def numpyBaseAlgorithm():
a = np.array([20, 30, 40, 50])
b = np.arange(4)
c = a - b
print(c)
d = b**2
print(d)
e = 10 * np.sin(a)
print(e)
f = a < 35
print(f)

# *返回的是每个元素相乘的结果, 要实现矩阵乘法, 需要使用dot函数
def numpyMatrixAlgorithm():
a = np.array([[1, 1],
[0, 1]])
b = np.array([[2, 0],
[3, 4]])
c = a * b # 对应位置的元素相乘
print(c)
d = a.dot(b) # 矩阵乘法
print(d)
e = np.dot(a, b) # 另一种形式的矩阵乘法
print(e)

# 一些操作, 如+=和*=是直接修改原有的数组, 而不是新建一个
def numpyMatrixAlgorithmSelf():
a = np.ones((2, 3), dtype=int)
print(a)
b = np.random.random((2, 3))
print(b)
print(a.dtype)
print(b.dtype)
b += a
print(b)
# a += b
# print(a)

# 当不同类型的数组运算操作时, 总是向精度更高的自动转换
def numpyMatrixAlgorithmPrecision():
a = np.ones(3, dtype=np.int32)
b = np.linspace(0, np.pi, 3)
c = a + b
print(c)
print(c.dtype)
d = np.exp(c * 1j)
print(d)
print(d.dtype)

# ndarray包含了很多一元运算. 如求和等
def numpyMatrixAlgorithmUnary():
a = np.arange(15).reshape(3, 5)
print(a)
print(a.sum())
print(a.min())
print(a.max())

# 默认情况下, 数组操作都是作用于每一个元素, 而不管它的维度. 但是, 我们也可以通过axis参数来限定操作的轴
def numpyMatrixAlgorithmAxis():
a = np.arange(12).reshape(3, 4)
b = a.sum(axis=0) # 计算每一列的和
print(b)
c = a.min(axis=1) # 计算每一行的最小值
print(c)
d = a.cumsum(axis=1) # 每一行累积和
print(d)

# Numpy提供了很多常见的数学上的运算, 如sin, cos, exp. 在Numpy中, 我们称这些为"universal functions"(ufunc)
def numpyUniversal():
a = np.arange(3)
b = np.exp(a)
print(b)
c = np.sqrt(a)
print(c)
d = np.add(a, a)
print(d)

'''
int32
[ 0 1 8 27 64 125 216 343 512 729]
8
[ 8 27 64]
[ 0 8 64]
[1000 1 1000 27 1000 125 216 343 512 729]
[ 729 512 343 216 125 1000 27 1000 1 1000]
[1000 1 1000 27 1000 125 216 343 512 729]
9.999999999999998 1.0 9.999999999999998 3.0 9.999999999999998 5.0 5.999999999999999 6.999999999999999 7.999999999999999 8.999999999999998
'''
# 一维数组的索引,切片,迭代跟普通的Python列表一样
def numpyArrayIndex():
a = np.arange(10) ** 3
print(a.dtype)
print(a)
print(a[2])
print(a[2:5])
print(a[:6:2]) # 等价于a[0:6:2]
a[:6:2] = 1000
print(a)
print(a[::-1]) # 反转数组a
for i in a:
i **= (1 / 3.)
print(a)
for i in range(len(a)):
print(a[i] ** (1 / 3.), end=' ')

def f(x, y):
return 10*x + y

'''
[[ 0 1 2 3]
[10 11 12 13]
[20 21 22 23]
[30 31 32 33]
[40 41 42 43]]
23
[ 1 11 21 31 41]
[ 1 11 21 31 41]
[[10 11 12 13]
[20 21 22 23]]
'''
def numpyArrayMatrix():
a = np.fromfunction(f, (5, 4), dtype=int)
print(a)
# help(np.fromfunction)
print(a[2, 3])
print(a[0:5, 1])
print(a[:, 1])
print(a[1:3, :])
# 当索引数少于轴数时,缺失的索引认为是全切片
print(a[-1]) # 等价于 a[-1, :]


# 可以使用...来表示全切片,它代表补全剩下的所有索引
# x[1,2,...]等价于x[1,2,:,:,:]
# x[...,3]等价于x[:,:,:,:,3]
# x[4,...,5,:]等价于x[4,:,:,5,:]
def numpyArrayDot():
a = np.array([[[0, 1, 2],
[10, 12, 13]],
[[100, 101, 102],
[110, 112, 113]]])
print(a.shape)
print(a[1, ...])
print(a[..., 2])


'''
[0 1 2 3]
[10 11 12 13]
[20 21 22 23]
[30 31 32 33]
[40 41 42 43]
0 1 2 3 10 11 12 13 20 21 22 23 30 31 32 33 40 41 42 43
'''
def numpyMatrixEnumerate():
a = np.array([[0, 1, 2, 3],
[10, 11, 12, 13],
[20, 21, 22, 23],
[30, 31, 32, 33],
[40, 41, 42, 43]])
# 多维数组的迭代是根据第一个轴来操作的
for row in a:
print(row)
# 如果想遍历每个元素,可以使用flat属性
for element in a.flat:
print(element, end=' ')


'''
(3, 4)
[[0. 8. 3. 0.]
[5. 2. 3. 5.]
[4. 6. 2. 3.]]
[0. 8. 3. 0. 5. 2. 3. 5. 4. 6. 2. 3.]
[[0. 8.]
[3. 0.]
[5. 2.]
[3. 5.]
[4. 6.]
[2. 3.]]
[[0. 5. 4.]
[8. 2. 6.]
[3. 3. 2.]
[0. 5. 3.]]
(4, 3)
[[0. 8. 3. 0. 5. 2.]
[3. 5. 4. 6. 2. 3.]]
[[0. 8. 3. 0.]
[5. 2. 3. 5.]
[4. 6. 2. 3.]]
'''
def numpyMatrixShape():
a = np.floor(10 * np.random.random((3, 4)))
print(a.shape)
print(a)
# 返回降维的数组
print(a.ravel())
# 直接修改shape
print(a.reshape(6, 2))
# 数组转置
print(a.T)
print(a.T.shape)
# reshape返回修改后的数组,不改变数组本身,但是resize函数直接修改原数组
a.resize((2, 6))
print(a)
# 如果一个维度为的是-1, 那么reshape函数会自动计算它的值
print(a.reshape(3, -1))


'''
[[3. 0.]
[3. 9.]]
[[9. 4.]
[8. 1.]]
[[3. 0.]
[3. 9.]
[9. 4.]
[8. 1.]]
[[3. 0. 9. 4.]
[3. 9. 8. 1.]]
'''
def numpyMatrixCombine():
# 多个数组可以根据不同的轴组合在一起
a = np.floor(10 * np.random.random((2, 2)))
print(a)
b = np.floor(10 * np.random.random((2, 2)))
print(b)
print(np.vstack((a, b)))
print(np.hstack((a, b)))


'''
[[1. 1. 2. 9.]
[4. 4. 0. 3.]]
[[4. 3.]
[2. 8.]]
[[4.]
[2.]]
[[4. 3.]
[2. 8.]]
[[4. 3.]
[2. 8.]]
[1 2 3 0 4]
'''
## 数组合并
def numpyColumnStack():
a = np.array([[1., 1.], [4., 4.]])
b = np.array([[2., 9.], [0., 3.]])
# 操作2维数组,等效于hstack
print(np.column_stack((a, b)))
a = np.array([4., 2.])
b = np.array([3., 8.])
# 操作1维数组,返回2维数组,a,b分别为2维数组的列
print(np.column_stack((a, b)))
# 将1维数组变成2维数组
print(a[:, newaxis])
# 都是操作二维数组,下面两个操作column_stack和hstack等效
print(np.column_stack((a[:, newaxis], b[:, newaxis])))
print(np.hstack((a[:, newaxis], b[:, newaxis])))
# 另外不论什么数组,row_stack函数等效于vstack
# 通常来说,2维以上的数组,hstack基于第2根轴做运算,vstack基于第1根轴
# concatenate函数额外多接受一个参数,可以指定基于哪根轴做数组的合并操作
# 另外, r_和c_函数对于在一个轴上组合数据相当实用,他们允许使用范围符号
print(np.r_[1:4, 0, 4])


## 数组切割
def numpyMatrixSplit():
a = np.array([[ 9., 0., 2., 0., 0., 4., 1., 6., 4., 8., 3., 9.],
[ 5., 3., 0., 5., 5., 8., 0., 5., 6., 3., 8., 7.]])
print(a)
# 横轴切割成3个数组
print(np.hsplit(a, 3))
# 纵轴切割成2个数组
# vsplit可以基于垂直轴切割,array_split可以指定基于哪个轴切割
print(np.vsplit(a, 2))
# 基于第3和第4列切割
print(np.hsplit(a, (3, 4)))


def f(x):
print(id(x))


'''
[ 0 1 2 3 4 5 6 7 8 9 10 11]
True
(12,)
(3, 4)
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
2889321266432
2889321266432
- - - - - - - - - - - - - - - - - - - -
False
True
False
(3, 4)
[[ 0 1 2 3 1234 5]
[ 6 7 8 9 10 11]]
[[ 0 1 2 3]
[1234 5 6 7]
[ 8 9 10 11]]
[[ 1 2]
[ 5 6]
[ 9 10]]
[[10 10]
[10 10]
[10 10]]
[[ 0 10 10 3]
[1234 10 10 7]
[ 8 10 10 11]]
- - - - - - - - - - - - - - - - - - - -
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
False
False
[[9999 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
'''
# 当进行数组运算和改变数组时,有时候数据是被复制到一个新的数组,有时候不是
def numpyCopy():
## 不复制
a = np.arange(12)
print(a)
b = a # 不会有新对象产生
print(b is a) # a和b是同一个数组
print(b.shape)
b.shape = 3, 4 # 改变b的shape, a也同样变化
print(a.shape)
print(a)
# Python中使用可变参数时,可以看做是引用传参,因此函数调用会产生新的数组
print(id(a))
f(a)

print('- - - - - - - - - - - - - - - - - - - -')

## 视图(View)和浅复制(Shallow Copy)
# 不同的数组可以共享数据,view函数可以创造一个数据相同的新数组
a = np.array([[0, 1, 2, 3],
[4, 5, 6, 7],
[8, 9, 10, 11]])
c = a.view()
print(c is a) # c和a不是同一个数组
print(c.base is a) # c是a的数据的视图
print(c.flags.owndata)
c.shape = 2, 6 # a的不会改变
print(a.shape)
c[0, 4] = 1234 # a的数据发生改变
print(c)
print(a)
# 一个数组的切片返回的就是它的视图
s = a[:, 1:3] # s是a的视图
print(s)
s[:] = 10 # s[:]是a的视图
print(s)
print(a)

print('- - - - - - - - - - - - - - - - - - - -')

## 深度复制(Deep Copy)
a = np.arange(12).reshape((3, 4))
print(a)
d = a.copy()
print(d is a)
print(d.base is a)
d[0, 0] = 9999
print(d)
print(a)


## 广播机制
def numpyBroadcast():
# 广播主要描述于numpy对于不同shape的数组如何进行算术运算。受限于一些特定约束
# 一般都是小的数组扩展为大的数组,以便能计算
# 通常情况下,numpy操作的数组必须是相同shape的
a = np.array([1.0, 2.0, 3.0])
b = np.array([2.0, 2.0, 2.0])
print(a * b)
# 当数组的shape满足某些特定约束时,numpy的广播机制可以使这个约束更宽松。最简单的就是广播例子就是当数组和一个标量操作时
a = np.array([1.0, 2.0, 3.0])
b = 2.0
print(a * b)
# 我们可以认为标量b被扩展为了和a同样shape的数组,b中的新元素就是原来标量的拷贝
# 这个扩展策略仅仅是概念上的,实际上Numpy足够聪明,能自动使用标量做运算,而不需要复制任何东西
# 所以广播运算从计算内存上来说更优秀
# 要能满足广播,必须符合下面两条规则:
# 1. 广播之后,输出数组的shape是输入数组shape的各个轴上的最大值,然后沿着较大shape属性的方向复制延伸
# 2. 要进行广播机制,要么两个数组的shape属性一样,要么其中有一个数组的shape属性必须有一个等于1


'''
[ 0 1 4 9 16 25 36 49 64 81 100 121]
[1 1 3 8 5]
print(a[k]) # 等价于a[i, j]
[ 1 1 9 64 25]
[[ 9 16]
[81 49]]
- - - - - - - - - - - - - - - - - - - -
[[[ 0 0 0]
[255 0 0]
[ 0 255 0]
[ 0 0 0]]

[[ 0 0 0]
[ 0 0 255]
[255 255 255]
[ 0 0 0]]]
- - - - - - - - - - - - - - - - - - - -
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
[[ 2 5]
[ 7 11]]
[[ 2 6]
[ 6 10]]
(3, 2, 2)
[[[ 2 1]
[ 3 3]]

[[ 6 5]
[ 7 7]]

[[10 9]
[11 11]]]
[array([[0, 1],
[1, 2]]), array([[2, 1],
[3, 3]])]
[[ 2 5]
[ 7 11]]
[[[0 1]
[1 2]]

[[2 1]
[3 3]]]
- - - - - - - - - - - - - - - - - - - -
[0 1 2 3 4]
[0 0 2 0 0]
[0 1 2 3 4]
[2 1 3 3 4]
[0 1 2 3 4]
[1 1 3 3 4]
- - - - - - - - - - - - - - - - - - - -
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
[[False False False False]
[False True True True]
[ True True True True]]
[ 5 6 7 8 9 10 11]
[[0 1 2 3]
[4 0 0 0]
[0 0 0 0]]
- - - - - - - - - - - - - - - - - - - -
[[ 0 1 2 3]
[ 4 5 6 7]
[ 8 9 10 11]]
[[ 4 5 6 7]
[ 8 9 10 11]]
[[ 4 5 6 7]
[ 8 9 10 11]]
[[ 0 2]
[ 4 6]
[ 8 10]]
[ 4 10]
'''
## 索引
def numpyIndices():
# numpy除了支持普通的python方式的索引和切片之外,还支持整数数组或布尔数组索引
a = np.arange(12) ** 2
i = np.array([1, 1, 3, 8, 5])
print(a)
print(i)
print(a[i]) # 返回a中再索引i的元素
j = np.array([[3, 4], [9, 7]])
print(a[j]) # 二维数组索引,返回a中再索引j的元素

print('- - - - - - - - - - - - - - - - - - - -')

# 当数组索引作用在多维数组时,是根据数组的第一个维度来索引的
palette = np.array([[0, 0, 0],
[255, 0, 0],
[0, 255, 0],
[0, 0, 255],
[255, 255, 255]])
image = np.array([[0, 1, 2, 0],
[0, 3, 4, 0]])
print(palette[image])

print('- - - - - - - - - - - - - - - - - - - -')

# 索引同样可以是多维的,但是必须是相同的shape
a = np.arange(12).reshape(3, 4)
print(a)
i = np.array([[0, 1],
[1, 2]])
j = np.array([[2, 1],
[3, 3]])
print(a[i, j])
print(a[i, 2])
b = a[:, j] # a[0, j], a[1, j], a[2, j]
print(b.shape)
print(b)
# 同样,我们可以把i和j放在一个列表里,然后用列表做索引
k = [i, j]
print(k)
print(a[k]) # 等价于a[i, j]
s = np.array([i, j]) # 三维数组
print(s)

print('- - - - - - - - - - - - - - - - - - - -')

# 同样可以给数组索引赋值
a = np.arange(5)
print(a)
a[[1, 3, 4]] = 0
print(a)
# 但是当列表包含相同的索引时,这个位置会被赋值多次,最终只保留最后一次的值
a = np.arange(5)
print(a)
a[[0, 0, 2]] = [1, 2, 3]
print(a)
# 上面看起来很合理,但是当使用+=符号的时候,结果和我们想的可能不太一样
a = np.arange(5)
print(a)
a[[0, 0, 2]] += 1 # 尽管索引中出现了两次0,但是第0个元素它只加了1次
print(a)

print('- - - - - - - - - - - - - - - - - - - -')

# 布尔数组索引
# 当使用数字数组索引时,我们提供了哪些元素要被索引的信息
# 但是当使用布尔数组时,我们是明确哪些元素需要,哪些元素不需要
a = np.arange(12).reshape((3, 4))
print(a)
b = a > 4
print(b)
print(a[b])
a[b] = 0 # 所有大于4的元素都赋值为0
print(a)

print('- - - - - - - - - - - - - - - - - - - -')

a = np.arange(12).reshape(3, 4)
b1 = np.array([False, True, True])
b2 = np.array([True, False, True, False])
print(a)
print(a[b1, :]) # 选择行
print(a[b1]) # 同上
print(a[:, b2]) # 选择列
print(a[b1, b2])


'''
(2, 3., b'World')
[1 2]
[2. 3.]
[b'Hello' b'World']
'''
## 字符串索引
# Numpy提供了创建结构化的数组的能力,可以通过列名来操作数据
def numpyStringIndices():
# Numpy提供了创建结构化的数组的能力,可以通过列名来操作数据
x = np.array([(1, 2., 'Hello'), (2, 3., 'World')], dtype=[('foo', 'i4'), ('bar', 'f4'), ('baz', 'S10')])
print(x[1])
print(x['foo'])
print(x['bar'])
print(x['baz'])


if __name__ == '__main__':
numpyBasic()
# numpyCreateArray()
# numpyBaseAlgorithm()
# numpyMatrixAlgorithm()
# numpyMatrixAlgorithmSelf()
# numpyMatrixAlgorithmPrecision()
# numpyMatrixAlgorithmUnary()
# numpyMatrixAlgorithmAxis()
# numpyUniversal()
# numpyArrayIndex()
# numpyArrayMatrix()
# numpyArrayDot()
# numpyMatrixEnumerate()
# numpyMatrixShape()
# numpyMatrixCombine()
# numpyColumnStack()
# numpyMatrixSplit()
# numpyCopy()
# numpyBroadcast()
# numpyIndices()
# numpyStringIndices()

函数和方法概览

如下是按照分类整理的常用函数和方法,完整的分类可以参考Routines

数组创建

  • arange
  • array
  • copy
  • empty
  • empty_like
  • eye # 创建一个对角线全是1的二维数组
  • fromfile
  • fromfunction
  • identity # 创建一个对角线全是1的方形矩阵,与eye方法差不多,只是可以接受的参数不同
  • linspace
  • logspace # 创建等比数列
  • mgrid
  • orgid
  • ones
  • ones_like
  • zeros
  • zeros_like

转换

  • ndarray.astype # 改变数组的元素格式
  • atleast_1d # 将输入转换为至少1维数组
  • atleast_2d
  • alteast_3d
  • mat # 将输入转换为矩阵

处理

  • array_split
  • column_stack
  • concatenate
  • diagonal
  • dsplit
  • dstack
  • hsplit
  • hstack
  • ndarray.item
  • newaxis
  • ravel
  • repeat
  • reshape
  • resize
  • squeeze
  • swapaxes
  • take
  • transpose
  • vsplit
  • vstack

Questions

  • all
  • any
  • nonezero
  • where

排序

  • argmax # 返回最大值的索引
  • argmin # 返回最小值的索引
  • argsort # 返回排序后的索引
  • max
  • min
  • ptp
  • searchsorted
  • sort

运算

  • choose
  • compress
  • cumprod
  • cumsum
  • inner
  • ndarray.fill
  • imag
  • prod
  • put
  • putmask
  • real
  • sum

基本统计

  • cov
  • mean
  • std
  • var

线性代数

  • cross
  • dot
  • outer
  • linalg
  • svd
  • vdot

Powered by AppBlog.CN     浙ICP备14037229号

Copyright © 2012 - 2020 APP开发技术博客 All Rights Reserved.

访客数 : | 访问量 :