numpy的基本使用2

最新推荐文章于 2024-07-16 16:58:10 发布

转载最新推荐文章于 2024-07-16 16:58:10 发布 · 143 阅读

0 ·

CC 4.0 BY-SA版权

原文链接：https://github.com/Exrick/Machine-Learning

机器学习专栏收录该内容

17 篇文章

订阅专栏

本文详细介绍了NumPy库的基础使用，包括数组的创建、拼接、分割，以及矩阵的运算，如加减乘除、指数、对数、矩阵乘法等。此外，还涉及到了向量和矩阵的转换以及逆矩阵的计算，是理解NumPy核心功能的实用教程。

numpy的基本使用2

官网：http://www.numpy.org

import numpy as np
##数组（矩阵）间操作：
x = np.array([1,2,3])
y = np.array([3,2,1])
z = np.array([6,6,6])
#拼接合并：
np.concatenate([x,y,z])
array([1, 2, 3, 3, 2, 1, 6, 6, 6])
A = np.array([])
A = np.array([[1,2,3],
              [3,2,1]])
np.concatenate([A,A])
array([[1, 2, 3],
       [3, 2, 1],
       [1, 2, 3],
       [3, 2, 1]])
#第三个参数为轴向，默认0（x轴行） 1（y轴列） 支持更多维度
np.concatenate([A,A],axis=1)
array([[1, 2, 3, 1, 2, 3],
       [3, 2, 1, 3, 2, 1]])
#注意：z为数组（向量），需转化为和A相同维度后才能合并
z
array([6, 6, 6])
z.reshape(1,-1)
array([[6, 6, 6]])
#注意：新版本不能直接这样子写：np.concatenate(A,z.reshape(1,-1))
np.concatenate((A,z.reshape(1,-1)),axis=0)
array([[1, 2, 3],
       [3, 2, 1],
       [6, 6, 6]])
#复习：Numpy中原矩阵并不会改变
#其他方法 垂直方向堆叠：
np.vstack([A,z])
array([[1, 2, 3],
       [3, 2, 1],
       [6, 6, 6]])

#构建2乘2矩阵 水平方向堆叠：
B = np.full(shape=(2,2),fill_value=1)
B
array([[1, 1],
       [1, 1]])
np.hstack([A,B])
array([[1, 2, 3, 1, 1],
       [3, 2, 1, 1, 1]])

#分割：
x = np.arange(10)
x
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
#分割点：3和8，将数组x分割为3段：
x1,x2,x3 = np.split(x,[3,8])
x1
array([0, 1, 2])
x2
array([3, 4, 5, 6, 7])
x3
array([8, 9])
#注意：分隔两段也需要传入数组：
x1,x2 = np.split(x,[5])
x1
array([0, 1, 2, 3, 4])
x2
array([5, 6, 7, 8, 9])

#创建一个4乘4的矩阵：
A = np.arange(16).reshape((4,4))
A
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11],
       [12, 13, 14, 15]])
#默认水平（行）拆分
A1,A2 = np.split(A,[2])
A1
array([[0, 1, 2, 3],
       [4, 5, 6, 7]])
A2
array([[ 8,  9, 10, 11],
       [12, 13, 14, 15]])
#指定垂直（列）方向分割，axis=1 默认0
A1,A2 = np.split(A,[2],axis=1)
A1
array([[ 0,  1],
       [ 4,  5],
       [ 8,  9],
       [12, 13]])
A2
array([[ 2,  3],
       [ 6,  7],
       [10, 11],
       [14, 15]])
#其他方法：
A1,A2 = np.vsplit(A,[2])
A1
array([[0, 1, 2, 3],
       [4, 5, 6, 7]])
A1,A2 = np.hsplit(A,[2])
A1
array([[ 0,  1],
       [ 4,  5],
       [ 8,  9],
       [12, 13]])

#前面提到数据集矩阵一般最后一列为标记，前面为特征：
data = np.arange(16).reshape((4,4))
data
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11],
       [12, 13, 14, 15]])
#从倒数第一列进行分割：
X,y=np.hsplit(data,[-1])
X
array([[ 0,  1,  2],
       [ 4,  5,  6],
       [ 8,  9, 10],
       [12, 13, 14]])
y
array([[ 3],
       [ 7],
       [11],
       [15]])
#转为向量：
y[:,0]
array([ 3,  7, 11, 15])

#数组（矩阵）运算
#原list中操作：
L = [i for i in range(10)]
L
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
#Python中乘法为2个L拼接：
L * 2
[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

#矩阵乘法（每个元素乘以2）
#法一：
M = []
for e in L:
... M.append(e*2);
...
M
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]
#法二（更加高效）：
M = [2 * e for e in L]
M
[0, 2, 4, 6, 8, 10, 12, 14, 16, 18]

#Numpy中：直接相乘即可（效率更高）：
L = np.arange(10)
L
array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])
M = L * 2
M
array([ 0,  2,  4,  6,  8, 10, 12, 14, 16, 18])
#注：Numpy中直接视为向量或矩阵进行运算，且算法进行优化，与Python中的list运算完全不在统一级别

#Universal Functions：
X = np.arange(16).reshape((4,4))
X
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11],
       [12, 13, 14, 15]])
X+1
array([[ 1,  2,  3,  4],
       [ 5,  6,  7,  8],
       [ 9, 10, 11, 12],
       [13, 14, 15, 16]])
X
array([[ 0,  1,  2,  3],
       [ 4,  5,  6,  7],
       [ 8,  9, 10, 11],
       [12, 13, 14, 15]])
#除 浮点/
X/2
array([[0. , 0.5, 1. , 1.5],
       [2. , 2.5, 3. , 3.5],
       [4. , 4.5, 5. , 5.5],
       [6. , 6.5, 7. , 7.5]])
#整除 //
X//2
array([[0, 0, 1, 1],
       [2, 2, 3, 3],
       [4, 4, 5, 5],
       [6, 6, 7, 7]], dtype=int32)
#n次方 **n
X ** 2
array([[  0,   1,   4,   9],
       [ 16,  25,  36,  49],
       [ 64,  81, 100, 121],
       [144, 169, 196, 225]], dtype=int32)
#其他函数方法 abs sin cos ...
np.sin(X)
array([[ 0.        ,  0.84147098,  0.90929743,  0.14112001],
       [-0.7568025 , -0.95892427, -0.2794155 ,  0.6569866 ],
       [ 0.98935825,  0.41211849, -0.54402111, -0.99999021],
       [-0.53657292,  0.42016704,  0.99060736,  0.65028784]])
#e的x次方
np.exp(X)
array([[1.00000000e+00, 2.71828183e+00, 7.38905610e+00, 2.00855369e+01],
       [5.45981500e+01, 1.48413159e+02, 4.03428793e+02, 1.09663316e+03],
       [2.98095799e+03, 8.10308393e+03, 2.20264658e+04, 5.98741417e+04],
       [1.62754791e+05, 4.42413392e+05, 1.20260428e+06, 3.26901737e+06]])
#power(n,x)x的n次方，等同于**n
np.power(3,X)
array([[       1,        3,        9,       27],
       [      81,      243,      729,     2187],
       [    6561,    19683,    59049,   177147],
       [  531441,  1594323,  4782969, 14348907]], dtype=int32)

X = np.arange(1,17)
X
array([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16])
np.log10(X)
array([0.        , 0.30103   , 0.47712125, 0.60205999, 0.69897   ,
       0.77815125, 0.84509804, 0.90308999, 0.95424251, 1.        ,
       1.04139269, 1.07918125, 1.11394335, 1.14612804, 1.17609126,
       1.20411998])

#矩阵间运算：
import numpy as np
A = np.arange(4).reshape(2,2)
A
array([[0, 1],
       [2, 3]])
B = np.full((2,2),6)
B
array([[6, 6],
       [6, 6]])
A + B
array([[6, 7],
       [8, 9]])
#注意：Numpy中乘法也是对应元素相乘
A * B
array([[ 0,  6],
       [12, 18]])
#标准矩阵乘法（线性代数知识）
A.dot(B)
array([[ 6,  6],
       [30, 30]])
#转置
A.T
array([[0, 2],
       [1, 3]])

#向量与矩阵的运算
v = np.array([1,2])
v
array([1, 2])
A
array([[0, 1],
       [2, 3]])
v + A
array([[1, 3],
       [3, 5]])
A.shape[0]
2
A.shape
(2, 2)
#堆叠相加
#np.tile(v,(水平方向堆叠次数，垂直方向堆叠次数))
np.tile(v,(2,1))
array([[1, 2],
       [1, 2]])
np.tile(v,(2,1)) + A
array([[1, 3],
       [3, 5]])
v * A
array([[0, 2],
       [2, 6]])
#标准矩阵间乘法
v.dot(A)
array([4, 7])
#注意：numpy会自动判断 将[1,2]转化为列向量
A.dot(v)
array([2, 8])

#矩阵的逆
A
array([[0, 1],
       [2, 3]])
#linalg：linear algebra线性代数缩写inv：逆inverse缩写
invA = np.linalg.inv(A)
invA
array([[-1.5,  0.5],
       [ 1. ,  0. ]])
#线性代数基础：A*A-1=E（单位矩阵）A为n*n的方阵
A.dot(invA)
array([[1., 0.],
       [0., 1.]])
#X不为方阵的情况下 numpy可以求伪逆阵
X = np.arange(16).reshape((2,8))
X
array([[ 0,  1,  2,  3,  4,  5,  6,  7],
       [ 8,  9, 10, 11, 12, 13, 14, 15]])