python Numpy库

配置

ubuntu下载：sudo apt-get install python-numpy
导入库：from numpy import *

加载数据

• 加载二进制文件：
  load()/save()
• 加载文本文件：
  loadtxt()/savetxt():

ndarray数组

numpy的数组是N维数组对象（ndarray），它可以直接执行一些数学计算。一般numpy创建后的数组都是ndarray类型。

创建数组

• arange()
  arange是python内置函数range的数组版（range是返回列表，arange返回ndarray）

  import numpy as np
a = np.arange(1,2,0.1)//创建数组a,从1开始，到2结束（不包括2），每次增加0.1

• 直接创建

  a = np.array([1,2,3,4]);//创建一个一维ndarray数组
  a = np.array([[2,3],[1,3]]);//创建一个多维数组，每个索引位置又是一个ndarray数组
  注意:numpy中的数组和python中的数组形式不一样，建议用numpy中的数组。它用[]嵌套表示。访问元素和c语言一样，如a[0][1]或a[0,1]（多维），a[i]返回的也是一个ndarray数组，如果是一维ndarray数组只能用a[i]来访问），下标从0开始。numpy中的矩阵访问元素只能用a[0,1]，和octave/matlab类似，如a[0,1]，表示访问第1行第2列的元素;a[:,1],表示第二列的所有元素。

索引数组

• 一维数组
  
  • a[1:4:2]
    一维数组切片，返回索引从1开始，到4结束（不包含4），步长为2的数组切片。

• 多维数组

  • a[:,:,::2]
    第一维和第二维全取，第三维取从头开始，到尾结束，步长为2的数组切片。
    

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

返回数组/矩阵元素类型

a.dtype//返回数组/矩阵a中元素类型

数组和矩阵相互转化

• 数组转化为矩阵

  b = mat(a)

• 矩阵转化为数组

  a = a.getA()

顶级函数和数组函数

顶级函数是直接numpy.function()调用的函数，数组函数是array.function()调用的函数。虽然重名但是效果可能会不一样。
如np.sort(a)是返回排序好的数组，但是他是a的一个副本，不会修改a本身，但是a.sort()直接就地排序，即a被排序。
还有min，max等等。

将一个数组转化为矩阵

a = np.mat(random.rand(4,4))//将一个随机4*4数组转化为矩阵a
b = np.asarray(a)//将矩阵a转化为数组b
b = a.getA()//也是将矩阵a转化为b（只有数组方法，没有顶级方法）

ndarray数组转化为list

• tolist()

a = np.array([[1,2,4,3],[3,4,4,3]])print(a.tolist())>>>[[1, 2, 4, 3], [3, 4, 4, 3]]

基本运算

• ndarray类型的数组的+-*/无法实现矩阵运算，都是对应元素的运算。真正的矩阵运算要使用dot()等方法，如
  np.dot(x,y)或者x.dot(y)是一个意思。
• 而将ndarray类型转化为matrix类型后，+-*/都会变成矩阵运算。如：
  x*y就会得到矩阵乘积
• 另外，矩阵和数组的一些方法用法还不同，比如求逆。
  np.linalg.inv(x)ndarray数组
  x.I//metric矩阵
• 数组/矩阵减去一个数，则是数组/矩阵的每一个元素减去这个数。而减去一个矩阵时，有三种情况：
  
  1. 两个矩阵行,列相等时
  2. 减去的矩阵为一个列向量，和原矩阵行数相等。
     a = np.array([[1,2],[4,5]]);
b = np.array([[1],[2]])
a-b
>>>[[0,1],[2,3]];
     这叫做numpy中的广播（broadcast），即维数不相等时，自动广播成维数相等的向量进行计算，比如上例就是b广播成np.array([1,1],[2,2]])
  3. 减去的矩阵为一个行向量，和原矩阵列数相等。
     a = np.array([[1,2],[4,5]]);
b = np.array([[1,2]])
a-b
>>>[[0,3],[0,3]];
     同样，这也是广播。
  4. 其他情况，报错
     综上，广播就是矩阵运算时，运算数维度不匹配，则低维自动广播为高维，然后再进行运算。

数学运算

• np.abs()/np.fabs()
• np.sqrt()/
• np.square()#各元素平方
• np.log()/log10()/log2
  np.log()是求自然对数
• np.ceil()/np.floor()
• np.rint()#四舍五入值
• np.modf()#将整数和小数部分分别以数组的形式返回
• np.sin/sinh/cos/cosh/tan/tanh()
• np.exp()
• np.sign()#符号，+1（+），0，-1（-）
• np.maximun/np.minimum(a,b)#返回一个数组，相应位置是数组a和b相应位置的最大/最小值
• np.average()
  np.average(a,axis,weight)
  对a中元素的给定轴进行加权平均，weight是权重。

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

求一个矩阵的逆

a.I//求a的逆

快速得到一个矩阵

eye(4)://得到4*4的单位矩阵
zeros(4)//不能得到4*4的全0矩阵，而是4行1列矩阵，必须是zeros((4,4))才行。除了eye单位矩阵，一个参数默认是行数，列数是1
ones((3,4))://得到3*4的全1矩阵，注意如果参数是两个，则一定要再套一个括号，即里面的参数是一个元组类型。
zeros((2,3))://得到2*3的全0矩阵

求矩阵的转置

a.T//求a的转置或者
a.transpose;

计算行列式的值

linalg.det(t);//计算行列式t的值

计算a和b的相关系数

corrcoef(a,b);
常用于得到预测值和真实值y的相关性，注意a和b必须都是行向量，返回a，b两两组合的相关性。
如：
corrcoef(y.T,(X*w).T);
>>> array([[ 1. , 0.74649717],
[ 0.74649717, 1. ]])//对角的两元素为1是与自身的相关系数

将两个矩阵合并成一个矩阵

column_stack()//列扩展
X = column_stack((one,X));//one是一个列向量，放在X第一列，左右顺序。
row_stack()//行扩展
X = row_stack((one,X));//one是一个行向量，放在X第一行，上下顺序。
concatenate(（a,b）)
一个顶级方法，把a，b两个数组合并成一个数组
例：

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

求矩阵的列数和行数

shape()
row,col = shape(X);//返回X的列数和行数
如果X是一个三维的数组，那么shape(x)返回三个数，（r,c,h);
如：
image = np.array([[[ 0.67826139, 0.29380381],
[ 0.90714982, 0.52835647],
[ 0.4215251 , 0.45017551]],
[[ 0.92814219, 0.96677647],
[ 0.85304703, 0.52351845],
[ 0.19981397, 0.27417313]],
[[ 0.60659855, 0.00533165],
[ 0.10820313, 0.49978937],
[ 0.34144279, 0.94630077]]])
print(np.shape(image))
>>>(3, 3, 2)

重新组织一个矩阵/数组

• reshape()

  a = np.array([[1,2],[3,4]])
a = a.reshape((1,4));
  输出：matrix([[1, 2, 3, 4]])
  注：reshape作用的数组必须是二维的（矩阵），三维及以上应该一级一级地降，最后变成二维才能用reshape。如上述例子，对于3*3*2的数组，想要得到一个向量，应该：
  r,c,h = np.shape(image)
v = image.reshape(r*c,h)
v = v.reshape(r*c*h,1)

• resize()

  resize和reshape的唯一区别是resize是在原数组上进行改动的。

• flatten()
  

  将数组降维成一维数组（无论多少维）

求元素个数

a.size或np.size(a)

均值和方差

var()
vx = var(x,0);//对矩阵x的每一列求方差，0是列，1是行
mean()
mx = mean(x,0);//对矩阵x的每一行求方差。
min(),max()
注意：这都是numpy模块下的函数，千万不能和python中的同名函数混了，一定要用import numpy as np;np.var()来调用这些函数！

排序

• argsort()

  index = argsort(matrix,0);//第二个参数为0是按列排序，为1是按行排序，返回的是各行/列排序后的索引
  matrix = matrix[index];//把索引传入矩阵，矩阵就会按索引顺序排好序。
  如：
  a = [[2],[1],[3],[4]];
index = argsort(a,0)
  //index = [[1],[0],[2],[3]];
  a =a [index];
  //a =[[1],[2],[3],[4]];

• argmin,argmax

  返回最大/最小元素的索引

复制

• a = b[:]
  b = array([1,2,3]);
a = b[:]
  这时b和a互相影响，即互相保持一致。（注意不要和python中的列表切片搞混，这里是numpy的数组）
• copy()
  b = array([1,2,3]);
a = b.copy();
  这时b，a互不影响

• 和python的list区别，以下摘自：

  http://blog.csdn.net/xidianliutingting/article/details/51682867

  
  

访问矩阵元素

a[:,0:2]//取出矩阵a的前2列，注意是前闭后开
a[0:-1,:]//取出矩阵a的前n-1行，即不包括最后一行（前闭后开）
a[0:,:]//取出矩阵a的所有行，省略代表到最后。

查找符合条件的特定行/列的下标

• np.where()

  1. x = np.array([1,2,3]);
indexlist = np.where(x==3);
>>> (array([2]),)//返回下标2
     x[indexlist]
>>>array([3])//返回3

  2. x = np.array([[1,2],[3,4],[5,6],[1,5]);
indexlist = np.where(x[:,0]==1);//取第一列为1的行的下标
     >>> (array([0]),)//返回下标0
     x[indexlist]
>>>[[[1 2]
         [1 5]]]//返回两行

为数组增加一个轴

使用numpy数组索引时，如果数字索引和切片同时使用，将会使ndarray数组降维，比如：

  print(np.shape(a[1,:])``` ```>>>(3,)```   就会降维成一维数组。如果还想要保持数组的维数，可以给数组再增加一个轴： ```print(a[1,:][:,np.newaxis])```

求ndarray的维度（轴的个数）

• ndim

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

数组元素类型转换

• astype()
  不在原数组上修改，返回一个新数组

a = np.array([[1,2,4,3],[3,4,4,3]])print(a.astype(np.float))>>>[[ 1.  2.  4.  3.] [ 3.  4.  4.  3.]]

读入和写入文件

• np.savetxt()/np.loadtxt()
  注：只能存取或读取一维和二维数组
• np.tofile()/np.fromfile()
  可以存取或读取任意维度的数组
• np.save()/np.load()
  最便捷的读取和写入文件方法

打乱数组顺序

• np.random.shuffle(a)
  打乱数组a的第一维顺序，原地改变数组a。（第一维指最外面一维）

a = np.array([[1,2,3]])random.shuffle(a)print(a)>>>[[1 2 3]]#只打乱第一维，即最外面一维只有一个元素[1,2,3],所以没什么改变。a = np.array([1,2,3])random.shuffle(a)print(a)>>>[3 1 2]#最外面一维有三个元素，所以打乱后改变了数组

• np.random.permutation
  效果和shuffle一样，但不改变原数组，即不是就地打乱。