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='\n') | 将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
来源：https://www.cnblogs.com/yangliguo/p/8969949.html