# !/usr/bin/env python3
import matplotlib.pyplot as plt
import numpy as np
# 创建数组
print(np.array([i for i in range(1, 10)]))
# 创建0矩阵
# [0. 0. 0. 0. 0. 0. 0. 0. 0. 0.]
print(np.zeros(10))
# 二维数组三行五列
# [[0 0 0 0]
# [0 0 0 0]
# [0 0 0 0]]
print(np.zeros(shape=(3, 4),dtype=int))
# 全为1的矩阵
# [[1 1 1 1]
# [1 1 1 1]
# [1 1 1 1]]
print(np.ones(shape=(3,4),dtype=int))
# 指定值的矩阵
# [[5 5 5 5]
# [5 5 5 5]
# [5 5 5 5]]
print(np.full((3,4),5))
#### arrange函数
# 按照指定的规则,排列数组 起始点 终止点 步长
# [1 3 5 7 9]
print(np.arange(1,10,2))
### linspace函数
# 按照指定的规则,排列数组 起始点 终止点 1到10的区间等长截取5个点 前闭后闭
# [1 3 5 7 9]
print(np.linspace(1,10,2))
### random函数
# 随机生成一个数组 前闭后开的区间 随机生成10个数
# [2 1 2 1 3 4 1 3 3 4]
print(np.random.randint(1,5,size = 10))
# 生成随机矩阵
# [[1 1 2 2]
# [3 4 3 4]
# [4 1 1 4]]
print(np.random.randint(1,5,size = (3,4)))
# 如果需要多次生成的随机矩阵相等,可以使用np.random.seed(seed)
# [2 4 1 1 4 2 4 2 4 1]
np.random.seed(1)
print(np.random.randint(1,5,size = 10))
# [2 4 1 1 4 2 4 2 4 1]
np.random.seed(1)
print(np.random.randint(1,5,size = 10))
# 生成随机浮点数
# [0.09233859 0.18626021 0.34556073 0.39676747 0.53881673 0.41919451
# 0.6852195 0.20445225 0.87811744 0.02738759]
print(np.random.random(10))
#生成符合正态分布的随机数 均值为0 方差为1 生成10个浮点数
# [-0.85990661 1.77260763 -1.11036305 0.18121427 0.56434487 -0.56651023
# 0.7299756 0.37299379 0.53381091 -0.0919733 ]
print(np.random.normal(0,1,10))
##############基本属性################
nparr = np.random.randint(1,5,size = (3,4))
# 数组的维度
print(nparr.ndim)
# 数组的类型
print(nparr.dtype)
# 数组的元素个数
print(nparr.size)
# 数组的形状
print(nparr.shape)
# 数组的元素
print(nparr.itemsize)
############数据访问################
print("############数据访问################")
arr2 = np.array([i for i in range(10)])
# 数组的第一个元素
# 0
print(arr2[0])
# 数组的最后一个元素
# 9
print(arr2[-1])
# 数组的第一行 添加一个元组访问多维数组 元组括号可以省略
# [0 1 2 3 4]
print(arr2[:5])
# 切片访问 第0个到第4个元素
# [0 1 2]
print(arr2[0:3])
# 倒数访问
#[9 8 7 6 5 4 3 2 1 0]
print(arr2[::-1])
X = np.array([i for i in range(10)]).reshape(2,5)
# [[0 1 2 3 4]
# [5 6 7 8 9]]
print(X)
# 矩阵前一行 前两列
# [[0 1]]
print(X[:1,:2])
# 访问前一行 从头到尾间隔为2的元素
# [[0 2 4]]
print(X[:1,::2])
# 对于行都获取但是元素倒着取,对于列都获取但是元素倒着取
# [[9 8 7 6 5]
# [4 3 2 1 0]]
Xq = X[::-1,::-1]
print(Xq)
# 将列的数据重置为行的数据
# [[0]
# [1]
# [2]
# [3]
# [4]
# [5]
# [6]
# [7]
# [8]
# [9]]
print(X.reshape(10,-1))
# 将行数据重置为列数据
# [[0 1 2 3 4 5 6 7 8 9]]
print(X.reshape(-1,10))
#########矩阵合并与分隔############
x = np.array([1,2,3])
X = x.reshape(-1,3)
y = np.array([3,2,1])
Y = y.reshape(-1,3)
print('###########合并原始数据##############')
print(x)
print(X)
print(y)
print(Y)
print('###########合并原始数据##############')
#########合并############
# 合并两个数组
# [1 2 3 3 2 1]
print(np.concatenate((x,y)))
# 合并两个矩阵 axis = 0沿着行堆叠
# [[1 2 3]
# [3 2 1]]
print(np.concatenate((X,Y),axis=0))
# 合并两个矩阵 axis = 1沿着列堆叠
# [[1 2 3 3 2 1]]
print(np.concatenate((X,Y),axis=1))
# 合并矩阵与数组 沿Y轴合并 行堆叠
# [[1 2 3]
# [1 2 3]]
print(np.vstack((X,x)))
# 将两个矩阵在水平方向上堆叠 列堆叠
#[[1 2 3 3 2 1]]
print(np.hstack((X,Y)))
#########分隔############
N = np.array([1,2,3,4,5,6,7,8,9,10])
print("###########分隔原始数据##############")
print(N)
print("###########分隔原始数据##############")
# 分隔两个数组 从分隔点开始分隔
# [1 2 3] [4 5 6 7] [ 8 9 10]
x1,x2,x3 = np.split(N,[3,7])
print(x1,x2,x3)
# 矩阵切割
NN = np.arange(16).reshape(4,4)
print("原始分隔矩阵数据")
print(NN)
# 默认 水平方向分隔
A1,A2 = np.split(NN,[2])
# [[0 1 2 3]
# [4 5 6 7]]
print(A1)
# [[ 8 9 10 11]
# [12 13 14 15]]
print(A2)
# 默认 纵轴方向分隔
A3,A4 = np.split(NN,[2],axis=1)
# [[ 0 1]
# [ 4 5]
# [ 8 9]
# [12 13]]
print(A3)
# [[ 2 3]
# [ 6 7]
# [10 11]
# [14 15]]
print(A4)
# 在X轴方向分隔 2 表示 从角标0开始算 0,1 不包含角标2
upper,lower = np.vsplit(NN,[2])
# [[0 1 2 3]
# [4 5 6 7]]
print(upper)
# [[ 8 9 10 11]
# [12 13 14 15]]
print(lower)
# 在Y轴方向分隔 3 表示 从角标0开始算 0,1,2 不包含角标3
left,right = np.hsplit(NN,[3])
# [[ 0 1 2]
# [ 4 5 6]
# [ 8 9 10]
# [12 13 14]]
print(left)
# [[ 3]
# [ 7]
# [11]
# [15]]
print(right)
# 表示从后面往前倒数,获取最后一个角标的矩阵
left01,right01 = np.hsplit(NN,[-1])
# [[ 0 1 2]
# [ 4 5 6]
# [ 8 9 10]
# [12 13 14]]
print(left01)
# [[ 3]
# [ 7]
# [11]
# [15]]
print(right01)
###########numpy运算##############
# 原始数据
n = 10
L = [i for i in range(n)]
# univaltion
Q = np.arange(n)
# 乘法
print(np.multiply(L,2))
print(np.multiply(Q,2))
print(Q * 2)
# # 加法
print(np.add(Q,2))
print(Q + 2)
# # 减法
print(np.subtract(Q,1))
# # 除法
print(np.divide(Q,2))
# # 求平方根
print(np.sqrt(Q))
# # 求绝对值
print(np.abs(Q))
# # 求最大值
print(np.max(Q))
# # 求最小值
print(np.min(Q))
#正弦函数
print(np.sin(Q))
#############矩阵运算############
QQ1 = np.full((3,3),2)
QQ2 = np.full((3,3),3)
# 对应原始之间进行运算
print(QQ1 + QQ2)
print(QQ1 - QQ2)
print(QQ1 * QQ2)
print(QQ1 / QQ2)
# 正确矩阵相乘运算
print(QQ1.dot(QQ2))
# 矩阵转置 行变列 列变行
print(QQ1.T)
#############向量与矩阵进行运算################
v = np.array([1,2,3])
print(v)
# 向量与矩阵相乘 向量与矩阵每一行相应的数进行加法运算
print(v + QQ1)
# 结果
# [[3 4 5]
# [3 4 5]
# [3 4 5]]
# 向量与矩阵相乘
#QQ1.shape[0] 行数 QQ1.shape[1] 列数
print(QQ1.shape[0])
# 将v 向量摞多少行
print(np.vstack([v] * QQ1.shape[0]))
# 结果
# [[1 2 3]
# [1 2 3]
# [1 2 3]]
print(QQ1 + np.vstack([v] * QQ1.shape[0]))
#结果
# [[3 4 5]
# [3 4 5]
# [3 4 5]]
# 将v 向量在 行向量堆叠3次在列向量堆叠1次
print(np.tile(v,(3,1)))
#结果
# [[1 2 3]
# [1 2 3]
# [1 2 3]]
# 向量与矩阵之间的乘法,需要转换为矩阵与矩阵之间的乘法
print(v.dot(QQ1))
###########矩阵的逆##############
H = np.arange(4).reshape(2,2)
print(H)
#矩阵的逆矩阵
print(np.linalg.inv(H))
#结果
# [[0 1]
# [2 3]]
# *
# [[a b]
# [c d]]
# =
# [[0 1] 单位矩阵
# [1 0]]
# 得出逆矩阵
# [[-1.5 0.5]
# [ 1. 0. ]]
# 很多情况下方正 才有逆矩阵,但是在机器学习中很多不是逆矩阵但是也需要求逆矩阵,
# 产生伪逆矩阵
HQ = np.arange(6).reshape(2,3)
print(HQ.shape)
print(np.linalg.pinv(HQ))
print(np.linalg.pinv(HQ).shape)
############聚合操作###############
L =np.random.random(100)
print(L)
# 求和
print(np.sum(L))
# 求平均值
print(np.mean(L))
# 求方差
print(np.var(L))
# 求标准差
print(np.std(L))
# 求最大值
print(np.max(L))
# 求最小值
print(np.min(L))
NS = np.arange(16).reshape(4,4)
print(NS)
# 矩阵求和
print(np.sum(NS))
# 沿着行求和
print(np.sum(NS,axis=0))
# 沿着列求和
print(np.sum(NS,axis=1))
# 求和的平均值
print(np.mean(NS))
# 求和的方差
print(np.var(NS))
# 求和的标准差
print(np.std(NS))
# 所有元素乘积
print(np.prod(NS + 1))
# 中位数 中位数 能比 平均值更好反应数据的特点
print(np.median(NS))
#索引
# 值在什么地方
x = np.random.normal(0,1,size = 1000000)
print(np.min(x))
print(np.argmin(x)) # 在哪个位置
#排序和使用索引
s = np.arange(16)
np.random.shuffle(s) # 打乱顺序
print(s)
s.sort() # 排序 注意:使用np.sort与 s.sort() 不同
print(s)
q = np.random.randint(10,size=(4,4))
print(q)
print(np.sort(q))
# 沿着行排序就是每一列排序
print(np.sort(q,axis=0))
# 沿着列排序就是每一行排序
print(np.sort(q,axis=1))
np.random.shuffle(q)
np.argsort(q)
o = np.random.randint(10,size=(4,4))
# 3左边都是比3小的对应索引,在右边的对应索引的值都是比3大的
print("=============")
print(o)
# 3左边都是比3小的对应索引值,在右边的对应索引值都是比3大的
print(np.partition(o,3))
# 3左边都是比3小的对应索引的值,在右边的对应索引的值都是比3大的
print(np.argpartition(o,3))
######################## Fancy Indexing ##################
P = np.arange(16)
print(P)
print(P[3])
# 等不长索引
print(P[3:9:2])
# 通过知道索引数字获取 指定索引的向量
ind = [3,5,8]
print(P[ind])
#通过指定二维数组索引,创建矩阵
index = np.array([[0,2],
[3,4]])
print(P[index])
#通过指定 行列的坐标获取坐标值
H = np.arange(16).reshape(4,4)
print(H)
row = np.array([0,1,2])
col = np.array([2,3,0])
print(H[row,col])
#前两行所在的列
print(H[:2,col])
###############批量比较#################
k = np.arange(16)
print(k)
print(k < 5)
# boolean矩阵
K = k.reshape(4,4)
print(K < 6)
#获取小于3的数量
print(np.sum(K < 3))
#获取小于3的非零元素数量
print(np.count_nonzero(K < 3))
#判断数字中是否有0元素
print(np.any(K < 3))
#判断所有元素是否都大于0
print(np.all(K > 0))
#判断沿着列的方向每一行有多少个偶数
print(np.sum(K % 2 ==0,axis=1))
#判断沿着行的方向每一列有多个个偶数
print(np.sum(K % 2 ==0,axis=0))
print(np.sum((K % 2 == 0) | (K > 10)))
#从数据表格中抽出一部分想要的数据
# [[ 0 1 2 3]
# [ 4 5 6 7]
# [ 8 9 10 11]
# [12 13 14 15]]
print(K)
print("======")
print(K[:,2])
print(K[2,:])
# [ True False False True]
print(K[:,3] % 3 == 0)
# [[ 0 1 2 3]
# [12 13 14 15]]
print(K[K[:,3] % 3 == 0,:])
numpy系统学习
于 2022-06-07 14:37:09 首次发布
本文介绍了NumPy库的基础用法,包括创建数组、零矩阵、全一矩阵、指定值矩阵,以及arange、linspace、random函数的使用。还涉及到了数组属性、数据访问、矩阵合并与分隔、基本数学运算和矩阵运算。此外,讲解了向量与矩阵的乘法、矩阵的逆、聚合操作和批量比较。内容详实,适合NumPy初学者。
摘要由CSDN通过智能技术生成