一、对 Numpy 认识
Numpy 是用于数据科学计算的基础，不但能够完成科学计算任务，还能被用作高效地多 维数据容器。用于存储和处理大型矩阵
Python 提供了一个 array 模块，和 list 不同，它直接保存数值，但是由于 Python 的 array 模块不支持多维，也没有各种运算函数
Numpy 弥补了这一遗憾，Numpy 提供了一种数组对象---ndarray(下文统称数组)
关于 ndarray 数组对象的认识：
是一种内存连续的、存储单一数据类型的、可以存储多维数组的对象
存在两种存储方式：
C 风格存储（C 语言风格） ----行优先存储
F 风格存储（Fortran 语言风格）---列优先存储
二、数组创建
1、Numpy.array 函数创建一维或多维数组
numpy.array (object,dtype=None,copy=True,order='K',subok=False,ndmin=0)
| 参数名称 | 说明 |
|---|---|
| object | 接收 array，表示想要创建的数组，无默认 |
| dtype | 接收 data-type。表示数组所需的数据类型。如果未给定，则选择保存对象 所需的最小类型。默认为 None |
| ndmin | 接收 int，指定生成数组应该具有的最小维数，默认为 None |
三、数组属性
Ndarray 是一个数组对象，对象都拥有以下属性：
| 属性 | 说明 |
|---|---|
| ndim | 返回 int，表示数组的维数 |
| shape | 返回 tuple。表示数组的尺寸，对于 n 行 m 列的矩阵，形状为(n,m) |
| size | 返回 int，表示数组的元素总数，等于数组形状的乘积 |
| dtype | 返回 data-type，描述数组中元素的类型 |
| itemsize | 返回 int，表示数组的每个元素的大小（以字节为单位） |
其中 shape 及 ndim 属性，可以参考下图来理解：
代码实现：
# 1、导包
import numpy as np
# 2、创建数组
# 可以使用np.array将列表对象转化ndarray数组对象
# arr = np.array([1, 2, 3, 4])
# print('arr:\n', arr) # [1 2 3 4]
# print('arr 类型：\n', type(arr)) # <class 'numpy.ndarray'>
#
arr = np.array([[1, 2, 3, 4], [5, 6, 7, 0]])
print('arr:\n', arr)
# [[1 2 3 4]
# [5 6 7 8]]
print('arr 类型：\n', type(arr)) # <class 'numpy.ndarray'>
print('*' * 100)
# arr = np.array([[[1, 2, 3, 4], [5, 6, 7, 0]],[[1, 2, 3, 4], [5, 6, 7, 0]]])
# print('arr:\n', arr)
# # [[1 2 3 4]
# # [5 6 7 8]]
#
# print('arr 类型：\n', type(arr)) # <class 'numpy.ndarray'>
# # print('*' * 100)
# 3、研究数组对象属性
# ndim shape size dtype itemsize
print('arr 的 ndim属性：', arr.ndim) # 数组的维度
print('arr 的 shape属性：', arr.shape) # 数组的形状，元组类型
print('arr 的 size 属性：', arr.size) # 数组中元素的个数
# print('arr 的 dtype 属性：', arr.dtype) # 数组中元素的数据类型 int32 --->numpy中的数据类型 --->32位平台的int类型
# print('arr 的 itemsize 属性：', arr.itemsize) # 每一个元素的占位大小，单位为字节
# ndim shape size
# len(shape) = ndim
# size = shape中元素的乘积
四、数据元素类型
在实际业务数据处理时，为了更精确的计算结果，需要使用不同的数据类型，Numpy 极大程度地扩充了原生python数据类型，其中大部分数据类型是以数字结尾的，这个数字表 示在内存中占有的位数，同时强调一点，在Numpy中，所有数据类型都是同质的，即数组中的所有元素类型必须是一致的，这样做的好处是，更容易确定该数组所需要的存储空间
如下表展示：
| 类型 | 描述 |
|---|---|
| bool | 用一位存储的布尔类型（值为 TRUE 或 FALSE） |
| inti | 由所在平台决定其精度的整数（一般为 int32 或 int64） |
| int8 | 整数，范围为−128 至 127 |
| int16 | 整数，范围为−32768 至 32767 |
对于数组元素类型的使用，可以在创建数组的时候，通过 dtype 参数来指定数组的元素 类型，如：在创建全部为 0，全部为 1 的数组的时候，就可以使用 dtype 参数
其实，numpy 中的数据类型也可以进行强制转换，也可以进行存储复合的数据，如：
import numpy as np
# numpy中的数据类型
# ---封装了Python中的数据类型，并进行了细致划分 ---->变为了numpy.数据类型
# np.int32 np.int64 np.float32 np.float64 .......
# (1) 可以在创建数组的 时候通过dtype参数来指定创建的数组的类型
arr = np.array([1, 2, 3, 4], dtype=np.float64)
print('arr:\n', arr)
print('arr 类型：\n', type(arr))
print('arr 的元素的类型：\n', arr.dtype)
arr = np.array([1, 2, 3, 4], dtype=np.int64)
print('arr:\n', arr)
print('arr 类型：\n', type(arr))
print('arr 的元素的类型：\n', arr.dtype)
# 创建一个bool数组
# 注意：0代表False 非0代表True
arr = np.array([1, 2, 3, 0], dtype=np.bool)
print('arr:\n', arr) # [ True True True False]
print('arr 类型：\n', type(arr))
print('arr 的元素的类型：\n', arr.dtype)
# (2) 也可以进行数据的强转换
print('将数值转化为bool类型：',np.bool(1))
print('将整型数据转化为float类型：',np.float32(3))
# print('将字符串a转化为float类型：',np.float64('a')) # 错误的
print('将字符串10转化为float类型：',np.float64('10'))
# # (3)了解、知道：ndarray可以存储不同类型的数据 --->转化 ---对象类型
# # 存储 ---个人信息---姓名(str) height(float) weight(float)
# # 通过自定义dtype来实现
df = np.dtype([('name', np.str, 20), ('hight', np.float64), ('weight', np.float32)])
#
# # 使用df 来创建数组
info = np.array([('bq', 168.0, 65.0), ('nl', 178.0, 70.0), ('yf', 173.0, 63.0)], dtype=df)
print('info:\n', info)
print('info 维度:\n', info.ndim)
print('info 形状:\n', info.shape)
print('info 类型:\n', info.dtype) # [('name', '<U20'), ('hight', '<f8'), ('weight', '<f4')]
#
# #
print('info 每一个元素的大小：', info.itemsize) # 92
# # 现在是以数据对象作为 数组info --->保证足够的空间
# ndarray 数组--->存储单一数据类型的数据 ---->科学运算
# 如果想要存储 ---整个数据对象--->后续会有更专业的结构来存储
但是，复合的数据存储的时候，也是以对象的形式进行存储，其每一个对象所占的内存大小都是一样，而且，一般情况下，我们也不会使用这样的结构去存储数据，因为后续我们有专门的类型来存储
五、特殊函数的数组创建
1、固定值数组的创建
1、 Numpy.arange 函数创建一维数组
numpy.arange(start=None, stop=None, step=None, dtype=None)
| 参数名称 | 说明 |
|---|---|
| start | 接收 int,表示开始位置 |
| stop | 接收 int，表示结束位置 |
| step | 接收 int，表示步长，默认为 1。如果开始位置为 0，并且步长为 1 时，此时 开始与步长可以同时省略 |
| dtype | 接收 data-type，表示数组所需的数据类型。如果未给定，则选择保存对象 所需的最小类型，默认为 None |
代码实现：
# 1、使用np.arange 来创建一维数组
# 参数1 ： 开始位置
# 参数2 ： 结束位置(默认不包含结束位置)
# 参数3 ： 步长
arr = np.arange(1, 8, 2)
# 注意：如果步长为1，步长可以省略
arr1 = np.arange(1, 8)
# 注意：如果开始位置为0，且步长为1 ，那么此时，开始与步长都可以省略
arr2 = np.arange(5)
print('arr:\n', arr)
print('arr 类型：\n', type(arr))
2、 Numpy.linspace 函数来创建等差数组
Numpy.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)
| 参数名称 | 说明 |
|---|---|
| start | 接收 int,表示开始位置 |
| stop | 接收 int，表示结束位置 |
| num | 接收 int，生成数组的元素的个数，默认为 50 |
| endpoint | 接收 boolean 类型，默认为 True，表示包含结束位置 |
代码实现：
# 2、使用np.linspace来创建一个等差数组
# 等差数组----> 有序序列，且后一个元素 - 前一个元素的差值是恒定的
# start : 开始位置
# end : 结束位置
# num :默认为50，指的是创建的数组的元素个数
# endpoint : 默认为True，指的是包含结束位置
arr = np.linspace(1, 6, 5)
print('arr:\n', arr)
print('arr:类型:\n', type(arr))
3、 Numpy.logspace 函数来创建等比数组
Numpy.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None)
| 参数名称 | 说明 |
|---|---|
| start | 接收 int,表示开始位置 |
| stop | 接收 int，表示结束位置 |
| num | 接收 int，生成数组的元素的个数，默认为 50 |
| endpoint | 接收 boolean 类型，默认为 True，表示包含结束位置 |
| base | 底数，默认为 10.0 |
代码实现：
# 3、使用np.logspace创建一个等比数组
# 等比数组 --->有序序列， 且后一个元素 / 前一个元素的比值是恒定的
# start : 开始位置
# end : 结束位置
# num : 默认为50，指的是创建的数组的元素的个数
# endpoint :默认为True，指的是包含结束位置
# base ： 默认为10 ，指的是底数
arr = np.logspace(0, 1, 3) # 指的是从10^0 到 10^1 创建一个长度为3的等比数组
arr1 = np.logspace(0, 2, 3, base=2) # 指的是从2^0 到 2^2 创建一个长度为3的等比数组
print('arr:\n', arr1)
print('arr 类型:\n', type(arr1))
4、 Numpy.zeros 函数创建全部为 0 的数组
Numpy.zeros(shape, dtype=None, order='C')
| 参数名称 | 说明 |
|---|---|
| shape | 接收元组，表示生成数组的形状 |
| dtype | 接收 data-type。表示数组所需的数据类型 |
代码实现：
# 4、使用np.zeros来创建一个全部为0的数组 ----占位
# shape : 创建的数组的形状
arr = np.zeros((2, 3))
print('arr:\n', arr)
print('arr 类型：\n', type(arr))
5、 Numpy.ones 函数创建全部为 1 的数组
Numpy.ones(shape, dtype=None, order='C')
| 参数名称 | 说明 |
|---|---|
| shape | 接收元组，表示生成数组的形状 |
| dtype | 接收 data-type。表示数组所需的数据类型 |
代码实现：
# 5、使用np.ones创建一个全部为1的数组 ---占位
# shape:创建的数组的形状
arr = np.ones((2, 2, 3))
print('arr:\n', arr)
print('arr 类型：\n', type(arr))
6、 Numpy.diag 函数创建类似对角矩阵的数组
Numpy.diag(v, k=0)
| 参数名称 | 说明 |
|---|---|
| v | 接收 array 或者 list |
代码实现：
# 6、使用np.diag来创建一个类似于对角矩阵的数组
arr = np.diag(v=[1, 2, 3, 4], k=0)
arr1 = np.diag(v=[1, 2, 3, 4], k=-2)
# 当v 为一维时，k=0, 此时v即为创建的对角数组的对角线元素
# 当v 为一维时，k!= 0, 此时 是将 v指定的元素 向上或向下移动k个单位
v = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9], [10, 11, 12]])
print('v:\n', v)
arr2 = np.diag(v=v, k=0)
arr3 = np.diag(v=v, k=1)
# # 当v 为二维时，k=0时，获取的是v的对角线位置元素组成的数组
# # 当v 为二维时，k !=0 , 获取的是 v 对角线位置，然后沿着对角线 移动k个单位所处的元素
print('arr:\n', arr)
print('arr 类型:\n', type(arr))
7、 Numpy.eye 函数创建一个类似于单位矩阵的数组
Numpy.eye(N, M=None, k=0, dtype=float)
| 参数名称 | 说明 |
|---|---|
| N | 生成数组的行数，默认生成一个行数与列数相等的类似于单位矩阵的数组 |
| dtype | 接收 data-type。表示数组所需的数据类型 |
代码实现：
# 8、使用np.eye来创建一个类似于单位矩阵的数组
# # N ：行数
# # M 默认为None，指的是列数
# # 如果N,M 传递一个参数，默认N=M=传递的参数
arr = np.eye(3, k=0)
arr1 = np.eye(N=3, M=4, k=0)
arr2 = np.eye(N=4, M=3, k=0)
# # 如果N M 不相等，也会生成一个类似于单位矩阵的数组（注意）
# # 如果k !=0 时，对角线上的1 会上下移动k个单位
print('arr:\n', arr)
print('arr 类型:\n', type(arr))
2、随机值数组创建
手动创建数组往往达不到要求，Numpy 提供了强大的生成随机数的功能
1、创建一个[0,1)的均匀分布的随机数组
均匀分布：
| 参数名称 | 说明 |
|---|---|
| size | 接收 int 或者元组，表示生成数组的元素或者生成数组的形状 |
代码实现：
# 1、使用 np.random.random 来创建一个[0,1）均匀分布的数组
# 均匀分布
# 参数size : 可以是指定创建的数组的元素个数，也可以为创建的数组的形状
arr = np.random.random(10)
arr1 = np.random.random((2,3))
print('arr:\n', arr)
print('arr 类型:\n', type(arr))
也可以使用 np.random.rand
| 参数名称 | 说明 |
|---|---|
| *dn | 接收可变参数，一般为生成数组的元素的个数或者生成数组的行、列数 |
代码实现：
# 也可以使用np.random.rand来创建一个[0,1)服从均匀分布的数组
# 参数: 可以是创建的数组的元素个数，也可以是创建的数组的行、列数，但是不能为形状
arr = np.random.rand(10)
# arr1 = np.random.rand((2,3)) # 错误的，不能为形状
arr2 = np.random.rand(2, 3)
print('arr:\n', arr)
print('arr 类型:\n', type(arr))
2、创建一个符合标准正态分布的数组
可以使用 np.random.randn 来创建一个符合标准正态分布的数组
标准正态分布：
| 参数名称 | 说明 |
|---|---|
| *dn | 接收可变参数，一般为生成数组的元素的个数或者生成数组的行、列数 |
代码实现：
# 2、可以使用np.random.randn来创建一个服从标准正态分布的数组
# 标准正态分布
# 参数： 可以是创建的数组的元素个数，也可以是创建的数组的行、列数，但是不能为形状
arr = np.random.randn(10)
# arr = np.random.randn((2,3)) # 错误的，不能为形状
arr1 = np.random.randn(2,3)
print('arr:\n', arr)
print('arr 类型:\n', type(arr))
3、创建一个指定范围内的随机整数数组
可以使用 np.random.randint 来创建指定范围内[low,high)的随机整数数组
np.random.randint(low, high=None, size=None, dtype='l')
| 参数名称 | 说明 |
|---|---|
| low | 接收 int,表示生成随机整数数组的范围的最小值 |
| high | 接收 int，表示生成随机整数数组的范围的最大值，默认不包含最大值，所 以注意：low<high |
| size | 接收 int 或者元组，表示生成随机整数数组的元素个数或者生成随机整数数 组的形状 |
| dtype | 接收 data-type。表示数组所需的数据类型 |
代码实现：
# 3、使用np.random.randint 来创建一个 [low,high)的随机整数数组
# low :最小值
# high：最大值（不包含）
# size： 可以是创建的数组的元素个数，也可以是创建的数组的形状
arr = np.random.randint(low=1, high=10, size=10)
arr1 = np.random.randint(low=1, high=10, size=(2, 3))
print('arr:\n', arr)
print('arr 类型:\n', type(arr))
# 4、可以np.random.uniform来创建[low,high)随机小数数组
# 随机分布：落在各个区间内的概率是相同的
# low :最小值
# high :最大值（默认不包含）
# size :以是创建的数组的元素个数，也可以是创建的数组的形状
arr = np.random.uniform(low=0.0, high=1.0, size=10)
arr1 = np.random.uniform(low=0.0, high=1.0, size=(2,3))
print('arr:\n', arr)
print('arr 类型:\n', type(arr))
也可以使用 random 模块进行其他随机数的生成
| 函数 | 说明 |
|---|---|
| seed | 确定随机数生成器的种子 |
| permutation | 返回一个序列的随机排列或返回一个随机排列的范围 |
| shuffle | 对一个序列进行随机排序 |
| binomial | 产生二项分布的随机数 |
| normal | 产生正态（高斯）分布的随机数 |
| beta | 产生 beta 分布的随机数 |
| chisquare | 产生卡方分布的随机数 |
| gamma | 产生 gamma 分布的随机数 |
六、数组索引
1、一维数组索引
import numpy as np
# # 创建一个一维数组
arr = np.array([2, 3, 1, 5, 6, 4, 0])
print('arr:\n', arr)
print('arr 类型:\n', type(arr))
#
# # 获取 arr 中 1 元素 --下标
print('获取arr 中的 1 元素：', arr[2])
#
# # 获取 arr 中的 4 元素 --下标
print('获取 arr 中的 4 元素：', arr[-2])
#
# # 获取 arr 中 1 元素 ---切片
print('获取 arr 中的 1元素：', arr[2:3:1])
#
# # 获取 arr 中的 4 元素 ---切片
print('获取 arr 中的 4 元素：', arr[-2:-1:1])
#
# # 获取 arr 中的 1 和 4 元素 ---切片 ---->下标是有规律的
print('获取 arr 中的 1和4 元素：', arr[2:-1:3])
#
# # 获取 arr 中的 1 和 5 和 4 元素 --下标列表
print('获取 arr 中 1 和 5 和 4 元素：', arr[[2, 3, -2]])
#
# # 索引元素的时候，使用下标，会造成数据维度降低
# # 使用切片不降低维度
# # 使用下标列表---->分别获取下标列表里面各个下标的值 --->再组合起来
2、二维数组索引
# 创建二维数组
arr = np.array([[1, 2, 3, 4],
[5, 6, 7, 8],
[9, 10, 11, 12],
[13, 14, 15, 16]])
print('arr:\n', arr)
print('arr 类型：\n', type(arr))
# 获取 arr 里面的 6 元素 --下标
print('获取 arr 里面的 6元素：', arr[1, 1])
# 获取 arr 里面的 15 元素 --下标
print('获取 arr 里面的 15 元素：', arr[3, -2])
# 获取 arr 里面的 6 元素 --切片
print('获取 arr 里面的 6元素：', arr[1:2, 1:2])
# 获取 arr 里面的 15 元素 -切片
print('获取 arr 里面的 15 元素：', arr[-1:, -2:-1])
# 获取 arr 里面的 [6 8 10 11] 元素 --下标列表 -- 前后一一对应
print('获取 arr 里面的 [6 8 10 11] 元素:', arr[[1, 1, 2, 2], [1, 3, 1, 2]])
# 下标列表 ---分别获取对应下标的值 --再进行组合
# 获取 arr 里面的
# [[6 7]
# [10 11]] 元素 ---切片---下标有规律的
print('获取 arr 里面的多个元素：\n', arr[1:3, 1:3])
3、多维数组索引
# 创建二维数组
arr = np.array([[1, 2, 3, 4],
[5, 6, 7, 8],
[9, 10, 11, 12],
[13, 14, 15, 16]])
print('arr:\n', arr)
print('arr 类型：\n', type(arr))
# arr三维数组----> arr[块,行,列]
# arr n维数组 ----> arr[n-1个逗号] n-1个逗号将各个维度分开，在各个维度上分别索引
# 利用高维度数组 是由 低维度数组组成 ---这一思路
# 获取arr 里面的6 元素
print('arr里面的6元素：',arr[1][1])
# 利用bool数组索引 ---干掉False 保留True
# 注意：bool数组的长度必须 要和你 索引的维度 的大小相同
# 先创建一个bool数组
mask = np.array([0, 1, 1, 0], dtype=np.bool)
# print('mask:', mask)
# 利用mask来索引二维数组
print('bool数组索引：\n', arr[mask, :])
print('bool数组索引：\n', arr[:, mask])
print('bool数组索引：\n', arr[mask, mask]) # 同行列都是下标列表的理解方式相同
print('bool数组索引：\n', arr[[False, True, True, False], [False, True, True, False]])
七、数组形状变换
Ndarray 数组的形状可以通过 shape 属性来获取，返回一个 tuple 类型的形状
关于形状，可以在创建数组的时候可以通过shape参数来指定创建数组的形状，如在上 面创建全部为 0，全部为1的数组的过程中，使用了shape参数指定创建数组的形状
那么一旦数组已经创建，那么如何来修改数组的形状呢？
可以使用 shape 属性重新赋值来更改已定数组的形状，如：
1、基于 shape 属性变换
代码实现：
import numpy as np
# 创建一个一维数组
arr = np.arange(6)
print('arr:\n', arr)
# 将arr 的形状 修改 二维
# 1、shape 属性重新赋值
arr.shape = (2, 3)
print('arr:\n', arr)
print('arr:\n', arr.shape)
2、基于 reshape 函数变换
可以使用 reshape 函数来进行数组已定形状的更改
代码实现：
# 创建一个一维数组
arr = np.arange(6)
print('arr:\n', arr)
# 2、是用reshape方法来修改形状
arr = arr.reshape((2, 3))
print('arr:\n', arr)
print('arr:\n', arr.shape)
# reshape与shape最大的区别在于reshape返回新的数组，而shape是直接对原数组产生修改
# 注意：reshape((-1,1)) # -1在此时的作用是占位作用，只要保证将arr转化为二维且为1列
arr = arr.reshape((-1, 1))
print('arr:\n', arr)
print('arr:\n', arr.shape)
# 注意：转换形状的时候，元素的个数不能改变，否则报错
但是，值得注意的是：在修改已定数组的形状的时候，必须要保证修改前的元素个数必 须和修改之后的元素个数相等，否则报错
此时还需要注意一种情况，就是 reshape((-1,1))这样的情况
那么在学习完数组创建 api 及 reshape 的情况下，就可以使用 np.arange 和 reshape 连用来创建一个高维度数组
代码实现：
# 使用 np.arange 和 reshape连用来创建高维度数组
arr = np.arange(16).reshape((4, 4))
print('arr:\n', arr)
3、基于 np.flatten 与 np.ravel 函数变换
那么思考一个问题：可以使用 np.arange 和 reshape
可以创建高维度数组，那么如何将 高维度数组展开为一维呢？
（1）shape 属性重新赋值
（2）reshape 也可以
（3）可以使用 np.flatten 与 np.ravel 来将高维度数组展开为一维，
代码实现：
# 如何又将高维度数组展开为一维呢？？？
# 1、shape属性重新赋值
arr.shape = (-1,) # -1 是占位作用
print('arr:\n', arr)
# 2、reshape 方法
arr = arr.reshape((-1,))
print('arr:\n', arr)
# 使用 np.arange 和 reshape连用来创建高维度数组
arr = np.arange(16).reshape((4, 4))
print('arr:\n', arr)
# 3、flatten 方法 ---复制一份内存
arr = arr.flatten('C')
arr1 = arr.flatten('F')
print('arr:\n',arr)
print('arr:\n',arr1)
# 4、ravel 方法 ---不复制
arr = arr.ravel('C')
arr = arr.ravel('F')
print('arr:\n', arr)
八、数组合并和拆分
1、数组合并
可以使用 np.hstack、np.vstack、np.concatenate 来进行数组的拼接合并
axis轴的方向如图：
import numpy as np
# 创建数组1
arr1 = np.array([[1, 2], [3, 4]])
# 创建数组2
arr2 = np.zeros((2, 2), dtype=np.int32)
print('arr1:\n', arr1)
print('arr2:\n', arr2)
print('*' * 100)
# 向右拼接 ---水平拼接
all_arr = np.hstack((arr1, arr2))
print('all_arr:\n', all_arr)
# 向下拼接 ---垂直拼接
all_arr = np.vstack((arr1, arr2))
print('all_arr:\n', all_arr)
# 可以使用np.concatenate实现向右 向下的拼接
# axis --->轴的方向
# axis = 0 --->行的方向 --->向下 --- np.vstack
all_arr = np.concatenate((arr1, arr2), axis=0)
print('all_arr:\n', all_arr)
# axis=1 ---->列的方向 ---->向右 ---np.hstack
all_arr = np.concatenate((arr1, arr2), axis=1)
print('all_arr:\n', all_arr)
2、数组拆分
可以使用 np.hsplit、np.vsplit、np.split 来将数组进行拆分
代码实现：
# 拆分
# 创建一个大的二维数组
arr = np.arange(16).reshape((4, 4))
print('arr:\n', arr)
# 拆分
# ---vsplit -- 将行的方向进行拆分--(将行的方向进行打断)
# ---hsplit -- 将列的方向进行拆分--（将列的方向进行打断）
# 注意：此时为平均拆分，需要被整除
split_res = np.vsplit(arr, 2)
print('split_res:\n',split_res)
split_res = np.hsplit(arr, 2)
print('split_res:\n', split_res)
# split ---同 vsplit
split_res = np.split(arr, 2, axis=0)
print('split_res:\n',split_res)
# split --同 hsplit
split_res = np.split(arr, 2, axis=1)
print('split_res:\n', split_res)
# 注意：在拆分的时候，这样指定
# :1,1:3,3: --->三部分
# arr[:1,:]
# arr[1:3,:]
# arr[3:,:]
split_res = np.split(arr, [1, 3], axis=0)
print('split_res:\n', split_res)
# 注意：一般不使用拆分 ---如果真要想获取部分数据---使用数组索引
# 获取前3列为一部分 ，最后1列为一部分
split_res_1 = arr[:, :3]
split_res_2 = arr[:, -1:]
print('split_res_1:\n', split_res_1)
print('split_res_2:\n', split_res_2)
注意：
# 注意：一般不使用拆分 ---如果真要想获取部分数据---使用数组索引
# 获取前3列为一部分 ，最后1列为一部分
split_res_1 = arr[:, :3]
split_res_2 = arr[:, -1:]
print('split_res_1:\n', split_res_1)
print('split_res_2:\n', split_res_2)
# # 如：不想要某列数据 --->bool数组索引
# # 创建一个数组
arr = np.arange(12).reshape((2, 6))
print('arr:\n', arr)
#
# # 创建bool数组
mask = np.array([1, 1, 0, 1, 0, 1], dtype=np.bool)
print('mask:\n', mask)
#
# # 进行筛选
res = arr[:, mask]
print('res:\n', res)
