Python数据分析——Numpy

纯个人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], 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）数据类型转换

a = np.array([1, 2, 3, 4, 5], dtype=int)
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")  # ————> 2（2维数组）

3、numpy数组计算

1）最基础的一维向量的加减乘除

# 简单加减乘除
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]

注意：如果是跟一个数字进行计算，就会把每一个元素都跟这个数计算

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）向量的点乘

# 点乘
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*8=24），2行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*3=12个元素

[将多维数组展开成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...), axis=0)】

# 用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...))】

# 用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)】

# 用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))】，类似将两个数组合并后，再【转置】
# 用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]])
# 一样，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=维度)】

# 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(数组, 分几份)】

# 用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函数，所以不变