纯个人python的一个小回忆笔记，当时假期花两天学的python，确实时隔几个月快忘光了，为了应付作业才回忆起来，不涉及太多基础 ，适用于有一定编程基础的参考回忆。
这一篇笔记来源于下面哔哩哔哩up主的视频：
一、NumPy是啥？
简单来说NumPy就是一个科学计算数组的库，所有数据都基于数组
因此，一切根源都要源自numpy.array( )------numpy数组来展开代码编写
它支持一维数组、二维数组、以及N维数组
可以用于计算线性代数计算、图像处理、数据分析......
二、NumPy的数组初始化创建
1、使用前提准备
首先我们要引入这个库
用下面命令安装
pip install numpy用anaconda管理python的可以执行这个命令安装，也是一样的
conda install numpy
然后在代码首行导入：
pythonimport numpy as np # as np的意思是给numpy起别名，用np代替numpy
2、numpy创建数组
在后面各种计算、图形分析、数据处理，都要基于各种数组数据，那么首先要做的就是创建数组数据
1）创建一个普通数组
python
# 创建数组
# 最普通的一维数组，有初始化数据
a = np.array([1, 2, 3, 4, 5])
print(a, end="\n\n") # ------------> [1 2 3 4 5]2）创建一个【多维】数组
python
# 创建一个【多维】数组
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】的初始化数组
python
# 注意：默认返回的是浮点数
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】的初始化数组
python
# 注意：默认返回的是浮点数
a = np.ones(5)
print(a, end="\n\n") # ------------> [1. 1. 1. 1. 1.]5）创建一个全是【其他任意一个值】的初始化数组可以
python
# 比如全是true的数组的，数组大小是5个元素
a = np.full(5, True)
print(a, end="\n\n") # ------------> [ True True True True True]6）创建一个【递增】或【递减】的数组
python
# 第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）创建一个介于某个区间、并且均等划分的数组
python
# 第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）创建一个随意任意数数组
python
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()不是返回的是浮点数嘛，那用这个方法就可以规定返回的是整型了）
python
# 比如规定一个数组内数据类型全都是【整数】
# 还可以更细节，设定是【8位】整型数据、【16位】、【32位】、【64位】
a = np.array([1, 2, 3, 4, 5], dtype=int)
a = np.zeros((1, 5), dtype=np.int8)
a = np.ones((1, 5), dtype=np.int16)
a = np.full(5, 6, dtype=np.int32)
a = np.array([1, 2, 3, 4, 5], dtype=np.int64)
# 还有【无符号整型】
a = np.array([1, 2, 3, 4, 5], dtype=np.uint8)
a = np.array([1, 2, 3, 4, 5], dtype=np.uint16)
a = np.array([1, 2, 3, 4, 5], dtype=np.uint32)
a = np.array([1, 2, 3, 4, 5], dtype=np.uint64)
# 比如规定一个数组内全是【浮点数】
a = np.array([1, 2, 3, 4, 5], dtype=float)
a = np.zeros((1, 5), dtype=np.float16) # ------------> 生成1行5列的全是【0】的16位浮点数
a = np.ones((1, 5), dtype=np.float32) # ------------> 生成1行5列的全是【1】的32位浮点数
# 比如规定一个数组内全是【布尔值】
a = np.array([1, 2, 3, 4, 5], dtype=bool) # ------------> 生成5个全是布尔值的数组
# 比如规定一个数组内全是【字符串】
a = np.full(5, True, dtype=str) # ------------> 生成5个全是字符串的数组10）数据类型转换
python
a = np.array([1, 2, 3, 4, 5], dtype=int)
a = a.astype(np.float32) # ------------> 把数组内数据类型转换为浮点数
a = a.astype(np.str) # ------------> 把数组内数据类型转换为字符串11）查看数组的形状
（当我们创建了一堆数组，不确定某个数组究竟多大，是几行几列的数组，就可以用它看一下）
python
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列的数组）（只看是几行的话就这样）
python
# 查看数组的维度
a = np.array([[1, 2, 3], [4, 5, 6]])
print(a.ndim, end="\n\n") # ------------> 2（2维数组）3、numpy数组计算
1）最基础的一维向量的加减乘除
python
# 简单加减乘除
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
print(a + b) # [1+4, 2+5, 3+6] = [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]注意：如果是跟一个数字进行计算，就会把每一个元素都跟这个数计算
python
print(a + 1) # [1+1, 2+1, 3+1] = [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）向量的点乘
python
# 点乘
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
print(np.dot(a, b)) # [1*4 + 2*5 + 3*6] = 323）矩阵的乘法
python
# 矩阵乘法运算
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()可以用于执行两个数组的点积或矩阵乘法，具体取决于输入数组的形状。
python
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）求平方
python
# 求平方
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）求指数、对数的运算
python
# 指数、对数运算
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值
python
# 求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）统计一个数组的最大、最小、平均、中位数、总和、方差、标准差......
python
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.04、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个取一个数
python
# 一维数组的切片序列是一样的
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行"......
【一维数组的花式索引】
python
# 要取已知索引位置的【那几个元素】，就在索引传入一个列表参数[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]【二维数组的花式索引】
【二维数组选择多行】
python
# 要取的已知索引位置的【那几行元素】，就在索引传入一个列表参数[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]行【二维数组选多列】（结合切片索引）
python
# 切片索引可以获取【一段范围的数】或【一段范围的某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]]【三】布尔索引
顾名思义，就是根据【条件】来取出符合条件的子序列
python
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]但是需要注意的是：
布尔索引的条件要用( )包起来，当只有一个条件时可以省略( )，当有多个条件时就要用( )，要么就用变量写好条件，再放入索引里
python
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*8=24），2行5列的二维数组就不行（2*5 = 20 < 24）
[1维数组 变2维数组]
python
# 创建一个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维数组]
python
# 创建一个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维数组]
python
# 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维数组]
python
# 只要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维数组展开]
python
# 只要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]][错误示范]：变形的数组的元素总数跟原数组的不一样
python
# a = np.arange(8).reshape(4, 3)
# print(a, end="\n\n") # 报错，因为变形后的总数一定要对上，8个元素对不上4*3=12个元素[将多维数组 展开成1维数组常用三方法]
虽然【.reshape(1, ?)】可以把多维数组展开成一维数组，但是有的时候我们并不知道多维数组里有多少元素，第2个参数就不知道写多少；那么常用的还有三种方法：【.reshape(-1)】、【.ravel( )】、【.flatten( )】
；
【.reshape(-1)】：是最常用的，因为它可以自动计算出需要多少列才能包含所有元素。
python# 用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( )】
python# 用ravel()也可以把多维变成1维 a = np.array([[1,3], [4,6], [3,5]]) print(a.ravel(), end="\n\n") # [1 3 4 6 3 5]【.flatten( )】
python# 用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】
python
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】是一样的
python
# 用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] ] ]
那么代码
python
# 创建一个三维数组
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...))】就行
python
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...))】
python# 用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...), axis=0)】
python# 用concatenate()合并 a = np.array([[1,3,4], [4,6,5]]) b = np.array([[2,3,4], [4,6,5]]) # axis=0表示纵向合并 print(np.concatenate((a, b), axis=0)) # [[1 3 4] # [4 6 5] # [2 3 4] # [4 6 5]]
【横向N个数组合并】
1）用【np.hstack((数组1, 数组2...))】
python# 用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...), axis=1)】
python# 用concatenate()合并 a = np.array([[1,3,4], [4,6,5]]) b = np.array([[2,3,4], [4,6,5]]) # axis=1表示横向合并 print(np.concatenate((a, b), axis=1)) # [[1 3 4 2 3 4] # [4 6 5 4 6 5]]
【合并后转置】
用【np.column_stack((数组1, 数组2))】，类似将两个数组合并后，再【转置】
python# 用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]]
【拓展】
python
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=维度】这个参数）
python
a = np.array([1,3,4])
print(np.split(a, 3)) # [array([1]), array([3]), array([4])]
# print(np.split(a, 2)) ------------> 报错，因为均等切割，3个元素不能均等分割成2块
python
a = np.array([[1,3,4],
[4,6,5],
[3,5,1]])
# 一样，axios=0表示纵向分割，均等分割成3块
print(np.split(a, 3, axis=0))
# [array([[1, 3, 4]]), array([[4, 6, 5]]), array([[3, 5, 1]])]
# 一样，axios=1表示横向分割，均等分割成3块
print(np.split(a, 3, axis=1))
# [array([[1],
# [4],
# [3]]),
# array([[3],
# [6],
# [5]]),
# array([[4],
# [5],
# [1]])]【不均等分割】：【np.array_split(数组, 分几份, axis=维度)】
python
# array_split()与split()的区别是，array_split()可以不等分，split()必须均分
a = np.array([[1,3,4],
[4,6,5],
[3,5,1]])
print(np.array_split(a, 2, axis=0))
# [array([[1, 3, 4],
# [4, 6, 5]]),
# array([[3, 5, 1]])]
print(np.array_split(a, 2, axis=1))
# [array([[1, 3],
# [4, 6],
# [3, 5]]),
# array([[4],
# [5],
# [1]])]跟合并一样，分割也有【横向分割】【竖向分割】
【横向分割】：【np.hsplit(数组, 分几份)】
python
# 用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(数组, 分几份)】
python
# 用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()】才不会让数组轻易改变
python
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将图像变成三维数组（行、列、有几个颜色）
访问某个元素颜色点'
提取所有红色的元素像素点
按比例将两个图片混合
......等等
暂时常用需要了解的就这么多，以后有需要用到别的知识点我再更新.......