Numpy 入门教程（2）

翻译自官方文档Tentative NumPy Tutorial，有删节。

基本操作

基本的算术运算符都可以应用于数组类型，结果为对应元素之间的运，返回值为一个新的数组。

[python] view plain copy

1. >>> a = array( [20,30,40,50] )  
2. >>> b = arange( 4 )  
3. >>> b  
4. array([0, 1, 2, 3])  
5. >>> c = a-b  
6. >>> c  
7. array([20, 29, 38, 47])  
8. >>> b**2  
9. array([0, 1, 4, 9])  
10. >>> 10*sin(a)  
11. array([ 9.12945251, -9.88031624,  7.4511316 , -2.62374854])  
12. >>> a<35  
13. array([True, True, False, False], dtype=bool)</span>  

乘法操作符 * 表示的也是元素乘法，如果需要矩阵乘法，可以使用dot函数或者生成一个matrix对象。 

[python] view plain copy

1. >>> A = array( [[1,1],  
2. ...             [0,1]] )  
3. >>> B = array( [[2,0],  
4. ...             [3,4]] )  
5. >>> A*B                         # elementwise product  
6. array([[2, 0],  
7.        [0, 4]])  
8. >>> dot(A,B)                    # matrix product  
9. array([[5, 4],  
10.        [3, 4]])  
11. >>> a = ones((2,3), dtype=int)  
12. >>> b = random.random((2,3))  
13. >>> a *= 3  
14. >>> a  
15. array([[3, 3, 3],  
16.        [3, 3, 3]])  
17. >>> b += a  
18. >>> b  
19. array([[ 3.69092703,  3.8324276 ,  3.0114541 ],  
20.        [ 3.18679111,  3.3039349 ,  3.37600289]])  
21. >>> a += b                                  # b is converted to integer type  
22. >>> a  
23. array([[6, 6, 6],  
24.        [6, 6, 6]])</span>  

当两个不同元素类型的数组运算时，结果的元素类型为两者中更精确的那个。（类型提升）

[python] view plain copy

1. >>> a = ones(3, dtype=int32)  
2. >>> b = linspace(0,pi,3)  
3. >>> b.dtype.name  
4. 'float64'  
5. >>> c = a+b  
6. >>> c  
7. array([ 1.        ,  2.57079633,  4.14159265])  
8. >>> c.dtype.name  
9. 'float64'  
10. >>> d = exp(c*1j)  
11. >>> d  
12. array([ 0.54030231+0.84147098j, -0.84147098+0.54030231j,  
13.        -0.54030231-0.84147098j])  
14. >>> d.dtype.name  
15. 'complex128'</span>  

Array类型提供了许多内置的运算方法，比如。

[python] view plain copy

1. >>> a = random.random((2,3))  
2. >>> a  
3. array([[ 0.6903007 ,  0.39168346,  0.16524769],  
4.        [ 0.48819875,  0.77188505,  0.94792155]])  
5. >>> a.sum()  
6. 3.4552372100521485  
7. >>> a.min()  
8. 0.16524768654743593  
9. >>> a.max()  
10. 0.9479215542670073</span>  

默认情况下， 这些方法作用于整个 array，通过指定 axis，可以使其只作用于某一个 axis : 

[python] view plain copy

1. >>> b = arange(12).reshape(3,4)  
2. >>> b  
3. array([[ 0,  1,  2,  3],  
4.        [ 4,  5,  6,  7],  
5.        [ 8,  9, 10, 11]])  
6. >>>  
7. >>> b.sum(axis=0)                            # sum of each column  
8. array([12, 15, 18, 21])  
9. >>>  
10. >>> b.min(axis=1)                            # min of each row  
11. array([0, 4, 8])  
12. >>>  
13. >>> b.cumsum(axis=1)                         # cumulative sum along each row  
14. array([[ 0,  1,  3,  6],  
15.        [ 4,  9, 15, 22],  
16.        [ 8, 17, 27, 38]])</span>  

常用函数

NumPy 提供了许多常用函数，如sin, cos, and exp. 同样，这些函数作用于数组中每一个元素，返回另一个数组。

[python] view plain copy

1. >>> B = arange(3)  
2. >>> B  
3. array([0, 1, 2])  
4. >>> exp(B)  
5. array([ 1.        ,  2.71828183,  7.3890561 ])  
6. >>> sqrt(B)  
7. array([ 0.        ,  1.        ,  1.41421356])  
8. >>> C = array([2., -1., 4.])  
9. >>> add(B, C)  
10. array([ 2.,  0.,  6.])</span>  

其他常用函数包括：

all, alltrue, any, apply along axis, argmax, argmin, argsort, average, bincount, ceil, clip, conj, conjugate, corrcoef, cov, cross, cumprod, cumsum, diff, dot, floor, inner, inv, lexsort, max, maximum, mean, median, min, minimum, nonzero, outer, prod, re, round, sometrue, sort, std, sum, trace, transpose, var, vdot, vectorize, where

索引、切片、和迭代

与list类似，数组可以通过下标索引某一个元素，也可以切片，可以用迭代器迭代。

[python] view plain copy

1. >>> a = arange(10)**3  
2. >>> a  
3. array([  0,   1,   8,  27,  64, 125, 216, 343, 512, 729])  
4. >>> a[2]  
5. 8  
6. >>> a[2:5]  
7. array([ 8, 27, 64])  
8. >>> a[:6:2] = -1000    # equivalent to a[0:6:2] = -1000; from start to position 6, exclusive, set every 2nd element to -1000  
9. >>> a  
10. array([-1000,     1, -1000,    27, -1000,   125,   216,   343,   512,   729])  
11. >>> a[ : :-1]                                 # reversed a  
12. array([  729,   512,   343,   216,   125, -1000,    27, -1000,     1, -1000])  
13. >>> for i in a:  
14. ...         print i**(1/3.),  
15. ...  
16. nan 1.0 nan 3.0 nan 5.0 6.0 7.0 8.0 9.0</span>  

多维数组可以用tuple 来索引.  

[python] view plain copy

1. >>> def f(x,y):  
2. ...         return 10*x+y  
3. ...  
4. >>> b = fromfunction(f,(5,4),dtype=int)  
5. >>> b  
6. array([[ 0,  1,  2,  3],  
7.        [10, 11, 12, 13],  
8.        [20, 21, 22, 23],  
9.        [30, 31, 32, 33],  
10.        [40, 41, 42, 43]])  
11. >>> b[2,3]  
12. 23  
13. >>> b[0:5, 1]                       # each row in the second column of b  
14. array([ 1, 11, 21, 31, 41])  
15. >>> b[ : ,1]                        # equivalent to the previous example  
16. array([ 1, 11, 21, 31, 41])  
17. >>> b[1:3, : ]                      # each column in the second and third row of b  
18. array([[10, 11, 12, 13],  
19.        [20, 21, 22, 23]])  
20. >>> b[-1]                                  # the last row. Equivalent to b[-1,:]  
21. array([40, 41, 42, 43])</span>  

省略号...表示那些列取完整的值，比如，如果x 的rank = 5，那么 

•  x[1,2,...] is equivalent to x[1,2,:,:,:], 
•  x[...,3] to x[:,:,:,:,3] and 
•  x[4,...,5,:] to x[4,:,:,5,:].

[python] view plain copy

1. >>> c = array( [ [[  0,  1,  2],               # a 3D array (two stacked 2D arrays)  
2. ...               [ 10, 12, 13]],  
3. ...  
4. ...              [[100,101,102],  
5. ...               [110,112,113]] ] )  
6. >>> c.shape  
7. (2, 2, 3)  
8. >>> c[1,...]                                   # same as c[1,:,:] or c[1]  
9. array([[100, 101, 102],  
10.        [110, 112, 113]])  
11. >>> c[...,2]                                   # same as c[:,:,2]  
12. array([[  2,  13],  
13.        [102, 113]])  

多维数组迭代时以第一个维度为迭代单位: 

[python] view plain copy

1. >>> for row in b:  
2. ...         print row  
3. ...  
4. [0 1 2 3]  
5. [10 11 12 13]  
6. [20 21 22 23]  
7. [30 31 32 33]  
8. [40 41 42 43]  

如果我们想忽略维度，将多维数组当做一个大的一维数组也是可以的，下面是例子

[python] view plain copy

1. >>> for element in b.flat:  
2. ...         print element,  
3. ...  
4. 0 1 2 3 10 11 12 13 20 21 22 23 30 31 32 33 40 41 42 43