Numpy详解

NumPy 简介

Python并没有提供数组功能。虽然列表可以完成基本的数组功能，但它不是真正的数组，而且在数据量比较大时，使用列表的速度会很慢。为此，Numpy提供了真正的数组功能，以及对数据进行快速处理的函数。

NumPy的主要对象是同种元素的多维数组。这是一个所有的元素都是一种类型、通过一个正整数元组索引的元素表格(通常是元素是数字)。在NumPy中维度(dimensions)叫做轴(axes)，轴的个数叫做秩(rank)。

例如，在3D空间一个点的坐标 [1, 2, 3] 是一个秩为1的数组，因为它只有一个轴。那个轴长度为3.又例如，在以下例子中，数组的秩为2(它有两个维度).第一个维度长度为2,第二个维度长度为3.

[[ 1., 0., 0.],
 [ 0., 1., 2.]]

NumPy的数组类被称作 ndarray 。通常被称作数组。注意numpy.array和标准Python库类array.array并不相同，后者只处理一维数组和提供少量功能。

数据类型

numpy的数据类型有下面的几个

数据类型	描述
bool_	以字节存储的布尔值（True 或 False）
int_	默认的整数类型（和 C 的 long 一样，是 int64 或者 int32）
intc	和 C 的 int 相同（一般为 int64 或 int32）
intp	用于下标的整数（和 C 的 ssize_t 相同，一般为int64 或者 int32）
int8	字节（-128 到 127）
int16	整数（-32768 到 32767）
int32	整数（-2147483648 到 2147483647）
int64	整数（-9223372036854775808 到 9223372036854775807）
uint8	无符号整数（0 到 255）
uint16	无符号整数（0 到 65535）
uint32	无符号整数（0 到 4294967295）
uint64	无符号整数（0 到 18446744073709551615）
float_	float64 的简写
float16	半精度浮点：1位符号，5位指数，10位尾数
float32	单精度浮点：1位符号，8位指数，23位尾数
float64	双精度浮点：1位符号，11位指数，52位尾数
complex_	complex128 的简写
complex64	由两个32位浮点（实部和虚部）组成的复数
complex128	由两个64位浮点（实部和虚部）组成的复数

此外，Intel平台相关的C整数类型 short、long，long long 和它们的无符号版本是有定义的。

NumPy 数组对象

NumPy中的 ndarray 是一个多维数组对象，该对象由两部分组成：

• 实际的数据；
• 描述这些数据的元数据。

大部分的数组操作仅仅修改元数据部分，而不改变底层的实际数据。

数组对象的创建

• 第一种就是创建数组的方式：使用array函数从常规的 list， tuple等格式的数据转创建为ndarray， 默认创建一个新的数组，所创建的数组类型由原序列中的元素类型推导而来。

• 第二种方法的应用场景是很多时候我们对所创建的数组内的元素未知，但数组的大小已知。针对这种情况，NumPy提供了一些使用占位符创建数组的函数，也就是说一个常量值初始化一个数组。比如：用函数zeros可创建一个全是0的数组，用函数ones可创建一个全为1的数组，函数empty创建一个内容随机并且依赖与内存状态的数组（默认数组类型(dtype)为float64）。这些函数有助于满足除了数组扩展的需要，同时降低了高昂的运算开销。

• 第三种常见的创建数组的方法.我们可以使用 arange方法，创建数组序列。

• 第四种创建随机数组
  最后，创建具有随机数字的数组通常是非常有用的。 np.random模块包含许多可用于此效果的函数，例如，这将生成一个从标准正态分布（0均值和方差1）中抽取的5个随机样本数组：

生成函数	作用
np.array( x )np.array( x, dtype )	将输入数据转化为一个ndarray将输入数据转化为一个类型为type的ndarray
np.asarray( array )	将输入数据转化为一个新的（copy）ndarray
np.ones( N )np.ones( N, dtype)np.ones_like( ndarray )	生成一个N长度的一维全一ndarray生成一个N长度类型是dtype的一维全一ndarray生成一个形状与参数相同的全一ndarray
np.zeros( N)np.zeros( N, dtype)np.zeros_like(ndarray)	生成一个N长度的一维全零ndarray生成一个N长度类型位dtype的一维全零ndarray类似np.ones_like( ndarray )
np.empty( N )np.empty( N, dtype)np.empty(ndarray)	生成一个N长度的未初始化一维ndarray生成一个N长度类型是dtype的未初始化一维ndarray类似np.ones_like( ndarray )
np.eye( N )np.identity( N )	创建一个N * N的单位矩阵（对角线为1，其余为0）
np.arange( num)np.arange( begin, end)np.arange( begin, end, step)	生成一个从0到num-1步数为1的一维ndarray生成一个从begin到end-1步数为1的一维ndarray生成一个从begin到end-step的步数为step的一维ndarray
np.mershgrid(ndarray, ndarray,...)	生成一个ndarray * ndarray * ...的多维ndarray
np.where(cond, ndarray1, ndarray2)	根据条件cond，选取ndarray1或者ndarray2，返回一个新的ndarray
np.in1d(ndarray, [x,y,...])	检查ndarray中的元素是否等于[x,y,...]中的一个，返回bool数组

np.zeros(5,dtype=int)
Out[8]: array([0, 0, 0, 0, 0])
np.zeros(5,dtype=complex)
Out[9]: array([0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j])
np.zeros((2,3),int)
Out[10]: 
array([[0, 0, 0],
       [0, 0, 0]])
np.ones((2, 3))
Out[11]: 
array([[1., 1., 1.],
       [1., 1., 1.]])
arr2 = np.array([1.1,1.2,1.3,1.4,1.5])
arr2
Out[13]: array([1.1, 1.2, 1.3, 1.4, 1.5])
np.ones_like(arr2)
Out[14]: array([1., 1., 1., 1., 1.])
np.zeros_like(arr2)
Out[15]: array([0., 0., 0., 0., 0.])
np.linspace(0, 1, 12,endpoint=False,retstep=True) 
Out[16]: 
(array([0.        , 0.08333333, 0.16666667, 0.25      , 0.33333333,
        0.41666667, 0.5       , 0.58333333, 0.66666667, 0.75      ,
        0.83333333, 0.91666667]), 0.08333333333333333)
np.linspace(0, 1, 12,endpoint=False,retstep=False)
Out[17]: 
array([0.        , 0.08333333, 0.16666667, 0.25      , 0.33333333,
       0.41666667, 0.5       , 0.58333333, 0.66666667, 0.75      ,
       0.83333333, 0.91666667])
np.linspace(2.0, 3.0, num=5, retstep=True)
Out[18]: (array([2.  , 2.25, 2.5 , 2.75, 3.  ]), 0.25)
np.empty((2,3))
Out[19]: 
array([[1., 1., 1.],
       [1., 1., 1.]])
np.eye(4, 3) #创建一个对角线为 1 其他为 0 的矩阵
Out[20]: 
array([[1., 0., 0.],
       [0., 1., 0.],
       [0., 0., 1.],
       [0., 0., 0.]])
np.identity(3)   #创建一个主对角线为 1 其他为 0 的方阵.
Out[21]: 
array([[1., 0., 0.],
       [0., 1., 0.],
       [0., 0., 1.]])
c=np.arange(10,30,5)
c
Out[23]: array([10, 15, 20, 25])
d=np.random.randn(7)
d
Out[25]: 
array([-2.42305704, -1.4176937 , -1.30105816, -0.2540588 , -0.01241032,
       -0.79794669,  0.71402996])
e=np.random.normal(10,3,(2,4))
e
Out[27]: 
array([[10.12814319, 11.56238839, 10.75997039,  9.09078182],
       [12.16908517, 13.34197263,  7.9504137 , 11.87499528]])

b = np.arange(24).reshape(6,4)

array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11],
       [12, 13, 14, 15],
       [16, 17, 18, 19],
       [20, 21, 22, 23]])

Out[30]: b.ravel()
array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16,
       17, 18, 19, 20, 21, 22, 23])

Out[31]: b.flatten()
array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16,
       17, 18, 19, 20, 21, 22, 23])

NumPy.ndarray的属性

ndarray对象属性有：

• ndarray.ndim

  数组轴的个数，在python的世界中，轴的个数被称作秩

• ndarray.shape

  数组的维度。这是一个指示数组在每个维度上大小的整数元组。例如一个n排m列的矩阵，它的shape属性将是(2,3),这个元组的长度显然是秩，即维度或者ndim属性

• ndarray.size

  数组元素的总个数，等于shape属性中元组元素的乘积。

• ndarray.dtype

  一个用来描述数组中元素类型的对象，可以通过创造或指定dtype使用标准Python类型。另外NumPy提供它自己的数据类型。

• ndarray.itemsize

  数组中每个元素的字节大小。例如，一个元素类型为float64的数组itemsiz属性值为8(=64/8),又如，一个元素类型为complex32的数组item属性为4(=32/8).

• ndarray.data

  包含实际数组元素的缓冲区，通常我们不需要使用这个属性，因为我们总是通过索引来使用数组中的元素。

一个例子

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

ndarray.ndim	获取ndarray的维数
ndarray.shape	获取ndarray各个维度的长度
ndarray.dtype	获取ndarray中元素的数据类型
ndarray.T	简单转置矩阵ndarray

NumPy.ndarray的函数

基本运算

数组的算术运算是按元素的。新的数组被创建并且被结果填充。

>>> a = array( [20,30,40,50] )
>>> b = arange( 4 )
>>> b
array([0, 1, 2, 3])
>>> c = a-b
>>> c
array([20, 29, 38, 47])
>>> b**2
array([0, 1, 4, 9])
>>> 10*sin(a)
array([ 9.12945251, -9.88031624,  7.4511316 , -2.62374854])
>>> a<35
array([True, True, False, False], dtype=bool)

不像许多矩阵语言，NumPy中的乘法运算符 * 指示按元素计算，矩阵乘法可以使用 dot 函数或创建矩阵对象实现(参见教程中的矩阵章节)

>>> A = array( [[1,1],
...             [0,1]] )
>>> B = array( [[2,0],
...             [3,4]] )
>>> A*B                         # elementwise product
array([[2, 0],
       [0, 4]])
>>> dot(A,B)                    # matrix product
array([[5, 4],
       [3, 4]])

有些操作符像 += 和 *= 被用来更改已存在数组而不创建一个新的数组。

>>> a = ones((2,3), dtype=int)
>>> b = random.random((2,3))
>>> a *= 3
>>> a
array([[3, 3, 3],
       [3, 3, 3]])
>>> b += a
>>> b
array([[ 3.69092703,  3.8324276 ,  3.0114541 ],
       [ 3.18679111,  3.3039349 ,  3.37600289]])
>>> a += b                                  # b is converted to integer type
>>> a
array([[6, 6, 6],
       [6, 6, 6]])

当运算的是不同类型的数组时，结果数组和更普遍和精确的已知(这种行为叫做upcast)。

>>> a = ones(3, dtype=int32)
>>> b = linspace(0,pi,3)
>>> b.dtype.name
'float64'
>>> c = a+b
>>> c
array([ 1.        ,  2.57079633,  4.14159265])
>>> c.dtype.name
'float64'
>>> d = exp(c*1j)
>>> d
array([ 0.54030231+0.84147098j, -0.84147098+0.54030231j,
       -0.54030231-0.84147098j])
>>> d.dtype.name
'complex128' 许多非数组运算，如计算数组所有元素之和，被作为ndarray类的方法实现

>>> a = random.random((2,3))
>>> a
array([[ 0.6903007 ,  0.39168346,  0.16524769],
       [ 0.48819875,  0.77188505,  0.94792155]])
>>> a.sum()
3.4552372100521485
>>> a.min()
0.16524768654743593
>>> a.max()
0.9479215542670073

这些运算默认应用到数组好像它就是一个数字组成的列表，无关数组的形状。然而，指定 axis 参数你可以吧运算应用到数组指定的轴上：

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

计算函数	说明
ndarray.mean( axis=0 )	求平均值
ndarray.sum( axis= 0)	求和
ndarray.cumsum( axis=0)ndarray.cumprod( axis=0)	累加 累乘
ndarray.std()ndarray.var()	方差标准差
ndarray.max()ndarray.min()	最大值最小值
ndarray.argmax()ndarray.argmin()	最大值索引最小值索引
ndarray.any()ndarray.all()	是否至少有一个True是否全部为True
ndarray.dot( ndarray)	计算矩阵内积

形状操作

更改数组的形状

函数	说明
ndarray.astype(dtype)	转换类型，若转换失败则会出现TypeError
ndarray.copy()	复制一份ndarray(新的内存空间)
ndarray.reshape((N,M,...))	将ndarray转化为NM...的多维ndarray（非copy）
ndarray.transpose((xIndex,yIndex,...))	根据维索引xIndex,yIndex...进行矩阵转置，依赖于shape，不能用于一维矩阵（非copy）
ndarray.swapaxes(xIndex,yIndex)	交换维度（非copy）

一个数组的形状由它每个轴上的元素个数给出：

>>> a = floor(10*random.random((3,4)))
>>> a
array([[ 7.,  5.,  9.,  3.],
       [ 7.,  2.,  7.,  8.],
       [ 6.,  8.,  3.,  2.]])
>>> a.shape
(3, 4)

一个数组的形状可以被多种命令修改：

>>> a.ravel() # flatten the array
array([ 7.,  5.,  9.,  3.,  7.,  2.,  7.,  8.,  6.,  8.,  3.,  2.])
>>> a.shape = (6, 2)
>>> a.transpose()
array([[ 7.,  9.,  7.,  7.,  6.,  3.],
       [ 5.,  3.,  2.,  8.,  8.,  2.]])

由 ravel() 展平的数组元素的顺序通常是“C风格”的，就是说，最右边的索引变化得最快，所以元素a[0,0]之后是a[0,1]。如果数组被改变形状(reshape)成其它形状，数组仍然是“C风格”的。NumPy通常创建一个以这个顺序保存数据的数组，所以 ravel() 将总是不需要复制它的参数 3 。但是如果数组是通过切片其它数组或有不同寻常的选项时，它可能需要被复制。函数 reshape()和 ravel() 还可以被同过一些可选参数构建成FORTRAN风格的数组，即最左边的索引变化最快。

reshape 函数改变参数形状并返回它，而 resize 函数改变数组自身。

>>> a
array([[ 7.,  5.],
       [ 9.,  3.],
       [ 7.,  2.],
       [ 7.,  8.],
       [ 6.,  8.],
       [ 3.,  2.]])
>>> a.resize((2,6))
>>> a
array([[ 7.,  5.,  9.,  3.,  7.,  2.],
       [ 7.,  8.,  6.,  8.,  3.,  2.]])

如果在改变形状操作中一个维度被给做-1，其维度将自动被计算

组合(stack)不同的数组

几种方法可以沿不同轴将数组堆叠在一起：

>>> a = floor(10*random.random((2,2)))
>>> a
array([[ 1.,  1.],
       [ 5.,  8.]])
>>> b = floor(10*random.random((2,2)))
>>> b
array([[ 3.,  3.],
       [ 6.,  0.]])
>>> vstack((a,b))
array([[ 1.,  1.],
       [ 5.,  8.],
       [ 3.,  3.],
       [ 6.,  0.]])
>>> hstack((a,b))
array([[ 1.,  1.,  3.,  3.],
       [ 5.,  8.,  6.,  0.]])

函数 column_stack 以列将一维数组合成二维数组，它等同与 vstack 对一维数组。

>>> column_stack((a,b))   # With 2D arrays
array([[ 1.,  1.,  3.,  3.],
       [ 5.,  8.,  6.,  0.]])
>>> a=array([4.,2.])
>>> b=array([2.,8.])
>>> a[:,newaxis]  # This allows to have a 2D columns vector
array([[ 4.],
       [ 2.]])
>>> column_stack((a[:,newaxis],b[:,newaxis]))
array([[ 4.,  2.],
       [ 2.,  8.]])
>>> vstack((a[:,newaxis],b[:,newaxis])) # The behavior of vstack is different
array([[ 4.],
       [ 2.],
       [ 2.],
       [ 8.]])

row_stack 函数，另一方面，将一维数组以行组合成二维数组。

对那些维度比二维更高的数组， hstack 沿着第二个轴组合， vstack 沿着第一个轴组合, concatenate 允许可选参数给出组合时沿着的轴。

Note

在复杂情况下， r_[] 和 c_[] 对创建沿着一个方向组合的数很有用，它们允许范围符号(“:”):

>>> r_[1:4,0,4]
array([1, 2, 3, 0, 4])

当使用数组作为参数时， r_ 和 c_ 的默认行为和 vstack 和 hstack 很像，但是允许可选的参数给出组合所沿着的轴的代号。

将一个数组分割(split)成几个小数组

使用 hsplit 你能将数组沿着它的水平轴分割，或者指定返回相同形状数组的个数，或者指定在哪些列后发生分割:

>>> a = floor(10*random.random((2,12)))
>>> a
array([[ 8.,  8.,  3.,  9.,  0.,  4.,  3.,  0.,  0.,  6.,  4.,  4.],
       [ 0.,  3.,  2.,  9.,  6.,  0.,  4.,  5.,  7.,  5.,  1.,  4.]])
>>> hsplit(a,3)   # Split a into 3
[array([[ 8.,  8.,  3.,  9.],
       [ 0.,  3.,  2.,  9.]]), array([[ 0.,  4.,  3.,  0.],
       [ 6.,  0.,  4.,  5.]]), array([[ 0.,  6.,  4.,  4.],
       [ 7.,  5.,  1.,  4.]])]
>>> hsplit(a,(3,4))   # Split a after the third and the fourth column
[array([[ 8.,  8.,  3.],
       [ 0.,  3.,  2.]]), array([[ 9.],
       [ 9.]]), array([[ 0.,  4.,  3.,  0.,  0.,  6.,  4.,  4.],
       [ 6.,  0.,  4.,  5.,  7.,  5.,  1.,  4.]])]

vsplit 沿着纵向的轴分割， array split 允许指定沿哪个轴分割。

ndarray索引/切片方式

ndarray[n]	选取第n+1个元素
ndarray[n:m]	选取第n+1到第m个元素
ndarray[:]	选取全部元素
ndarray[n:]	选取第n+1到最后一个元素
ndarray[:n]	选取第0到第n个元素
ndarray[ bool_ndarray ]注：bool_ndarray表示bool类型的ndarray	选取为true的元素
ndarray[[x,y,m,n]]...	选取顺序和序列为x、y、m、n的ndarray
ndarray[n,m]ndarray[n][m]	选取第n+1行第m+1个元素
ndarray[n,m,...]ndarray[n][m]....	选取n行n列....的元素

当少于轴数的索引被提供时，确失的索引被认为是整个切片：

>>> b[-1]                                  # the last row. Equivalent to b[-1,:]
array([40, 41, 42, 43])

b[i] 中括号中的表达式被当作 i 和一系列 : ，来代表剩下的轴。NumPy也允许你使用“点”像 b[i,...] 。

点 (…)代表许多产生一个完整的索引元组必要的分号。如果x是秩为5的数组(即它有5个轴)，那么:

• x[1,2,…] 等同于 x[1,2,:,:,:],
• x[…,3] 等同于 x[:,:,:,:,3]
• x[4,…,5,:] 等同 x[4,:,:,5,:].

Numpy的常用函数

矩阵函数	说明
np.diag( ndarray)np.diag( [x,y,...])	以一维数组的形式返回方阵的对角线（或非对角线）元素将一维数组转化为方阵（非对角线元素为0）
np.dot(ndarray, ndarray)	矩阵乘法
np.trace( ndarray)	计算对角线元素的和

排序函数	说明
np.sort( ndarray)	排序，返回副本
np.unique(ndarray)	返回ndarray中的元素，排除重复元素之后，并进行排序
np.intersect1d( ndarray1, ndarray2)np.union1d( ndarray1, ndarray2)np.setdiff1d( ndarray1, ndarray2)np.setxor1d( ndarray1, ndarray2)	返回二者的交集并排序。返回二者的并集并排序。返回二者的差。返回二者的对称差

一元计算函数	说明
np.abs(ndarray)np.fabs(ndarray)	计算绝对值计算绝对值（非复数）
np.mean(ndarray)	求平均值
np.sqrt(ndarray)	计算x^0.5
np.square(ndarray)	计算x^2
np.exp(ndarray)	计算e^x
log、log10、log2、log1p	计算自然对数、底为10的log、底为2的log、底为(1+x)的log
np.sign(ndarray)	计算正负号：1（正）、0（0）、-1（负）
np.ceil(ndarray)np.floor(ndarray)np.rint(ndarray)	计算大于等于改值的最小整数计算小于等于该值的最大整数四舍五入到最近的整数，保留dtype
np.modf(ndarray)	将数组的小数和整数部分以两个独立的数组方式返回
np.isnan(ndarray)	返回一个判断是否是NaN的bool型数组
np.isfinite(ndarray)np.isinf(ndarray)	返回一个判断是否是有穷（非inf，非NaN）的bool型数组返回一个判断是否是无穷的bool型数组
cos、cosh、sin、sinh、tan、tanh	普通型和双曲型三角函数
arccos、arccosh、arcsin、arcsinh、arctan、arctanh	反三角函数和双曲型反三角函数
np.logical_not(ndarray)	计算各元素not x的真值，相当于-ndarray

多元计算函数	说明
np.add(ndarray, ndarray)np.subtract(ndarray, ndarray)np.multiply(ndarray, ndarray)np.divide(ndarray, ndarray)np.floor_divide(ndarray, ndarray)np.power(ndarray, ndarray)np.mod(ndarray, ndarray)	相加相减乘法除法圆整除法（丢弃余数）次方求模
np.maximum(ndarray, ndarray)np.fmax(ndarray, ndarray)np.minimun(ndarray, ndarray)np.fmin(ndarray, ndarray)	求最大值求最大值（忽略NaN）求最小值求最小值（忽略NaN）
np.copysign(ndarray, ndarray)	将参数2中的符号赋予参数1
np.greater(ndarray, ndarray) np.greater_equal(ndarray, ndarray) np.less(ndarray, ndarray) np.less_equal(ndarray, ndarray) np.equal(ndarray, ndarray) np.not_equal(ndarray, ndarray)	> >= < <= == !=
logical_and(ndarray, ndarray) logical_or(ndarray, ndarray) logical_xor(ndarray, ndarray)	& | ^
np.dot( ndarray, ndarray)	计算两个ndarray的矩阵内积
np.ix_([x,y,m,n],...)	生成一个索引器，用于Fancy indexing(花式索引)

文件读写	说明
np.save(string, ndarray)	将ndarray保存到文件名为 [string].npy 的文件中（无压缩）
np.savez(string, ndarray1, ndarray2, ...)	将所有的ndarray压缩保存到文件名为[string].npy的文件中
np.savetxt(sring, ndarray, fmt, newline=' ')	将ndarray写入文件，格式为fmt
np.load(string)	读取文件名string的文件内容并转化为ndarray对象（或字典对象）
np.loadtxt(string, delimiter)	读取文件名string的文件内容，以delimiter为分隔符转化为ndarray

NumPy.random函数和属性

函数	说明
seed()seed(int)seed(ndarray)	确定随机数生成种子
permutation(int)permutation(ndarray)	返回一个一维从0~9的序列的随机排列返回一个序列的随机排列
shuffle(ndarray)	对一个序列就地随机排列
rand(int)randint(begin,end,num=1)	产生int个均匀分布的样本值从给定的begin和end随机选取num个整数
randn(N, M, ...)	生成一个NM...的正态分布（平均值为0，标准差为1）的ndarray
normal(size=(N,M,...))	生成一个NM...的正态（高斯）分布的ndarray
beta(ndarray1,ndarray2)	产生beta分布的样本值，参数必须大于0
chisquare()	产生卡方分布的样本值
gamma()	产生gamma分布的样本值
uniform()	产生在[0,1)中均匀分布的样本值

NumPy.linalg函数和属性

函数	说明
det(ndarray)	计算矩阵列式
eig(ndarray)	计算方阵的本征值和本征向量
inv(ndarray)pinv(ndarray)	计算方阵的逆计算方阵的Moore-Penrose伪逆
qr(ndarray)	计算qr分解
svd(ndarray)	计算奇异值分解svd
solve(ndarray)	解线性方程组Ax = b，其中A为方阵
lstsq(ndarray)	计算Ax=b的最小二乘解

函数和方法(method)总览

这是个NumPy函数和方法分类排列目录。

创建数组

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