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)

>>

2

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='
', header='', footer='', comments='# ')

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

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

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

newline=' '   ----换行

newline=' '   ----表头

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(6).reshape(2,3)
>>> for x in np.nditer(a):
...     print x,
...
0 1 2 3 4 5

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

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

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

>>> a = np.arange(6).reshape(2,3)
>>> a
array([[0, 1, 2],
       [3, 4, 5]])
>>> for x in np.nditer(a, op_flags=['readwrite']):
...     x[...] = 2 * x
...
>>> a
array([[ 0,  2,  4],
       [ 6,  8, 10]])

注意打开读写标志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([     [1, 2, 3, 4], 
                             [5, 5, 6, 8],
                             [7, 9, 9, 1],
                              [4, 6, 7, 1]       ])

     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([1,3,4,5,6])
s =np.array([[13],[4],[6]])
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([ [7,5,6],
               [5,4,2],
               [7,3,6]])
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

?