numpy作业
numpy中常用操作
代码及注释
#垂直拆分，水平拆分
c = np.arange(1,13).reshape(6,2)#np.reshape()
print(c)
print(np.vsplit(c,3))#np.vsplit(),垂直拆分
d = c.T
print(d)
print(np.hsplit(d,3))#np.hspilt()水平拆分
e = np.array([
[[11, 21],
[12, 22],
[13, 23]],
[[14, 24],
[15, 25],
[16, 26]],
[[17, 27],
[18, 28],
[19, 29]]])
print(np.dsplit(e,2))#np.dsplit()
运行结果：
[[ 1 2]
[ 3 4]
[ 5 6]
[ 7 8]
[ 9 10]
[11 12]]
[array([[1, 2],
[3, 4]]), array([[5, 6],
[7, 8]]), array([[ 9, 10],
[11, 12]])]
[[ 1 3 5 7 9 11]
[ 2 4 6 8 10 12]]
[array([[1, 3],
[2, 4]]), array([[5, 7],
[6, 8]]), array([[ 9, 11],
[10, 12]])]
[array([[[11],
[12],
[13]],
[[14],
[15],
[16]],
[[17],
[18],
[19]]]), array([[[21],
[22],
[23]],
[[24],
[25],
[26]],
[[27],
[28],
[29]]])]
代码及注释
#numpy基本加减和取行操作
a = np.array([1,1,1,1])
b = np.array([[1],[1],[1],[1]])
print(a + b)
c = np.array([[1,1,1,1]])
print(b + c)
w = np.array([[1,1,1],[2,2,2]])
print(w[:1])#取得w第一列，返回的是一维数组
print(w[1])#取第一行，返回的也是一维数组
w[:,1] = np.array([5,5])#直接把矩阵的第二列替换
print(w)
运行结果
[[2 2 2 2]
[2 2 2 2]
[2 2 2 2]
[2 2 2 2]]
[[2 2 2 2]
[2 2 2 2]
[2 2 2 2]
[2 2 2 2]]
[[1 1 1]]
[2 2 2]
[[1 5 1]
[2 5 2]]
代码及注释
#矩阵删除、插入、尾部添加(delete,insert,append)
#numpy.delete(arr, obj, axis)
#arr：需要处理的矩阵obj：在什么位置处理axis：这是一个可选参数，axis = None，1，0
#axis=None：arr会先按行展开，然后按照obj，删除第obj-1（从0开始）位置的数，返回一个行矩阵。
#axis = 0：arr按行删除，axis = 1：arr按列删除
matrix = np.array([[1,2,3,4],[5,6,7,8],[9,10,11,12]])
print(matrix)
print(np.delete(matrix,1,0))
print(np.delete(matrix,1,1))
print(np.delete(matrix,5))
print(np.delete(matrix,[0,1],1))
#numpy.insert(arr,obj,value,axis=None)
#arr 为目标向量，obj 为目标向量的axis维度的目标位置，value 为插入的数值，axis 为想要插入的维
print(np.insert(matrix,1,[1,1,1,1],0))
print(np.insert(matrix,0,[1,1,1],1))
print(np.insert(matrix,3,[1,1,1,1],0))
#numpy.append(arr,values,axis=None)
#将values插入到目标arr的最后，其中values与arr应该有相同维度
print(np.append(matrix,[[1,1,1,1]],axis=0))
print(np.append(matrix,[[1],[1],[1]],axis=1))
print(np.append(matrix,[1,1,1,1]))
运行结果
[[ 1 2 3 4]
[ 5 6 7 8]
[ 9 10 11 12]]
[[ 1 2 3 4]
[ 9 10 11 12]]
[[ 1 3 4]
[ 5 7 8]
[ 9 11 12]]
[ 1 2 3 4 5 7 8 9 10 11 12]
[[ 3 4]
[ 7 8]
[11 12]]
[[ 1 2 3 4]
[ 1 1 1 1]
[ 5 6 7 8]
[ 9 10 11 12]]
[[ 1 1 2 3 4]
[ 1 5 6 7 8]
[ 1 9 10 11 12]]
[[ 1 2 3 4]
[ 5 6 7 8]
[ 9 10 11 12]
[ 1 1 1 1]]
[[ 1 2 3 4]
[ 5 6 7 8]
[ 9 10 11 12]
[ 1 1 1 1]]
[[ 1 2 3 4 1]
[ 5 6 7 8 1]
[ 9 10 11 12 1]]
[ 1 2 3 4 5 6 7 8 9 10 11 12 1 1 1 1]
代码及注释
#np.random.choice(a,size,replace,p)
#其作用是按要求生成一个一维数组,a是生成一维数组的来源，可以是int类型，可以是数组，也可以是list
# size 数组的维度replace 表示从a中是否不重复抽取，默认可重复 p 给出抽取概率，默认随机
print(np.random.choice(7,5))
print(np.random.choice([0,1,2,3,4,5,6],5))
print(np.random.choice(np.array([0,1,2,3,4,5,6]),5))
print(np.random.choice([0,1,2,3,4,5,6],5,replace=False))
print(np.random.choice(np.array([0,1,2,3,4,5,6]),5,p = [0.1,0.1,0.1,0.1,0.1,0.1,0.4]))
运行结果
[4 2 2 5 3]
[0 6 2 2 6]
[5 6 4 5 5]
[5 2 4 1 6]
[2 6 0 3 6]
代码及注释
# np.argmax(a, axis=None, out=None)
# 作用是返回轴的最大值的索引值a：需要操作的数组或者矩阵，默认情况拉平成数组
# axis：默认将a拉平，当axis=0对a按列取最大值索引，axis=1则对a按行取最大值索引out：将结果写到a中
a = np.array([[1,1,1],[2,2,2],[0,3,6]])
print(a)
print(np.argmax(a))
print(np.argmax(a,axis=0))
print(np.argmax(a,axis=1))
运行结果
[[1 1 1]
[2 2 2]
[0 3 6]]
8
[1 2 2]
[0 0 2]
代码及注释
# numpy.linspace用法
# numpy.linspace(start, shop, num==50, endpoint=True, retstep=False, dtype=None)
# 在指定间隔start到stop内返回均匀间隔的数组。返回num均匀分布的样本，在[start, stop]，默认生成50个数据
# endpoint， 如果是真，则一定包括stop，如果为False，一定不会有stopretstep，是否显示步长信息
print(np.linspace(-10.0,10.0))
print(np.linspace(1,10,10))
print(np.linspace(1,10,10,endpoint=False))
print(np.linspace(1, 10, 6, retstep=True))
运行结果
[-10. -9.59183673 -9.18367347 -8.7755102 -8.36734694
-7.95918367 -7.55102041 -7.14285714 -6.73469388 -6.32653061
-5.91836735 -5.51020408 -5.10204082 -4.69387755 -4.28571429
-3.87755102 -3.46938776 -3.06122449 -2.65306122 -2.24489796
-1.83673469 -1.42857143 -1.02040816 -0.6122449 -0.20408163
0.20408163 0.6122449 1.02040816 1.42857143 1.83673469
2.24489796 2.65306122 3.06122449 3.46938776 3.87755102
4.28571429 4.69387755 5.10204082 5.51020408 5.91836735
6.32653061 6.73469388 7.14285714 7.55102041 7.95918367
8.36734694 8.7755102 9.18367347 9.59183673 10. ]
[ 1. 2. 3. 4. 5. 6. 7. 8. 9. 10.]
[1. 1.9 2.8 3.7 4.6 5.5 6.4 7.3 8.2 9.1]
(array([ 1. , 2.8, 4.6, 6.4, 8.2, 10. ]), 1.8)
代码及注释
# 拉平操作 ravel()和faltten()及reshape(1,-1)的区别联系
# 都是对numpy矩阵进行拉平处理，区别在于flatten()返回的仅仅是copy值，而ravel()返回的是实际的值，有点返回地址的意思。而x.reshape(1,-1)表示把向量 x reshape成一个行向量，注意的它仍然保持x的维度。
# 另外，Numpy中的 一维向量 有个特殊的用法，将行或者列设置成None，用来将矩阵转换成行或者列。偶尔会看到np.newaxis，这与None用法一致。
x = np.array([[1,2,3],[4,5,6],[1,2,3]])
print(x.flatten())
print(x.ravel())
print(x.ravel('F'))
print(x.flatten('F'))
print(x.reshape(1,-1))
x.flatten()[1] = 20
print(x)
x.ravel()[1] = 20
print(x)
x = np.array([1,2,3,6,7,8])
print(x[None,:])
print(x[:,None])
print(x[np.newaxis,:])
运行结果
[1 2 3 4 5 6 1 2 3]
[1 2 3 4 5 6 1 2 3]
[1 4 1 2 5 2 3 6 3]
[1 4 1 2 5 2 3 6 3]
[[1 2 3 4 5 6 1 2 3]]
[[1 2 3]
[4 5 6]
[1 2 3]]
[[ 1 20 3]
[ 4 5 6]
[ 1 2 3]]
[[1 2 3 6 7 8]]
[[1]
[2]
[3]
[6]
[7]
[8]]
[[1 2 3 6 7 8]]
代码及注释
# np.prod() 计算元素乘积
# 默认计算矩阵所有元素的乘积，也可以通过axis计算指定轴的乘积
x = np.array([[1,2,3],[2,3,4]])
print(np.prod(x))
print(np.prod(x,axis=1))
print(np.prod(x,axis=0))
运行结果
144
[ 6 24]
[ 2 6 12]
代码及注释
# 把矩阵大于或小于N的元素置M的技巧
# 技巧包括 maximum() 函数 、minimum() 函数，以及 矩阵操作的技巧
x = np.array([[1,2,3],[-3,2,4],[5,-2,9]])
print(x)
y1 = np.maximum(0,x) # 把小于0的元素置0，比改变x的值
print(y1)
y2 = np.minimum(0,x) # 把大于0的元素置0，不改变x的值
print(y2)
x1 = x.copy()
print(x1)
x1[x1 < 0] = 0 # 把小于0的元素置0，改变x1的值
print(x1)
x2 = x.copy()
x2[x2 > 0] = 0 # 把大于0的元素置0，改变x2的值
print(x2)
运行结果
[[ 1 2 3]
[-3 2 4]
[ 5 -2 9]]
[[1 2 3]
[0 2 4]
[5 0 9]]
[[ 0 0 0]
[-3 0 0]
[ 0 -2 0]]
[[ 1 2 3]
[-3 2 4]
[ 5 -2 9]]
[[1 2 3]
[0 2 4]
[5 0 9]]
[[ 0 0 0]
[-3 0 0]
[ 0 -2 0]]
代码及注释
# numpy中的矩阵copy问题
# 还记得Python的可变可不变对象不，简单温习一下：
# 不可变对象： 该对象所指向的内存中的值不能被改变。当改变某个变量的时候，由于其所指的值不能被改变，相当于把原来的值复制一份后再改变，这会开辟一个新的地址，变量再指向这个地址。
# 不可变对象包括 int string float tuple None
# 可变对象： 该对象所指向的内存中的值可以被改变。变量（准确说是引用）被改变后，实际上是其所指的值直接发生改变，并没有发生复制行为，也没有开辟新的地址，通俗点说就是原地改变。
# 可变对象包括 list dictionary set
# numpy的narray用法就类似于可变对象，直接等于并不会开辟新的地址，改变赋值对象也就改变了原来的值。举例如下：
x = np.array([[1,2,3],[-3,2,4],[5,-2,9]])
print(x)
x1 = x.copy() # copy()，开辟新地址
x1[x1 > 0] = 0
print(x1)
print(x)# x不变
x2 = x # 直接等于，未开辟新地址，x2与x相关联
print(x2)
x2[x2>0] = 0
print(x2)
print(x)# x也改变
x = np.array([[1,2,3],[-3,2,4],[5,-2,9]])
x3 = x[2] # 取x的第3行
print(x3)
x3[2] = 100 # 将x3第3个元素置100
print(x) # x中对应的元素置也被置成100了
运行结果
[[ 1 2 3]
[-3 2 4]
[ 5 -2 9]]
[[ 0 0 0]
[-3 0 0]
[ 0 -2 0]]
[[ 1 2 3]
[-3 2 4]
[ 5 -2 9]]
[[ 1 2 3]
[-3 2 4]
[ 5 -2 9]]
[[ 0 0 0]
[-3 0 0]
[ 0 -2 0]]
[[ 0 0 0]
[-3 0 0]
[ 0 -2 0]]
[ 5 -2 9]
[[ 1 2 3]
[ -3 2 4]
[ 5 -2 100]]
代码及注释
# np.zeros_like()构造全零矩阵，无需指定大小
# 复制矩阵的维度，但是元素全是0
x = np.array([[1,2,3],[4,5,6]])
print(np.zeros_like(x))
运行结果
[[0 0 0]
[0 0 0]]
代码及注释
# random.rand和random.rand和random.randint区别
# np.random.random() 生成一个随机数
# 产生 0 ~ 1 之间的随机浮点数，无输入参数
# np.random.rand() 生成均匀分布矩阵
# 创建一个矩阵，服从[0,1]随机分布
n = np.random.rand(3,4)
print(n)
# np.random.randn() 生成正太分布矩阵
# 创建一个矩阵，服从N(0,1)标准正太分布。
# 一般正太分布N = ( μ , σ 2 ) N=(\mu ,\sigma^2)N=(μ,σ 2 )可通过 sigma * np.random.randn(…) + m 实现
x = np.random.randn(2,3)
print(x)
y = np.multiply(0.1,np.random.randn(2,3))+0.5 # 一般正太分布
print(y)
# np.randm.randint() 生成离散均匀分布的整数值组成的矩阵
# numpy.random.randint(low,high=None,size=None,dtype)
# 生成半开半闭区间[low, high)上离散均匀分布的整数值，未给出high时，区间变为[0, low)
z = np.random.randint(2,9,(2,3))
print(z)
m = np.random.randint(9,size = (2,3))
print(m)
运行结果
[[0.84775011 0.70778694 0.81807681 0.41380388]
[0.95191272 0.67835464 0.08276193 0.40344103]
[0.02562104 0.29761765 0.44131128 0.83164551]]
[[-0.33486654 0.77398047 1.7614849 ]
[ 0.73355253 -1.52507986 -1.85712484]]
[[0.29008488 0.57563778 0.57929245]
[0.28575707 0.51777769 0.48023628]]
[[6 4 6]
[2 2 4]]
[[7 7 3]
[8 4 3]]
代码及注释
# np.pad(array, pad_width, mode, **kwargs)返回值：数组
# array——表示需要填充的数组；
# pad_width——表示每个轴（axis）边缘需要填充的数值数目。
# 参数输入方式为：（(before_1, after_1), … (before_N, after_N)），其中(before_1, after_1)表示第1轴两边缘分别填充before_1个和after_1个数值。取值为：{sequence, array_like, int}
# mode——表示填充的方式（取值：str字符串或用户提供的函数）,总共有11种填充模式；
# 填充方式：
# ‘constant’——表示连续填充相同的值，每个轴可以分别指定填充值，constant_values=（x, y）时前面用x填充，后面用y填充，缺省值填充0
# ‘edge’——表示用边缘值填充;‘linear_ramp’——表示用边缘递减的方式填充
# ‘maximum’——表示最大值填充;‘mean’——表示均值填充;‘median’——表示中位数填充
# ‘minimum’——表示最小值填充;‘reflect’——表示对称填充;‘symmetric’——表示对称填充
# ‘wrap’——表示用原数组后面的值填充前面，前面的值填充后面
A = np.arange(95,99).reshape(2,2)
print(A)
print(np.pad(A,((3,2),(2,3)),constant_values = (0,0)))
b = np.array([[[1,2],[3,4]],[[3,4],[7,8]],[[4,5],[1,2]]])
print(b)
print(np.pad(b, ((0,0),(1,1),(1,1)),constant_values = 0))
运行结果
[[95 96]
[97 98]]
[[ 0 0 0 0 0 0 0]
[ 0 0 0 0 0 0 0]
[ 0 0 0 0 0 0 0]
[ 0 0 95 96 0 0 0]
[ 0 0 97 98 0 0 0]
[ 0 0 0 0 0 0 0]
[ 0 0 0 0 0 0 0]]
[[[1 2]
[3 4]]
[[3 4]
[7 8]]
[[4 5]
[1 2]]]
[[[0 0 0 0]
[0 1 2 0]
[0 3 4 0]
[0 0 0 0]]
[[0 0 0 0]
[0 3 4 0]
[0 7 8 0]
[0 0 0 0]]
[[0 0 0 0]
[0 4 5 0]
[0 1 2 0]
[0 0 0 0]]]
代码及注释
# numpy.empty() 创建指定形状和数据类型且未初始化的数组
# numpy.empty(shape, dtype = float, order = ‘C’)
# shape数组形状,dtype数据类型，可选
# order有"C"和"F"两个选项,分别代表，行优先和列优先，在计算机内存中的存储元素的顺序。
x = np.empty([3,2], dtype = int)
print(x)
运行结果
[[1518461776 191338536]
[ 0 1516699648]
[ 0 0]]
代码及注释
# 关于 np.mat() 的使用
# np.array() 更具有通用性，np.mat 只适用于二维矩阵
# np.mat() 和 np.matrix() 都可以将 list 转换为 numpy.matrix 类型的矩阵，而 np.array() 不行
# np.full 用于形成元素全为某元素的矩阵
# np.full(shape, val): 生成形为 shape 的元素全为 val 的矩阵
# astype 转换数据类型
c = np.array([[1,2],[3,4]])
print(c)
print(c.astype(np.float32))
运行结果
[[1 2]
[3 4]]
[[1. 2.]
[3. 4.]]
代码及注释
# np.meshgrid() 快速生成网格
# meshgrid(x,y) 可用于快速生成由于 x轴坐标 x 和 y 轴坐标 y 组合的网格点
x = np.array([1,3,5])
y = np.array([4,6])
XX,YY = np.meshgrid(x,y)
print(XX)
print(YY)
运行结果
[[1 3 5]
[1 3 5]]
[[4 4 4]
[6 6 6]]
代码及注释
# np.hstack() 和 np.vstack() 用于堆叠矩阵
# 注意下面的 M 是 tuple 形式，如 (x,y)，x和y均为 np.array 形式的矩阵
# np.vstack(M) 用于沿着竖直方向将矩阵堆叠起来
# np.hstack(M) 用于沿着水平方向将矩阵堆叠起来
x = np.array([[3,4,5],[1,3,4]])
y = np.array([[1,1,1],[2,2,2]])
print(np.hstack((x,y)))#水平堆叠
print(np.vstack((x,y)))#数值堆叠
运行结果
[[3 4 5 1 1 1]
[1 3 4 2 2 2]]
[[3 4 5]
[1 3 4]
[1 1 1]
[2 2 2]]
代码及注释
# numpy 取整
# np.round 和 np.around 一致，均是四舍五入运算，默认取整，可通过 decimals 调整小数位数
# np.floor 是向下取整操作
# np.ceil 是向上取整操作
a = np.array([0.125,0.568,5.688])
print(np.round(a))# 四舍五入取整， np.around 和 round 用法一致
print(np.round(a,decimals = 2))# 四舍五入保留2位小数
print(np.floor(a) )# 向下取整
print(np.ceil(a))# 向上取整
运行结果
[0. 1. 6.]
[0.12 0.57 5.69]
[0. 0. 5.]
[1. 1. 6.]
代码及注释
# np.newaxis 在特定位置增加一个维度
# 记着 c[:,np.newaxis] 是将矩阵c再加一个维度，如果c是一维的，那么这个表达式是将 c 变成列向量，
# c[np.newaxis,:] 是将矩阵 c 变成行向量。
c = np.array([1,2,5,4])
print(c[:,np.newaxis])
print(c[np.newaxis,:])
运行结果
[[1]
[2]
[5]
[4]]
[[1 2 5 4]]
代码及注释
# python 广播机制
# Numpy要求输入的数组shape一致，当shape不一致的时候，则会使用广播机制，调整数组的shape一致，否则出错。
# 广播的原则：如果两个数组的后缘维度（trailing dimension，即从末尾开始算起的维度）的轴长度相符，或其中的一方的长度为1，则认为它们是广播兼容的。广播会在缺失和（或）长度为1的维度上进行。
# 这句话乃是理解广播的核心。广播主要发生在两种情况，一种是两个数组的维数不相等，但是它们的后缘维度的轴长相符，另外一种是有一方的长度为1。
# 广播机制的四条规则如下：
# 1、让所有输入数组都向其中shape最长的数组看齐，shape中不足的部分都通过在前面加1补齐
# 2、输出数组的shape是输入数组shape的各个轴上的最大值
# 3、如果输入数组的某个轴和输出数组的对应轴的长度相同或者其长度为1时，这个数组能够用来计算，否则出错
# 4、当输入数组的某个轴的长度为1时，沿着此轴运算时都用此轴上的第一组值
a = np.array([[1,2,3,6],[4,5,6,6]])
a1 = a.reshape((1,2,4))
print(a1)
b = np.array([[3,4,5,6],[1,2,3,4],[4,5,5,5]])
print(b)
b1 = b.reshape((1,3,4)).transpose((1,0,2))
print(b1)
print(a1 + b1)
运行结果[[[1 2 3 6]
[4 5 6 6]]]
[[3 4 5 6]
[1 2 3 4]
[4 5 5 5]]
[[[3 4 5 6]]
[[1 2 3 4]]
[[4 5 5 5]]]
[[[ 4 6 8 12]
[ 7 9 11 12]]
[[ 2 4 6 10]
[ 5 7 9 10]]
[[ 5 7 8 11]
[ 8 10 11 11]]]
上面这个例子中，a1 是 [1,2,4] 维度的数组，b1 是 [3,1,4] 维度的数组，可以如此理解，他们相加后由于广播机制的作用应该生成 [3,2,4] 大小的数组。那么我们将 a1 扩展成 [3,2,4] 成
[[[1, 2, 3, 6],
[4, 5, 6, 6]],
[[1, 2, 3, 6],
[4, 5, 6, 6]],
[[1, 2, 3, 6],
[4, 5, 6, 6]]]
将 b1 扩展成 [3,2,4] 成
[[[3, 4, 5, 6],
[3, 4, 5, 6]],
[[1, 2, 3, 4],
[1, 2, 3, 4]],
[[4, 5, 5, 5],
[4, 5, 5, 5]]]
扩展后的 a1 和 b1 相加得到
[[ 4, 6, 8, 12],
[ 7, 9, 11, 12]],
[[ 2, 4, 6, 10],
[ 5, 7, 9, 10]],
[[ 5, 7, 8, 11],
[ 8, 10, 11, 11]]]
即为通过广播机制相加的结果。
详见 Numpy中的广播操作 https://blog.csdn.net/qq_36387683/article/details/80628577
代码及注释
# numpy.transpose()转置
# transpose()是以交换维度的方式进行转置。
c = np.array([[[1,2,5],[3,4,6]],[[4,5,6],[7,8,9]]])
print(c)
print(c.transpose(1,0,2))# 将c的维度按照 第1维度，第0维度，第2维度的排序排成 第0,1,2维度
print(c.transpose(1,2,0))# 将c的维度按照 第1维度，第2维度，第0维度的排序排成 第0,1,2维度
运行结果
[[[1 2 5]
[3 4 6]]
[[4 5 6]
[7 8 9]]]
[[[1 2 5]
[4 5 6]]
[[3 4 6]
[7 8 9]]]
[[[1 4]
[2 5]
[5 6]]
[[3 7]
[4 8]
[6 9]]]
代码及注释
# numpy 中双冒号的用法
# numpy 中 ndarray 对象内容可以索引或切片来访问和修改。可以通过 start:stop:step 来进行切片操作
a = np.array([2,2,3,4,5,5,6,7])
print(a[0:7:2])
# 双冒号实则是两个冒号之间缺省了必要的值，它省略的是 stop 值，那么 stop 值就默认尾部
print(a[0::2])
# 除了一般的切片用法，也常用 [::-1] 来将序列按倒序排列。
print(a[::-1])
# 一般而言，python 的内置函数 slice 就实现了此功能，用法是 slice(start, stop, step)。
a = np.array([2,2,3,4,5,5,6,7])
s = slice(0,7,2)
print(a[s])
运行结果
[2 3 5 6]
[2 3 5 6]
[7 6 5 5 4 3 2 2]
[2 3 5 6]
329
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
