Python-科学计算库 Numpy

ndarray 的简单特性

• ndarray是 Numpy 中的 array（下文的 array 全部为 ndarray）， 可以直接进行加减乘除。

array = np.array([1,2,3,4,5])
print('numpy 中的 array 格式：',type(array))
print(array + 1)

• 查看数组、矩阵的结构（几行几列）

array.shape

• 可以将 list 直接转换为 ndarray

array 结构相关

一维

• array 默认要求内部所有的数据元素的数据类型是相同的（可以通过参数进行设置）
• 属性名称以及对应表示

tang_list = [1,2,3,4,5]
tang_array = np.array(tang_list)
#输出数据类型
print(tang_array.dtype)
print('每个 int 占多少个字节：',tang_array.itemsize)
print('tang_array 的结构（行，列）：',tang_array.shape)
print('tang_array 的元素个数：',tang_array.size)
print('tang_array 的维数：',tang_array.ndim)
# tang_array.fill(0)#全部填充 0
#索引与切片和 python 一样
print('tang_array 的索引：',tang_array[0])
print('tang_array 的切片：',tang_array[1:3])
print('tang_array 的切片：',tang_array[-2:])

二维（矩阵形式）

• 、索引方式、复制

#二维矩阵
tang_array = np.array([[1,2,3],
                       [4,5,6],
                       [7,8,9]])
print('tang_array 的结构（行，列）：',tang_array.shape)
print('tang_array 的元素个数：',tang_array.size)
print('tang_array 的维数：',tang_array.ndim)
print(tang_array[1][1])
tang_array[1][1] = 10
print(tang_array[1][1])
print('取第一行的值：',tang_array[1])
print('取第一列的值：',tang_array[:,1])
print('tang_array：\n',tang_array)
print('取第一列的前两个值：',tang_array[0:2,1])
print('取第一行前两个的值：',tang_array[0,0:2])
print('\n')

# 等号赋值是直接指向 tang_array 的位置
tang_array2 = tang_array
tang_array2[1][1] = 100
print('等号直接赋值：\n')
print('矩阵 array_tang ：\n',tang_array)
print('\n')
print('矩阵 array_tang2 ：\n',tang_array2)
print('\n')

#使用 copy 进行复制，两个矩阵互不干扰
tang_array2 = tang_array.copy()
tang_array2[1][1] = 1000
print('copy 进行复制：\n')
print('矩阵 array_tang ：\n',tang_array)
print('\n')
print('矩阵 array_tang2 ：\n',tang_array2)
print('\n')

ndarray 的索引和改变数据类型

• ndarray 的索引其实可以是 bool 数组，返回 true 的索引所在的数据

#构造十个等差数组,左闭右开
c_arr = np.arange(0,100,10)
print('构造等差数组:',c_arr)
print('\n')

#将 bool 类型数组作为索引
mask = np.array([0,0,0,1,1,1,0,0,0,1],dtype = bool)
print('将 bool 类型数组作为索引:',c_arr[mask])
mask = c_arr > 50
print('将 bool 类型数组作为索引输出大于 50 的数:',c_arr[mask])
print('输出大于 50 的索引:',np.where(c_arr > 50))
print('将 bool 类型数组作为索引输出大于 50 的数:',c_arr[c_arr > 50])
print('\n')

#指定 np.array 的格式
c_arr = np.array([1,2,3,4,5],dtype = np.float32)
print(c_arr)
print('c_arr 的类型：',c_arr.dtype)
print('c_arr 所占的总字节数：',c_arr.nbytes)

#什么格式都可以的 ndarray
c_arr = np.array([1,2,3.5,"str"],dtype = object)
print('c_arr:',c_arr)

#改变数据类型同时进行复制  np.asarray(c_arr,dtype = np.float32)
c_arr = np.array([1,2,3,4,5])
c_arr2 = np.asarray(c_arr,dtype = np.float32)
print('np.asarray()不会修改原有数据（貌似所有的这些函数都不会修改原有数据）:',np.asarray(c_arr,dtype = np.float32))
print('c_arr:',c_arr)
print('复制并转换数据类型后的结果：',c_arr2)

#直接改变数据类型
print('直接改变数据类型(原始的 c_arr 不变，想要操作新的 ndarray，可以设置新的ndarray):',c_arr.astype(np.float32))
print('\n')

array数组、矩阵便捷的计算函数

• 行相加、列相加、最大值、最小值、最大值索引、最小值索引、平均值、标准差、方差、添加限制

#怎么计算的
c_arr = np.array([[1,2,3],[4,5,6]])
print(np.sum(c_arr))

#指定要进行的操作按什么维度进行
print("行相加：",np.sum(c_arr,axis = 0))
print('维度共有：',c_arr.ndim)
print('列相加：',np.sum(c_arr,axis = 1))
print('列相加：',np.sum(c_arr,axis = -1))
print('\n')

print('相乘：',c_arr.prod())
print("行相乘：",c_arr.prod(axis = 0))
print('列相乘：',c_arr.prod(axis = 1))
print('\n')

print("最小值：",c_arr.min())
print("最小行：",c_arr.min(axis = 0))
print('最小列：',c_arr.min(axis = 1))
print('\n')

print("最大值：",c_arr.max())
print("最大行：",c_arr.max(axis = 0))
print('最大列：',c_arr.max(axis = 1))
print('\n')

print("最大值的索引：",c_arr.argmax())
print("行中最大的索引：",c_arr.argmax(axis = 0))
print('列中最大的索引：',c_arr.argmax(axis = 1))
print('\n')

print("平均值：",c_arr.mean())
print("行平均值：",c_arr.mean(axis = 0))
print('列平均值：',c_arr.mean(axis = 1))
print('\n')

print("标准差：",c_arr.std())
print("行标准差：",c_arr.std(axis = 0))
print('列标准差：',c_arr.std(axis = 1))
print('\n')

print("方差：",c_arr.var())
print("行方差：",c_arr.var(axis = 0))
print('列方差：',c_arr.var(axis = 1))
print('\n')

# 添加限制
c_arr = np.array([[1.1,2.4,3.6],[4.5,5.4,6.3]])
print("矩阵中小于 2 的全部为 2，大于 4 的全部为 4：\n",c_arr.clip(2,4))
print("四舍五入：\n",c_arr.round())
print("四舍五入添加精度：\n",c_arr.round(decimals = 1))
print('\n')

数组形状操作（修改维度）

#生成 0~9 的 一维 ndarray
c_arr = np.arange(10)
print('c_arr 的维度：\n',c_arr.shape)
#修改成二维的 ndarray,大小不能改变
c_arr.shape = 2,5
print('c_arr 两行五列：\n',c_arr)
c_arr = c_arr.reshape(1,10)
print('c_arr ：\n',c_arr.reshape(1,10))
print('\n')

print('c_arr 的维度：\n',c_arr.shape)
print('c_arr 删除多余的维度之后：\n',c_arr.squeeze())
print('c_arr 删除多余的维度之后的维度：\n',c_arr.shape)
print('\n')

#添加新维度,这些函数直接调用是不改变原来的样子的，需要调用之后再重新赋值给本身
c_arr = c_arr[np.newaxis,:]
print('c_arr 添加新维度 的维度：\n',c_arr.shape)
print('c_arr 删除多余的维度之后：\n',c_arr.squeeze())
c_arr = c_arr.squeeze()
print('c_arr 删除多余的维度之后的维度：\n',c_arr.shape)
print('\n')

#转置
c_arr = np.arange(10)
c_arr.shape = 2,5
c_arr = c_arr.transpose()
print('c_arr 转置之后：\n',c_arr)
#转置简便表示 T
c_arr = c_arr.T
print('c_arr 再转置之后：\n',c_arr)

数组的连接

• 可以竖着拼接，横着拼接，也可以拉平

a = np.array([[1,2,3],[4,5,6]])
b = np.array([[11,22,33],[44,55,66]])
#必须在括号里写成元组的形式
c = np.concatenate((a,b))#默认 axis = 0
# c = np.vstack((a,b))
print('竖着拼接：\n',c)

c = np.concatenate((a,b),axis = 1)
# c = np.hstack((a,b))
print('横着拼接：\n',c)

#拉平 a.flatten() a.ravel() a 不变
print('拉平：\n',a.flatten())
print('拉平：\n',a.ravel())
print('a不变：\n',a)

数组、网格、向量、单位矩阵的构造

c_arr = np.arange(2,20,2,dtype = np.float32)
print('2~20之间，步长为 2 的数：\n',c_arr)
c_arr = np.linspace(0,10,50)
# print('0~10之间的五十个间距相等的数:\n',c_arr)
c_arr = np.logspace(0,1,5)
print('默认以十为底，输出值在 0~1 之间的x',c_arr)
print('\n')

#构造一个二维的网格 linspace
x = np.linspace(-10,10,5)
y = np.linspace(-10,10,5)
x,y = np.meshgrid(x,y)
print(x)
print(y)
print('\n')

#构造一个行向量/列向量
c_arr = np.r_[0:10:1]
print('构造一个行向量：\n',c_arr)

c_arr = np.c_[0:10:1]
print('构造一个列向量：\n',c_arr)
print('\n')

#更常用的构造 zeros ones，建立一个新的数组常用
c_arr = np.zeros(3)
print('构造一个0数组：\n',c_arr)
c_arr = np.zeros((3,3))
print('构造一个0数组：\n',c_arr)

c_arr = np.ones((3,3))
print('构造一个1数组：\n',c_arr)
c_arr = np.ones((3,3)) * 8
print('构造一个8数组：\n',c_arr)
print('\n')

#构造一个空数组，之后往里面填充
c_arr = np.empty(6)
c_arr.fill(1)
print('构造一个空数组：\n',c_arr)
print('\n')

#zeros_like ones_like 生成与用于计算的矩阵的大小比例相同的全新矩阵
c_arr = np.arange(2,20,2,dtype = np.float32)
print('c_arr 数组:\n',c_arr)
c_arr_zeroslike = np.zeros_like(c_arr)
print('构造一个和 c_arr 一样大小比例的0数组 c_arr_zeroslike：\n',c_arr_zeroslike)
c_arr_oneslike = np.ones_like(c_arr)
print('构造一个和 c_arr 一样大小比例的1数组 c_arr_oneslike：\n',c_arr_oneslike)
print('\n')

#生成一个单位矩阵
c_arr = np.identity(5)
print('c_arr 5*5 单位矩阵:\n',c_arr)

运算

x = np.array([1,2])
y = np.array([3,4])
z = np.multiply(x,y)
print('对应元素相乘：',z)
z = np.dot(x,y)
print('两向量相乘（内积）：',z)

#矩阵相乘
x.shape = 2,1
y.shape = 1,2
z = np.dot(x,y)
print('两矩阵相乘：\n',z)
z = np.dot(y,x)
print('两矩阵相乘：\n',z)

# *
x = np.array([1,1,1])
y = np.array([[1,2,3],[4,5,6]])
print('* 也可以相乘，Numpy 会自动补全维度，但是不要图省事',x * y)

#数组之间的判断操作
x = np.array([1,1,1])
y = np.array([1,1,1])
print(x == y)
print('矩阵之间的与操作',np.logical_and(x,y))
print('矩阵之间的或操作',np.logical_or(x,y))
print('矩阵之间的非操作',np.logical_not(x,y))

随机模块

• 初始化时使用随机生成的矩阵，然后对矩阵进行更新

#所有的值都是 0~1 之间的
c_arr = np.random.rand(3,2)
print('随机生成的 0~1 之间的 3 行 2 列 浮点数',c_arr)

#返回的随机数是整数，左闭右开
c_arr = np.random.randint(10,size=(5,4))
print('随机生成的 0~10 之间的 5 行 4 列 整数',c_arr)

# 随机获取 0~1 之间的浮点数
print(np.random.rand())
print(np.random.random_sample())

#生成整数
print('随机生成的 0~10 之间的3个整数',np.random.randint(0,10,3))

# 高斯分布 （我们可以制定很多随机的分布）
mu,sigma = 0,0.1
print('高斯分布',np.random.normal(mu,sigma,10))

#设置 Numpy 中的参数
np.set_printoptions(precision = 2)
print('设置完参数的高斯分布',np.random.normal(mu,sigma,10))

#洗牌 np.random.shuffle(c_arr) 这个函数是会修改原有函数的
c_arr = np.arange(10)
np.random.shuffle(c_arr)
print('洗过牌之后的 shuffle_arr：\n',c_arr)

# 随机的种子 那么接下来生成的随机数就固定了，想看其中某一个参数对实验结果的影响，就得保证其他参数不变
np.random.seed(100)
mu,sigma = 0,0.1
print('高斯分布',np.random.normal(mu,sigma,10))

文件的读写

• Numpy 可以直接读取文件，设置间隔符读取文件，限定行数读取文件
• 保存 array ，设置间隔符、数据类型、小数点位数
• 保存 成 npy 或者 npz（保存成多个文件并且放置在一起） 格式