Numpy 入门教程

转自http://blog.youkuaiyun.com/liyuanbhu/article/details/28611429

转自http://blog.youkuaiyun.com/liyuanbhu/article/details/28870439

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

Numpy 入门教程

NumPy 提供了对多维数组的支持，与Python原生支持的List类型不同，数组的所有元素必须同样的类型。数组的维度被称为axes，维数称为 rank。 

Numpy的数组类型为 ndarray， ndarray 的重要属性包括: 

• ndarray.ndim：数组的维数，也称为rank
• ndarray.shape：数组各维的大小tuple 类型，对一个n 行m 列的矩阵来说， shape 为 (n,m)。
• ndarray.size：元素的总数。 
• Ndarray.dtype：每个元素的类型，可以是 numpy.int32, numpy.int16, and numpy.float64 等。 
• Ndarray.itemsize：每个元素占用的字节数。
• Ndarray.data：指向数据内存。

 

一个简单的例子：

[python]  view plain  copy

1. >>> from numpy  import *  
2. >>> a = arange(15).reshape(3, 5)  
3. >>> a  
4. array([[ 0,  1,  2,  3,  4],  
5.        [ 5,  6,  7,  8,  9],  
6.        [10, 11, 12, 13, 14]])  
7. >>> a.shape  
8. (3, 5)  
9. >>> a.ndim  
10. 2  
11. >>> a.dtype.name  
12. 'int32'  
13. >>> a.itemsize  
14. 4  
15. >>> a.size  
16. 15  
17. >>> type(a)  
18. numpy.ndarray  
19. >>> b = array([6, 7, 8])  
20. >>> b  
21. array([6, 7, 8])  
22. >>> type(b)  
23. numpy.ndarray  

生成数组

有许多种方法生成数组。比如，可以将Python list 或 tuple 转化为数组，转化后的数组元素的类型由原来的对象的类型来决定。

[python]  view plain  copy

1. >>> from numpy  import *  
2. >>> a = array( [2,3,4] )  
3. >>> a  
4. array([2, 3, 4])  
5. >>> a.dtype  
6. dtype('int32')  
7. >>> b = array([1.2, 3.5, 5.1])  
8. >>> b.dtype  
9. dtype('float64')  
10. >>> b = array( [ (1.5,2,3), (4,5,6) ] )  
11. >>> b  
12. array([[ 1.5,  2. ,  3. ],  
13.        [ 4. ,  5. ,  6. ]])  

生成数组时也可以指定元素的数据类型: 

[python]  view plain  copy

1. >>> c = array( [ [1,2], [3,4] ], dtype=complex )  
2. >>> c  
3. array([[ 1.+0.j,  2.+0.j],  
4.        [ 3.+0.j,  4.+0.j]])  

通常，我们无法事先知道数组元素的具体值，但是数组大小是已知的。 这时可以用下面几种方法生成数组。 

zeros 函数生成元素全部为0的数组，ones函数生成元素全部为1的数组empty函数生成元素没有赋值的数组，这时元素值由内存中原来的内容决定。 默认的，生成的数组的元素类型为float64.

[python]  view plain  copy

1. >>> zeros( (3,4) )  
2. array([[0.,  0.,  0.,  0.],  
3.        [0.,  0.,  0.,  0.],  
4.        [0.,  0.,  0.,  0.]])  
5. >>> ones( (2,3,4), dtype=int16 )                # dtype can also be specified  
6. array([[[ 1, 1, 1, 1],  
7.         [ 1, 1, 1, 1],  
8.         [ 1, 1, 1, 1]],  
9.        [[ 1, 1, 1, 1],  
10.         [ 1, 1, 1, 1],  
11.         [ 1, 1, 1, 1]]], dtype=int16)  
12. >>> empty( (2,3) )  
13. array([[  3.73603959e-262,   6.02658058e-154,   6.55490914e-260],  
14.        [  5.30498948e-313,   3.14673309e-307,   1.00000000e+000]])  

arange 函数生成的数组的元素按照等比数列排布，类似于 range函数。

[python]  view plain  copy

1. >>> arange( 10, 30, 5 )  
2. array([10, 15, 20, 25])  
3. >>> arange( 0, 2, 0.3 )                 # it accepts float arguments  
4. array([ 0. ,  0.3,  0.6,  0.9,  1.2,  1.5,  1.8])  

linspace 函数有些类似matlab中的同名函数，下面是个例子: 

[python]  view plain  copy

1. >>> linspace( 0, 2, 9 )                 # 9 numbers from 0 to 2  
2. array([ 0.  ,  0.25,  0.5 ,  0.75,  1.  ,  1.25,  1.5 ,  1.75,  2.  ])  
3. >>> x = linspace( 0, 2*pi, 100 )        # useful to evaluate function at lots of points  
4. >>> f = sin(x)  

屏幕输出 Arrays

当用print 打印一个 array时, 输出结果类似于 lists: 

[python]  view plain  copy

1. >>> a = arange(6)                         # 1d array  
2. >>> print a  
3. [0 1 2 3 4 5]  
4. >>>  
5. >>> b = arange(12).reshape(4,3)           # 2d array  
6. >>> print b  
7. [[ 0  1  2]  
8.  [ 3  4  5]  
9.  [ 6  7  8]  
10.  [ 9 10 11]]  
11. >>>  
12. >>> c = arange(24).reshape(2,3,4)         # 3d array  
13. >>> print c  
14. [[[ 0  1  2  3]  
15.   [ 4  5  6  7]  
16.   [ 8  9 10 11]]  
17.   
18.  [[12 13 14 15]  
19.   [16 17 18 19]  
20.   [20 21 22 23]]]  

如果数组过大，显示时会有一些省略号: 

[python]  view plain  copy

1. >>> print arange(10000)  
2. [   0    1    2 ..., 9997 9998 9999]  
3. >>>  
4. >>> print arange(10000).reshape(100,100)  
5. [[   0    1    2 ...,   97   98   99]  
6.  [ 100  101  102 ...,  197  198  199]  
7.  [ 200  201  202 ...,  297  298  299]  
8.  ...,  
9.  [9700 9701 9702 ..., 9797 9798 9799]  
10.  [9800 9801 9802 ..., 9897 9898 9899]  
11.  [9900 9901 9902 ..., 9997 9998 9999]]  

如果我们需要显示完整的数组，可以如下设置 

[python]  view plain  copy

1. >>> set_printoptions(threshold='nan')  

翻译自官方文档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