Numpy数组

# 导入Numpy数组时，给它起一个别名np
import numpy as np

# numpy数组只能容纳一种数据类型

# 整型numpy数组
arr1 = np.array([1, 2, 3, 4, 5])
print(arr1)
print(type(arr1))

# 浮点型numpy数组
arr2 = np.array([1.0, 2.0, 3.0])
print(arr2)
print(type(arr2))

# 往整型numpy数组里面插入浮点型，该浮点型会被截成整型
arr3 = np.array([1, 2, 3])
arr3[1] = 3.14
print(arr3)

# 往浮点型numpy数组里面插入整型，该整型会直接变成浮点型
arr4 = np.array([1.0, 2.0, 3.0])
arr4[1] = 3
print(arr4)

# 整型numpy数组和浮点型numpy数组之间的相互转化
# 标准方法.astype()方法
arr1_float = arr1.astype(float)
print(arr1_float)
arr2_int = arr2.astype(int)
print(arr2_int)

# 共同改变定理，在运算过程中自动升级
print(arr2_int + 4.0)  # 加法
print(arr2_int * 1.0)  # 乘法
print(arr2_int / 1)  # 除法
print(arr2_int + [1.0, 2.0, 3.0])  # 数组相加

# .zeros()演示一维数组，二维数组和三维数组
arr5_1 = np.zeros(3)  # 一维数组
arr5_2 = np.zeros((1, 3))  # 二维数组
arr5_3 = np.zeros((1, 1, 3))  # 三维数组
print(arr5_1)
print(arr5_2)
print(arr5_3)

# .shape属性查看数组的维度
print(arr5_1.shape)
print(arr5_2.shape)
print(arr5_3.shape)

# 不同维度数组之间的相互转换 .reshape()  给定其他维度的数组，剩下一个维度可以填-1，让它自己计算
arr6 = np.arange(10)  # 一维数组
print(arr6)
# 转化为二维数组
print(arr6.reshape((1, -1)))

arr7 = np.arange(10).reshape(2, 5)  # 二维数组
print(arr7)
# 转化为一维数组
print(arr7.reshape(-1))
# 一维数组称为向量，二维数组称为矩阵

# 创建指定元素的数组，.array()
# 向量
arr8 = np.array([1, 2, 3])
print(arr8)
# 行矩阵
arr9 = np.array([[1, 2, 3]])
print(arr9)
# 列矩阵
arr10 = np.array([[1], [2], [3]])
print(arr10)
# 矩阵
arr11 = np.array([[1, 2, 3], [4, 5, 6]])
print(arr11)

# 创建递增数组.arange()
arr12 = np.arange(10)  # 0开始，10之前结束
print(arr12)
arr13 = np.arange(10, 20)  # 10开始，20之前结束
print(arr13)
# 指定步长
arr14 = np.arange(1, 20, 2)  # 步长为2
print(arr14)

# 创建同值数组
# 全0数组 .zeros()
arr15 = np.zeros((1, 3))
print(arr15)
# 全1数组 .ones()
arr16 = np.ones((2, 3))
print(arr16)
# 全某值n数组 n*ones()
arr17 = 3.14 * np.ones((2, 3))
print(arr17)

# 随机创建数组 .random()
arr18 = np.random.random(5)  # 0-1随机分布的浮点型随机数组   形状为5的向量
print(arr18)

# 整数型随机数组
arr19 = np.random.randint(10, 100, (1, 15))  # 10到100，形状1行15列
print(arr19)

# 服从正太分布的随机数组
arr20 = np.random.normal(0, 1, (2, 3))  # 均值0，标准差1，形状2行3列
print(arr20)
arr21 = np.random.randn(2, 3)  # 无需传入正态参数，只需指定形状
print(arr21)

# numpy数组的索引  正访问从0开始，倒访问-1开始
arr22 = np.arange(1, 10)
print(arr22)
# 正访问
print(arr22[0])
# 倒访问
print(arr22[-1])
# 修改元素
arr22[1] = 100
print(arr22)

# 访问矩阵
arr23 = np.array([[1, 2, 3], [4, 5, 6]])
print(arr23)
print(arr23[0, 2])
print(arr23[1, -1])
# 修改元素
arr23[0, 2] = 100
print(arr23)

# 向量的花式索引
arr24 = np.arange(1, 100, 10)
print(arr24)
print(arr24[[0, 2]])  # 访问索引为0和索引为2的元素

# 矩阵的花式索引
arr25 = np.arange(1, 17).reshape(4, 4)  # 创建矩阵
print(arr25)
print(arr25[[0, 1], [0, 1]])  # 第一行第一列，第二行第二列
print(arr25[[0, 1, 2], [0, 1, 2]])  # 第一行第一列，第二行第二列,第三行第三列

# 修改元素
arr25[[0, 1, 2], [0, 1, 2]] = 100  # 修改第一行第一列，第二行第二列,第三行第三列
print(arr25)

# numpy数组切片
# 向量的切片
arr26 = np.arange(1, 10)
print(arr26)
print(arr26[0:1])
print(arr26[1:])
print(arr26[:])
print(arr26[2:-2])
print(arr26[2:])
print(arr26[:-2])
print(arr26[::2])
print(arr26[1:-1:2])

# 矩阵的切片
arr27 = np.arange(1, 10).reshape(3, 3)
print(arr27)
# 提取第二行
print(arr27[1, :])
# 提取第二列
print(arr27[:, 1])
# 提取第一行和第二行
print(arr27[0:2, :])
# 提取第一列和第二列
print(arr27[:, 0:2])
# 规范的提取行
print(arr27[1, :])
# 简单的提取行
print(arr27[1])
# 规范的提取列
print(arr27[:, 1])  # 不能简单的提取列
print(arr27[:, 1].reshape(-1, 1))

# numpy数组切片仅时视图
# 对切片的数值进行改变，原数组的数值也会被改变
arr28 = np.arange(1, 10)
print(arr28)
cut = arr28[0:3]
print(cut)
cut[0] = 100
print(cut)
print(arr28)

# 将切片变为新的变量  用.copy()方法
arr29 = np.arange(1, 10)
print(arr29)
cut1 = arr29[0:3].copy()
print(cut1)
cut1[0] = 100
print(cut1)
print(arr29)

# numpy数组之间的赋值
# 把数组1赋值给数组2，修改数组2，原数组1也会被修改
arr30 = np.arange(1, 10)
print(arr30)
arr30_1 = arr30
print(arr30_1)
arr30_1[0] = 100
print(arr30_1)
print(arr30)

# 赋值数组为新变量  用.copy()方法
arr31 = np.arange(1, 10)
print(arr31)
arr31_1 = arr31.copy()
print(arr31_1)
arr31_1[0] = 100
print(arr31_1)
print(arr31)

# 数组的转置  用.T
# 向量无法直接转置，必须将变量转化为数组才能转置
arr32 = np.arange(0, 3)
print(arr32)
arr32_1 = arr32.reshape(1, -1)
print(arr32_1)  # 行矩阵
print(arr32_1.T)  # 行矩阵的转置

# 列矩阵的转置
arr32_2 = np.arange(0, 3).reshape(3, 1)
print(arr32_2)
print(arr32_2.T)

# 矩阵的转置
arr33 = np.arange(0, 4).reshape(2, 2)
print(arr33)
print(arr33.T)

# 数组的翻转   上下翻转np.flipud()   左右翻转np.fliplr()
# 向量的翻转 只能上下翻转
# 因为在数学中向量并不是横着排的，而是竖着排的
arr34 = np.arange(1, 10)
print(arr34)
arr34_flipud = np.flipud(arr34)
print(arr34_flipud)

# 矩阵的翻转
arr35 = np.arange(1, 10).reshape(3, 3)
print(arr35)
arr35_flipud = np.flipud(arr35)
print(arr35_flipud)
arr35_fliplr = np.fliplr(arr35)
print(arr35_fliplr)

# 改变数组的形状：.reshape()
# 给定其他维度的数值，剩下一个维度可以填-1，让它自己去计算
# 向量的变形
arr36 = np.arange(1, 10).reshape(3, 3)
print(arr36)
# 矩阵的变形
arr37 = np.arange(1, 10).reshape(3, 3).reshape(9).reshape(1, 9)
print(arr37)

# 数组的拼接 用np.concatenate函数
# 向量的拼接，得到一个加长版的向量
arr38 = np.arange(1, 10)
arr38_2 = np.arange(11, 20)
arr38_3 = np.concatenate([arr38, arr38_2])
print(arr38_3)
# 数组的拼接   按行拼接    默认axis=0
arr39 = np.arange(1, 10).reshape(3, 3)
arr39_2 = np.arange(11, 20).reshape(3, 3)
arr39_3 = np.concatenate([arr39, arr39_2])
print(arr39_3)
# 按列拼接
arr40 = np.arange(1, 10).reshape(3, 3)
arr40_2 = np.arange(11, 20).reshape(3, 3)
arr40_3 = np.concatenate([arr40, arr40_2], axis=1)
print(arr40_3)

# 数组的分裂
# 向量的分裂，np.split()函数
# 把一个长的向量分裂成若干个短的向量
arr41 = np.arange(1, 10)
arr41_1, arr41_2, arr41_3 = np.split(arr41, [2, 8])
# np.split()函数中，给出的第二个参数[2,8]表示在索引[2]和索引[8]的位置截断
print(arr41_1)
print(arr41_2)
print(arr41_3)
# 矩阵的分裂  分裂出来的还是一个矩阵
arr42 = np.arange(1, 10).reshape(3, 3)
# 按行分裂 默认axis=0
arr42_1, arr42_2 = np.split(arr42, [1])
print(arr42_1)
print(arr42_2)

# 按列分裂   axis=1
arr42_3, arr42_4 = np.split(arr42, [1], axis=1)
print(arr42_3)
print(arr42_4)

# 数组的运算
# 数组与系数之间的运算
# 以矩阵为例，向量与之相同
arr43 = np.arange(1, 10).reshape(3, 3)
# 加法
print(arr43 + 10)
# 减法
print(arr43 - 10)
# 乘法
print(arr43 * 10)
# 除法
print(arr43 / 10)
# 平方
print(arr43 ** 2)
# 取整
print(arr43 // 10)
# 取余
print(arr43 % 10)

# 数组与数组之间的运算
# 以矩阵为例，向量与之相同
arr44 = np.arange(1, 10).reshape(3, 3)
arr44_1 = np.arange(11, 20).reshape(3, 3)
# 加法
print(arr44 + arr44_1)
# 减法
print(arr44 - arr44_1)
# 乘法
print(arr44 * arr44_1)
# 除法
print(arr44 / arr44_1)
# 幂方
print(arr44 ** arr44_1)

# 不同形状的数组之间的运算
# 如果是向量和矩阵做运算，向量自动升级为行矩阵
# 如果某矩阵是行矩阵或列矩阵，则其被广播，以适配另一个矩阵的形状

# 向量被广播
arr45 = np.array([-100, 0, 100])
arr45_1 = np.random.random((10, 3))
print(arr45 * arr45_1)

# 矩阵被广播  (x,1)的列矩阵
arr46 = np.arange(3).reshape(3, 1)
arr46_1 = np.ones((3, 5))
print(arr46 * arr46_1)

# 行矩阵和列矩阵同时被广播  (x,1)的列矩阵，(1,y)的行矩阵
arr47 = np.arange(3)
arr47_1 = np.arange(3).reshape(3, 1)
print(arr47 * arr47_1)

# 矩阵乘法  np.dot()函数
# 向量与向量的乘积
arr48 = np.arange(3)
arr48_1 = np.arange(3)
print(np.dot(arr48, arr48_1))

# 向量与矩阵的乘积
arr49 = np.arange(3)
arr49_1 = np.arange(1, 10).reshape(3, 3)
print(np.dot(arr49, arr49_1))
# 矩阵与向量的乘积
arr50 = np.arange(1, 10).reshape(3, 3)
arr50_1 = np.arange(3)
print(np.dot(arr50, arr50_1))
# 矩阵与矩阵的乘积
arr51 = np.arange(1, 10).reshape(3, 3)
arr51_1 = np.arange(11, 20).reshape(3, 3)
print(np.dot(arr51, arr51_1))

# 数学函数
# 绝对值函数  np.abs()
arr52 = np.array([-100, 0, 100])
arr52_abs = np.abs(arr52)
print(arr52_abs)
# 三角函数 正弦值 余弦值 正切值
arr53 = np.arange(1, 10)
arr53_sin = np.sin(arr53)
arr53_cos = np.cos(arr53)
arr53_tan = np.tan(arr53)
print(arr53_sin)
print(arr53_cos)
print(arr53_tan)
# 指数函数  以e为底np.exp()函数，以2为底，以10为底
arr54 = np.arange(1, 10)
arr54_e = np.exp(arr54)
arr54_2 = 2 ** arr54
arr54_10 = 10 ** arr54
print(arr54_e)
print(arr54_2)
print(arr54_10)
# 对数函数 以e为底，以2为底，以10为底
arr55 = np.arange(1,10)
arr55_e=np.log(arr55)
arr55_2=np.log(arr55)/np.log(2)
arr55_10=np.log(arr55)/np.log(10)
print(arr55_e)
print(arr55_2)
print(arr55_10)

#聚合函数
#以矩阵为例，向量与之一致
#最大值函数np.max()和最小值函数np.min()
arr56 = np.random.random((2,3))
print(arr56)
print("按列求最大值",np.max(arr56,axis=0))
print("按行求最大值",np.max(arr56,axis=1))
print("整体求最大值",np.max(arr56))

#求和函数np.sum()，求积函数np.prod()
arr57 = np.random.random((2,3))
print(arr57)
print("按列求和",np.sum(arr57,axis=0))
print("按行求和",np.sum(arr57,axis=1))
print("整体求和",np.sum(arr57))

#均值函数np.mean()和标准差函数np.std()
arr58 = np.random.random((2,3))
print(arr58)
print("按列求均值",np.mean(arr58,axis=0))
print("按行求均值",np.mean(arr58,axis=1))
print("整体求均值",np.mean(arr58))

#聚类函数的安全版本，即计算时忽略缺失值
#np.nansum(),np.nanprod(),np.nanmean().np.nanstd(),np.nanmax(),np.nanmin()

#布尔型数组
#创建布尔型数组
#将数组与系数做比较，以产生布尔型数组
arr59 = np.arange(1,10).reshape(3,3)
print(arr59>=4)
#将同维数组作比较，以产生布尔型数组
arr60=np.arange(1,10)
arr60_flipup=np.flipud(arr60)
print(arr60>arr60_flipup)
#同时比较多个条件  与 and $, 或 or |  非 not ~
arr61=np.arange(1,10)
print((arr61<4)|(arr61>6))

#布尔数组中True的数量
#np.sum()函数：统计布尔数组中True的个数
#创建一个标准形状为10000的标准正态分布数组
#统计该分布中绝对值小于1的元素个数
arr62=np.random.normal(0,1,10000)
num=np.sum(np.abs(arr62)<1)
print(num)

#np.any()函数，只要布尔型数组里含有一个及其以上的True，就返回True
#创建同维数组，统计这两个数组里面是否有相同的元素
arr62=np.arange(1,10)
arr62_flipup=np.flipud(arr62)
print(np.any(arr62==arr62_flipup))
#np.all()函数，当布尔型数组里全是True时，才返回True
#模拟英语六级成绩，创建100000个样本，判断是否所有考生的分数都高于250
arr63=np.random.normal(500,70,100000)
print(np.all(arr63>250))

#布尔型数组作为掩码
#若一个普通数组和一个布尔型数组的维度相同，可以将布尔型数组作为普通数组的掩码，这样可以对普通数组中的元素做筛选
#示例一：筛选出数组中大于、等于或小于某个数字的元素
arr64=np.arange(1,10).reshape(3,3)
print(arr64)
print(arr64>4)
print(arr64[arr64>4])
#示例二：筛选出数组逐元素比较的结果
arr65_1=np.arange(1,10).reshape(3,3)
arr65_2=np.arange(11,20).reshape(3,3)
print(arr65_1>arr65_2)
print(arr65_1[arr65_1>arr65_2])
print(arr65_2[arr65_1>arr65_2])

#确定满足条件的元素所在位置
#情况：假设一个很长的数组，我想知道满足某个条件的元素所在的索引位置，此时使用np.where()函数
#模拟英语英语六级成绩的随机数组
arr66=np.random.normal(700,50,10000)
#找出六级成绩超过650的元素所在位置
print(np.where(arr66>650))
#找出六级成绩最高分的元素所在位置
print(np.where(arr66==np.max(arr66)))

#数组和张量
#NumPy和PyTorch的基础语法几乎一致，具体表现为：
#np对应torch
#数组array对应张量tensor
#NumPy的n维数组对应着PyTorch的n阶张量
#数组和张量之间可以互相转换
#数组arr转为张量ts:ts=torch.tensor(arr)
#张量ts转为数组arr:arr=np.array(ts)