numpy库中的mat和array使用小结

numpy的导入和使用： from numpy import *;

矩阵Mat的创建

1、由一维或二维数据创建矩阵

a1=array([1,2,3]);
a1=mat(a1);

由列表list创建矩阵 

list=[1,2,3]
mat(list)
》》matrix([[1, 2, 3]])

 2、创建常见的矩阵

data1=mat(zeros((3,3)));
#创建一个3*3的零矩阵，矩阵这里zeros函数的参数是一个tuple类型(3,3)
data2=mat(ones((2,4)));
#创建一个2*4的1矩阵，默认是浮点型的数据，如果需要时int类型，可以使用dtype=int

data3=mat(random.rand(2,2));
#这里的random模块使用的是numpy中的random模块，random.rand(2,2)创建的是一个二维数组，需要将其转换成#matrix
data4=mat(random.randint(10,size=(3,3)));
#生成一个3*3的0-10之间的随机整数矩阵，如果需要指定下界则可以多加一个参数

3、矩阵运算

矩阵相乘：

a1=mat([1,2]);
a2=mat([[1],[2]]);
a3=a1*a2;  #1*2的矩阵乘以2*1的矩阵，得到1*1的矩阵
np.matmul(a, b) #方法二
np.dot(a, b)     #方法三

矩阵点乘——矩阵对应元素相乘

a1=mat([1,1]);

a2=mat([2,2]);

a3=multiply(a1,a2);

矩阵转置

a2=a.T;
np.transpose(a)   #方法二

矩阵求和

a1=mat([[1,1],[2,3],[4,2]]);


a2=a1.sum(axis=0);//列和，这里得到的是1*2的矩阵
a3=a1.sum(axis=1);//行和，这里得到的是3*1的矩阵
a4=sum(a1[1,:]);//计算第一行所有列的和，这里得到的是一个数值

最值索引

a1.max();//计算a1矩阵中所有元素的最大值,这里得到的结果是一个数值
a2=max(a1[:,1]);//计算第二列的最大值，这里得到的是一个1*1的矩阵
a1[1,:].max();//计算第二行的最大值，这里得到的是一个数值

np.max(a1,0);//计算所有列的最大值，这里使用的是numpy中的max函数
np.max(a1,1);//计算所有行的最大值，这里得到是一个矩阵

np.argmax(a1,0);//计算所有列的最大值对应在该列中的索引
np.argmax(a1[1,:]);//计算第二行中最大值对应在该行的索引

矩阵分割

a=mat(ones((3,3)));
b=a[1:,1:];//分割出第二行以后的行和第二列以后的列的所有元素

矩阵的合并（适用于array）

a=mat(ones((2,2)));
b=mat(eye(2));
c=vstack((a,b));//按列合并，即增加行数
d=hstack((a,b));//按行合并，即扩展列数

行列数

m,n=a.shape;
m=a.shape[0];#行数
n=a.shape[1];#列数

排序 

m=np.mat([[2,5,1],[4,6,2]])    #创建2行3列矩阵
>>> m
matrix([[2, 5, 1],
        [4, 6, 2]])
>>> m.sort()                    #对每一行进行排序
>>> m
matrix([[1, 2, 5],
        [2, 4, 6]])

4、mat转list，array

tolist

tolist函数用于把一个矩阵转化成为list列表

>>x=np.mat([[1,2,3],[4,5,6]])
>>print(x)
>>matrix([[1,2,3],[4,,5,6]])
>>type(x)
>>matrix
 
 
>>x.tolist()
>>[[1,2,3],[4,5,6]]

getA()或mat.A ,matrix矩阵名.A 代表将矩阵转化为array数组类型

getA()函数是numpy.matrix下的一个函数，用作把矩阵转换成数组array，等价于np.asarray(self).


>>> x = np.matrix(np.arange(12).reshape((3,4))); 
matrix([[ 0,  1,  2,  3],
        [ 4,  5,  6,  7],
        [ 8,  9, 10, 11]])
>>> x.getA()
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])

>>> b=x.A
b=array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11]])

 from：https://blog.csdn.net/qq_30638831/article/details/79907684

数组array的创建

1、使用numpy.array方法将tuple和list, array, 或者其他的序列模式的数据转创建为 ndarray, 默认创建一个新的 ndarray

>>> np.array([1,2,3,4]) 
[1 2 3 4]

>>> b = array( [ (1.5,2,3), 
                 (4,5,6)  ]  )　　 
array([[ 1.5,  2. ,  3. ],  
　　　  [ 4. ,  5. ,  6. ]])  

>>> c = array( [ [1,2], [3,4] ], dtype=complex)  
#指定数组中元素的类型
>>> c  
    array([[ 1.+0.j,  2.+0.j],  
　　　    [ 3.+0.j,  4.+0.j]]) 

2、生成均匀分布的array： 
arange（最小值，最大值，步长）（左闭右开） : 创建等差数列 
linspace（最小值，最大值，元素数量） 

>>> np.arange(15)
[ 0  1  2  3  4  5  6  7  8  9 10 11 12 13 14]

>>> np.arange(15).reshape(3,5)
[[ 0  1  2  3  4]
 [ 5  6  7  8  9]
 [10 11 12 13 14]]

>>> np.arange( 0, 2, 0.3 )        
array([ 0. ,  0.3,  0.6,  0.9,  1.2,  1.5,  1.8])

>>> np.linspace(1,3,9)
[ 1.    1.25  1.5   1.75  2.    2.25  2.5   2.75  3.  ]

3、生成特殊数组 
np.ones: 创建一个数组, 其中的元素全为 1 
np.zeros: 创建元素全为 0 的数组, 类似 np.ones 
np.empty创建一个内容随机并且依赖与内存状态的数组。 
np.eye: 创建一个对角线为 1 其他为 0 的矩阵. 
np.identity: 创建一个主对角线为 1 其他为 0 的方阵.

4、获取数组的属性

>>> a = np.zeros((2,2,2))
>>> a.ndim   #数组的维数
3
>>> a.shape  #数组每一维的大小
(2, 2, 2)
>>> a.size   #数组全部元素的数量 
8
>>> a.dtype  #数组中元素的类型
float64
>>> print a.itemsize  #每个元素所占的字节数
8

5、数组运算（注意array乘法与mat不同）

print a
[[ 1.  1.]
 [ 1.  1.]]
>>> print b
[[ 1.  0.]
 [ 0.  1.]]

>>> print a > 2
[[False False]
 [False False]]
>>> print a+b             #数组加，对应位置相加
[[ 2.  1.]
 [ 1.  2.]]
>>> print a-b             #数组减，对应位置相减
[[ 0.  1.]
 [ 1.  0.]]
>>> print b*2             #数组与数值相乘，对应位置乘
[[ 2.  0.]
 [ 0.  2.]]

>>> print (a*2)*(b*2)     #数组与数组相乘，按位置一对一相乘
[[ 4.  0.]
 [ 0.  4.]]
>>> print b/(a*2)          #数组与数组相除，按位置一对一相除
[[ 0.5  0. ]
 [ 0.   0.5]]

>>> print a.dot(b)                    # matrix product，矩阵乘
>>> np.dot(a,a)                       #矩阵乘法
array([[ 2.,  2.],
       [ 2.,  2.]])

>>> print (a*2)**4
[[ 16.  16.]
 [ 16.  16.]]

>>> b = a              #浅拷贝
>>> b is a
True
>>> c = a.copy()       #深拷贝
>>> c is a
False

from：https://blog.csdn.net/github_36669230/article/details/78038756

 

1. mat()函数与array()函数生成矩阵所需的数据格式有区别

(1) mat()函数中数据可以为字符串以分号(；)分割，或者为列表形式以逗号（，）分割。而array()函数中数据只能为后者形式。

如mat()函数生成矩阵时一下两种方式都正确。

   和     

(2) 而array()函数生成矩阵时数据只能为列表形式。

2. mat()函数与array()函数生成的矩阵计算方式不同

(1) mat()函数中矩阵的乘积可以使用（星号） *  或 .dot()函数，其结果相同。而矩阵对应位置元素相乘需调用numpy.multiply()函数。

(2) array()函数中矩阵的乘积只能使用 .dot()函数。而星号乘 （*）则表示矩阵对应位置元素相乘，与numpy.multiply()函数结果相同。