numpy常用函数及实例

强制打印所有数组元素

set_printoptions(threshold='nan')

>>> a = array( [20,30,40,50] )a<35>out: array([ True,  True, False, False], dtype=bool)

>>> (a=b).all()#比较a、b是否相同>>> (a=b).any()#只要有一个元素相同返回truea=array([[ 1.,  1.],       [ 5.,  8.]])b=array([[ 3.,  3.],       [ 6.,  0.]])>>> vstack((a,b))>out: array([[ 1.,  1.],       [ 5.,  8.],       [ 3.,  3.],       [ 6.,  0.]])>>> hstack((a,b))>out: array([[ 1.,  1.,  3.,  3.],       [ 5.,  8.,  6.,  0.]])>>>hsplit(a,(3,4))   #按第三列和第四列切分>>>hsplit(a,3) #按列分为三份切分d = a.copy()  #深复制

通过数组索引

>>> a = arange(12)**2           # 定义a>>> i = array( [ 1,1,3,8,5 ] )  # 索引数组>>> a[i]                  array([ 1,  1,  9, 64, 25])>>>>>> j = array( [ [ 3, 4], [ 9, 7 ] ] )# 索引二维数组>>> a[j]           array([[ 9, 16],       [81, 49]])

定义二维索引

>>> a = arange(12).reshape(3,4)>>> aarray([[ 0,  1,  2,  3],       [ 4,  5,  6,  7],       [ 8,  9, 10, 11]])>>> i = array( [ [0,1],                        ...              [1,2] ] )>>> j = array( [ [2,1],                        ...              [3,3] ] )>>>>>> a[i,j]                                    array([[ 2,  5],       [ 7, 11]])#a[i,j]分别是元素(0,2),(1,1),(1,3),(2,3)#i,j换成list效果不变

time = linspace(20, 145, 5) #均分为5份，#arange(20,145,5)是每隔5，是65份>>> data = sin(arange(20)).reshape(5,4)         >>> timearray([  20.  ,   51.25,   82.5 ,  113.75,  145.  ])>>> dataarray([[ 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]])>>> ind = data.argmax(axis=0) #每列最大值的index>>> indarray([2, 0, 3, 1])

通过bool数组赋值

>>> a = arange(12).reshape(3,4)>>> b = a > 4>>> b                                          array([[False, False, False, False],       [False, True, True, True],       [True, True, True, True]], dtype=bool)>>> a[b]                                      array([ 5,  6,  7,  8,  9, 10, 11])

>>> a = arange(12).reshape(3,4)>>> b1 = array([False,True,True])             >>> b2 = array([True,False,True,False])      >>>>>> a[b1,:]                                   array([[ 4,  5,  6,  7],       [ 8,  9, 10, 11]])#和之前二维索引方式类似

线性代数

>>> from numpy import *>>> from numpy.linalg import *>>> a = array([[1.0, 2.0], [3.0, 4.0]])>>> a.transpose()>>> inv(a)>>> u = eye(2)>>> dot (j, j)>>> trace(u) >>> y = array([[5.], [7.]])>>> solve(a, y)array([[-3.],       [ 4.]])>>> eig(j)(array([ 0.+1.j,  0.-1.j]),array([[ 0.70710678+0.j,  0.70710678+0.j],       [ 0.00000000-0.70710678j,  0.00000000+0.70710678j]]))

矩阵类

>>> A = matrix('1.0 2.0; 3.0 4.0')#创建>>> type(A)<class 'numpy.matrixlib.defmatrix.matrix'>

创建数组

arange, array, copy, empty, empty_like, eye, fromfile, fromfunction, identity, linspace, logspace, mgrid, ogrid, ones, ones_like, r , zeros, zeros_like

转化

astype, atleast 1d, atleast 2d, atleast 3d, mat

操作

array split, column stack, concatenate, diagonal, dsplit, dstack, hsplit, hstack, item, newaxis, ravel, repeat, reshape, resize, squeeze, swapaxes, take, transpose, vsplit, vstack

询问

all, any, nonzero, where

排序

argmax, argmin, argsort, max, min, ptp, searchsorted, sort

运算

choose, compress, cumprod, cumsum, inner, fill, imag, prod, put, putmask, real, sum

基本统计

cov, mean, std, var

基本线性代数

cross, dot, outer, svd, vdot

创建数组

arange

>>> np.arange(3)array([0, 1, 2])>>> np.arange(3.0)array([ 0.,  1.,  2.])>>> np.arange(3,7)array([3, 4, 5, 6])>>> np.arange(3,7,2)array([3, 5])

empty_like

>>> a = ([1,2,3], [4,5,6])                         # a is array-like>>> np.empty_like(a)array([[-1073741821, -1073741821,           3],    #random       [          0,           0, -1073741821]])>>> a = np.array([[1., 2., 3.],[4.,5.,6.]])>>> np.empty_like(a)array([[ -2.00000715e+000,   1.48219694e-323,  -2.00000572e+000],#random       [  4.38791518e-305,  -2.00000715e+000,   4.17269252e-309]])

fromfunction

>>> np.fromfunction(lambda i, j: i == j, (3, 3), dtype=int)array([[ True, False, False],       [False,  True, False],       [False, False,  True]], dtype=bool)>>> np.fromfunction(lambda i, j: i + j, (3, 3), dtype=int)array([[0, 1, 2],       [1, 2, 3],       [2, 3, 4]])

identity

>>> np.identity(3)array([[ 1.,  0.,  0.],       [ 0.,  1.,  0.],       [ 0.,  0.,  1.]])

linspace

>>> np.linspace(2.0, 3.0, num=5)    array([ 2.  ,  2.25,  2.5 ,  2.75,  3.  ])>>> np.linspace(2.0, 3.0, num=5, endpoint=False)    array([ 2. ,  2.2,  2.4,  2.6,  2.8])>>> np.linspace(2.0, 3.0, num=5, retstep=True)    (array([ 2.  ,  2.25,  2.5 ,  2.75,  3.  ]), 0.25)

logspace

>>> np.logspace(2.0, 3.0, num=4)    array([  100.        ,   215.443469  ,   464.15888336,  1000.        ])>>> np.logspace(2.0, 3.0, num=4, endpoint=False)    array([ 100.        ,  177.827941  ,  316.22776602,  562.34132519])>>> np.logspace(2.0, 3.0, num=4, base=2.0)    array([ 4.        ,  5.0396842 ,  6.34960421,  8.        ])

mgrid

>>> np.mgrid[0:5,0:5]array([[[0, 0, 0, 0, 0],        [1, 1, 1, 1, 1],        [2, 2, 2, 2, 2],        [3, 3, 3, 3, 3],        [4, 4, 4, 4, 4]],       [[0, 1, 2, 3, 4],        [0, 1, 2, 3, 4],        [0, 1, 2, 3, 4],        [0, 1, 2, 3, 4],        [0, 1, 2, 3, 4]]])>>> np.mgrid[-1:1:5j]array([-1. , -0.5,  0. ,  0.5,  1. ])

ogrid

>>> from numpy import ogrid>>> ogrid[-1:1:5j]array([-1. , -0.5,  0. ,  0.5,  1. ])>>> ogrid[0:5,0:5][array([[0],        [1],        [2],        [3],        [4]]), array([[0, 1, 2, 3, 4]])]

ones

>>> np.ones(5)array([ 1.,  1.,  1.,  1.,  1.])>>> np.ones((5,), dtype=np.int)array([1, 1, 1, 1, 1])>>> np.ones((2, 1))array([[ 1.],       [ 1.]])>>> s = (2,2)>>> np.ones(s)array([[ 1.,  1.],       [ 1.,  1.]])

ones_like

>>> a = np.array([[1, 2, 3], [4, 5, 6]])>>> np.ones_like(a)array([[1, 1, 1],       [1, 1, 1]])

r_

>>> np.r_[np.array([1,2,3]), 0, 0, np.array([4,5,6])]array([1, 2, 3, 0, 0, 4, 5, 6])>>> np.r_[-1:1:6j, [0]*3, 5, 6]array([-1. , -0.6, -0.2,  0.2,  0.6,  1. ,  0. ,  0. ,  0. ,  5. ,  6. ])>>> a = np.array([[0, 1, 2], [3, 4, 5]])>>> np.r_['-1', a, a] # concatenate along last axisarray([[0, 1, 2, 0, 1, 2],       [3, 4, 5, 3, 4, 5]])>>> np.r_['0,2', [1,2,3], [4,5,6]] # concatenate along first axis, dim>=2array([[1, 2, 3],       [4, 5, 6]])>>> np.r_['0,2,0', [1,2,3], [4,5,6]]array([[1],       [2],       [3],       [4],       [5],       [6]])>>> np.r_['1,2,0', [1,2,3], [4,5,6]]array([[1, 4],       [2, 5],       [3, 6]])

zeros

#like ones

zeros_like

#like ones_like

fromfile

#Construct an ndarray:>>> dt = np.dtype([('time', [('min', int), ('sec', int)]),...                ('temp', float)])>>> x = np.zeros((1,), dtype=dt)>>> x['time']['min'] = 10; x['temp'] = 98.25>>> xarray([((10, 0), 98.25)],      dtype=[('time', [('min', '<i4'), ('sec', '<i4')]), ('temp', '<f8')])#Save the raw data to disk:>>> import os>>> fname = os.tmpnam()>>> x.tofile(fname)#Read the raw data from disk:>>> np.fromfile(fname, dtype=dt)array([((10, 0), 98.25)],      dtype=[('time', [('min', '<i4'), ('sec', '<i4')]), ('temp', '<f8')])#The recommended way to store and load data:>>> np.save(fname, x)>>> np.load(fname + '.npy')array([((10, 0), 98.25)],      dtype=[('time', [('min', '<i4'), ('sec', '<i4')]), ('temp', '<f8')])

转化

astype

>>> x = np.array([1, 2, 2.5])>>> xarray([ 1. ,  2. ,  2.5])>>> x.astype(int)array([1, 2, 2])

atleast 1d

>>> np.atleast_1d(1.0)array([ 1.])>>> x = np.arange(9.0).reshape(3,3)>>> np.atleast_1d(x)array([[ 0.,  1.,  2.],       [ 3.,  4.,  5.],       [ 6.,  7.,  8.]])>>> np.atleast_1d(x) is xTrue>>> np.atleast_1d(1, [3, 4])[array([1]), array([3, 4])]

atleast 2d

>>> np.atleast_2d(3.0)array([[ 3.]])>>> x = np.arange(3.0)>>> np.atleast_2d(x)array([[ 0.,  1.,  2.]])>>> np.atleast_2d(x).base is xTrue>>> np.atleast_2d(1, [1, 2], [[1, 2]])[array([[1]]), array([[1, 2]]), array([[1, 2]])]

atleast 3d

>>> np.atleast_3d(3.0)array([[[ 3.]]])>>> x = np.arange(3.0)>>> np.atleast_3d(x).shape(1, 3, 1)>>> x = np.arange(12.0).reshape(4,3)>>> np.atleast_3d(x).shape(4, 3, 1)>>> np.atleast_3d(x).base is xTrue>>> for arr in np.atleast_3d([1, 2], [[1, 2]], [[[1, 2]]]):...     print arr, arr.shape...[[[1]  [2]]] (1, 2, 1)[[[1]  [2]]] (1, 2, 1)[[[1 2]]] (1, 1, 2)

mat

>>> x = np.array([[1, 2], [3, 4]])>>> m = np.asmatrix(x)>>> x[0,0] = 5>>> mmatrix([[5, 2],        [3, 4]])

操作

array split

>>> x = np.arange(8.0)>>> np.array_split(x, 3)    [array([ 0.,  1.,  2.]), array([ 3.,  4.,  5.]), array([ 6.,  7.])]

column stack

#np.vstack(tup).T>>> a = np.array((1,2,3))>>> b = np.array((2,3,4))>>> np.column_stack((a,b))array([[1, 2],       [2, 3],       [3, 4]])

concatenate

>>> a = np.array([[1, 2], [3, 4]])>>> b = np.array([[5, 6]])>>> np.concatenate((a, b), axis=0)array([[1, 2],       [3, 4],       [5, 6]])>>> np.concatenate((a, b.T), axis=1)array([[1, 2, 5],       [3, 4, 6]])

diagonal

>>> a = np.arange(4).reshape(2,2)>>> aarray([[0, 1],       [2, 3]])>>> a.diagonal()array([0, 3])>>> a.diagonal(1)array([1])A 3-D example:>>> a = np.arange(8).reshape(2,2,2); aarray([[[0, 1],        [2, 3]],       [[4, 5],        [6, 7]]])>>> a.diagonal(0, # Main diagonals of two arrays created by skipping...            0, # across the outer(left)-most axis last and...            1) # the "middle" (row) axis first.array([[0, 6],       [1, 7]])

dsplit

>>> x = np.arange(16.0).reshape(2, 2, 4)>>> xarray([[[  0.,   1.,   2.,   3.],        [  4.,   5.,   6.,   7.]],       [[  8.,   9.,  10.,  11.],        [ 12.,  13.,  14.,  15.]]])>>> np.dsplit(x, 2)[array([[[  0.,   1.],        [  4.,   5.]],       [[  8.,   9.],        [ 12.,  13.]]]), array([[[  2.,   3.],        [  6.,   7.]],       [[ 10.,  11.],        [ 14.,  15.]]])]>>> np.dsplit(x, np.array([3, 6]))[array([[[  0.,   1.,   2.],        [  4.,   5.,   6.]],       [[  8.,   9.,  10.],        [ 12.,  13.,  14.]]]), array([[[  3.],        [  7.]],       [[ 11.],        [ 15.]]]), array([], dtype=float64)]

dstack

>>> a = np.array((1,2,3))>>> b = np.array((2,3,4))>>> np.dstack((a,b))array([[[1, 2],        [2, 3],        [3, 4]]])>>> a = np.array([[1],[2],[3]])>>> b = np.array([[2],[3],[4]])>>> np.dstack((a,b))array([[[1, 2]],       [[2, 3]],       [[3, 4]]])

hsplit

>>> x = np.arange(16.0).reshape(4, 4)>>> xarray([[  0.,   1.,   2.,   3.],       [  4.,   5.,   6.,   7.],       [  8.,   9.,  10.,  11.],       [ 12.,  13.,  14.,  15.]])>>> np.hsplit(x, 2)[array([[  0.,   1.],       [  4.,   5.],       [  8.,   9.],       [ 12.,  13.]]), array([[  2.,   3.],       [  6.,   7.],       [ 10.,  11.],       [ 14.,  15.]])]>>> np.hsplit(x, np.array([3, 6]))[array([[  0.,   1.,   2.],       [  4.,   5.,   6.],       [  8.,   9.,  10.],       [ 12.,  13.,  14.]]), array([[  3.],       [  7.],       [ 11.],       [ 15.]]), array([], dtype=float64)]

hstack

>>> a = np.array((1,2,3))>>> b = np.array((2,3,4))>>> np.hstack((a,b))array([1, 2, 3, 2, 3, 4])>>> a = np.array([[1],[2],[3]])>>> b = np.array([[2],[3],[4]])>>> np.hstack((a,b))array([[1, 2],       [2, 3],       [3, 4]])

item

>>> x = np.random.randint(9, size=(3, 3))>>> xarray([[3, 1, 7],       [2, 8, 3],       [8, 5, 3]])>>> x.item(3)2>>> x.item(7)5>>> x.item((0, 1))1>>> x.item((2, 2))3

newaxis

>>> x = np.array([[[1],[2],[3]], [[4],[5],[6]]])>>> x[:,np.newaxis,:,:].shape(2, 1, 3, 1)#

ravel

#It is equivalent to reshape(-1, order=order).>>> x = np.array([[1, 2, 3], [4, 5, 6]])>>> print np.ravel(x)[1 2 3 4 5 6]>>> print x.reshape(-1)[1 2 3 4 5 6]>>> print np.ravel(x, order='F')[1 4 2 5 3 6]#When order is ‘A’, it will preserve the array’s ‘C’ or ‘F’ ordering:>>> print np.ravel(x.T)[1 4 2 5 3 6]>>> print np.ravel(x.T, order='A')[1 2 3 4 5 6]#When order is ‘K’, it will preserve orderings that are neither ‘C’ nor ‘F’, but won’t reverse axes:>>> a = np.arange(3)[::-1]; aarray([2, 1, 0])>>> a.ravel(order='C')array([2, 1, 0])>>> a.ravel(order='K')array([2, 1, 0])>>> a = np.arange(12).reshape(2,3,2).swapaxes(1,2); aarray([[[ 0,  2,  4],        [ 1,  3,  5]],       [[ 6,  8, 10],        [ 7,  9, 11]]])>>> a.ravel(order='C')array([ 0,  2,  4,  1,  3,  5,  6,  8, 10,  7,  9, 11])>>> a.ravel(order='K')array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])

repeat

>>> x = np.array([[1,2],[3,4]])>>> np.repeat(x, 2)array([1, 1, 2, 2, 3, 3, 4, 4])>>> np.repeat(x, 3, axis=1)array([[1, 1, 1, 2, 2, 2],       [3, 3, 3, 4, 4, 4]])>>> np.repeat(x, [1, 2], axis=0)array([[1, 2],       [3, 4],       [3, 4]])

reshape

>>> a = np.array([[1,2,3], [4,5,6]])>>> np.reshape(a, 6)array([1, 2, 3, 4, 5, 6])>>> np.reshape(a, 6, order='F')array([1, 4, 2, 5, 3, 6])>>> np.reshape(a, (3,-1))       # the unspecified value is inferred to be 2array([[1, 2],       [3, 4],       [5, 6]])

resize

>>> a=np.array([[0,1],[2,3]])>>> np.resize(a,(1,4))array([[0, 1, 2, 3]])>>> np.resize(a,(2,4))array([[0, 1, 2, 3],       [0, 1, 2, 3]])

squeeze

>>> x = np.array([[[0], [1], [2]]])>>> x.shape(1, 3, 1)>>> np.squeeze(x).shape(3,)

swapaxes

>>> x = np.array([[1,2,3]])>>> np.swapaxes(x,0,1)array([[1],       [2],       [3]])>>> x = np.array([[[0,1],[2,3]],[[4,5],[6,7]]])>>> xarray([[[0, 1],        [2, 3]],       [[4, 5],        [6, 7]]])>>> np.swapaxes(x,0,2)array([[[0, 4],        [2, 6]],       [[1, 5],        [3, 7]]])

take

>>> a = [4, 3, 5, 7, 6, 8]>>> indices = [0, 1, 4]>>> np.take(a, indices)array([4, 3, 6])#In this example if a is an ndarray, “fancy” indexing can be used.>>> a = np.array(a)>>> a[indices]array([4, 3, 6])

transpose

>>> x = np.arange(4).reshape((2,2))>>> xarray([[0, 1],       [2, 3]])>>> np.transpose(x)array([[0, 2],       [1, 3]])>>> x = np.ones((1, 2, 3))>>> np.transpose(x, (1, 0, 2)).shape(2, 1, 3)

vsplit

>>> x = np.arange(16.0).reshape(4, 4)>>> xarray([[  0.,   1.,   2.,   3.],       [  4.,   5.,   6.,   7.],       [  8.,   9.,  10.,  11.],       [ 12.,  13.,  14.,  15.]])>>> np.vsplit(x, 2)[array([[ 0.,  1.,  2.,  3.],       [ 4.,  5.,  6.,  7.]]), array([[  8.,   9.,  10.,  11.],       [ 12.,  13.,  14.,  15.]])]>>> np.vsplit(x, np.array([3, 6]))[array([[  0.,   1.,   2.,   3.],       [  4.,   5.,   6.,   7.],       [  8.,   9.,  10.,  11.]]), array([[ 12.,  13.,  14.,  15.]]), array([], dtype=float64)]

vstack

>>> a = np.array([1, 2, 3])>>> b = np.array([2, 3, 4])>>> np.vstack((a,b))array([[1, 2, 3],       [2, 3, 4]])>>> a = np.array([[1], [2], [3]])>>> b = np.array([[2], [3], [4]])>>> np.vstack((a,b))array([[1],       [2],       [3],       [2],       [3],       [4]])

查询

all

>>> np.all([[True,False],[True,True]])False>>> np.all([[True,False],[True,True]], axis=0)array([ True, False], dtype=bool)>>> np.all([-1, 4, 5])True>>> np.all([1.0, np.nan])True>>> o=np.array([False])>>> z=np.all([-1, 4, 5], out=o)>>> id(z), id(o), z                             (28293632, 28293632, array([ True], dtype=bool))

any

>>> np.any([[True, False], [True, True]])True>>> np.any([[True, False], [False, False]], axis=0)array([ True, False], dtype=bool)>>> np.any([-1, 0, 5])True>>> np.any(np.nan)True>>> o=np.array([False])>>> z=np.any([-1, 4, 5], out=o)>>> z, o(array([ True], dtype=bool), array([ True], dtype=bool))>>> # Check now that z is a reference to o>>> z is oTrue>>> id(z), id(o) # identity of z and o              (191614240, 191614240)

nonzero

>>> x = np.eye(3)>>> xarray([[ 1.,  0.,  0.],       [ 0.,  1.,  0.],       [ 0.,  0.,  1.]])>>> np.nonzero(x)(array([0, 1, 2]), array([0, 1, 2]))>>> x[np.nonzero(x)]array([ 1.,  1.,  1.])>>> np.transpose(np.nonzero(x))array([[0, 0],       [1, 1],       [2, 2]])

where

>>> np.where([[True, False], [True, True]],...          [[1, 2], [3, 4]],...          [[9, 8], [7, 6]])array([[1, 8],       [3, 4]])>>> np.where([[0, 1], [1, 0]])(array([0, 1]), array([1, 0]))>>> x = np.arange(9.).reshape(3, 3)>>> np.where( x > 5 )(array([2, 2, 2]), array([0, 1, 2]))>>> x[np.where( x > 3.0 )]               # Note: result is 1D.array([ 4.,  5.,  6.,  7.,  8.])>>> np.where(x < 5, x, -1)               # Note: broadcasting.array([[ 0.,  1.,  2.],       [ 3.,  4., -1.],       [-1., -1., -1.]])

排序

argmax

>>> a = np.arange(6).reshape(2,3)>>> aarray([[0, 1, 2],       [3, 4, 5]])>>> np.argmax(a)5>>> np.argmax(a, axis=0)array([1, 1, 1])>>> np.argmax(a, axis=1)array([2, 2])>>> b = np.arange(6)>>> b[1] = 5>>> barray([0, 5, 2, 3, 4, 5])>>> np.argmax(b) # Only the first occurrence is returned.1

argmin

#like argmax

argsort

#One dimensional array:>>> x = np.array([3, 1, 2])>>> np.argsort(x)array([1, 2, 0])#Two-dimensional array:>>> x = np.array([[0, 3], [2, 2]])>>> xarray([[0, 3],       [2, 2]])>>> np.argsort(x, axis=0)array([[0, 1],       [1, 0]])>>> np.argsort(x, axis=1)array([[0, 1],       [0, 1]])#Sorting with keys:>>> x = np.array([(1, 0), (0, 1)], dtype=[('x', '<i4'), ('y', '<i4')])>>> xarray([(1, 0), (0, 1)],      dtype=[('x', '<i4'), ('y', '<i4')])>>> np.argsort(x, order=('x','y'))array([1, 0])>>> np.argsort(x, order=('y','x'))array([0, 1])

max

>>> a = np.arange(4).reshape((2,2))>>> aarray([[0, 1],       [2, 3]])>>> np.amax(a)3>>> np.amax(a, axis=0)array([2, 3])>>> np.amax(a, axis=1)array([1, 3])>>> b = np.arange(5, dtype=np.float)>>> b[2] = np.NaN>>> np.amax(b)nan>>> np.nanmax(b)4.0

min

#like max

ptp

>>> x = np.arange(4).reshape((2,2))>>> xarray([[0, 1],       [2, 3]])>>> np.ptp(x, axis=0)array([2, 2])>>> np.ptp(x, axis=1)array([1, 1])

searchsorted

>>> np.searchsorted([1,2,3,4,5], 3)2>>> np.searchsorted([1,2,3,4,5], 3, side='right')3>>> np.searchsorted([1,2,3,4,5], [-10, 10, 2, 3])array([0, 5, 1, 2])

sort

>>> a = np.array([[1,4],[3,1]])>>> np.sort(a)                # sort along the last axisarray([[1, 4],       [1, 3]])>>> np.sort(a, axis=None)     # sort the flattened arrayarray([1, 1, 3, 4])>>> np.sort(a, axis=0)        # sort along the first axisarray([[1, 1],       [3, 4]])Use the order keyword to specify a field to use when sorting a structured array:>>> dtype = [('name', 'S10'), ('height', float), ('age', int)]>>> values = [('Arthur', 1.8, 41), ('Lancelot', 1.9, 38),...           ('Galahad', 1.7, 38)]>>> a = np.array(values, dtype=dtype)       # create a structured array>>> np.sort(a, order='height')                        array([('Galahad', 1.7, 38), ('Arthur', 1.8, 41),       ('Lancelot', 1.8999999999999999, 38)],      dtype=[('name', '|S10'), ('height', '<f8'), ('age', '<i4')])Sort by age, then height if ages are equal:>>> np.sort(a, order=['age', 'height'])               array([('Galahad', 1.7, 38), ('Lancelot', 1.8999999999999999, 38),       ('Arthur', 1.8, 41)],      dtype=[('name', '|S10'), ('height', '<f8'), ('age', '<i4')])

运算

choose

>>> choices = [[0, 1, 2, 3], [10, 11, 12, 13],...   [20, 21, 22, 23], [30, 31, 32, 33]]>>> np.choose([2, 3, 1, 0], choices... # the first element of the result will be the first element of the... # third (2+1) "array" in choices, namely, 20; the second element... # will be the second element of the fourth (3+1) choice array, i.e.,... # 31, etc.... )array([20, 31, 12,  3])>>> np.choose([2, 4, 1, 0], choices, mode='clip') # 4 goes to 3 (4-1)array([20, 31, 12,  3])>>> # because there are 4 choice arrays>>> np.choose([2, 4, 1, 0], choices, mode='wrap') # 4 goes to (4 mod 4)array([20,  1, 12,  3])>>> # i.e., 0

compress

>>> a = np.array([[1, 2], [3, 4], [5, 6]])>>> aarray([[1, 2],       [3, 4],       [5, 6]])>>> np.compress([0, 1], a, axis=0)array([[3, 4]])>>> np.compress([False, True, True], a, axis=0)array([[3, 4],       [5, 6]])>>> np.compress([False, True], a, axis=1)array([[2],       [4],       [6]])

cumprod

>>> a = np.array([1,2,3])>>> np.cumprod(a) # intermediate results 1, 1*2...               # total product 1*2*3 = 6array([1, 2, 6])>>> a = np.array([[1, 2, 3], [4, 5, 6]])>>> np.cumprod(a, dtype=float) # specify type of outputarray([   1.,    2.,    6.,   24.,  120.,  720.])>>> np.cumprod(a, axis=0)array([[ 1,  2,  3],       [ 4, 10, 18]])

cumsum

>>> a = np.array([[1,2,3], [4,5,6]])>>> aarray([[1, 2, 3],       [4, 5, 6]])>>> np.cumsum(a)array([ 1,  3,  6, 10, 15, 21])>>> np.cumsum(a, dtype=float)     # specifies type of output value(s)array([  1.,   3.,   6.,  10.,  15.,  21.])>>> np.cumsum(a,axis=0)      # sum over rows for each of the 3 columnsarray([[1, 2, 3],       [5, 7, 9]])>>> np.cumsum(a,axis=1)      # sum over columns for each of the 2 rowsarray([[ 1,  3,  6],       [ 4,  9, 15]])

inner

Ordinary inner product for vectors:>>> a = np.array([1,2,3])>>> b = np.array([0,1,0])>>> np.inner(a, b)2A multidimensional example:>>> a = np.arange(24).reshape((2,3,4))>>> b = np.arange(4)>>> np.inner(a, b)array([[ 14,  38,  62],       [ 86, 110, 134]])An example where b is a scalar:>>> np.inner(np.eye(2), 7)array([[ 7.,  0.],       [ 0.,  7.]])

fill

>>> a = np.array([1, 2])>>> a.fill(0)>>> aarray([0, 0])>>> a = np.empty(2)>>> a.fill(1)>>> aarray([ 1.,  1.])

imag

>>> x = np.sqrt([1+0j, 0+1j])>>> x.imagarray([ 0.        ,  0.70710678])>>> x.imag.dtypedtype('float64')

prod

By default, calculate the product of all elements:>>> np.prod([1.,2.])2.0Even when the input array is two-dimensional:>>> np.prod([[1.,2.],[3.,4.]])24.0But we can also specify the axis over which to multiply:>>> np.prod([[1.,2.],[3.,4.]], axis=1)array([  2.,  12.])If the type of x is unsigned, then the output type is the unsigned platform integer:>>> x = np.array([1, 2, 3], dtype=np.uint8)>>> np.prod(x).dtype == np.uintTrueIf x is of a signed integer type, then the output type is the default platform integer:>>> x = np.array([1, 2, 3], dtype=np.int8)>>> np.prod(x).dtype == np.intTrue

put

>>> a = np.arange(5)>>> np.put(a, [0, 2], [-44, -55])>>> aarray([-44,   1, -55,   3,   4])>>> a = np.arange(5)>>> np.put(a, 22, -5, mode='clip')>>> aarray([ 0,  1,  2,  3, -5])

putmask

>>> x = np.arange(6).reshape(2, 3)>>> np.putmask(x, x>2, x**2)>>> xarray([[ 0,  1,  2],       [ 9, 16, 25]])If values is smaller than a it is repeated:>>> x = np.arange(5)>>> np.putmask(x, x>1, [-33, -44])>>> xarray([  0,   1, -33, -44, -33])

real

>>> a = np.array([1+2j, 3+4j, 5+6j])>>> a.realarray([ 1.,  3.,  5.])>>> a.real = 9>>> aarray([ 9.+2.j,  9.+4.j,  9.+6.j])>>> a.real = np.array([9, 8, 7])>>> aarray([ 9.+2.j,  8.+4.j,  7.+6.j])

sum

>>> np.sum([0.5, 1.5])2.0>>> np.sum([0.5, 0.7, 0.2, 1.5], dtype=np.int32)1>>> np.sum([[0, 1], [0, 5]])6>>> np.sum([[0, 1], [0, 5]], axis=0)array([0, 6])>>> np.sum([[0, 1], [0, 5]], axis=1)array([1, 5])

基本统计

cov

Consider two variables, x_0 and x_1, which correlate perfectly, but in opposite directions:>>> x = np.array([[0, 2], [1, 1], [2, 0]]).T>>> xarray([[0, 1, 2],       [2, 1, 0]])Note how x_0 increases while x_1 decreases. The covariance matrix shows this clearly:>>> np.cov(x)array([[ 1., -1.],       [-1.,  1.]])

mean

>>> a = np.array([[1, 2], [3, 4]])>>> np.mean(a)2.5>>> np.mean(a, axis=0)array([ 2.,  3.])>>> np.mean(a, axis=1)array([ 1.5,  3.5])In single precision, mean can be inaccurate:>>> a = np.zeros((2, 512*512), dtype=np.float32)>>> a[0, :] = 1.0>>> a[1, :] = 0.1>>> np.mean(a)0.546875

std

>>> a = np.array([[1, 2], [3, 4]])>>> np.std(a)1.1180339887498949>>> np.std(a, axis=0)array([ 1.,  1.])>>> np.std(a, axis=1)array([ 0.5,  0.5])In single precision, std() can be inaccurate:>>> a = np.zeros((2,512*512), dtype=np.float32)>>> a[0,:] = 1.0>>> a[1,:] = 0.1>>> np.std(a)0.45172946707416706

var

>>> a = np.array([[1,2],[3,4]])>>> np.var(a)1.25>>> np.var(a,0)array([ 1.,  1.])>>> np.var(a,1)array([ 0.25,  0.25])In single precision, var() can be inaccurate:>>> a = np.zeros((2,512*512), dtype=np.float32)>>> a[0,:] = 1.0>>> a[1,:] = 0.1>>> np.var(a)0.20405951142311096

基本线性代数

cross

Vector cross-product.>>> x = [1, 2, 3]>>> y = [4, 5, 6]>>> np.cross(x, y)array([-3,  6, -3])One vector with dimension 2.>>> x = [1, 2]>>> y = [4, 5, 6]>>> np.cross(x, y)array([12, -6, -3])Equivalently:>>> x = [1, 2, 0]>>> y = [4, 5, 6]>>> np.cross(x, y)array([12, -6, -3])Both vectors with dimension 2.>>> x = [1,2]>>> y = [4,5]>>> np.cross(x, y)-3Multiple vector cross-products. Note that the direction of the cross product vector is defined by the right-hand rule.>>> x = np.array([[1,2,3], [4,5,6]])>>> y = np.array([[4,5,6], [1,2,3]])>>> np.cross(x, y)array([[-3,  6, -3],       [ 3, -6,  3]])The orientation of c can be changed using the axisc keyword.>>> np.cross(x, y, axisc=0)array([[-3,  3],       [ 6, -6],       [-3,  3]])Change the vector definition of x and y using axisa and axisb.>>> x = np.array([[1,2,3], [4,5,6], [7, 8, 9]])>>> y = np.array([[7, 8, 9], [4,5,6], [1,2,3]])>>> np.cross(x, y)array([[ -6,  12,  -6],       [  0,   0,   0],       [  6, -12,   6]])>>> np.cross(x, y, axisa=0, axisb=0)array([[-24,  48, -24],       [-30,  60, -30],       [-36,  72, -36]])

dot

>>> np.dot(3, 4)12Neither argument is complex-conjugated:>>> np.dot([2j, 3j], [2j, 3j])(-13+0j)For 2-D arrays it’s the matrix product:>>> a = [[1, 0], [0, 1]]>>> b = [[4, 1], [2, 2]]>>> np.dot(a, b)array([[4, 1],       [2, 2]])>>> a = np.arange(3*4*5*6).reshape((3,4,5,6))>>> b = np.arange(3*4*5*6)[::-1].reshape((5,4,6,3))>>> np.dot(a, b)[2,3,2,1,2,2]499128>>> sum(a[2,3,2,:] * b[1,2,:,2])499128

outer

Make a (very coarse) grid for computing a Mandelbrot set:>>> rl = np.outer(np.ones((5,)), np.linspace(-2, 2, 5))>>> rlarray([[-2., -1.,  0.,  1.,  2.],       [-2., -1.,  0.,  1.,  2.],       [-2., -1.,  0.,  1.,  2.],       [-2., -1.,  0.,  1.,  2.],       [-2., -1.,  0.,  1.,  2.]])>>> im = np.outer(1j*np.linspace(2, -2, 5), np.ones((5,)))>>> imarray([[ 0.+2.j,  0.+2.j,  0.+2.j,  0.+2.j,  0.+2.j],       [ 0.+1.j,  0.+1.j,  0.+1.j,  0.+1.j,  0.+1.j],       [ 0.+0.j,  0.+0.j,  0.+0.j,  0.+0.j,  0.+0.j],       [ 0.-1.j,  0.-1.j,  0.-1.j,  0.-1.j,  0.-1.j],       [ 0.-2.j,  0.-2.j,  0.-2.j,  0.-2.j,  0.-2.j]])>>> grid = rl + im>>> gridarray([[-2.+2.j, -1.+2.j,  0.+2.j,  1.+2.j,  2.+2.j],       [-2.+1.j, -1.+1.j,  0.+1.j,  1.+1.j,  2.+1.j],       [-2.+0.j, -1.+0.j,  0.+0.j,  1.+0.j,  2.+0.j],       [-2.-1.j, -1.-1.j,  0.-1.j,  1.-1.j,  2.-1.j],       [-2.-2.j, -1.-2.j,  0.-2.j,  1.-2.j,  2.-2.j]])An example using a “vector” of letters:>>> x = np.array(['a', 'b', 'c'], dtype=object)>>> np.outer(x, [1, 2, 3])array([[a, aa, aaa],       [b, bb, bbb],       [c, cc, ccc]], dtype=object)

svd

>>> a = np.random.randn(9, 6) + 1j*np.random.randn(9, 6)Reconstruction based on full SVD:>>> U, s, V = np.linalg.svd(a, full_matrices=True)>>> U.shape, V.shape, s.shape((9, 6), (6, 6), (6,))>>> S = np.zeros((9, 6), dtype=complex)>>> S[:6, :6] = np.diag(s)>>> np.allclose(a, np.dot(U, np.dot(S, V)))TrueReconstruction based on reduced SVD:>>> U, s, V = np.linalg.svd(a, full_matrices=False)>>> U.shape, V.shape, s.shape((9, 6), (6, 6), (6,))>>> S = np.diag(s)>>> np.allclose(a, np.dot(U, np.dot(S, V)))True

vdot

>>> a = np.array([1+2j,3+4j])>>> b = np.array([5+6j,7+8j])>>> np.vdot(a, b)(70-8j)>>> np.vdot(b, a)(70+8j)Note that higher-dimensional arrays are flattened!>>> a = np.array([[1, 4], [5, 6]])>>> b = np.array([[4, 1], [2, 2]])>>> np.vdot(a, b)30>>> np.vdot(b, a)30>>> 1*4 + 4*1 + 5*2 + 6*230