numpy模块

numpy模块

计算速度快，提供了数组操作、数组运算、以及统计分布和简单的数学模型，用来存储和处理大型矩阵。

创建矩阵（掌握）

矩阵即numpy的ndarray对象，创建矩阵就是把一个列表传入np.arrray()方法。

#创建一维的ndarray对象
import numpy as np
lis = [1,2,3]
np.array(lis)
print(arr,type(arr))

[1 2 3] <class 'numpy.ndarray'>

#创建二维的ndarray对象
print(np.array([[1,2,3],[4,5,6]]))

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

#创建三维的ndarray
print(np.array([[[2.10025514,  0.12015895,  0.61720311],
        [ 0.30017032, -0.35224985, -1.1425182 ],
        [-0.34934272, -0.20889423,  0.58662319]],

       [[ 0.83898341,  0.93110208,  0.28558733],
        [ 0.88514116, -0.75439794,  1.25286816],
        [ 0.51292982, -0.29809284,  0.48851815]],

       [[-0.07557171,  1.13162939,  1.51981682],
        [ 2.18557541, -1.39649634, -1.44411381],
        [-0.50446586,  0.16003707,  0.87616892]]]))


[[[ 2.10025514,  0.12015895,  0.61720311],
    [ 0.30017032, -0.35224985, -1.1425182 ],
    [-0.34934272, -0.20889423,  0.58662319]],

   [[ 0.83898341,  0.93110208,  0.28558733],
    [ 0.88514116, -0.75439794,  1.25286816],
    [ 0.51292982, -0.29809284,  0.48851815]],

   [[-0.07557171,  1.13162939,  1.51981682],
    [ 2.18557541, -1.39649634, -1.44411381],
    [-0.50446586,  0.16003707,  0.87616892]]]    

获取矩阵的行列数

arr = np.array([[1,2,3],[4,5,6]])
print(arr)

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

#获取矩阵的行和列构成的数组
print(arr.shape)

(2,3)

#获取矩阵的行
print(arr.shape[0])

2

#获取矩阵的列
print(arr.shape[1])

3

切割矩阵

切分矩阵类似于列表的切割，但是与列表不切割不同的是，矩阵的切割涉及到行和列的切割，但是两者的切割的方式都是从索引0开始，并且取头不取尾。

arr = np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12]])
print(arr)

[[1  2  3  4]
 [5  6  7  8]
 [9 10 11 12]]

#取出第二行，第三列的元素，默认第一行参数为0
print(arr[1,2]) 

7

#取第一行矩阵的元素
print(arr[0,[0,1,2,3]])   

[1 2 3 4]                

#取出第一行矩阵的元素
print(arr[0,:])

[1 2 3 4]         

#取出第一列矩阵的元素
print(arr[:,0])   

[1 5 9]

#矩阵按运算符取元素的原理，即通过arr > 5生成一个布尔矩阵
print(arr > 5)

[[False False False False]
 [False  True  True  True]
 [ True  True  True  True]]

#取大于5的元素，返回一个数组
print(arr[arr > 5])

[ 6  7  8  9 10 11 12]

矩阵元素替换

矩阵元素的替换，类似于列表元素的替换，并且矩阵也是一个可变类型的数据，即如果对矩阵进行替换操作，会修改原矩阵的元素，所以下面我们用.copy()方法举例矩阵元素的替换。

arr = np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12]])
print(arr)

[[ 1  2  3  4]
 [ 5  6  7  8]
 [ 9 10 11 12]]

#替换6为0
arr[1,1] = 0
print(arr)

[[ 1  2  3  4]
 [ 5  0  7  8]
 [ 9 10 11 12]]

#取第一行的所有元素，并且让第一行的元素都为1
arr[0,:] = 1
print(arr)

[[ 1  1  1  1]
 [ 5  6  7  8]
 [ 9 10 11 12]]

# 取出大于5的元素，并且让大于5的元素都为2
arr[arr>5] = 2
print(arr)

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

矩阵的合并

arr1 = np.array([[1,2],[3,4],[5,6]])
print(arr1)

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

arr2 = np.array([[7,8],[9,10],[11,12]])
print(arr2)

[[ 7  8]
 [ 9 10]
 [11 12]]

• vstack和hstack只能放一个参数，这个参数必须得是容器

#合并两个矩阵的列，注意使用vatack()方法合并矩阵，矩阵应该有相同的列，其中vstack的v表示vertical垂直的
print(np.vstack((arr1,arr2)))  

[[ 1  2]
 [ 3  4]
 [ 5  6]
 [ 7  8]
 [ 9 10]
 [11 12]]

#合并两个矩阵的行，注意使用hstack()方法合并矩阵，矩阵应该有相同的行，其中hastack的h表示horizontal水平的
print(np.hstack((arr1,arr2)))

[[ 1  2  7  8]
 [ 3  4  9 10]
 [ 5  6 11 12]]

#合并两个矩阵的列   默认垂直
print(np.concatenate((arr1,arr2)))

[[ 1  2]
 [ 3  4]
 [ 5  6]
 [ 7  8]
 [ 9 10]
 [11 12]]

在numpy中，为了统一做处理，只要有axis参数的，axis=0就是列，axis=1就是行

#合并两个矩阵，其中axis=0表示合并两个矩阵的列
print(np.concatenate((arr1,arr2),axis=0))  

[[ 1  2]
 [ 3  4]
 [ 5  6]
 [ 7  8]
 [ 9 10]
 [11 12]]

#合并两个矩阵，其中axis=0表示合并两个矩阵的行
print(np.concatenate((arr1,arr2),axis=1))  

[[ 1  2  7  8]
 [ 3  4  9 10]
 [ 5  6 11 12]]

通过函数创建多维数组

方法	详解
array()	将列表转换为数组，可选择显式指定dtype
arange()	range的numpy版，支持浮点数
linspace()	类似arange()，第三个参数为数组长度
zeros()	根据指定形状和dtype创建全0数组
ones()	根据指定形状和dtype创建全1数组
eye()	创建单位矩阵
empty()	创建一个元素全随机的数组
reshape()	重塑形状

#创建一维数组
print(np.arange(10))

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

#取出1到10的数组，步长为2
print(np.arange(1,10,2))

[1 3 5 7 9]

#创建一个3*4值为1的矩阵
print(np.ones((3,4)))

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

#创建一个3*4*5 高为3，行为4，列为5的全0矩阵
print(np.zeros((3,4,5)))

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

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

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

#创建一个5*5的单位矩阵
print(np.eye(5))

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

矩阵的运算

+  两个矩阵对应元素相加
-  两个矩阵对应元素相减
*  两个矩阵对应元素相乘
/  两个矩阵对应的元素相除，如果都是整数则取商
%  两个矩阵对应元素相除后取余数
**n 单个矩阵每个元素都取n次方，如**2：每个元素都取平方

print(arr1+arr2)

[[ 8 10]
 [12 14]
 [16 18]]

#点乘和转置
print(np.dot(arr1,arr2.T))

[[ 23  29  35]
 [ 53  67  81]
 [ 83 105 127]]

#求逆矩阵
print(np.linalg.inv(np.dot(arr1,arr2.T)))

[[-3.51843721e+13  7.03687442e+13 -3.51843721e+13]
 [ 7.03687442e+13 -1.40737488e+14  7.03687442e+13]
 [-3.51843721e+13  7.03687442e+13 -3.51843721e+13]]

#最大值
print(arr1.max())

6

#最小值
print(arr1.min())

1

arr1.argmax(axis=1)  # 获取矩阵最大元素的索引位置

arr1.mean()  # 获取矩阵所有元素的平均值
arr1.mean(axis=0)  # 获取矩阵每一列的平均值
arr1.mean(axis=1)  # 获取矩阵每一行的平均值

arr1.var()  # 获取矩阵所有元素的方差
arr1.var(axis=0)  # 获取矩阵每一列的元素的方差
arr1.var(axis=1)  # 获取矩阵每一行的元素的方差

arr1.std()  # 获取矩阵所有元素的标准差
arr1.std(axis=0)  # 获取矩阵每一列的元素的标准差
arr1.std(axis=1)  # 获取矩阵每一行的元素的标准差

np.median(arr1)  # 获取矩阵所有元素的中位数
np.median(arr1,axis=0)  # 获取矩阵每一列的元素的中位数
np.median(arr1,axis=1)  # 获取矩阵每一行的元素的中位数

arr1.sum()  # 对矩阵的每一个元素求和
arr1.sum(axis=0)  # 对矩阵的每一列求和
arr1.sum(axis=1)  # 对矩阵的每一行求和

arr1.cumsum()  # 累加和，如arr1=[1,2,3],arr1.cumsum=[1,3,6],第n个元素为前n-1个元素累加

numpy生成随机数

函数名称	函数功能	参数说明
rand(d0,d1,⋯,dnd0,d1,⋯,dn)	产生均匀分布的随机数	dndn为第n维数据的维度
randn(d0,d1,⋯,dnd0,d1,⋯,dn)	产生标准正态分布随机数	dndn为第n维数据的维度
randint(low[, high, size, dtype])	产生随机整数	low:最小值；high:最大值；size:数据个数
random_sample([size])	在[0,1)内产生随机数	size为随机数的shape，可以为元祖或者列表
choice(a[, size])	从arr中随机选择指定数据	arr为1维数组；size为数组形状
uniform(low,high [,size])	给定形状产生随机数组	low为最小值；high为最大值，size为数组形状
shuffle(a)	与random.shuffle相同	a为指定数组

np.random.seed(1)  #固定随机数，永不随机，固定
print(np.random.rand(3,4))  #生成3*4的矩阵

#RandomState()方法会让数据值随机一次，之后都是相同的数据
rs = np.random.RandomState(1)
print(rs.rand(3,4))

[[4.17022005e-01 7.20324493e-01 1.14374817e-04 3.02332573e-01]
 [1.46755891e-01 9.23385948e-02 1.86260211e-01 3.45560727e-01]
 [3.96767474e-01 5.38816734e-01 4.19194514e-01 6.85219500e-01]]