numpy系统学习

# !/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,:])