Numpy学习总结

Python-科学计算库 Numpy

ndarray 的简单特性

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

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

<class ‘numpy.ndarray’>
[2 3 4 5 6]

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

array.shape

(5,)

• 可以将 list 直接转换为 ndarray

array 结构相关

大家关注的可能还是 ndarray 关于矩阵方面的操作

一维

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

目的	方式
数据类型	.dytype
结构（行列）	.shape
元素个数	.size
每个元素所占的字	.itemsize
维数	.ndim
索引	[0]
切片	[1:3] 或者 [-2:]
总字节数	.nbytes
在[0~100)中构造十个等差数列	np.arange(0,100,10)

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[1])
	print(‘取第一列的值：’,tang_array[:,1])
	print(‘取第一列的前两个值：’,tang_array[0:2,1])
	print(‘取第一行前两个的值：’,tang_array[0,0:2])
等号赋值	# 等号赋值是直接指向 tang_array 的位置
	tang_array2 = tang_array
（创建一个新矩阵进行操作，不修改原有矩阵）	#使用 copy 进行复制，两个矩阵互不干扰
	tang_array2 = tang_array.copy()

#二维矩阵
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[mask]
	np.where(c_arr > 50))
	c_arr[c_arr > 50]
制定 ndarray 的数据类型	c_arr = np.array([1,2,3,4,5],dtype = np.float32)
什么格式都可以的 ndarray	c_arr = np.array([1,2,3.5,“str”],dtype = object)
改变数据类型（直接.astype 不会改变其类型，需要重新赋值）	c_arr = c_arr.astype(np.float32)
改变数据类型同时进行复制	c_arr2 = np.asarray(c_arr,dtype = np.float32)

#构造十个等差数组,左闭右开
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]])
所有元素求和	np.sum(c_arr)
行相加	np.sum(c_arr,axis = 0)
列相加	np.sum(c_arr,axis = 1)
	np.sum(c_arr,axis = -1)
所有元素	以下括号中 axis = 0 为行相关 axis = 1 为列相关
相乘	c_arr.prod()
最小值	c_arr.min()
最大值	c_arr.max()
返回最大值索引	c_arr.argmax()
平均值	c_arr.mean()
标准差	c_arr.std()
方差	c_arr.var()
对所有元素添加限制（过滤）
矩阵中小于 2 的全部为 2，大于 4 的全部为 4	c_arr.clip(2,4)
四舍五入	c_arr.round()
四舍五入添加精度	c_arr.round(decimals = 1)

#怎么计算的
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)
修改成二维的 ndarray,元素总量相等	c_arr.shape = 2,5
	c_arr = c_arr.reshape(1,10)
添加新维度	c_arr = c_arr[np.newaxis,:]
	np.newaxis的插入位置即你想添加的维度位置（这个用法还比较迷）
删除多余的维度之后	c_arr.squeeze()
转置	c_arr = c_arr.transpose()
转置简便表示 T	c_arr = c_arr.T

#生成 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)

数组的连接

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

目的	方式
竖着拼接	c = np.concatenate((a,b))#默认 axis = 0
	c = np.vstack((a,b))
横着拼接	c = np.concatenate((a,b),axis = 1)
	c = np.hstack((a,b))
拉平	a.flatten()
	a.ravel()

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)

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

目的	方式
2~20之间，步长为 2 的数组	c_arr = np.arange(2,20,2,dtype = np.float32)
0~10之间的五十个间距相等的数	c_arr = np.linspace(0,10,50)
默认以十为底，输出值在 0~1 之间的x	c_arr = np.logspace(0,1,5)
构造一个二维的网格 linspace	x = np.linspace(-10,10,5)
	y = np.linspace(-10,10,5)
	x,y = np.meshgrid(x,y)
行向量/列向量	c_arr = np.r_[0:10:1]
	c_arr = np.c_[0:10:1]
构造一个零数组/矩阵	c_arr = np.zeros(3)
	c_arr = np.zeros((3,3))
构造一个一数组/矩阵	c_arr = np.ones((3,3))
构造一个空数组/矩阵	c_arr = np.empty(6)
构造单位矩阵	c_arr = np.identity(5)

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)

运算

目的	方式
对应元素相乘 *	z = np.multiply(x,y)
	z = x * y
两向量相乘（内积）/矩阵相乘	z = np.dot(x,y)
判断操作	np.logical_and(x,y)
	np.logical_or(x,y)
	np.logical_not(x,y)

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 之间的 3 行 2 列 浮点数	c_arr = np.random.rand(3,2)
随机获取 0~1 之间的浮点数	np.random.rand()
	np.random.random_sample()
随机生成的 0~10 之间的 5 行 4 列 整数	c_arr = np.random.randint(10,size=(5,4))
随机生成的 0~10 之间的3个整数	np.random.randint(0,10,3)
高斯分布	mu,sigma = 0,0.1
	'print(‘高斯分布’,np.random.normal(mu,sigma,10))
设置 打印 参数	np.set_printoptions(precision = 2)
洗牌 会修改原有值	np.random.shuffle(c_arr)
随机的种子（生成的随机数就固定了）	np.random.seed(100)

#所有的值都是 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（保存成多个文件并且放置在一起） 格式

目的	方式
读取文件	data = np.loadtxt(‘c.txt’)
	默认分隔符为空格
指定分隔符	data = np.loadtxt(‘c2.txt’,delimiter = ‘,’)
指定分隔符且去掉第一行	data = np.loadtxt(‘c3.txt’,delimiter = ‘,’,skiprows = 1)
numpy 保存数据	np.savetxt(‘c4.txt’,c_arr,fmt = ‘%.2f’,delimiter = ‘,’)
将 c和 c2 保存在同样一个压缩文件中	np.savez(‘c.npz’,a = c,b = c2)
读取 npz 中的数据	data = np.load(‘c.npz’)
	print(‘data 中有什么：\n’,data.keys())
	print(‘data 中a 文件内有什么：\n’,data[‘a’])