Numpy应用100问

　　对于从事机器学习的人，python+numpy+scipy+matplotlib是重要的基础；它们基本与matlab相同，而其中最重要的当属numpy；因此，这里列出100个关于numpy函数的问题，希望读者通过“题海”快速学好numpy；题中示例可以粘贴运行，读者可以边执行边看效果；

1 如何引入numpy？

import numpy as np（或者from numpy import *）

2 如何定义一个数组？

import numpy as np

x = np.array([[1,2,3],[5,6,7],np.int32])

y = x[.,1] # 取出x的一列，y = [2,6]

3 实部和虚部如何提取？

x = np.array([ 1+2j, 3 + 4j, 5+6j] )

>> x.imag # x.imag就是x集合中取出的虚部的集合

>> array([ 2., 4., 6.])

>> x.imag = [4,8,12] # 将集合x.imag一次赋值

4 序列如何排序？

>> x = [3,4,1,2,5]

>> x.argsort()

>> [2,3,0,1,4] # 排序后的序列下标

5 何为矩阵的坐标轴axis=0或axis=1是啥？

axis = 0 是指按照列方向，axis = 1是按照行方向（操作）。

6 如何用choose函数？

>> x = np.arange(25).reshape(5,5) # 定义矩阵x[5][5]

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, 24]

] )

>>np.choose([1,2,1,2,1],x) # 选择x的[1,2,1,2,1]行对应数

>>[5,11,7,13,9]

再如：

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

b = np.array([12,-11,8,7])

np.choose( a, b )

array([[ 12, -11, 8], # 取a的架构，用b的item填写
[ 8, 7, 12],
[-11, 12, -11]])

7 何为裁剪clips函数？

是按照一个范围剪切数组；

8 何为all和any函数？

all和any函数测试两个矩阵的元素；当全部相等用all，部分相等用any；

示例：

a = np.arange(15).reshape(3,5)

b = a.copy()

(a ==b).all()

>>True

9 何为argmax和argmin,argsort函数？

argmax和argmin返回矩阵中，最大元或最校元的下标；argsort返回矩阵排序的下标；其中可选坐标横向或纵向；

10 何为compress 函数？

a = np.arange(15).reshape(3,5)

np.compress([True,False,True],a,axis=0) #此处为行方向，取0，2向量构成的矩阵

array([[ 0, 1, 2, 3, 4],
[10, 11, 12, 13, 14]])

11 如何求共轭复数conjugate函数？

np.conjugate（1+3j）

>> 1-3j

12 copy函数是啥？

a = b.copy()或 a = np.copy(b) #生成b的副本，赋值给a

13 何为cumprod乘积？

b = array([3,8,9])

np.cumprod(b) #该乘积是将[a，b，c]转换成[a，a*b，a*b*c]的乘积

>>[3,24,216]

另：

a = array([[1, 2, 3],
[4, 5, 6]])

np.cunprod(a)

array([ 1, 2, 6, 24, 120, 720])

14 何为cumsum和？

array([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11])

cumsum(b) #累计的和数列，类似于阶乘的数列

array([ 0, 1, 3, 6, 10, 15, 21, 28, 36, 45, 55, 66])

15 何为diagonal函数？

求一个矩阵的主对角元素组成的数列。

a = array([[ 0, 1, 2, 3, 4],
[ 5, 6, 7, 8, 9],
[10, 11, 12, 13, 14]])

diagonal(a)

array([0,6,12) #注意，不论是否方阵；

16 何为dot函数？

dot是两个矩阵相乘的函数，当矩阵为一维时，是向量内积，二维的是矩阵相乘；

17何为mean函数？

就是对矩阵所有元求平均；

18何为nonzero函数？

nonzero（a）返回a中非零数据项的下标；

a = array([[ 0, 1, 2, 3, 4],

[ 5, 6, 7, 8, 9],
[ 0, 11, 12, 0, 14]])

nonzero（a）

(array([0, 0, 0, 0, 1, 1, 1, 1, 1, 2, 2, 2], dtype=int64),
array([1, 2, 3, 4, 0, 1, 2, 3, 4, 1, 2, 4], dtype=int64))

另：（a〉3).nonzero() #表示大于3的数的下标

19 何为prod函数？

就是将矩阵所有元素相乘；

a = array([ 0, 1, 2, 3, 4])

prod(a)

>> 24

20 何为ptp函数？

是指矩阵按照某个轴上最大值和最小值得差，即数据gap范围；

21 何为put函数？

将指定下标的元素，赋值为其它值；

22 何为ravel函数？

将矩阵扁平化，即转换成一维排列；参见ndarray的flat和flaten函数；

23 何为repeat函数？

将矩阵每个元素重复n遍，放入一维序列中；

a = array（[[1，2]，[4，5]）

np.repeat(a,2) #将a的元素重复2次

>> array([1,1,2,2,4,4,5,5])

24 何为reshape函数？

将矩阵所有元素重新排列，构成新的矩阵；数据不变；

如：a = np.arange(12).reshape(3,4)

25 何为resize函数？

构成新的矩阵；数据可变；

a = np.array([[1,2,3]])

np.resize(a,[2,3])

array([[1,2,3],[1,2,3]])

26 函数searchsorted的作用

若存在一个数，和一个排序向量；求该数在排序向量对应的下标；

np.searchsorted([1,2,3,4,5], 3)

np.searchsorted([1,2,3,4,5], [3,-1,8])

[2,0,5]

27 函数sort的用法

对矩阵排序，分两种：轴排序，扁平（无轴）排序

>>> a = np.array([[1,4],[3,1]])
>>> np.sort(a) # sort along the last axis
array([[1, 4],
[1, 3]])
>>> np.sort(a, axis=None) # sort the flattened array
array([1, 1, 3, 4])
>>> np.sort(a, axis=0) # sort along the first axis
array([[1, 1],
[3, 4]])

28 函数squeeze(a)如何用？

将一个具有冗余多维的向量，压缩成一维的向量；

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

29 函数std()用法？

对矩阵各元素，求出标准均方差；

30 函数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])

31 函数swapaxes的用法？

swapaxes(): 将n个维度中任意两个维度(坐标轴)进行调换

32 函数take的用法？

numpy.take(a, indices, axis=None, out=None, mode=’raise’)

该函数从a中取出indices下标所对应的元素；

>>> a = [4, 3, 5, 7, 6, 8]
>>> indices = [0, 1, 4]
>>> np.take(a, indices)
array([4, 3, 6])

33 函数trace的用途？

numpy.trace(a, offset=0, axis1=0, axis2=1, dtype=None, out=None)

求矩阵对角线元素的和；

34 矩阵的transpose函数？

numpy.transpose(a, axes=None)

上述给出a矩阵的转置矩阵；

35 函数var是什么？

numpy.var(a, axis=None, dtype=None, out=None, ddof=0)

是求出某个轴向的方差；

36 何为矩阵的切割Slicing？

就是将矩阵通过[i：j：k]转换的新矩阵，i是起始下标，j是终了下标，k是步长；这些下标都能为负；

如：

>>> x = np.array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
>>> x[1:7:2]
array([1, 3, 5])

>>> x[1:7:1]
array([1, 2, 3, 4, 5, 6])

37 如何求一个向量的转置？

a = np.array([1,2,3]) 的转置依旧是它本身

b = np.array([ [1,2,3] ])的转置是

array [[1]，

[2]，

[3] ]

要想从a求出列向转置需要:

a[：，np.newaxis ] 这个语法，切记之

38 如何求行向量和列向量之和？

a = np.array([1,2,3])

b = np.array([[x],[y]])

a + b = array([ [1+x,2+x,3+x], [1+y,2+y,3+y] ])这就是规则！

39 如何将数据从文本文件读入？

numpy.loadtxt(fname, dtype=<type 'float'>, comments='#', delimiter=None, converters=None, skiprows=0,usecols=None, unpack=False, ndmin=0)[source]

例子：

V1,V2 = np.loadtxt('datas.txt',dtype='float',delimiter=',',skiprows =1,usecols=[1,2],unpack = True)

参数解释：

'datas.txt' ---文件名

dtype='float' ---数据格式

delimiter=',' ---分隔符逗号

skiprows =1 ---跳过第一行

usecols=[1,2] ---选第1，2列读出

unpack = True ---读出两列将拆开，分别给V1和V2

converters=None ---缺省数据用什么填充

40 如何将数据写出到文本文件？

numpy.savetxt(fname, X, fmt='%.18e', delimiter=' ', newline='\n', header='', footer='', comments='# ')

fname ---文件名
X ---写出的数据表格

fmt='%.18e' ---数据格式

delimiter=',' ---分隔符逗号

newline='\n' ----换行

newline='\n' ----表头

footer='' ----表尾

comments='# ' 注释

41 linspace和arange区别？

x = np.linspace(0, 4*np.pi, 100) 在0-4pi中间有100个点
x = np.arange(0, 4*np.pi, 2) 在0-4pi中间每两个点抽样一次

42 newaxis如何使用？

关于newaxis是很难理解的东西，而矩阵变换中又常用，这里用形式表现之：

1：a = array([A,B,C]) 这里ABC可能是数列，也可能是单独数，当使用a[：，newaxis]时，一定是如下格式：

将a中的最外层不管，将次外层看成独立元素，将他们加上“[]”，然后进行行排列

a[：，newaxis]等价于

[[A]，

[B]，

[C]]

2：a = array([A,B,C]) 这里ABC可能是数列，也可能是单独数，当使用a[newaxis，：]时，一定是如下格式：

在a上加外扩号：

a[newaxis，：] = array([ [A,B,C] ])

举例：

>>>print a.shape

(3L, 3L)

b = a[:,newaxis]

>>>print a[:,newaxis]

[[[0 1 3]]

[[4 5 6]]

[[7 8 9]]]

>>>print b.shape

(3L, 1L, 3L) //意思为三行，每行是[1，3]的矩阵

当 b = a[ newaxis，：]

>>>print b
[[[0 1 3]
[4 5 6]
[7 8 9]]]

>>>print b.shape

(1L, 3L, 3L) //意思为1行，内部是[3，3]的矩阵；

43 如何构造一个hilbert矩阵？

构造10X10的希尔伯特矩阵，参考第42问，第38问：

X = 1. / (np.arange(1, 11) + np.arange(0, 10)[:, np.newaxis])

44 何为logspace？

s = np.logspace(2.0, 3.0, num=3,base =4)

等价于

r =np.linspace(2,3,3)
l = 4**r

45 何为numpy.meshgrid(x, y)？

用两个1维向量变换出两个矩阵X，Y，其规则如下：

对于向量 x, y ，长度 Nx=len(x) 和 Ny=len(y), 返回矩阵X, Y 其中X 和 Y 形状shape= (Ny, Nx) ，填充数据为 x的Ny重复, 后者为 y的Nx次重复.

例：

>>> X, Y = np.meshgrid([1,2,3], [4,5,6,7])

>>> X

array([[1, 2, 3],

       [1, 2, 3],

       [1, 2, 3],

       [1, 2, 3]])

>>> Y

array([[4, 4, 4],

       [5, 5, 5],

       [6, 6, 6],

       [7, 7, 7]])

46 何为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. ])

47 如何numpy.ravel实现矩阵扁平化？

例：

>>> x = np.array([[1, 2, 3], [4, 5, 6]])
>>> print(np.ravel(x))
[1 2 3 4 5 6]

48 如何理解np.nditer(a)？

请看代码：

>>> a = np.arange().reshape(,)

>>> for x in np.nditer(a):

...     print x,

...

上述代码中，np.nditer(a)将a的元素扁平化后存入对象np.nditer中，然后读取出来，注意np.nditer不是个列表，是对象;不可用print np.nditer(a)打印出来;用时要注意;

49 如何实现数组元素无差别函数变换？

所谓无差别函数操作就是将每一个元素按照同样变换方式，并写回;比如a中的元素都乘2，这是比较简单的变换，常规通过a *=2就能完成，但是变换如果很复杂，比如每个元素求自然对数，就无法简单表示，因此需要下列代码完成：

>>> a = np.arange().reshape(,)

>>> a

array([[, , ],

       [, , ]])

>>> for x in np.nditer(a, op_flags=['readwrite']):

...     x[...] =  * x

...

>>> a

array([[ ,  ,  ],

       [ ,  , ]])

注意打开读写标志op_flags=['readwrite']，x[...]不可写成x;因为x是从对象中读出的临时变量;而x[...]是当前临时变量x所面向的数组内地址，用以指明当前x写到哪里。

50 什么是class numpy.ndenumerate(arr)？

ndenumerate和nditer类似，只是ndenumerate不返回元素的值，返回的全是下标;下标有两组，一组是数组的（Nx和Ny）另一组是nditer的顺序标号;与nditer同，不可用print np.ndenumerate(a)打印;

>>> a = np.arange(6).reshape(2,3)

>>> for index, x in np.ndenumerate(a):
    ...:     print(index, x)
    ...:    
((0, 0), 0)
((0, 1), 1)
((0, 2), 2)
((1, 0), 3)
((1, 1), 4)
((1, 2), 5)

51 如何理解np的mean函数的axis？

关于numpy mean函数的axis参数，理解多维矩阵的"求和"、"平均"操作确实太恶心了，numpy提供的函数里还有一堆参数，搞得晕头转向的，这里做个笔记，提醒一下自己，下面是例程

import numpy as np

X = np.array([[1, 2], [4, 5], [7, 8]])

print np.mean(X, axis=0, keepdims=True)

print np.mean(X, axis=1, keepdims=True)

结果是分别是

                 [[ 1.5]

 [[ 4.  5.]]      [ 4.5]

                  [ 7.5]]

我个人比较raw的认识就是，axis=0，那么输出矩阵是1行，求每一列的平均（按照每一行去求平均）；axis=1，输出矩阵是1列，求每一行的平均（按照每一列去求平均）。还可以这么理解，axis是几，那就表明哪一维度被压缩成1。

再举个更复杂点的例子，比如我们输入为batch = [128, 28, 28]，可以理解为batch=128，图片大小为28×28像素，我们相求这128个图片的均值，应该这么写

m = np.mean(batch, axis=0)

输出结果m的shape为(28,28)，就是这128个图片在每一个像素点平均值。

52 矩阵相关计算如何实现？

1）定义：

a = np.matrix([     [, , , ],

                             [, , , ],

                             [, , , ],

                              [, , , ]       ])

2）加法减法

　　　　#矩阵加减法：

　　　　e = a + a 　　#or 　e = a - a

e = a + a转置 #or 　e = a.转置+ a a为向量时这里转置是 a[：，np.newaxis ] 这个语法，切记之

3）乘法

#矩阵乘法:

b = a * a                 #not matrix multiplication!

#or

c = np.dot(a, a)          #matrix multiplication

#or

d = a

np.dot(a, a, d)           #matrix multiplication

4）转置矩阵(transpose)

　　g = a.transpose() 或h = a.T 等价

5）逆矩阵(inverse)

f = np.linalg.inv(a) 　或 f = a.I

f = a ** (-1) 求各元素倒数，不是求逆

6）行列式(determinant)

j = np.linalg.det(a)

7）伴随矩阵(adjoint)

#(need more test)

m = np.dot(np.linalg.det(a), np.linalg.inv(a)) # A^-1 = A^'' / |A| ==> A^''= A^-1|A|

8）矩阵范数(matrix norms)

k = np.linalg.norms(a)

53 如何初始化矩阵？

Python使用NumPy包完成了对N-维数组的快速便捷操作。使用这个包，需要导入numpy。 SciPy包以NumPy包为基础，大大的扩展了numpy的能力。为了使用的方便，scipy包在最外层名字空间中包括了所有的numpy内容，因此只要导入了scipy，不必在单独导入numpy了！但是为了明确哪些是numpy中实现的，哪些是scipy中实现的，本文还是进行了区分。以下默认已经：import numpy as np 以及 impor scipy as sp

下面简要介绍Python和MATLAB处理数学问题的几个不同点。1.MATLAB的基本是矩阵，而numpy的基本类型是多为数组，把matrix看做是array的子类。2.MATLAB的索引从1开始，而numpy从0开始。

1.建立矩阵

a1=np.array([1,2,3],dtype=int) #建立一个一维数组，数据类型是int。也可以不指定数据类型，使用默认。几乎所有的数组建立函数都可以指定数据类型，即dtype的取值。

a2=np.array([[1,2,3],[2,3,4]]) #建立一个二维数组。此处和MATLAB的二维数组（矩阵）的建立有很大差别。

同样，numpy中也有很多内置的特殊矩阵：

b1=np.zeros((2,3)) #生成一个2行3列的全0矩阵。注意，参数是一个tuple：(2,3)，所以有两个括号。完整的形式为：zeros(shape,dtype=)。相同的结构，有ones()建立全1矩阵。empty()建立一个空矩阵，使用内存中的随机值来填充这个矩阵。

b2=identity(n) #建立n*n的单位阵，这只能是一个方阵。

b3=eye(N,M=None,k=0) #建立一个对角线是1其余值为0的矩阵，用k指定对角线的位置。M默认None。

此外，numpy中还提供了几个like函数，即按照某一个已知的数组的规模（几行几列）建立同样规模的特殊数组。这样的函数有zeros_like()、empty_like()、ones_like()，它们的参数均为如此形式：zeros_like(a,dtype=)，其中，a是一个已知的数组。

c1=np.arange(2,3,0.1) #起点，终点，步长值。含起点值，不含终点值。

c2=np.linspace(1,4,10) #起点，终点，区间内点数。起点终点均包括在内。同理，有logspace()函数

d1=np.linalg.companion(a) #伴随矩阵

d2=np.linalg.triu()/tril() #作用同MATLAB中的同名函数

e1=np.random.rand(3,2) #产生一个3行2列的随机数组。同一空间下，有randn()/randint()等多个随机函数

fliplr()/flipud()/rot90() #功能类似MATLAB同名函数。

xx=np.roll(x,2) #roll()是循环移位函数。此调用表示向右循环移动2位。

2.数组的特征信息

先假设已经存在一个N维数组X了，那么可以得到X的一些属性，这些属性可以在输入X和一个.之后，按tab键查看提示。这里明显看到了Python面向对象的特征。

X.flags #数组的存储情况信息。

X.shape #结果是一个tuple，返回本数组的行数、列数、……

X.ndim #数组的维数，结果是一个数

X.size #数组中元素的数量

X.itemsize #数组中的数据项的所占内存空间大小

X.dtype #数据类型

X.T #如果X是矩阵，发挥的是X的转置矩阵

X.trace() #计算X的迹

np.linalg.det(a) #返回的是矩阵a的行列式

np.linalg.norm(a,ord=None) #计算矩阵a的范数

np.linalg.eig(a) #矩阵a的特征值和特征向量

np.linalg.cond(a,p=None) #矩阵a的条件数

np.linalg.inv(a) #矩阵a的逆矩阵

3.矩阵分解

常见的矩阵分解函数，numpy.linalg均已经提供。比如cholesky()/qr()/svd()/lu()/schur()等。某些算法为了方便计算或者针对不同的特殊情况，还给出了多种调用形式，以便得到最佳结果。

4.矩阵运算

np.dot(a,b)用来计算数组的点积；vdot(a,b)专门计算矢量的点积，和dot()的区别在于对complex数据类型的处理不一样；innner(a,b)用来计算内积；outer(a,b)计算外积。

专门处理矩阵的数学函数在numpy的子包linalg中定义。比如 np.linalg.logm(A)计算矩阵A的对数。可见，这个处理和MATLAB是类似的，使用一个m后缀表示是矩阵的运算。在这个空间内可以使用的有cosm()/sinm()/signm()/sqrtm()等。其中常规exp()对应有三种矩阵形式：expm()使用Pade近似算法、 expm2()使用特征值分析算法、expm3()使用泰勒级数算法。在numpy中，也有一个计算矩阵的函数：funm(A,func)。

5.索引

numpy中的数组索引形式和Python是一致的。如：

x=np.arange(10)

print x[2] #单个元素，从前往后正向索引。注意下标是从0开始的。

print x[-2] #从后往前索引。最后一个元素的下标是-1

print x[2:5] #多个元素，左闭右开，默认步长值是1

print x[:-7] #多个元素，从后向前，制定了结束的位置，使用默认步长值

print x[1:7:2] #指定步长值

x.shape=(2,5) #x的shape属性被重新赋值，要求就是元素个数不变。2*5=10

print x[1,3] #二维数组索引单个元素，第2行第4列的那个元素

print x[0] #第一行所有的元素

y=np.arange(35).reshape(5,7) #reshape()函数用于改变数组的维度

print y[1:5:2,::2] #选择二维数组中的某些符合条件的元素

QQ空间 QQ好友新浪微博腾讯微博推荐给朋友

54 矩阵加法的注意事项？

a =np.array([,,,,])

s =np.array([[],[],[]])

print( a )

print (s)

print(a+s)   #此处a和s可以交换

结果：
[1 3 4 5 6]
[[13]
[ 4]
[ 6]]
[[14 16 17 18 19]
[ 5 7 8 9 10]
[ 7 9 10 11 12]]

55 logspace指数序列的产生？

>>> a = np.logspace(0,9,10,base=2)
>>> a
array([ 1., 2., 4., 8., 16., 32., 64., 128., 256., 512.])

每一项的形态是base=2的0-9次方序列

56 numpy如何产生等比数列？

import numpy as np
np.logspace(2.0, 3.0, num=4)

array([  100.        ,   215.443469  ,   464.15888336,  1000.        ])

57 如何生成复杂矩阵？

通过形式函数是现，比如：

 b = np.fromfunction(lambda x,y,z:x*100+y*10+z,(3,3,3),dtype=int)

58 如何遍历数组？

分三个办法：

第一种，最常用的，通过for in遍历数组

colours = ["red","green","blue"]

for colour in colours:

    print colour

第二种，先获得数组的长度，然后根据索引号遍历数组，同时输出索引号

colours = ["red","green","blue"]

 for i in range(0, len(colours)):

print i, colour[i]

第三种通过迭代器完成

 for element in b.flat:

        print element,

59 如何定义等距序列numpy.linspace？

函数原型numpy.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)

start : scalar(标量值)，表明序列起始数

stop : scalar(标量值)，序列终结位置，若endpoint=True，序列包含end；若endpoint=False，序列不包含end；

　　num：int 序列中元素个数

endpoint : bool 如果是真，则一定包括stop，如果为False，一定不会有stop

retstep : bool 如果真，将间隔步长也返回，否则，不返回步长

dtype：数据的类型（int32，float32）

实例：

>>> import numpy as np

>>> np.linspace(1, 10, 10)

array([ 1., 2., 3., 4., 5., 6., 7., 8., 9., 10.])

>>> np.linspace(1, 10, 10, endpoint = False)

array([ 1. , 1.9, 2.8, 3.7, 4.6, 5.5, 6.4, 7.3, 8.2, 9.1])

In [4]: np.linspace(1, 10, 10, endpoint = False, retstep= True)

Out[4]: (array([ 1. , 1.9, 2.8, 3.7, 4.6, 5.5, 6.4, 7.3, 8.2, 9.1]), 0.9)

60 向量和矩阵的关系（newaxis改变）？

向量无论如何转置，都是它本身；如：

s_data = np.linspace(-1,1,30) 
r_data = np.transpose(s_data)

在此，s_data和r_data 两个向量完全一样。而

x_data = np.linspace(-1,1,30)[:,np.newaxis]
y_data = np.linspace(-1,1,30)[np.newaxis,:]
就成了[30X1]和[1X30]的矩阵。

61 如何求矩阵的逆矩阵？
A = np.array( [[1,-2,1],[0,2,-1],[1,1,-2]] ) 
B = np.linalg.inv( A ) 
print(B)

62 求矩阵行列式
A = np.array( [[1,-2,1],[0,2,-1],[1,1,-2]] ) 
B = np.linalg.det( A ) 
print(B)

63 获取张量的最小量对应的序号
当axis=None时，为张量展开成一维单列的序号，否则就是行向，或列向的若干序号。

a = np.array([ [,,],

               [,,],

               [,,]])

print(np.argmin(a,axis=None))

64  将某个张量矩阵写成二进制的位张量np.unpackbits

a = np.array([[2], [7], [23]], dtype=np.uint8)

>>> a

array([[ 2],

       [ 7],

       [23]], dtype=uint8)

b = np.unpackbits(a, axis=1)

>>> b

array([[0, 0, 0, 0, 0, 0, 1, 0],

       [0, 0, 0, 0, 0, 1, 1, 1],

       [0, 0, 0, 1, 0, 1, 1, 1]], dtype=uint8)

65  将某个张量改变形状，但数值不变
numpy.reshape(a, newshape, order='C')

>>> 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 2

array([[1, 2],

       [3, 4],

       [5, 6]])

66 numpy.matrix系列函数

`matrix.T`	Returns the transpose of the matrix.
`matrix.H`	Returns the (complex) conjugate transpose of self.
`matrix.I`	Returns the (multiplicative) inverse of invertible self.
`matrix.A`	Return self as an `ndarray` object.

67  内存和文件的映射

　　Memory-mapped file arrays

>>> a = memmap('newfile.dat', dtype=float, mode='w+', shape=1000)

>>> a[10] = 10.0

>>> a[30] = 30.0

>>> del a

>>> b = fromfile('newfile.dat', dtype=float)

>>> print b[10], b[30]

10.0 30.0

>>> a = memmap('newfile.dat', dtype=float)

>>> print a[10], a[30]

10.0 30.0