一句Python，一句R︱numpy、array——高级matrix

先学了R，最近刚刚上手python,所以想着将python和R结合起来互相对比来更好理解python。最好就是一句python，对应写一句R。

python中的numpy模块相当于R中的matirx矩阵格式，化为矩阵，很多内容就有矩阵的属性，可以方便计算。

以下符号：

=R=

代表着在R中代码是怎么样的。

Array在线速查表:https://github.com/JulianGaal/python-cheat-sheet/blob/master/NumPy.md#arrays

使用之前先载入：

from numpy import *

1、数列构造

构造单一数列

arange(10)  =R=1:10   生成一个连贯的数列arange(3,7)  =R=3:7arange(3,10,2)  =R=  seq(3, 9, by = 2)array(arange(4))  =R= matrix(1:4)

类似cut分组

np.linspace(2.0, 3.0, num=5)   =R= cut(2:3,5)  #类似cut功能，在2,3之间分成5份

matrix矩阵组

ma=arange(10).reshape(5,2)        #matrix(rep(1:10),nrow=5,ncol=2)  按行或列生成一定规则的ones((2,3), dtype=int)  =R= matrix(rep(1,6),2,3)             #矩阵内元素都为1random.random((2,3))        =R= matrix(runif(6),2,3)         #生成随机数       

构造空白数组：

ones创建全1矩阵 
zeros创建全0矩阵 
eye创建单位矩阵 
empty创建空矩阵（实际有值）

import numpy as npa_ones = np.ones((3,4)) # 创建3*4的全1矩阵print(a_ones)# 结果[[ 1.  1.  1.  1.] [ 1.  1.  1.  1.] [ 1.  1.  1.  1.]]a_zeros = np.zeros((3,4)) # 创建3*4的全0矩阵print(a_zeros)# 结果[[ 0.  0.  0.  0.] [ 0.  0.  0.  0.] [ 0.  0.  0.  0.]]a_eye = np.eye(3) # 创建3阶单位矩阵print(a_eye)# 结果[ 1.  0.  0.] [ 0.  1.  0.] [ 0.  0.  1.]]a_empty = np.empty((3,4)) # 创建3*4的空矩阵 print(a_empty)# 结果[[  1.78006111e-306  -3.13259416e-294   4.71524461e-309   1.94927842e+289] [  2.10230387e-309   5.42870216e+294   6.73606381e-310   3.82265219e-297] [  6.24242356e-309   1.07034394e-296   2.12687797e+183   6.88703165e-315]]

生成等差、等比数列

linspace()和matlab的linspace很类似，用于创建指定数量等间隔的序列，实际生成一个等差数列。

import numpy as npa = np.linspace(0,10,7) # 生成首位是0，末位是10，含7个数的等差数列print(a) # 结果 [  0.           1.66666667   3.33333333   5.         6.66666667  8.33333333  10.        ]


linspace用于生成等差数列，而logspace用于生成等比数列。 
下面的例子用于生成首位是100，末位是102，含5个数的等比数列。

import numpy as npa = np.logspace(0,2,5)print(a)# 结果[   1.      3.16227766   10.           31.6227766   100.  ]

2、矩阵属性

ma.shape                    #输出5,2（矩阵横纵维度）ma.ndim =R=dim(ma)          #维度,dim(data)ma.size                     #元素总数，5*2

In [26]: arr3.dtype  #dtype方法返回数组的数据类型Out[26]: dtype('int32')

3、矩阵运算

 (arange(4).reshape(2,2))* (arange(8).reshape(2,2))    #组内数字相乘 dot( (arange(4).reshape(2,2)),(array([[1,2],[3,5]]))) #矩阵相乘ma*=2                                                  #ma=ma*2,会原地的改变数组而不是创建一个新的数组

4、矩阵运用函数
ma.sum()ma.min()ma.max()ma.sum(axis=0)  =R=apply(b,1,sum)  =R=colSums（data）      #axis=0代表纵向,列；axis=1，代表横向ma.cumsum(axis=1)                       #按行，累计加总的结果
求和：
ma.sum/min代表所有元素加总.
其中，如果是矩阵连加，有两种方式：

第一种就是mat + mat,用加号；

第二种就是sum(mat)，用sum.

同时注意，跟ma.sum()不一样，.sum()返回的是一个矩阵总和。

参考文献：NumPy教程(一)

求平均：

获得矩阵中元素的平均值可以通过函数mean()。同样地，可以获得整个矩阵、行或列的平均值。

import numpy as npa = np.array([[1,2,3],[4,5,6]])print(a.mean()) #结果为： 3.5# 同样地，可以通过关键字axis参数指定沿哪个方向获取平均值print(a.mean(axis=0)) # 结果 [ 2.5  3.5  4.5]print(a.mean(axis=1)) # 结果 [ 2.  5.]

进行正弦计算：

 >>> y = np.sin(x) >>> y array([  0.00000000e+00,   6.42787610e-01,   9.84807753e-01,          8.66025404e-01,   3.42020143e-01,  -3.42020143e-01,         -8.66025404e-01,  -9.84807753e-01,  -6.42787610e-01,         -2.44921271e-16])

矩阵函数说明np.sin(a)对矩阵a中每个元素取正弦,sin(x)np.cos(a)对矩阵a中每个元素取余弦,cos(x)np.tan(a)对矩阵a中每个元素取正切,tan(x)np.arcsin(a)对矩阵a中每个元素取反正弦,arcsin(x)np.arccos(a)对矩阵a中每个元素取反余弦,arccos(x)np.arctan(a)对矩阵a中每个元素取反正切,arctan(x)np.exp(a)对矩阵a中每个元素取指数函数,e^xnp.sqrt(a)对矩阵a中每个元素开根号√x

累计和：

aaa.cumsum()2 结果为：array([ 10,  19,  27,  34,  40,  45,  87, 120, 122])

所有元素之积：

prod() 

得到数组所有元素之积，是个数字。也可以aaa.sum(axis)，分别求每一行或者是每一列的元素之积

累计积：cumprod() 

all() ：如果所有元素为真，返回真；否则返回假 

特征值 ：linalg.eigvals() 

返回A的特征值 

求最大值，最小值：

获得矩阵中元素最大最小值的函数分别是max和min，可以获得整个矩阵、行或列的最大最小值。 
例如

import numpy as npa = np.array([[1,2,3],[4,5,6]])print(a.max()) #获取整个矩阵的最大值 结果： 6print(a.min()) #结果：1# 可以指定关键字参数axis来获得行最大（小）值或列最大（小）值# axis=0 行方向最大（小）值，即获得每列的最大（小）值# axis=1 列方向最大（小）值，即获得每行的最大（小）值# 例如print(a.max(axis=0))# 结果为 [4 5 6]print(a.max(axis=1))# 结果为 [3 6]# 要想获得最大最小值元素所在的位置，可以通过argmax函数来获得print(a.argmax(axis=1))# 结果为 [2 2]

5、数组拉直

拉直的办法有两个：arr3.ravel()  和  arr3.flatten()

第一种办法：

a = arr3.ravel()    #通过ravel的方法将数组拉直（多维数组降为一维数组）

In [24]: arr3Out[24]:array([[  1,   1,   2,   3],[  5,   8,  13,  21],[ 34,  55,  89, 144]])

第二种办法：

In [29]: b = arr3.flatten()  #通过flatten的方法将数组拉直In [30]: bOut[30]: array([  1,   1,   2,   3,   5,   8,  13,  21,  34,  55,  89, 144])

两者的区别在于ravel方法生成的是原数组的视图，无需占有内存空间，但视图的改变会影响到原数组的变化。而flatten方法返回的是真实值，其值的改变并不会影响原数组的更改。

通过下面的例子也许就能明白了：

In [31]: b[:3] = 0In [32]: arr3Out[32]:array([[  1,   1,   2,   3],[  5,   8,  13,  21],[ 34,  55,  89, 144]])

通过更改b的值，原数组没有变化。

6、复制多份数组

用repeat和tile扩充数组元素，例如，

In [32]: a=np.arange(10)In [33]: aOut[33]: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])In [34]: a.repeat(5)Out[34]: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, 5, 5, 5, 5, 5, 6, 6, 6, 6, 6, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 9,9, 9, 9, 9])In [40]: np.tile(a,2)Out[40]: array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]) 

参考：【Python】用Numpy扩充数组元素之repeat和tile

7、numpy如何导出以及导入

参考：Python Numpy数组保存

  Numpy提供了几种数据保存的方法。

   以3*4数组a为例：

    1. a.tofile("filename.bin")

      这种方法只能保存为二进制文件，且不能保存当前数据的行列信息，文件后缀不一定非要是bin，也可以为txt，但不影响保存格式，都是二进制。

      这种保存方法对数据读取有要求，需要手动指定读出来的数据的的dtype，如果指定的格式与保存时的不一致，则读出来的就是错误的数据。

       b = numpy.fromfile("filename.bin",dtype = **)

       读出来的数据是一维数组，需要利用

        b.shape = 3,4重新指定维数。

 

    2.numpy.save("filename.npy",a)

       利用这种方法，保存文件的后缀名字一定会被置为.npy，这种格式最好只用

       numpy.load("filename")来读取。

 

   3.numpy.savetxt("filename.txt",a)

      b =  numpy.loadtxt("filename.txt")

     用于处理一维和二维数组

————————————————————————————————————————

延展一：array的用法

官方网址：https://docs.python.org/2/library/array.html

   array模块定义了一种序列数据结构，看起来和list很相似，但是所有成员必须是相同基本类型。

   array-固定类型数据序列array作用是高效管理固定类型数值数据的序列。

   笔者在使用的时候，觉得array十分特别，笔者这样的新手，感觉有点驾驭不了。

   1、生成的过程：

np.array([1,2])

   需要np.，笔者在写的时候，常常用R的思维去写... 

出错： array(1,2)  array([1,2])  np.array([1,2],[1,2])

   2、添加数据过程：

a=[]#appenda.append([1,2])#inserta.insert(2,1)a.insert(2,[1,2])

   append加在后面，insert(位置，内容)可以加在指定位置。这边笔者又要吐槽自己了...以为又在使用R，如果a是array格式的，append是不可以使用的。只有a=[]元组的时候，才可以append加进去。

   注意append用法：其中append用在list之中，在DataFrame/array无法使用

   3、切片过程：

>>>Array[0:]　　——>切片从前面序号“0”开始到结尾，包括“0”位　　[2, 3, 9, 1, 4, 7, 6, 8]　　>>>Array[:-1]　　——>切片从后面序号“-1”到最前，不包括“-1”位　　[2, 3, 9, 1, 4, 7, 6]　　>>>Array[3:-2]　　——>切从前面序号“3”开始(包括)到从后面序号“-2”结束(不包括)　　[1, 4, 7]　　>>>Array[3::2]　　——>从前面序号“3”(包括)到最后，其中分隔为“2”　　[1, 7, 8]

4、numpy对象纵向合并

用numpy中的concatenation函数进行合并。

5、横向拼接

In [40]: arr3Out[40]:array([[  0,   0,   0,   3],[  5,   8,  13,  21],[ 34,  55,  89, 144]])In [41]: arr4Out[41]:array([[ 1,  2,  3,  4],[ 5,  6,  7,  8],[ 9, 10, 11, 12]])In [42]: np.hstack((arr3,arr4))Out[42]:array([[  0,   0,   0,   3,   1,   2,   3,   4],[  5,   8,  13,  21,   5,   6,   7,   8],[ 34,  55,  89, 144,   9,  10,  11,  12]])

横向拼接arr3和arr4两个数组，但必须满足两个数组的行数相同。

In [43]: np.vstack((arr3,arr4))  Out[43]:array([[  0,   0,   0,   3],[  5,   8,  13,  21],[ 34,  55,  89, 144],[  1,   2,   3,   4],[  5,   6,   7,   8],[  9,  10,  11,  12]])

纵向拼接arr3和arr4两个数组，但必须满足两个数组的列数相同。

In [44]: np.column_stack((arr3,arr4))    #与hstack函数具有一样的效果Out[44]:array([[  0,   0,   0,   3,   1,   2,   3,   4],[  5,   8,  13,  21,   5,   6,   7,   8],[ 34,  55,  89, 144,   9,  10,  11,  12]])In [45]: np.row_stack((arr3,arr4))    #与vstack函数具有一样的效果Out[45]:array([[  0,   0,   0,   3],[  5,   8,  13,  21],[ 34,  55,  89, 144],[  1,   2,   3,   4],[  5,   6,   7,   8],[  9,  10,  11,  12]])

6、数组格式转换

数组转换：tolist将数组转换为列表，astype()强制转换数组的数据类型，下面是两个函数的例子：

In [53]: b = a.tolist()In [54]: bOut[54]:[[0, 1, 2, 3],[4, 5, 6, 7],[8, 9, 10, 11],[12, 13, 14, 15],[16, 17, 18, 19],[20, 21, 22, 23]]In [55]: type(b)Out[55]: listIn [56]: c = a.astype(float)In [57]: cOut[57]: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.]])In [58]: a.dtypeOut[58]: dtype('int32')In [59]: c.dtypeOut[59]: dtype('float64')

这里有一个非常实际的问题：

一般结果输出都是array格式，然后我要加一个字符串形式进行，总不能.append的加，所以需要把array转化格式。譬如有一个名称为a的array格式数据。

['a1.jpg',]  +  a.tolist()

其中，[]中间有一个"，"，这个很有意思，如果你不加就是单纯的字符格式，需要加一个逗号，才能识别为[]  

————————————————————————————————————————

延展二：range的用法

   一开始还是R的思维以为[1:2]就可以得到一个序列，python里面不是，需要range，有点像R里面的rep

   range(0,2) =R= [1,2]

   range(0,10,2) 0-9每隔2个取数一次

xrange 用法与 range 完全相同，所不同的是生成的不是一个list对象，而是一个生成器。

>>> xrange(5)xrange(5)>>> list(xrange(5))[0, 1, 2, 3, 4]>>> xrange(1,5)xrange(1, 5)>>> list(xrange(1,5))[1, 2, 3, 4]>>> xrange(0,6,2)xrange(0, 6, 2)>>> list(xrange(0,6,2))[0, 2, 4]

参考：Python xrange与range的区别