个人建网站的步骤,wordpress 粘贴代码,微信app下载安装官方版2020,个人主页的制作纯个人python的一个小回忆笔记#xff0c;当时假期花两天学的python#xff0c;确实时隔几个月快忘光了#xff0c;为了应付作业才回忆起来#xff0c;不涉及太多基础#xff0c;适用于有一定编程基础的参考回忆。 这一篇笔记来源于下面哔哩哔哩up主的视频#xff1a; 一…纯个人python的一个小回忆笔记当时假期花两天学的python确实时隔几个月快忘光了为了应付作业才回忆起来不涉及太多基础适用于有一定编程基础的参考回忆。 这一篇笔记来源于下面哔哩哔哩up主的视频 一个10分钟的numpy入门教程_哔哩哔哩_bilibili 一、NumPy是啥
简单来说NumPy就是一个科学计算数组的库所有数据都基于数组
因此一切根源都要源自numpy.array( )——numpy数组来展开代码编写 它支持一维数组、二维数组、以及N维数组 可以用于计算线性代数计算、图像处理、数据分析...... 二、NumPy的数组初始化创建
1、使用前提准备
首先我们要引入这个库
用下面命令安装 pip install numpy用anaconda管理python的可以执行这个命令安装也是一样的 conda install numpy 然后在代码首行导入 import numpy as np
# as np的意思是给numpy起别名用np代替numpy 2、numpy创建数组
在后面各种计算、图形分析、数据处理都要基于各种数组数据那么首先要做的就是创建数组数据
1创建一个普通数组
# 创建数组
# 最普通的一维数组有初始化数据
a np.array([1, 2, 3, 4, 5])
print(a, end\n\n) # ———— [1 2 3 4 5]
2创建一个【多维】数组
# 创建一个【多维】数组
a np.array([[1, 2, 3], [4, 5, 6]])
print(a, end\n\n) # ———— 二维数组[[1 2 3] [4 5 6]]
a np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(a, end\n\n) # ———— 三位数组[[1 2 3] [4 5 6] [7 8 9]]
3创建一个【全是0】的初始化数组
# 注意默认返回的是浮点数
a np.zeros(5)
print(a, end\n\n) # ———— [0. 0. 0. 0. 0.]# 同理也可以设置多维全是0的数组
a np.zeros((2, 3))
print(a, end\n\n) # ———— [[0. 0. 0.] [0. 0. 0.]]
4创建一个【全是1】的初始化数组
# 注意默认返回的是浮点数
a np.ones(5)
print(a, end\n\n) # ———— [1. 1. 1. 1. 1.]
5创建一个全是【其他任意一个值】的初始化数组可以
# 比如全是true的数组的数组大小是5个元素
a np.full(5, True)
print(a, end\n\n) # ———— [ True True True True True]
6创建一个【递增】或【递减】的数组
# 第1个参数是起始第2个是末尾第3个是这个范围内均每【?】是一个
# 递增
a np.arange(1, 10, 2)
print(a) # ———— [1 3 5 7 9]# 递减
a np.arange(10, 1, -2)
print(a, end\n\n) # ———— [10 8 6 4 2]
7创建一个介于某个区间、并且均等划分的数组
# 第1个参数是起始第2个是末尾第3个是这个范围内均等分成几份
# 返回的是【浮点数】形式
a np.linspace(1, 5, 3)
print(a) # ———— 把[1~5]均等分成3份[1. 3. 5.]a np.linspace(0, 1, 10)
print(a, end\n\n) # ———— 把[0~1]均等分成10份[0. 0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]
8创建一个随意任意数数组
a np.random.rand(5)
print(a, end\n\n) # ———— 生成5个【0~1】之间的随机数a np.random.rand(2, 4)
print(a, end\n\n) # ——— 生成2行4列的【0~1】之间的随机数a np.random.rand(1, 10, 5)
print(a, end\n\n) # ———— 生成1行10列5层的【0~1】之间的随机数
9规定数组成员的数据类型
比如.zeros()、.ones()不是返回的是浮点数嘛那用这个方法就可以规定返回的是整型了
# 比如规定一个数组内数据类型全都是【整数】
# 还可以更细节设定是【8位】整型数据、【16位】、【32位】、【64位】
a np.array([1, 2, 3, 4, 5], dtypeint)
a np.zeros((1, 5), dtypenp.int8)
a np.ones((1, 5), dtypenp.int16)
a np.full(5, 6, dtypenp.int32)
a np.array([1, 2, 3, 4, 5], dtypenp.int64)
# 还有【无符号整型】
a np.array([1, 2, 3, 4, 5], dtypenp.uint8)
a np.array([1, 2, 3, 4, 5], dtypenp.uint16)
a np.array([1, 2, 3, 4, 5], dtypenp.uint32)
a np.array([1, 2, 3, 4, 5], dtypenp.uint64)# 比如规定一个数组内全是【浮点数】
a np.array([1, 2, 3, 4, 5], dtypefloat)
a np.zeros((1, 5), dtypenp.float16) # ———— 生成1行5列的全是【0】的16位浮点数
a np.ones((1, 5), dtypenp.float32) # ———— 生成1行5列的全是【1】的32位浮点数# 比如规定一个数组内全是【布尔值】
a np.array([1, 2, 3, 4, 5], dtypebool) # ———— 生成5个全是布尔值的数组# 比如规定一个数组内全是【字符串】
a np.full(5, True, dtypestr) # ———— 生成5个全是字符串的数组
10数据类型转换
a np.array([1, 2, 3, 4, 5], dtypeint)
a a.astype(np.float32) # ———— 把数组内数据类型转换为浮点数
a a.astype(np.str) # ———— 把数组内数据类型转换为字符串
11查看数组的形状
当我们创建了一堆数组不确定某个数组究竟多大是几行几列的数组就可以用它看一下
a np.array([[1, 2, 3], [4, 5, 6]])
print(a.shape, end\n\n) # ———— (2, 3) 2行3列的数组a np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(a.shape, end\n\n) # ———— (3, 3) 3行3列的数组
只看是几行的话就这样
# 查看数组的维度
a np.array([[1, 2, 3], [4, 5, 6]])
print(a.ndim, end\n\n) # ———— 22维数组 3、numpy数组计算
1最基础的一维向量的加减乘除
# 简单加减乘除
a np.array([1, 2, 3])
b np.array([4, 5, 6])
print(a b) # [14, 25, 36] [5, 7, 9]
print(a - b) # [1-4, 2-5, 3-6] [-3, -3, -3]
print(a * b) # [1*4, 2*5, 3*6] [4, 10, 18]
print(a / b) # [1/4, 2/5, 3/6] [0.25, 0.4, 0.5]
注意如果是跟一个数字进行计算就会把每一个元素都跟这个数计算
print(a 1) # [11, 21, 31] [2, 3, 4]
print(a - 1) # [1-1, 2-1, 3-1] [0, 1, 2]
print(a * 2) # [1*2, 2*2, 3*2] [2, 4, 6]
print(a / 2) # [1/2, 2/2, 3/2] [0.5, 1.0, 1.5] 2向量的点乘
# 点乘
a np.array([1, 2, 3])
b np.array([4, 5, 6])
print(np.dot(a, b)) # [1*4 2*5 3*6] 32
3矩阵的乘法
# 矩阵乘法运算
A np.array([[1, 2],[3, 4]])B np.array([[5, 6],[7, 8]])
#【第一种方法】A B
print(A B)[[1*5 2*7, 1*6 2*8], [[19, 22],[3*5 4*7, 3*6 4*8]] ———— [43, 50]]
# 【第二种方法】np.matmul()
print(np.matmul(A, B))
这里有一点要注意因为同行同列的N维向量进行点乘时也是得到一个同行同列的N维向量所以用【np.dot(A,B)】结果是等于上面两种矩阵相乘的结果的但是这不代表【点乘】【矩阵相乘】因为矩阵相乘严格要求【形状相同同行同列】的两个矩阵相乘。
那么假设两个一维向量用np.dot() 会执行点乘而 A B 和 np.matmul() 会因为形状不兼容而抛出错误。
np.dot() 可以用于执行两个数组的点积或矩阵乘法具体取决于输入数组的形状。
print(np.dot(A, B))[[1*5 2*7, 1*6 2*8], [[19, 22], [3*5 4*7, 3*6 4*8]] ———— [43, 50]]4求平方
# 求平方
a np.array([1, 2, 3])
print(a ** 2) # [1*1, 2*2, 3*3] [1, 4, 9]
print(np.square(a)) # [1*1, 2*2, 3*3] [1, 4, 9]
5求指数、对数的运算
# 指数、对数运算
a np.array([1, 2, 3])
print(np.pow(a, 3)) # [1^3, 2^3, 3^3] [1, 8, 27]
print(np.log(a)) # [log(1), log(2), log(3)] [0, 0.6931471805599453, 1.0986122886681098]
6求sin、cos值
# 求sin、cos
a np.array([1, 2, 3])
print(np.sin(a)) # [sin(1), sin(2), sin(3)]
print(np.cos(a)) # [cos(1), cos(2), cos(3)]
7统计一个数组的最大、最小、平均、中位数、总和、方差、标准差......
a np.array([1, 2, 3])# 返回数组最小元素
print(np.min(a)) # 1# 返回数组最大元素
print(np.max(a)) # 3# 返回数组平均值
print(np.mean(a)) # 2.0# 返回数组中位数
print(np.median(a)) # 2.0# 返回数组最小数的位置
print(np.argmin(a)) # 0# 返回数组最大数的位置
print(np.argmax(a)) # 2# 返回数组总和
print(np.sum(a)) # 6# 返回数组标准差
print(np.std(a)) # 1.0# 返回数组方差
print(np.var(a)) # 1.0 4、numpy数组索引
【一】序列切片式索引
这个跟数据容器list、tuple......这些的序列是一样的都是一样的规则切片不同的在二维以上的切片形式不同
1维数组的切片一样的 ———— [ 起始位 : 末尾位 : 步长 ]起始位默认0末尾位默认最后步长默认1 2维以上数组 基本是就是 [ 行的切片 , 列的切片 ] 【行】如果不是切片形式就代表固定是【某一行取序列】 【列】如果没有切片形式就代表固定某一行或所有行都只取【这一列这个数】 【固定取一行】
———— [ 一个数 ]比如a[ 0 ]就是取第0行
———— 或者[ a, : ]比如a[ 0, : ]就是取第0行的从头到尾
【固定取一列】
———— [ a, b ]就是取第a行的第b列
———— [ : , b ]就是取每一行的第b列
【取某一行的部分】
———— [ a, b:c ]比如a[ 1, 1:5 ]就是取第1行的[第1列 ~ 第(5-1)列]
【取整个数组】
———— [ : , : ]
【带上步长的话跟其他序列一样】
———— [ a, b:c:d ]比如a[ 1, ::3 ]就是取第1行的[从头 ~ 到尾]每3个取一个数
————步长是负数就是反着取比如a[ 1, ::-2 ]就是取第1行的[从尾 ~ 到头]倒着每2个取一个数
# 一维数组的切片序列是一样的
a np.array([1, 2, 3, 4, 5])print(a[1:4]) # [2, 3, 4]
print(a[4::-1]) # [5, 4, 3, 2, 1]
print(a[::2]) # [1, 3, 5]# 如果是二维以上的就需要把起始位跟末尾位带上而且切片形式和不切片形式都有不同的含义
# 基本是就是 [ 行的切片 , 列的切片 ]
#【行】如果不是切片形式就代表固定是【某一行取序列】
#【列】如果没有切片形式就代表固定某一行或所有行都只取【这一列这个数】
a np.array([[1, 2, 3], [4, 5, 6]])print(a[0]) # 如果是直接取一行就直接1个数字代表第几行就行 ———— [1, 2, 3]
print(a[0, :]) # 这样也是直接取一行只不过是取第[0]行,从第[0]列到第[尾]列[1, 2, 3]print(a[0, 1]) # 2取第[0]行第[1]列的数
print(a[:, 1]) # [2, 5]每一行的第[1]列的数
print(a[:, :]) # [[1, 2, 3], [4, 5, 6]]从第[1]行开始的[从头到尾]到第[2]行开始的[从头到尾]print(a[1, 0:2]) # [4, 5]从第[1]行开始分割[第0列~第2列]print(a[1, ::-1]) # [6, 5, 4]从第[1]行开始分割[第尾列~第0列]步长为-1倒着1个1个取 【二】花式索引
切片索引可以获取【一段范围的数】或【一段范围的某1列、某1行...的数】是有一定规律的 比如“2维数组的第2到第3行的数”、“二维数组的每一行的第3列的数”、“2维数组第1行的第2到第4列的数”、“2维数组的每一行从后往前每隔2个取一个数”....... 但是普通花式索引可以任意获取【已知下标索引的某几个数】可以我们自定义的、没有规律 比如“2维数组的第一行的第2、第0、第10列”、“1维数组的第1个、第3个数”、“2维数组的第3行、第0行”...... 【一维数组的花式索引】
# 要取已知索引位置的【那几个元素】就在索引传入一个列表参数[a, b, c, ...]
a np.array([0,1,2,3,4,5,6,7,8,9])
print(a[[1, 5, 8]]) # 取到原数组的下标1、5、8的元素装入新数组[1 5 8]
【二维数组的花式索引】
【二维数组选择多行】
# 要取的已知索引位置的【那几行元素】就在索引传入一个列表参数[a, b, c, ...]
a np.array([[0,1,2,3,4],[10,11,12,13,14,],[20,21,22,23,24,],[30,31,32,33,34,]])
print(a[[1, 3, 2]])
# 取到原数组的下标1、3、2的行按顺序装入新数组
# [[10 11 12 13 14] —— 第[1]行
# [30 31 32 33 34] —— 第[3]行
# 20 21 22 23 24]] —— 第[2]行
【二维数组选多列】结合切片索引
# 切片索引可以获取【一段范围的数】或【一段范围的某1列、某1行...的数】是有一定规律的
# 但是普通花式索引可以任意获取【已知下标索引的某几个数】可以我们自定义没有规律
# 那么二者加起来就无敌了
# 比如一个2维数组只要每一行的第[2]列、第[0]列的数、第[1]列的数
a np.array([[0,1,2,3,4],[10,11,12,13,14],[20,21,22,23,24]])
colum [2, 0, 1]
print(a[:, colum])
# [[2 0 1]
# [12 10 11] —— 每一行第[2]列、第[0]列、第[1]列的数
# [22 20 21]] 【三】布尔索引
顾名思义就是根据【条件】来取出符合条件的子序列
a np.array([[0,1,2,3,4],[10,11,12,13,14],[20,21,22,23,24]])# 取到原数组中大于10的数
print(a[a 10]) # ———— [11 12 13 14 21 22 23 24]
但是需要注意的是
布尔索引的条件要用( )包起来当只有一个条件时可以省略( )当有多个条件时就要用( )要么就用变量写好条件再放入索引里
a np.array([[0,1,2,3,4],[10,11,12,13,14],[20,21,22,23,24]])# 取到原数组中大于10且小于22的数
print(a[(a 10) (a 22)]) # ———— [11 12 13 14 21]
# 或者
up (a 10)
low (a 22)
print(a[up low]) # ———— [11 12 13 14 21] 5、numpy数组变形、转置
【变形】
就是一维数组可以变二维、二维变三维、三维变四维......也可以从多维变低维比如三维变一维数组
这些的前提条件都是不管几维数组总的元素一定要互相一样比如24个元素的一维数组不管变成二维、三维...多少维只能总数是24个3行8列的二维数组可以3*8242行5列的二维数组就不行2*5 20 24
[1维数组变2维数组]
# 创建一个8个数的1维数组但是马上用reshape变成2行4列的二维数组
a np.arange(8).reshape(2, 4)
print(a, end\n\n) # [0 1 2 3 4 5 6 7] ———— [[0 1 2 3], [4 5 6 7]]
[1维数组变3维数组]
# 创建一个8个数的1维数组但是马上用reshape变成2块3行3列的三维数组
a np.arange(24).reshape(2, 3, 4)
print(a, end\n\n)
# [0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23]
# ———— [[[ 0 1 2 3] # 1块
# [ 4 5 6 7]
# [ 8 9 10 11]]
#
# [[12 13 14 15] # 2块
# [16 17 18 19]
# [20 21 22 23]]]
[2维数组变2维数组]
# 2维数组变形2维数组
# 只要reshape那边数字总数能对的上就行(2维)2行3列 (2维)3行2列
a np.array([[1,3,4],[4,6,5]]).reshape(3, 2)
print(a, end\n\n)
# [[1 3]
# [4 6]
# [4 5]]
[2维数组变3维数组]
# 只要reshape那边数字总数能对的上就行(2维)2行3列 (3维)2块、每一块2行3列
a np.array([[1,3,4],[4,6,5],[2,2,2],[0,0,1]]).reshape(2, 2, 3)
print(a, end\n\n)
# [[[1 3 4]
# [4 6 5]] # 1块
#
# [[2 2 2]
# [0 0 1]]] # 2块
[2维数组变1维数组展开]
# 只要reshape那边数字总数能对的上就行(2维)3行2列 (1维)1行6个
a np.array([[1,3],[4,6],[3,5]]).reshape(1, 6)
print(a, end\n\n)
# [[1 3 4 6 3 5]]
[错误示范]变形的数组的元素总数跟原数组的不一样
# a np.arange(8).reshape(4, 3)
# print(a, end\n\n) # 报错因为变形后的总数一定要对上8个元素对不上4*312个元素
[将多维数组展开成1维数组常用三方法] 虽然【.reshape(1, ?)】可以把多维数组展开成一维数组但是有的时候我们并不知道多维数组里有多少元素第2个参数就不知道写多少那么常用的还有三种方法【.reshape(-1)】、【.ravel( )】、【.flatten( )】 【.reshape(-1)】是最常用的因为它可以自动计算出需要多少列才能包含所有元素。 # 用reshape(-1)也可以把多维变成1维
a np.array([[1,3],[4,6],[3,5]])
print(a.reshape(-1), end\n\n) # [1 3 4 6 3 5] 【.ravel( )】 # 用ravel()也可以把多维变成1维
a np.array([[1,3],[4,6],[3,5]])
print(a.ravel(), end\n\n) # [1 3 4 6 3 5] 【.flatten( )】 # 用flatten()也可以把多维变成1维
a np.array([[1,3],[4,6],[3,5]])
print(a.flatten(), end\n\n) # [1 3 4 6 3 5] 另外
很多地方reshape里的参数是写成元组tulpe形式的但是其实直接写数字也是可以的 【转置】
就是线性代数里行列式的转置没学过线性代数的可以去了解一下大概就是 [行元素变列元素、列元素边行元素]
一种写法常用【数组.T】
a np.array([[1,3,4],[4,6,5],[3,5,1]])
print(a.T) # [[1 4 3]# [3 6 5]# [4 5 1]]
另一种写法【数组.transpose( )】transpoe针对于多维数组的转置
【数组.transpose( )】对于二维数组的转置和【数组.T】是一样的
# 用transpose()也可以转置
a np.array([[1,3,4],[4,6,5],[3,5,1]])
print(a.transpose()) # [[1 4 3]# [3 6 5]# [4 5 1]]
但对于多维数组可以指定更细致的转置比如3维数组可以指定x、y、z轴之间的互换
比如对于三维数组转置需要将一个(x, y, z)的元组作为参数传进【数组.transpose( )】其中默认0代表x、1代表y、2代表z那么(0, 1, 2)代表(x, y, z)(2, 1, 0)代表(z, y, x)
那么假设要将一个三维的数组的x轴和z轴互相转置一下比如例子 [ [ [ 0 1 2] [ 3 4 5] ] , [ [ 6 7 8] [ 9 10 11] ] ]
———— 变成 [ [ [ 0 6] [ 3 9] ], [ [ 1 7] [ 4 10] ], [ [ 2 8] [ 5 11] ] ] 那么代码
# 创建一个三维数组
array_3d np.array([[[ 0, 1, 2],[ 3, 4, 5]],[[ 6, 7, 8],[ 9, 10, 11]]])# 使用 transpose 函数重新排列轴将第一个轴和第三个轴交换:(0x,1y,2z)————(2z,1y,0x)
print(array_3d.transpose((2, 1, 0)))#[[[ 0 1 2] [[[ 0 6]# [ 3 4 5]], [ 3 9]],# ————————# [[ 6 7 8] [[ 1 7]# [ 9 10 11]]] [ 4 10]],## [[ 2 8]# [ 5 11]]] 6、numpy数组合并
对于1维数组
直接用【np.concatenate((数组1, 数组2...))】就行
a np.array([1,3,4])
b np.array([4,6,5])
c np.array([7,8,9])
print(np.concatenate((a, b, c))) # [1 3 4 4 6 5 7 8 9]
对于N维数组
【竖向N个数组合并】 1用【np.vstack((数组1, 数组2...))】 # 用vstack()合并: 纵向合并
a np.array([[1,3,4],[4,6,5]])
b np.array([[2,3,4],[4,6,5]])
print(np.vstack((a, b))) # [[1 3 4]# [4 6 5]# [2 3 4]# [4 6 5]] 2用【np.concatenate((数组1, 数组2...), axis0)】 # 用concatenate()合并
a np.array([[1,3,4],[4,6,5]])
b np.array([[2,3,4],[4,6,5]])# axis0表示纵向合并
print(np.concatenate((a, b), axis0)) # [[1 3 4]# [4 6 5]# [2 3 4]# [4 6 5]] 【横向N个数组合并】 1用【np.hstack((数组1, 数组2...))】 # 用hstack()合并: 横向合并
a np.array([[1,3,4],[4,6,5]])
b np.array([[2,3,4],[4,6,5]])
print(np.hstack((a, b))) # [[1 3 4 2 3 4]# [4 6 5 4 6 5]] 2用【np.concatenate((数组1, 数组2...), axis1)】 # 用concatenate()合并
a np.array([[1,3,4],[4,6,5]])
b np.array([[2,3,4],[4,6,5]])# axis1表示横向合并
print(np.concatenate((a, b), axis1)) # [[1 3 4 2 3 4]# [4 6 5 4 6 5]] 【合并后转置】 用【np.column_stack((数组1, 数组2))】类似将两个数组合并后再【转置】 # 用column_stack()合并
a np.array([1,3,4])
b np.array([4,6,5])
print(np.column_stack((a, b))) # [[1 4]# [3 6]# [4 5]] 【拓展】
a np.array([1,1,1])
print(a.T) # [1 1 1],一行的一维序列是不能直接像线性代数那样被转置成一列的矩阵的
# 但是用newaxis()可以增加维度在索引第1位就是在行上增加一个维度
print(a[np.newaxis, :])
# 在索引第2位就是在列上增加一个维度那么这时就相当于把增加一“空”列就相当于转置了只不是是二维的数组了
print(a[: , np.newaxis]) 7、numpy数组分割
【均等分割】【np.split(数组, 分几份, axis维度)】
一维数组就不用带上【axis维度】这个参数
a np.array([1,3,4])
print(np.split(a, 3)) # [array([1]), array([3]), array([4])]
# print(np.split(a, 2)) ———— 报错因为均等切割3个元素不能均等分割成2块
a np.array([[1,3,4],[4,6,5],[3,5,1]])
# 一样axios0表示纵向分割均等分割成3块
print(np.split(a, 3, axis0))
# [array([[1, 3, 4]]), array([[4, 6, 5]]), array([[3, 5, 1]])]# 一样axios1表示横向分割均等分割成3块
print(np.split(a, 3, axis1))
# [array([[1],
# [4],
# [3]]),
# array([[3],
# [6],
# [5]]),
# array([[4],
# [5],
# [1]])]
【不均等分割】【np.array_split(数组, 分几份, axis维度)】
# array_split()与split()的区别是array_split()可以不等分split()必须均分
a np.array([[1,3,4],[4,6,5],[3,5,1]])
print(np.array_split(a, 2, axis0))
# [array([[1, 3, 4],
# [4, 6, 5]]),
# array([[3, 5, 1]])]
print(np.array_split(a, 2, axis1))
# [array([[1, 3],
# [4, 6],
# [3, 5]]),
# array([[4],
# [5],
# [1]])]
跟合并一样分割也有【横向分割】【竖向分割】
【横向分割】【np.hsplit(数组, 分几份)】
# 用hsplit()横向分割
a np.array([[1,3,4],[4,6,5],[3,5,1]])
print(np.hsplit(a, 2))
# [array([[1, 3, 4],
# [4, 6, 5]]),
# array([[3, 5, 1]])]【竖向分割】 【np.vsplit(数组, 分几份)】
# 用vsplit()纵向分割
a np.array([[1,3,4],[4,6,5],[3,5,1]])
print(np.vsplit(a, 2))
# [array([[1, 3],
# [4, 6],
# [3, 5]]),
# array([[4],
# [5],
# [1]])] 8、numpy的copy方法
虽然【数组2 数组1】可以直接把数组1的值给到数组2但是他们是一直关联着的当数组1发生改变的时候数组2也会被跟着改变
那么只有【数组.copy()】才不会让数组轻易改变
a np.array([1, 2, 3, 4, 5])
b a
c a.copy()# 然后改变a数组里某一个值
a[0] 100
print(a) # [100 2 3 4 5]
print(b) # [100 2 3 4 5]此时b也跟着关联被改变
print(c) # [ 1 2 3 4 5]但是c因为用numpy的copy函数所以不变 三、一些numpy的真实应用场景
图像处理可以把一个灰度图像当成一个二维数组 每个数值代表图像的亮度值 那么彩色的图像就可以用一个三位数组表示第三维用来表示红绿蓝三种颜色 先获取图像 用numpy的array将图像变成三维数组行、列、有几个颜色 访问某个元素颜色点‘ 提取所有红色的元素像素点 按比例将两个图片混合 ......等等 暂时常用需要了解的就这么多以后有需要用到别的知识点我再更新.......
