Numpy是什么？

Numpy 是 Numerical Python 的简写，是Python数值计算的基石。特别是数组与向量化计算，Numpy可以针对全量数组进行复杂计算而不需要写Python循环。Numpy提供多种数据结构、算法以及大部分设计Python数值计算所需的接口。Numpy还包括以下内容：

• 快速、高效的多维数组对象ndarray
• 基于元素的数组计算或数组间数学操作函数
• 用于读写硬盘中基于数组的数据集的工具
• 线性代数操作、傅里叶变换以及随机数生成
• 成熟的C语言API，允许Python拓展和本地的C或C++代码访问Numpy的数据结构和计算设施。

Numpy的另一个主要用途是在算法和库之间作为数据传递的数据容器。

下面是Numpy的一个不算太全的大纲：

---

一、Numpy的优势

Numpy(Numerical Python)是一个开源的Python科学计算库，用于快速处理任意维度的数组。
Numpy支持常见的数组和矩阵操作，对于同样的数值计算任务，使用Numpy比直接使用Python要简洁的多。
Numpy使用ndarray(n-dimensional array object)对象来处理多维数组，该对象是一个快速而灵活的大数据容器。

二、ndarray对象

1. 为什么需要ndarray对象？

NumPy的核心特征之一，就是N-维数组对象–ndarray。ndarray是python中快速、灵活的大型数据集容器。

ndarray是储存单一数据类型的多维数组，是一个快速而灵活的大数据容器。

一个ndarray是一个通用的多维同类数据容器，也就是说，它包含的每一个元素均为相同类型。

提问：使用Python列表可以存储一维数组，通过列表嵌套可以实现多维数组，那么为什么还需要使用Numpy的ndarray对象呢？

以下进行ndarray与Python原生list运算效率对比，（假设一个numpy数组包含100万个整数，还有一个同样数据内容的Python列表）：

nndarray_list = np.arange(1000000)
python_list = list(range(1000000))
# 原生python list求和
t1 = time.time()
a = sum(python_list)
t2 = time.time()
d1 = t2 - t1 # 计算求和的时间差
# ndarray求和
t3 = time.time()
b = np.sum(nndarray_list)
t4 = time.time() # 计算求和的时间差
d2 = t4 - t3
# 输出最后的计算时间对比
print(d1) # 0.022939205169677734
print(d2) # 0.0

从中我们看到ndarray的计算速度要快很多，节约了时间。而机器学习的最大特点就是大量的数据运算。
Numpy专门针对ndarray的操作和运算进行了设计，所以数组的存储效率和输入输出性能远优于Python中的嵌套列表，数组越大，Numpy的优势就越明显。

2. ndarray优势

1、存储风格：ndarray存储相同类型，通用性不强；list可以存储不同类型，通用性很强。
2、并行化运算：ndarray支持并行化运算（向量化计算）。
3、低层语言：Numpy低层使用C语言编写，内部解除了GIL(全局解释器锁)，其对数组的操作速度不受Python解释器的限制，效率远高于纯Python代码。

3. ndarray属性

认识N维数组-ndarray属性（数组属性反映了数组本身固有的信息）

• ndarray.shape：形状（数组维度的元组）
• ndarray.ndim：维度（数组维数）
• ndarray.size：总共有多少个元素（数组中的元素数量）
• ndarray.itemsize：一个数组元素的长度了（字节）
• ndarray.dtype：类型（数组元素的类型）（在创建ndarray的时候，若不指定，整数默认是int64，小数默认是float64）

# 以代码形式介绍ndarray的各个属性
score = np.array([[80, 89, 86, 67],
                  [78, 97, 89, 67],
                  [91, 91, 90, 67],
                  [86, 85, 83, 67],
                  [78, 98, 67, 89]])
print(score)
print(score.shape) # (5, 4),五行四列
print(score.ndim) # 2
print(score.size) # 20
print(score.dtype) # int32
print(score.itemsize) # 4

三、基本操作

1. 生成数组方法（重点掌握）

下面四种方法主要以代码进行介绍

1.1 生成0和1的数组

np.zeros()：数组元素都是float类型的0.
np.ones()：数组元素都是1

# 生成0和1的数组
# 可以用元组也可以用列表来表示形状，下面这行代码生成float32类型的三行四列的二维数组
data1 = np.zeros(shape=(3, 4), dtype='float32') 
print(data1) # 数组元素都是float类型的0
print(data1.dtype) # float32

data2 = np.ones(shape=[2, 3], dtype=np.int32)
print(data2) # 数组元素都是1
print(data2.dtype) # int32

1.2 从现有数组生成

np.array()，深拷贝
np.asarray()，浅拷贝
np.copy()，深拷贝

# -- 从现有数组生成
score = np.array([[80, 89, 86, 67],
                  [78, 97, 89, 67],
                  [91, 91, 90, 67],
                  [86, 85, 83, 67],
                  [78, 98, 67, 89]])
# 以三种方式从现有数组中生成
data1 = np.array(score)
data2 = np.asarray(score)
data3 = np.copy(score)
print(data1) # 无变化
print(data2) # 无变化
print(data3) # 无变化

# 修改原数组score中的[3, 1]值后
score[3, 1] = 1000
print(data1) # 无变化 深拷贝
print(data2) # 变化 浅拷贝（data2中的[3, 1]元素，与原数组一起发生改变）
print(data3) # 无变化 深拷贝

对深拷贝和浅拷贝进行补充解释：
浅拷贝：指的是重新分配一块内存，创建一个新的对象，但里面的元素是原对象中各个子对象的引用。
深拷贝：是指重新分配一块内存，创建一个新的对象，并且将原对象中的元素，以递归的方式，通过创建新的子对象拷贝到新对象中。因此，新对象和原对象没有任何关联。

1.3 生成固定范围的数组

np.linspace(a, b, c)：生成a-b之间的数，[a, b]左右都包含，c个数，每个数之间等距离（相等差）。
np.arange(a, b, c)：生成a-b之间的数，[a, b)不包含b，c是步长，与range类似。(range(a, b, c)：a-b之间，不包含b，c是步长)。

# 生成固定范围的数组
data1 = np.linspace(0, 10, 5)
print(data1) # [ 0.   2.5  5.   7.5 10. ]

data2 = np.arange(0, 10, 5)
print(data2) # [0 5]

1.4 生成随机数组

np.random

先对 “ 均匀分布 ” 与 “ 正态分布 ”进行介绍
均匀分布：（Uniform Distribution）是概率统计中的重要分布之一；均匀表示可能性相等的含义。

• np.random.rand(d0, d1, …, dn)

   返回(0.0, 1.0)内的一组均匀分布的数。
   1、该函数旨在输出0~1的正态分布随机数。
   2、其参数可以是1个，也可以是多个。
   3、函数内部可以不写参数，默认为1，输出1个随机数。
   4、输出的是0~1范围内的正态分布。输出的结果可以是一维列表，也可以是多维列表。多为列表的索引类似套娃。
  

• np.random.uniform(low=0.0, high=1.0, size=None)

   从一个均匀分布[low,high)中随机采样，定义域是左闭右开，包含low，不包含high
   low:采样下界，float类型，默认值是0
   high:采样上界，float类型，默认值是1
   size:输出样本数目，为int或元组(tuple)类型，
   返回值:ndarray类型，其形状和参数size中描述一致。
  

• np.random.randint(low, high=None,size=None,dtype=‘I’)

   从一个均匀分布中随机采样，生成一个整数或N维整数数组；
   取数范围：若high不为None时，取[low,high)之间随机整数，否则取值[0, low)之间随机整数。
   1、该函数的参数不能为空！否则会报错。
   2、该函数输出的是整数型，包头不包尾，函数内部参数有：low, high, size, dtype，其中，low必须小于high，size可以不写，默认为1。
   3、np.random.randint() 输出的是随机int构成的数组。一维数组，输出时函数会提醒索要输入的参数。依然包头不包尾。
  

---

正态分布：正态分布是一种概率分布。正态分布是具有两个参数u和a的连续型随机变量的发布，第一个参数u是服从正态分布的随机变量的均值，第二个参数a是此随机变量的标准差，所以正态分布记作N(u, a)。

图像分析：（u=0,a2=0.2）（u=0,a2=1.0）（u=0,a*2=5.0）,标准差越小，分布越集中，标准差越大，分布越散。

正态分布的应用：生活、生产与科学实验中，很多随机变量的概率分布都可以近似的用正态分布来描述。

正态分布特点：u决定了其位置，其标准差a决定了分布的幅度。当u=0，a=1时的正态分布是标准正态分布。

• np.random.randn(d0, d1, …, dn)

   从标准正态分布中返回一个或多个样本值。
   1、该函数也可以选择传入参数，如果无参数，默认生成一个随机数。
   2、random.randn()中包含的正态分布不再局限于0~1
   参数为1个的时候，输出的是一维数组，一维数组的个数为参数。
   参数为2个的时候，输出2维数组，第一个参数决定二维数组中一维数组的个数，第二个参数确定每个一维数组中数据的个数。
   参数为3个的时候，输出3维数组，第一个参数确定三维数组中二维数组的个数，第二个参数确定二维数组中一维数组的个数……以此类推
  

• np.random.normal(loc=0.0,scale=1.0,size=None)

   loc：float,此概率分布的均值(对应这整个分布的中心centre)
   scale：float,此概率分布的标准差(对应与分布的宽度，scale越大越矮胖，scale越小越瘦高)
   size：int or tuple of ints,输出的shape(形状)，默认是None，只输出一个值
  

• np.random.standard_normal(size=None)

   返回指定形状的标准正态分布的数组
  

下面是示例代码，方便理解：

# 均匀分布
data1 = np.random.uniform(low=-1, high=1, size=100000)
print(data1)
print(data1.shape) # (100000,)
plt.figure(figsize=(20, 8), dpi=80) # 创建画布
plt.hist(data1, 1000,) # 绘制直方图
plt.show() # 显示图像

# 正态分布
data2 = np.random.normal(loc=1.75, scale=0.1,size=1000000)
print(data2)
plt.figure(figsize=(20, 8), dpi=80) # 创建画布
plt.hist(data2, 1000,) # 绘制直方图
plt.show() # 显示图像

2. 数组的索引、切片

案例：随机生成8只股票2周的交易日涨幅数据;8只股票，两周（10天）的涨跌幅数据，如何获取？
两周的交易日数量为：2*5=10；随机生成涨跌幅在某个正态分布内，比如均值0，方差1

下面是示例代码，方便理解：

# 获取符合正态分布的8只股票10天的涨跌幅数据
stock_change = np.random.normal(0, 1, (8, 10))
print(stock_change)

# 二维数组的索引与切片（获取第一个股票的“前三个”交易日的涨跌幅数据）
print(stock_change[0, 0:3])

# 三位数组的索引与切片
a1 = np.array([[[1, 2, 3], [4, 5, 6]], [[11, 12, 13], [14, 15, 16]]])
print(a1.shape) # (2, 2, 3)
print(a1[1, 1, 1]) # 15

补充：
1、不写切片值的 [:] 将会引用数组的所有值。

2、数组的切片是原数组的视图。这意味着数据并不是被复制了，任何对于视图的修改都会反映到原数组上。如果你想要一份数组切片的拷贝而不是一份视图的话，你就必须显式的复制这个数组，例如arr[5:8].copy()。

3. 形状修改

让上一例子中的股票行，日期列反过来，变成日期行，股票列。

1、ndarray.reshape(shape[,order])：返回一个新的ndarray，原始数据没有改，其中包含具有新形状的相同数据,（数据排列没有变，理解为分割，改变了形状）

2、ndarray.resize(new_shape[,refcheck])：改变阵列的形状和大小（没有返回值，对原始的ndarray进行了修改,数据排列没有变，理解为分割，改变了形状）

3、ndarray.T：数组的转置（将数组的行、列进行互换）

下面是示例代码，方便理解：

# ndarray.reshape(shape[,order])
stock_change = np.random.normal(0, 1, (8, 10))
print(stock_change)
print(stock_change.shape) # (8, 10)
print(stock_change.reshape((10, 8)))

# ndarray.resize(new_shape[,refcheck])
stock_change = np.random.normal(0, 1, (8, 10))
print(stock_change)
print(stock_change.shape)
stock_change.resize((10, 8))
print(stock_change.shape)
print(stock_change)

# ndarray.T
stock_change = np.random.normal(0, 1, (8, 10))
print(stock_change)
print(stock_change.shape) # (8, 10)
# print(stock_change.T)
print(stock_change.T.shape)

4. 类型修改

ndarray.astype(type)
下面是示例代码，方便理解：

stock_change = np.random.normal(0, 1, (8, 10))
print(stock_change)
print('-----------------------')
print(stock_change.astype('int32')) # 去掉小数点后面的数

5. 数组的去重

Numpy包含一些针对一维ndarray的基础集合操作。常用的一个方法就是ndarray.unique()，返回的是数组中唯一值排序后形成的数组。

下面是示例代码，方便理解：

# ndarray.unique
temp = np.array([[1, 2, 3, 4], [3, 4, 5, 6]])
print(temp)
print(temp.shape) # (2, 4)
print(np.unique(temp)) # [1 2 3 4 5 6]
print(np.unique(temp).shape) # (6,)

另一个函数，ndarray.in1d()，可以检查一个数组中的值是否在另外一个数组中，并返回一个布尔值数组。

values = np.array([6, 0, 0, 3, 2, 5, 6])
print(np.in1d(values, [2, 3, 6])) # [ True False False  True  True False  True]

下面是对数组集合操作的一些方法：

6. 排序

和Python的内建列表类型相似，Numpy数组可以使用sort方法按位置排序：
下面是示例代码，方便理解：

arr = np.random.randn(6)
print(arr) # [-0.14614743  1.03606164  0.91044154 -0.80661417 -0.46876509  1.23726896]
arr.sort()
print(arr) # [-0.80661417 -0.46876509 -0.14614743  0.91044154  1.03606164  1.23726896]

可以在多维数组中根据传递的axis值，沿着轴向对每一个一维数据段进行排序：
sort(1)参数为1是对每一行进行排序，参数为0是对每一列进行排序

arr = np.random.randn(5, 3)
print(arr)
arr.sort(1) # 对每一行进行排序，参数为0是对每一列进行排序
print(arr)

四、ndarray运算

1. 逻辑运算（布尔索引）

下面是示例代码，方便理解：

# 这里生成8只股票10个交易日的涨跌幅数据
stock_change = np.random.normal(0, 1, (8, 10))
# 取前五行的前五列
stock_change = stock_change[0:5, 0:5] 
print(stock_change)

# 逻辑判断，如果数据的涨跌幅大于0.5就标记为True，否则为False
print(stock_change > 0.5)

# Bool赋值，将满足条件的设置为指定的值--布尔索引
# print(stock_change[stock_change > 0.5])
# 对满足条件大于0.5的进行统一的操作
stock_change[stock_change > 0.5] = 1.1
print(stock_change)

2. 通用判断函数

布尔值会被强制为1（True）和0（False）。因此，sum通常可以用于计算布尔值数组中的True的个数。

arr = np.random.randn(100)
print((arr > 0).sum()) # 正值的个数

对于布尔值数组，有以下两个非常有用的方法：
np.all(布尔值)：只要有一个False就返回False,只有全是True才返回True。
np.any(布尔值)：只要有一个True就返回True，只有全是False才返回False。

下面是示例代码，方便理解：

# 符合正态分布的8行10列的数据
stock_change = np.random.normal(0, 1, (8, 10)) 

# 判断stock_change[0:2, 0:5]是否全是上涨的
print(np.all(stock_change[0:2, 0:5] > 0)) # False

# 判断前5只股票这段期间是否有上涨的
print(np.any(stock_change[0:5, :] > 0)) # True

3. np.where（三元运算符）

我们可以通过使用np.where()方法能够进行更加复杂的运算。
使用方式：np.where(布尔值, True的位置的值, False的位置的值)

以及复合逻辑的的使用：
np.logical_and()
np.logical_or()

下面是示例代码，方便理解：

# 判断前四个股票前四天的涨跌幅，大于0的置为1，否则为0
# 符合正态分布的8行10列的数据
stock_change = np.random.normal(0, 1, (8, 10))
# 取前4行前4列
temp = stock_change[:4, :4]
print(np.where(temp > 0, 1, 0))

# 判断前四个股票前四天的涨跌幅，大于0.5并且小于1的，换为1，否则为0
print(np.where(np.logical_and(temp > 0.5, temp < 1), 1, 0))

# 判断前四个股票前四天的涨跌幅，大于0.5或者小于-0.5的，换为1，否则为0
print(np.where(np.logical_or(temp > 0.5, temp < -0.5), 1, 0))

4. 统计运算

统计聚合函数：min（最小值）、max（最大值）、mean（平均值）、median（中位数）、var（方差）、std（标准差）。

以求最大值、最小值作为示例，方便理解：

stock_change = np.random.normal(0, 1, (8, 10))
temp = stock_change[:4, :4] # 取stock_change的前4行的前4列

# temp中所有数据的最大值（两种方法都可以使用）
print(temp.max()) # ndarray.方法名（数据容器名称.方法名）
print(np.max(temp)) # numpy.函数名

# 前四只股票前四天的最大涨幅
print(temp.max(axis=1)) # 按行求得最大值，获得前4天每一天的最大涨幅股票
print(temp.max(axis=0)) # 按列求得最大值

# 返回最大值，最小值所在位置
# 统计出哪一只股票在某个交易日的涨幅最大或最小
print(np.argmax(temp, axis=1)) # 前四只股票前四天内涨幅最大{}
print(np.argmin(temp, axis=1)) # 前四只股票前四天内涨幅最小{}

5. 数组间运算

5.1 场景

以学生的平时成绩作为一个二维数组。

# 学生 平时成绩 期末成绩 最终成绩
# 1       80      86      84.2
# 2       82      80      80.6
# 3       85      78      80.1
# 4       90      90      90
# 5       86      82      83.2
# 6       82      90      87.6
# 7       78      80      79.4
# 8       92      94      93.4

# 数据：[[80, 86], [82, 80], [85, 78], [90, 90], [86, 82], [82, 90], [78, 80], [92, 94]]

5.2 数组与数之间的运算

试着尝试对数组的加、减、除运算；注意乘运算是吧原数组的元素重复了3遍。

下面是示例代码，方便理解：

# arr = np.array([[1, 2, 3, 2, 1, 4], [5, 6, 1, 2, 3, 1]])
# print(arr)
# print(arr+1)
# print(arr/2)
# # 可以对比python列表的运算，看出区别

# a = [1, 2, 3, 4, 5]
# print(a*3) # [1, 2, 3, 4, 5, 1, 2, 3, 4, 5, 1, 2, 3, 4, 5]

5.3 数组与数组之间的运算

运行程序可以发现，在对两个数组之间进行运算时报错，至于报错原因后面进行说明。

# arr1 = np.array([[1, 2, 3, 2, 1, 4], [5, 6, 1, 2, 3, 1]]) # 两行六列
# arr2 = np.array([[1, 2, 3, 4], [3, 4, 5, 6]]) # 两行四列
# print(arr1+arr2) # 能进行运算吗，结果是不行的

5.4 广播机制

Broadcast机制的功能是为了方便不同形状的ndarray（nump库中的核心数据结构）进行数学运算。当操作两个数组时，numpy会逐个比较他们的shape，只有在下述情况下，两个数组才能够进行数组与数组的运算：
1、维度相等
2、shape（其中相对应的一个地方为1）

arr1 = np.array([[1, 2, 3, 2, 1, 4], [5, 6, 1, 2, 3, 1]]) # 两行六列
arr2 = np.array([[1], [3]]) # 两行一列
print(arr1.shape) # (2, 6)
print(arr2.shape) # (2, 1)
print(arr1 * arr2)
print(arr1 / arr2)

5.5 矩阵运算（什么是矩阵、矩阵乘法、矩阵应用场景）

什么是矩阵(matrix)？
矩阵和array的区别是矩阵必须是2维的，但是array可以是多维的；矩阵一定是array，但是array不一定是矩阵。

存储矩阵的两种方式：1、ndarray数组，2、matrix数据结构
np.mat()：将数组转换成矩阵类型

下面是示例代码，方便理解：

data = np.array([[80, 86], [82, 80], [85, 78], [90, 90], [86, 82], [82, 90], [78, 80], [92, 94]]) # 使用数组存储八行两列的二维数组
data_mat = np.mat([[80, 86], [82, 80], [85, 78], [90, 90], [86, 82], [82, 90], [78, 80], [92, 94]]) # 使用matrix存储相同的数据
print(data_mat) #  # <class 'numpy.ndarray'>
print(type(data_mat)) # <class 'numpy.matrix'>

矩阵乘法运算的两个关键：
1、形状改变 (m,n) * (n,l) = (m,l)
2、运算规则 ：设A为m * p的矩阵，B为p * n的矩阵，那么称m*n的矩阵C为矩阵A与B的乘积，记作C=AB，其中矩阵C中的i行j列元素可以表示为（与线代矩阵相似）

矩阵乘法api（使用ndarray方式存储的矩阵，可以用这两种方法）：np.matmul()，np.dot()，其中np.dot(x, y)等价于x.dot(y)。
下面是示例代码，方便理解：

data = np.array([[80, 86], [82, 80], [85, 78], [90, 90], [86, 82], [82, 90], [78, 80], [92, 94]])
data_mat = np.mat([[80, 86], [82, 80], [85, 78], [90, 90], [86, 82], [82, 90], [78, 80], [92, 94]])
proportion = np.array([[0.3], [0.7]])
proportion_mat = np.mat([[0.3], [0.7]])
print(type(proportion)) # <class 'numpy.ndarray'>
print(type(proportion_mat)) # <class 'numpy.matrix'>

# （使用ndarray方式存储的矩阵，可以用这两种方法）
# print(np.matmul(data, proportion)) # (8,2)*(2,1)=(8,1)
# print(np.dot(data, proportion)) # # (8,2)*(2,1)=(8,1)

# （如果是matrix类型，可以直接乘）
print(data_mat * proportion_mat) # 与上面两个方式输出一样的结果

常用的矩阵函数：

6. 通用函数（快速的逐元素数组函数）

调用函数，也可以称为ufunc，是一种在ndarray数据中进行逐个元素操作的函数。分为：

一元通用函数：某些简单函数接受一个或多个标量数值，并产生一个或多个标量结果，而通用函数就是对着些简单函数的向量化封装。

二元通用函数：会接收两个数组并返回一个数组作为结果。

下面是示例代码，方便理解，
使用一元通用函数sqrt和exp函数：

# 比如sqrt或exp函数：
arr = np.arange(10)
print(arr)
print(np.sqrt(arr))
print(np.exp(arr))

使用二元通用函数maximun和modf函数：

# 比如maximum或modf函数：
x = np.random.randn(8)
y = np.random.randn(8)
print(x) # [-0.98657161 -1.10721513 -1.09449583 -0.58143697  1.02293088 -0.00915819 0.40674858 -0.3533227 ]
print(y) # [ 0.73609248 -0.50559984  0.33405018 -1.75666408  2.02588057  0.75095775 0.83204865 -0.3073611 ]
# maximum函数逐个元素地将x和y中元素的最大值计算出来
print(np.maximum(x, y)) # [ 0.73609248 -0.50559984  0.33405018 -0.58143697  2.02588057  0.75095775 0.83204865 -0.3073611 ]

arr = np.random.randn(7) * 5
print(arr)
# modf函数返回一个浮点值数组的小数部分和整数部分
remainder, whole_part = np.modf(arr) # [-12.50008176   3.10735121  -4.728658     4.1094753   -0.46531775 0.6040996   -0.42747267]
print(remainder) # [-0.50008176  0.10735121 -0.728658    0.1094753  -0.46531775  0.6040996-0.42747267]
print(whole_part) # [-12.   3.  -4.   4.  -0.   0.  -0.]

五、合并、分割

实现数据的切分和合并，将数据进行切分合并处理。

1、合并

np.hstack()：水平拼接
np.vstack()：竖直拼接
np.concatenate()：指定轴拼接；axis=0表示竖直拼接，axis=1表示水平拼接。

下面是示例代码，方便理解：

# np.hstack()：水平拼接
a = np.array((1, 2, 3))
b = np.array((2, 3, 4))
print(np.hstack((a, b)))
a = np.array([[1], [2], [3]])
b = np.array([[2], [3], [4]])
print(np.hstack((a, b)))

# np.vstack()：竖直拼接
a = np.array([1, 2, 3])
b = np.array([2, 3, 4])
print(np.vstack((a, b)))
a = np.array([[1], [2], [3]])
b = np.array([[2], [3], [4]])
print(np.vstack((a, b)))

# np.concatenate：指定轴拼接
a = np.array([[1, 2], [3, 4]])
b = np.array([[5, 6]])
print(np.concatenate((a, b), axis=0)) # 竖直拼接
print(np.concatenate((a, b.T), axis=1)) # 水平拼接 (b.T表示先把b进行转置，才能水平拼接)

2、分割

np.split(ary,indices_or_sections,axis=0)

下面是示例代码，方便理解：

x = np.arange(12.0) # [0. 1. 2. 3. 4. 5. 6. 7. 8.]
print(np.split(x, 3)) # 平等分割
# [array([0., 1., 2., 3.]), array([4., 5., 6., 7.]), array([ 8.,  9., 10., 11.])]

print(np.split(x, [3, 5, 6, 10])) # 按索引进行分割
# [array([0., 1., 2.]), array([3., 4.]), array([5.]), array([6., 7., 8., 9.]), array([10., 11.])]

---

总结

一步一个脚印，lyy加油！