Python numpy的基本用法(一)

矩阵的基本用法

mat()函数将目标数据的类型转化为矩阵

mat()与array()的区别

Numpy函数库中存在两种不同的数据类型（矩阵matrix和数组array），都可以用于处理行列表示的数字元素，虽然他们看起来很相似，但是在这两个数据类型上执行相同的数学运算可能得到不同的结果，其中Numpy函数库中的matrix与MATLAB中matrices等价。
例如

import numpy as np
 
a = np.mat('1 2;3 4')
b = np.mat([[1,2],[3,4]])
print(a)
print(b)
print(type(a))
print(type(b))
c = np.array([[1,3],[4,5]])
print(c)
print(type(c))

结果：

首先，mat() 函数与array()函数生成矩阵所需的数据格式有区别，mat()函数中数据可以为字符串以分号（;）分割或者为列表形式以逗号（，）分割，而array()函数中数据只能为后者形式。
其次，两者的类型不同，用mat函数转换为矩阵后才能进行一些线性代数的操作。

mat()函数创建常见的矩阵

import numpy as np
#创建一个2*2的零矩阵
data1=np.mat(np.zeros((2,2)))
#创建一个2*2的全1矩阵
data2=np.mat(np.ones((2,2)),dtype=int)
#创建一个2*2的单位矩阵
data3=np.mat(np.eye(2,2))
#创建一个2*2的随机数矩阵
data4=np.mat(np.random.randn(2,2))
#生成一个对角矩阵
a=[1,2,3]
data5=np.mat(np.diag(a))
#numpy.full(shape,fill_value=num)自定义填充,可以是数字，也可以是字符
data6=np.full(shape=(2,2,2),fill_value=5) #第一个2表示，填充两个矩阵
print(data1,'\n\n',data2,'\n\n',data3,'\n\n',data4,'\n\n',data5,'\n\n',data6)

结果

[[0. 0.]
 [0. 0.]] 

 [[1 1]
 [1 1]] 

 [[1. 0.]
 [0. 1.]] 

 [[ 0.90988277  0.72030404]
 [ 1.24342433 -0.50141365]] 

 [[1 0 0]
 [0 2 0]
 [0 0 3]]
 
 [[[5 5]
  [5 5]]

 [[5 5]
  [5 5]]]

##常见的矩阵运算

矩阵相乘（*）

from numpy import  *
''' 1*2 的矩阵乘以2*1 的矩阵  得到1*1 的矩阵''' 
a1 = mat([1,2])
print(a1)
a2 = mat([[1],[2]])
print(a2)
a3 = a1*a2
print(a3)

[[1 2]]
[[1]
[2]]
[[5]]

矩阵点乘（multiply）

from numpy import  *
''' 矩阵点乘为对应矩阵元素相乘'''
 
a1 = mat([1,1])
print(a1)
a2 = mat([2,2])
print(a2)
a3 = multiply(a1,a2)
print(a3)

[[1 1]]
[[2 2]]
[[2 2]]

矩阵求逆变换（.I）

2
3
4
5
6
7
8
9
10
11
12
13
from numpy import *
''' 矩阵求逆变换:求矩阵matrix([[0.5,0],[0,0.5]])的逆矩阵'''
 
a1 = mat(eye(2,2)*0.5)
print(a1)
a2 = a1.I
print(a2)

[[0.5 0. ]
 [0.  0.5]]
[[2. 0.]
 [0. 2.]]

矩阵求转置（.T）

from numpy import *
'''矩阵的转置'''
 
a1 = mat([[1,1],[0,0]])
print(a1)
a2 = a1.T
print(a2)

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

求矩阵对应列行的最大值，最小值，和。

from numpy import *
'''计算每一列，行的和'''
 
a1 = mat([[1,1],[2,3],[4,5]])
print(a1)
#  列和，这里得到的是1*2的矩阵,求列和只需要将axis=1
a2=a1.sum(axis=0)
print(a2)

[[7 9]]

#  计算a1矩阵中所有元素的最大值,这里得到的结果是一个数值
maxa = a1.max()
print(maxa)   #5
#  计算第二列的最大值，这里得到的是一个1*1的矩阵
a2=max(a1[:,1])
print(a2)   #[[5]]
#  计算第二行的最大值，这里得到的是一个一个数值
maxt = a1[1,:].max()
print(maxt)   #3
#   计算所有列的最大值，这里使用的是numpy中的max函数
maxrow = np.max(a1,0)
print(maxrow)   #[[4 5]]
# ;//计算所有行的最大值，这里得到是一个矩阵
maxcolumn = np.max(a1,1)
print(maxcolumn)
#  计算所有列的最大值对应在该列中的索引
maxindex = np.argmax(a1,0)
print(maxindex)   #[[2 2]]
#  计算第二行中最大值对应在改行的索引
tmaxindex = np.argmax(a1[1,:])
print(tmaxindex)  # 1

矩阵的分隔和合并　（vstack hstack）

from numpy import *
 
a = mat(ones((2,2)))
print(a)
b = mat(eye(2))
print(b)
# 按照列和并，即增加行数
c = vstack((a,b))
print(c)
# 按照行合并，即行数不变，扩展列数
d = hstack((a,b))
print(d)

[[1. 1.]
 [1. 1.]]
  
[[1. 0.]
 [0. 1.]]
  
[[1. 1.]
 [1. 1.]
 [1. 0.]
 [0. 1.]]
  
[[1. 1. 1. 0.]
 [1. 1. 0. 1.]]

数组叠加合并
列合并/扩展：np.column_stack()
行合并/扩展：np.row_stack()

a = np.array((1,2,3,4))
b = np.array((4,5,6,7))
res1 = np.column_stack((a,b))
res2 = np.row_stack((a,b))
print(a)
print(b)
print(res1)
print(res2)

[1 2 3 4]
[4 5 6 7]
[[1 4]
 [2 5]
 [3 6]
 [4 7]]
[[1 2 3 4]
 [4 5 6 7]]

数组均分（np.array.split()）

x = np.arange(10)
res1 = np.array_split(x,2)
res2 = np.array_split(x,3)
print(res1)
print(res2)

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

矩阵、列表、数组的转换

from numpy import *
#列表
a1=[[1,2],[3,2],[5,2]]
#将列表转化为二维数组
a2=array(a1)
#将列表转化为矩阵
a3=mat(a1)
#将矩阵转化为数组
a4=array(a3)
#将矩阵转化为列表
a5=a3.tolist()
#将数组转化为列表
a6=a2.tolist()

数组的基本用法

**np.array()创建 **

import numpy as np
a=[1,2,3]
b=np.array(a)
print(b)

[1 2 3]

Numpy查看数组属性

import numpy as np
a=np.array([1,2,3])
#查看数组元素个数
print(a.size)
#查看数组形状
print(a.shape)
#查看数组维度
print(a.ndim)
#查看数组元素类型
print(a.dtype)

3
(3,)
1
int32

数组的基本操作
1、索引

arr=np.random.randint(0,10,(2,2))
print(arr)
print(arr[1,1])

2、切片

#切片时，左闭右开
arr=np.random.randint(0,10,(4,4))
print(arr,'\n')
print(arr[:3,:2])

[[0 1 6 0]
 [1 4 4 3]
 [9 4 2 7]
 [8 9 0 6]] 

[[0 1]
 [1 4]
 [9 4]]

3、变形

arr=np.array([1,2,3,4])
arr1=arr.reshape(2,2)
print(arr1)

[[1 2]
 [3 4]]

4、级联
np.concatenate()级联需要注意的点：
1.级联的参数是列表：一定要加中括号或小括号
2.维度必须相同
3.形状相符
4.【重点】级联的方向默认是shape这个tuple的第一个值所代表的维度方向
5.可通过axis参数改变级联的方向

#级联
n1=np.array([[1,2],[3,4]])
b=np.concatenate((n1,n1),axis = 0) #axis=0表示行级联，axis=1表示列级联
print(b)

[[1 2]
 [3 4]
 [1 2]
 [3 4]]

np.hstack与np.vstack
水平级联与垂直级联，处理自己。进行维度的变更

n1=np.array([1,2,3,4])
n2=np.vstack(n1)   #垂直级联
n3=np.hstack(n2) #水平级联
print(n2,"\n\n",n3)

[[1]
 [2]
 [3]
 [4]] 

 [1 2 3 4]

5、切分
与级联类似，常用函数：
np.split
np.vsplit
np.hsplit

n4 = np.random.randint(0,10,size=(5,7))
print(n4)
print(np.split(n4,(1,3)),'\n\n')  #切分为1行2列,默认axis=0
print(np.split(n4,(1,3),axis=1),'\n\n')  #水平切分,即按照行切分
print(np.vsplit(n4,(1,3)),'\n\n')#垂直切分，即按照列切分
print(np.hsplit(n4,(1,3)))#水平切分

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


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


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


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

6、矩阵的广播
ndarray广播的两条规则：
规则一：为缺失的维度补1
规则二：假定缺失元素用已有值填充

#实例2：a = np.arange(3).reshape((3,1)) b = np.arange(3) 求a+b
a = np.arange(3).reshape((3,1))
b = np.arange(3)
print(a,'\n\n',b,'\n\n')
print(a+b)

[[0]
 [1]
 [2]] 

 [0 1 2] 

[[0 1 2]
 [1 2 3]
 [2 3 4]]