numpy模块

时间：2019-05-04 12:17:07 阅读：124 评论：0 收藏：0 [点我收藏+]

标签：state 3.3 ref 2.4 .sh 方法 warning amp 随机数

numpy官方文档：https://docs.scipy.org/doc/numpy/reference/?v=20190307135750

numpy是Python的一种开源的数值计算扩展库。这种库可用来存储和处理大型矩阵，比Python自身的嵌套列表结构要高效的多（该结构也可以用来表示矩阵）。

numpy库有两个作用：

区别于list列表，提供了数组操作、数组运算、以及统计分布和简单的数学模型
计算速度快，甚至要由于python内置的简单运算，使得其成为pandas、sklearn等模块的依赖包。高级的框架如TensorFlow、PyTorch等，其数组操作也和numpy非常相似。

创建矩阵(掌握)

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

import numpy as np

# 创建一维的ndarray对象
arr = np.array([1, 2, 3])
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([[1, 2, 3], [4, 5, 6], [7, 8, 9]]))

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

获取矩阵的行列数(掌握)

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])

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

切割矩阵(掌握)

切分矩阵类似于列表的切割，但是与列表的切割不同的是，矩阵的切割涉及到行和列的切割，但是两者切割的方式都是从索引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]]

# 取所有元素
print(arr[:, :])

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

# 取第一行的所有元素
print(arr[:1, :])

[[1 2 3 4]]

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

[1 2 3 4]

# 取第一列的所有元素
print(arr[:, :1])

[[1]
 [5]
 [9]]

# 取第一列的所有元素
print(arr[(0, 1, 2), 0])

[1 5 9]

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

[1 5 9]

# 取第一行第一列的元素
print(arr[0, 0])

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

[ 6  7  8  9 10 11 12]

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

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

矩阵元素替换(掌握)

矩阵元素的替换，类似于列表元素的替换，并且矩阵也是一个可变类型的数据，即如果对矩阵进行替换操作，会修改原矩阵的元素，所以下面我们用.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]]

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

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

# 取所有大于5的元素，并且让大于5的元素为0
arr2 = arr.copy()
arr2[arr > 5] = 0
print(arr2)

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

# 对矩阵清零
arr3 = arr.copy()
arr3[:, :] = 0
print(arr3)

[[0 0 0 0]
 [0 0 0 0]
 [0 0 0 0]]

矩阵的合并(熟悉)

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]]

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

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

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

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

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

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

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

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

通过函数创建矩阵(掌握)

arange

# 构造0-9的ndarray数组
print(np.arange(10))

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

# 构造1-4的ndarray数组
print(np.arange(1, 5))

[1 2 3 4]

# 构造1-19且步长为2的ndarray数组
print(np.arange(1, 20, 2))

[ 1  3  5  7  9 11 13 15 17 19]

linspace/logspace

# 构造一个等差数列，取头也取尾，从0取到20，取5个数
print(np.linspace(0, 20, 5))

[  0.   5.  10.  15.  20.]

# 构造一个等比数列，从10**0取到10**20，取5个数
print(np.logspace(0, 20, 5))

[  1.00000000e+00   1.00000000e+05   1.00000000e+10   1.00000000e+15
   1.00000000e+20]

zeros/ones/eye/empty

# 构造3*4的全0矩阵
print(np.zeros((3, 4)))

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

# 构造3*4的全1矩阵
print(np.ones((3, 4)))

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

# 构造3个主元的单位矩阵
print(np.eye(3))

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

# 构造一个4*4的随机矩阵，里面的元素是随机生成的
print(np.empty((4, 4)))

[[  1.72723371e-077  -2.68678116e+154   3.95252517e-323   0.00000000e+000]
 [  0.00000000e+000   0.00000000e+000   0.00000000e+000   0.00000000e+000]
 [  0.00000000e+000   0.00000000e+000   0.00000000e+000   0.00000000e+000]
 [  0.00000000e+000   0.00000000e+000   0.00000000e+000   1.17248833e-308]]

fromstring/fromfunction(了解)

# fromstring通过对字符串的字符编码所对应ASCII编码的位置，生成一个ndarray对象
s = 'abcdef'
# np.int8表示一个字符的字节数为8
print(np.fromstring(s, dtype=np.int8))

[ 97  98  99 100 101 102]

def func(i, j):
    """其中i为矩阵的行，j为矩阵的列"""
    return i*j


# 使用函数对矩阵元素的行和列的索引做处理，得到当前元素的值，索引从0开始，并构造一个3*4的矩阵
print(np.fromfunction(func, (3, 4)))

[[ 0.  0.  0.  0.]
 [ 0.  1.  2.  3.]
 [ 0.  2.  4.  6.]]

矩阵的运算(掌握)

普通矩阵运算

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

arrarr1 = 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]]

print(arr1+arr2)

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

print(arr1**2)

[[ 1  4]
 [ 9 16]
 [25 36]]

常用矩阵运算函数(了解)

矩阵函数	详解
np.sin(arr)	对矩阵arr中每个元素取正弦，$sin(x)$
np.cos(arr)	对矩阵arr中每个元素取余弦，$cos(x)$
np.tan(arr)	对矩阵arr中每个元素取正切，$tan(x)$
np.arcsin(arr)	对矩阵arr中每个元素取反正弦，$arcsin(x)$
np.arccos(arr)	对矩阵arr中每个元素取反余弦，$arccos(x)$
np.arctan(arr)	对矩阵arr中每个元素取反正切，$arctan(x)$
np.exp(arr)	对矩阵arr中每个元素取指数函数，$e^x$
np.sqrt(arr)	对矩阵arr中每个元素开根号$\sqrt{x}$

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]]

# 对矩阵的所有元素取正弦
print(np.sin(arr))

[[ 0.84147098  0.90929743  0.14112001 -0.7568025 ]
 [-0.95892427 -0.2794155   0.6569866   0.98935825]
 [ 0.41211849 -0.54402111 -0.99999021 -0.53657292]]

# 对矩阵的所有元素开根号
print(np.sqrt(arr))

[[ 1.          1.41421356  1.73205081  2.        ]
 [ 2.23606798  2.44948974  2.64575131  2.82842712]
 [ 3.          3.16227766  3.31662479  3.46410162]]

# 对矩阵的所有元素取反正弦，如果元素不在定义域内，则会取nan值
print(np.arcsin(arr))

[[ 1.57079633         nan         nan         nan]
 [        nan         nan         nan         nan]
 [        nan         nan         nan         nan]]


/Applications/anaconda3/lib/python3.6/site-packages/ipykernel_launcher.py:2: RuntimeWarning: invalid value encountered in arcsin

矩阵的点乘(掌握)

矩阵的点乘必须满足第一个矩阵的列数等于第二个矩阵的行数，即$m*n·{n*m}=m*m$。

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

(2, 3)

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

(3, 2)

assert arr1.shape[0] == arr2.shape[1]
# 2*3·3*2 = 2*2
print(arr2.shape)

(3, 2)

矩阵的转置(掌握)

矩阵的转置，相当于矩阵的行和列互换。

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

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

print(arr.transpose())

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

print(arr.T)

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

矩阵的逆(掌握)

矩阵行和列相同时，矩阵才可逆。

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

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

print(np.linalg.inv(arr))

[[  3.15251974e+15  -6.30503948e+15   3.15251974e+15]
 [ -6.30503948e+15   1.26100790e+16  -6.30503948e+15]
 [  3.15251974e+15  -6.30503948e+15   3.15251974e+15]]

# 单位矩阵的逆是单位矩阵本身
arr = np.eye(3)
print(arr)

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

print(np.linalg.inv(arr))

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

矩阵其他操作(熟悉)

最大最小值

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

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

# 获取矩阵所有元素中的最大值
print(arr.max())

# 获取矩阵所有元素中的最小值
print(arr.min())

# 获取举着每一行的最大值
print(arr.max(axis=0))

[7 8 9]

# 获取矩阵每一列的最大值
print(arr.max(axis=1))

[3 6 9]

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

[2 2 2]

平均值

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

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

# 获取矩阵所有元素的平均值
print(arr.mean())

5.0

# 获取矩阵每一列的平均值
print(arr.mean(axis=0))

[ 4.  5.  6.]

# 获取矩阵每一行的平均值
print(arr.mean(axis=1))

[ 2.  5.  8.]

方差

方差公式为
\[ mean(|x-x.mean()|^2) \]
其中x为矩阵。

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

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

# 获取矩阵所有元素的方差
print(arr.var())

6.66666666667

# 获取矩阵每一列的元素的方差
print(arr.var(axis=0))

[ 6.  6.  6.]

# 获取矩阵每一行的元素的方差
print(arr.var(axis=1))

[ 0.66666667  0.66666667  0.66666667]

标准差

标准差公式为
\[ \sqrt{mean|x-x.mean()|^2} = \sqrt{x.var()} \]

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

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

# 获取矩阵所有元素的标准差
print(arr.std())

2.58198889747

# 获取矩阵每一列的标准差
print(arr.std(axis=0))

[ 2.44948974  2.44948974  2.44948974]

# 获取矩阵每一行的标准差
print(arr.std(axis=1))

[ 0.81649658  0.81649658  0.81649658]

中位数

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

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

# 获取矩阵所有元素的中位数
print(np.median(arr))

5.0

# 获取矩阵每一列的中位数
print(np.median(arr, axis=0))

[ 4.  5.  6.]

# 获取矩阵每一行的中位数
print(np.median(arr, axis=1))

[ 2.  5.  8.]

矩阵求和

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

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

# 对矩阵的每一个元素求和
print(arr.sum())

# 对矩阵的每一列求和
print(arr.sum(axis=0))

[12 15 18]

# 对矩阵的每一行求和
print(arr.sum(axis=1))

[ 6 15 24]

累加和

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

[1 2 3 4 5]

# 第n个元素为前n-1个元素累加和
print(arr.cumsum())

[ 1  3  6 10 15]

numpy.random生成随机数(熟悉)

函数名称	函数功能	参数说明
rand($d_0, d_1, \cdots , d_n$)	产生均匀分布的随机数	$d_n$为第n维数据的维度
randn($d_0, d_1, \cdots , d_n$)	产生标准正态分布随机数	$d_n$为第n维数据的维度
randint(low[, high, size, dtype])	产生随机整数	low:最小值；high:最大值；size:数据个数
random_sample([size])	在$[0,1)$内产生随机数	size为随机数的shape，可以为元祖或者列表
choice(a[, size])	从arr中随机选择指定数据	arr为1维数组；size为数据形状

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

[  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]

# 构造3*4的均匀分布的矩阵
# seed()方法会让数据值随机一次，之后都是相同的数据
np.random.seed(1)
print(np.random.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]]

# 构造3*4*5的均匀分布的矩阵
print(np.random.rand(3, 4, 5))

[[[ 0.20445225  0.87811744  0.02738759  0.67046751  0.4173048 ]
  [ 0.55868983  0.14038694  0.19810149  0.80074457  0.96826158]
  [ 0.31342418  0.69232262  0.87638915  0.89460666  0.08504421]
  [ 0.03905478  0.16983042  0.8781425   0.09834683  0.42110763]]

 [[ 0.95788953  0.53316528  0.69187711  0.31551563  0.68650093]
  [ 0.83462567  0.01828828  0.75014431  0.98886109  0.74816565]
  [ 0.28044399  0.78927933  0.10322601  0.44789353  0.9085955 ]
  [ 0.29361415  0.28777534  0.13002857  0.01936696  0.67883553]]

 [[ 0.21162812  0.26554666  0.49157316  0.05336255  0.57411761]
  [ 0.14672857  0.58930554  0.69975836  0.10233443  0.41405599]
  [ 0.69440016  0.41417927  0.04995346  0.53589641  0.66379465]
  [ 0.51488911  0.94459476  0.58655504  0.90340192  0.1374747 ]]]

# 构造3*4的正态分布的矩阵
print(np.random.randn(3, 4))

[[ 0.30017032 -0.35224985 -1.1425182  -0.34934272]
 [-0.20889423  0.58662319  0.83898341  0.93110208]
 [ 0.28558733  0.88514116 -0.75439794  1.25286816]]

# 构造取值为1-5内的10个元素的ndarray数组
print(np.random.randint(1, 5, 10))

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

# 构造取值为0-1内的3*4的矩阵
print(np.random.random_sample((3, 4)))

[[ 0.62169572  0.11474597  0.94948926  0.44991213]
 [ 0.57838961  0.4081368   0.23702698  0.90337952]
 [ 0.57367949  0.00287033  0.61714491  0.3266449 ]]

arr = np.array([1, 2, 3])
# 随机选取arr中的两个元素
print(np.random.choice(arr, size=2))

[1 3]

numpy模块

标签：state 3.3 ref 2.4 .sh 方法 warning amp 随机数

原文地址：https://www.cnblogs.com/nickchen121/p/10807564.html

踩

(0)

评论一句话评论（0）

分享档案

更多>

2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)

周排行

矩阵函数	详解
np.sin(arr)	对矩阵arr中每个元素取正弦，\(sin(x)\)
np.cos(arr)	对矩阵arr中每个元素取余弦，\(cos(x)\)
np.tan(arr)	对矩阵arr中每个元素取正切，\(tan(x)\)
np.arcsin(arr)	对矩阵arr中每个元素取反正弦，\(arcsin(x)\)
np.arccos(arr)	对矩阵arr中每个元素取反余弦，\(arccos(x)\)
np.arctan(arr)	对矩阵arr中每个元素取反正切，\(arctan(x)\)
np.exp(arr)	对矩阵arr中每个元素取指数函数，\(e^x\)
np.sqrt(arr)	对矩阵arr中每个元素开根号\(\sqrt{x}\)

函数名称	函数功能	参数说明
rand(\(d_0, d_1, \cdots , d_n\))	产生均匀分布的随机数	\(d_n\)为第n维数据的维度
randn(\(d_0, d_1, \cdots , d_n\))	产生标准正态分布随机数	\(d_n\)为第n维数据的维度
randint(low[, high, size, dtype])	产生随机整数	low:最小值；high:最大值；size:数据个数
random_sample([size])	在$[0,1)$内产生随机数	size为随机数的shape，可以为元祖或者列表
choice(a[, size])	从arr中随机选择指定数据	arr为1维数组；size为数据形状