AI算法工程师 | 03人工智能基础-Python科学计算和可视化（一）Numpy

Python 之 科学计算模型 Numpy

NumPy（Numerical Python）是科学计算基础库，提供大量科学计算相关功能，比如数据统计，随机数生成等。其提供最核心类型为多维数组类型（ndarray），支持大量的维度数组与矩阵运算，Numpy 支持向量处理 ndarray 对象，提高程序运算速度。

Numpy 的功能：主要用于数组计算。Numpy 可以让用户在 Python 语言中使用向量和数学矩阵，如果想通过 Python 语言学习数据科学、人工智能（包括深度学习、语言处理等分支），就必须学习 Numpy。

使用 Numpy 好处：有很多默认函数供我们使用，去做数据分析。且 Numpy 的兼容性非常好。

一、Numpy 开发环境搭建

说明

• Numpy 属于第三方程序库，在使用 Numpy 之前必须安装 Numpy。
• 如果使用的是 Anaconda Python 开发环境，则 Numpy 已经集成到Anaconda 环境中了，不需要再安装。

测试与安装

若不清楚 Python 环境是否安装了 Numpy，可先测试：

• Windows电脑中按键 win + R 后输入“cmd” → 在 cmd 的命令窗口输入 python →
• 进入 python 环境中后，输入 import numpy as np 并回车 →
• 若输入后提示模块没有找到“ModuleNotFoundError: No module named 'numpy'”，说明未安装 Numpy；若什么都没显示，则说明已安装。
• 注：输入 exit() 可退出 python 环境。

cmd 中使用 pip 命令安装 Numpy：

# 命令 1（不指定版本）
pip install numpy

# 命令 2（指定对应版本号），如：
pip install numpy==1.14.5

安装完成后，可使用 numpy 模块，每次使用前需要写导入模块的语句，如：

import numpy as np # 导入模块并起别名 

图示

使用

通过numpy模块创建一个一维数组：（在使用前需先导入模块）

import numpy as np # 导入模块并起别名
np.arange(10) # 创建数组

array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])

type(np.arange(10)) # 查看类型

numpy.ndarray

小贴士

• 返回值类型 numpy.ndarray 是 Numpy 中特有的数组类型。
• 如果传入 arange 函数 的参数值是 n，那么 arange 函数会返回 0 到 n-1 的 ndarray 类型的数。

二、数组的创建

知识补充 - 获取 shape 形状

• 通过 ndarray 类的 shape 属性可以获得数组每一维的元素个数（元组形式）

import numpy as np # 导入模块并起别名
arr = np.arange(10)
arr.shape # 获取所对应的形状（输出表示：有10个元素的一元组）

(10,)

• 也可以通过 shape[n] 形式获得每一维的元素个数，其中 n 是维度，从 0 开始

arr.shape[0] # 第一个维度所对应的元素个数

10

1. array 创建

array 函数的介绍

numpy 模块的 array 函数可以生成多维数组。例如：

• 如果要生成一个二维数组，需要向 array 函数传递一个列表类型的参数；
• 每一个列表元素是一维的 ndarray 类型数组，作为二维数组的行。

通过 array 转化

Python 的 list

Numpy 的 ndarray

语法格式：

# 括号内除 object，其余参数都是可选的，非必选
numpy.array(object, dtype = None, copy = True, order = None, subok = False, ndmin = 0)

参数说明：

名称	描述
object	数组或嵌套的数列
dtype	数组元素的数据类型，可选
copy	对象是否需要复制，可选
order	创建数组的样式，C 为行方向，F 为列方向，A 为任意方向（默认）
subok	默认返回一个与基类类型一致的数组
ndmin	指定生成数组的最小维度

示例 - array 函数的使用

创建一维数组：

• 使用 array 创建一维数组

import numpy as np # 导入模块并起别名
np.array([1,2,3,4,5])

array([1, 2, 3, 4, 5])

• 感受 numpy 的优势：列表中无 shape 属性

my_list = [1,2,3,4,5]
my_list.shape  # 列表中无 shape 属性

---------------------------------------------------------------------------
AttributeError                 Traceback (most recent call last)
 in ()
      1 my_list = [1,2,3,4,5]
----> 2 my_list.shape

AttributeError: 'list' object has no attribute 'shape'

• 感受 numpy 的优势：numpy 中有许多默认函数可供使用，如 shape

arr = np.array(my_list)
arr.shape # numpy 好处：有许多默认函数供我们去使用，帮助我们做数据分析

(5,)

创建二维数组：

• 使用 array 创建二维数组

arr = np.array([[1,2,3],[4,5,6],[7,8,9]]) 
print(arr.shape)  # 数组的维度（输出代表：3行3列的二维数组）
print(arr) # 输出创建的数组

(3, 3)
[[1 2 3]
 [4 5 6]
 [7 8 9]]

array 中参数的使用：

• 参数 ndmin：指定生成数组的最小维度

arr = np.array([1,2,3,4,5], ndmin=3) # 生成三个维度一个数组
print(arr.shape)  # （输出代表：一个一行五列的三维数组）
print(arr)

(1, 1, 5)
[[[1 2 3 4 5]]]

• 参数 dytpe ：指定数组元素的数据类型

arr = np.array([1,2,3,4,5],dtype=float)  # dytpe 指定数据对应的类型
arr

array([1., 2., 3., 4., 5.])

2. arange 创建

arange 函数的介绍

使用 arange 函数创建数值范围并返回 ndarray 对象

语法格式：

numpy.arange(start, stop, step, dtype)

参数说明：

名称	描述
start	起始值，默认为 0
stop	终止值（不包含）
step	步长，默认为 1
dtype	返回 ndarray 的数据类型，如果没有提供，则会使用输入数据的类型

示例 - arange 函数的使用

创建数组：

• 感受输出数据的范围及类型

import numpy as np # 导入模块并起别名

print(np.arange(10)) # 返回 0~9
print(np.arange(10.0)) # 输出：使用输入数据的类型（且不包含10.0）
print(np.arange(10.5)) # 输出范围：不会关心.5,会向下取整

[0 1 2 3 4 5 6 7 8 9]
[0. 1. 2. 3. 4. 5. 6. 7. 8. 9.]
[ 0.  1.  2.  3.  4.  5.  6.  7.  8.  9. 10.]

array 中参数的使用：

• 指定起始值、终止值及步长等

print(np.arange(1,10))    # 起始 1，结束10
print(np.arange(1,10,2))  # 步长为 2
print(np.arange(1,10,2, dtype=float))  # 指定数据类型：浮点型

[1 2 3 4 5 6 7 8 9]
[1 3 5 7 9]
[1. 3. 5. 7. 9.]

arange 函数创建二维数组：

• array 与 arrange 可联合使用

b=np.array([np.arange(1,4),np.arange(4,7),np.arange(7,10)])
b.shape # 查看形状（三行三列的二维数组）

(3, 3)

b  # 输出创建后的数组

array([[1, 2, 3],
       [4, 5, 6],
       [7, 8, 9]])

3. random 随机数生成

random 模块的介绍

numpy 中的 random 模块包含了很多方法可以用来产生随机数

random 的常用方法：

函数	说明
random(size=None)	该方法返回[0.0, 1.0)范围的随机数
randint	该方法有三个参数 low、high（默认 None）、size 三个参数。① 如果只有 low，那范围就是 [0,low)；② 如果有 high，范围就是 [low,high)
randn(d0,d1,…,dn)	randn 函数返回一个或一组样本，具有标准正态分布（期望为 0，方差为 1）。dn 为 n 维数据的维度，返回值为指定维度的 array
seed	确定随机生成器种子
shuffle	对一个序列就地随机排列
permutation	返回一个序列的随机排列或返回一个随机排列的范围
rand	产生均匀分布的样本值

示例 - random 模块中方法的使用

① random 函数的使用：

• 生成一维 (10,) 的随机数组

# numpy.random.random(size=None)
# 返回[0.0, 1.0)范围的随机数

import numpy as np # 导入模块并起别名

arr = np.random.random(size=10)
arr

array([0.10289107, 0.7626481 , 0.57774218, 0.55252354, 0.51513559,
       0.55679949, 0.22482356, 0.05471953, 0.22847806, 0.64784352])

• 查看形状

arr.shape # （输出表示：一行10列——即 一元组）

(10,)

• 生成二维 (3,4) 的随机数组

arr = np.random.random(size=(3,4)) # （默认0~1间）随机生成 三行四列的二维数组
arr

array([[0.07525423, 0.23016941, 0.18855109, 0.7965775 ],
       [0.83462746, 0.4501435 , 0.4985075 , 0.80113762],
       [0.43671224, 0.76218594, 0.6482414 , 0.29685941]])

② randint 函数的使用：

• randint() 括号中不能只写 size 参数

# numpy.random.randint(low, high=None, size=None)
# 该方法的三个参数中，参数 low 为必填项，否则报错

np.random.randint(size=10) # 会报错，没指定数值范围

---------------------------------------------------------
TypeError                          Traceback (most recent call last)
Input In [24], in ()
----> 1 np.random.randint(size=10)

File mtrand.pyx:646, in numpy.random.mtrand.RandomState.randint()

TypeError: randint() takes at least 1 positional argument (0 given)

• 生成 [0,low) 范围的随机整数（长度为10的数组）

arr = np.random.randint(10,size=10) # 随机生成0~9的数值（整数），随机10次
arr

array([8, 6, 1, 3, 9, 8, 5, 9, 8, 4])

• 随机返回 [low,high) 的 一个整数

np.random.randint(4) # 随机返回 [0,4) 的 一个整数

2

• 生成 [low,high) 范围的随机整数（长度为10的数组）

arr = np.random.randint(5,10, size=10)
arr

array([8, 6, 8, 5, 7, 8, 7, 5, 5, 7])

• 生成 [low,high) 范围的 3*4 的随机整数（二维数组）

arr = np.random.randint(5,10, size=(3,4)) # 5~10间的整数（不包括10），三行四列
arr

array([[5, 6, 5, 8],
       [7, 9, 6, 9],
       [8, 8, 5, 9]])

③ randn 函数的使用：

• 若 randn 函数括号内没有参数：返回一个浮点数

# randn(d0,d1,…,dn)
# randn 函数返回一个或一组样本，具有标准正态分布（期望为 0，方差为 1）
# dn:为 n维数据的维度，返回值为指定维度的 array

import numpy as np # 导入模块并起别名

np.random.randn()

0.19650183392918344

• 若 randn 函数括号内有一个参数：返回秩为1的数组，不能表示向量和矩阵

np.random.randn(2)  # 随机生成一个长度为2的一维数组

array([-0.1174755,  0.2220789])

自我解惑：

• 疑惑：为什么上方说 “秩为1的数组，不能表示向量和矩阵”？
• 解答：参考文章 Numpy库学习——向量表示

• 若 函数括号内有两个及以上参数：返回对应维度的数组，能表示向量或矩阵
  如：生成二维的数组

np.random.randn(2,3) # 2 行 3 列 二维数组

array([[ 1.69537671,  0.99040676,  0.32886744],
       [ 0.26155432, -0.42947806,  1.76046921]])

• 生成三维的数组

np.random.randn(2,3,4) # 两个 3行4列

array([[[ 0.49671415, -0.1382643 ,  0.64768854,  1.52302986],
        [-0.23415337, -0.23413696,  1.57921282,  0.76743473],
        [-0.46947439,  0.54256004, -0.46341769, -0.46572975]],

       [[ 0.24196227, -1.91328024, -1.72491783, -0.56228753],
        [-1.01283112,  0.31424733, -0.90802408, -1.4123037 ],
        [ 1.46564877, -0.2257763 ,  0.0675282 , -1.42474819]]])

小贴士：关于 randn 函数

• randn 中的 n 代表 normal （表示：正态分布 Normal distribution）
• 通过标准正态分布，randn 函数可随机初始相对连续的浮点数的值（其中，生成 峰值位置 y 轴 对应的 x 值的概率最大，并且向两侧概率逐渐减小）

④ normal 函数的使用：

• normal 函数 与 randn 函数类似，但 normal 可指定期望和方差

import numpy as np

# normal：正太分布（高斯分布）loc：期望 scale：方差 size 形状
np.random.normal(loc=3,scale=4,size=(2,2,3))

array([[[4.98685661, 2.4469428 , 5.59075415],
        [9.09211943, 2.0633865 , 2.06345217]],

       [[9.31685126, 6.06973892, 1.12210246],
        [5.17024017, 1.14632923, 1.13708099]]])

⑤ seed 函数的使用：

• 感受 seed() 中写数值和不写数值的区别

# numpy.random.seed(可写数值)
# 确定随机生成器种子

import numpy as np

np.random.seed()
print ("使用默认种子生成随机数：", np.random.random())
print ("使用默认种子生成随机数：", np.random.random())

np.random.seed(42) # 若随机种子写死了，每次随机生成的数都是一样的
print ("使用整数 42 种子生成随机数：", np.random.random()) 

print ("使用默认种子生成随机数：", np.random.random()) # 完全随机

np.random.seed(42) # 再次运行，结果还是一样
print ("使用整数 42 种子生成随机数：", np.random.random())   

使用默认种子生成随机数： 0.8428717811661656
使用默认种子生成随机数： 0.019591591046518753
使用整数 42 种子生成随机数： 0.3745401188473625
使用默认种子生成随机数： 0.9507143064099162
使用整数 42 种子生成随机数： 0.3745401188473625

seed 中固定死随机种子的用处：

小贴士：

• 关于seed的详细介绍，可参考： 菜鸟教程——Python3 seed() 函数

⑥ shuffle 函数的使用：

import numpy as np

arr = np.array([1,2,3,4,5]) # 创建一维数组
print(arr)

np.random.shuffle(arr) # shuffle：洗牌（打乱顺序），但不会返回任何结果
print(arr)

[1 2 3 4 5]
[3 1 5 2 4]

4. ndarray 对象

ndarray 对象的介绍

NumPy 最重要的一个特点是其 N 维数组对象 ndarray，它是一系列同类型数据的集合，以 0 下标为开始进行集合中元素的索引

• ndarray 对象是用于存放同类型元素的多维数组
• ndarray 中的每个元素在内存中都有相同存储大小的区域

ndarray 内部的组成：

• 一个指向数据（内存或内存映射文件中的一块数据）的指针
• 数据类型或 dtype，描述在数组中的固定大小值的格子
• 一个表示数组形状（shape）的元组，表示各维度大小的元组

ndarray 对象属性：

属性	说明
ndarray.ndim	秩，即轴的数量或维度的数量
ndarray.shape	数组的维度，对于矩阵来说实际上是二维数组：n 行 m 列
ndarray.size	数组元素的总个数，相当于 .shape 中 n*m 的值
ndarray.dtype	ndarray 对象的元素类型
ndarray.itemsize	ndarray 对象中每个元素的大小，以字节为单位
ndarray.flags	ndarray 对象的内存信息
ndarray.real	ndarray 元素的实部
ndarray.imag	ndarray 元素的虚部
ndarray.data	包含实际数组元素的缓冲区，由于一般通过数组的索引获取元素，所以通常不需要使用这个属性

示例 - ndarray 对象属性的使用

5. 其他方式创建

ndarray 数组除了可以使用底层 ndarray 构造器来创建外，也可以通过以下几种方式来创建

1）zeros

zeros 创建指定大小的数组，数组元素以 0 来填充

语法格式：

numpy.zeros(shape, dtype = float, order = 'C')
# 参数说明：
# shape 指定形状
# dtype 可选，数据类型（默认浮点型）
# order 可选，一般用的少，C 代表按行方向创建数组

示例：创建数组

import numpy as np

a = np.zeros(4) # 默认为浮点型
print(a)

b = np.zeros((4,),dtype=int) # 设置类型为整数
print(b)

c = np.zeros((3,4)) # 创建 3行 4列 的二维数组
print(c)

[0. 0. 0. 0.]
[0 0 0 0]
[[0. 0. 0. 0.]
 [0. 0. 0. 0.]
 [0. 0. 0. 0.]]

2）ones

ones 创建指定形状的数组，数组元素以 1 来填充

语法格式：

numpy.ones(shape, dtype = None, order = 'C')
# 参数说明：
# shape 指定形状
# dtype 可选，数据类型（默认浮点型）
# order 可选，一般用的少，C 代表按行方向创建数组

示例：创建数组

import numpy as np

a = np.ones(4) 
print(a)

b = np.ones((4,),dtype=int) # 设置类型为整数
print(b)

c = np.ones((3,4)) # 创建 3行 4列 的二维数组
print(c)

[1. 1. 1. 1.]
[1 1 1 1]
[[1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]]

3）empty

empty 创建一个指定形状（shape）、数据类型（dtype）且未初始化的数组，里面的元素的值是之前内存的值

语法格式：

numpy.empty(shape, dtype = float, order = 'C')
# 参数说明：
# shape 数组形状
# dtype 可选，数据类型
# order 可选，有"C"和"F"两个选项，分别代表：行优先和列优先，在计算机内存中的存储元素的顺序

示例：创建数组

import numpy as np

# np.empty 比 np.zeros 初始化数组时，效率更高

a = np.empty((3,4)) # 里面的元素的值是之前内存的值
print(a)

b = np.empty((4,2)) 
print(b)

[[1. 1. 1. 1.]
 [1. 1. 1. 1.]
 [1. 1. 1. 1.]]
[[0.00000000e+000 0.00000000e+000]
 [0.00000000e+000 0.00000000e+000]
 [0.00000000e+000 3.53751002e-321]
 [1.24610723e-306 1.29061142e-306]]

4）linspace

linspace 用于创建一个一维数组，数组是一个等差数列构成的

语法格式：

numpy.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)
# 参数说明：
# start：序列的起始值
# stop ：序列的终止值 （若 endpoint 为 true，该值包含于数列中）
# num  ：要生成的等步长的样本数量，默认为 50
# endpoint ：该值为 ture 时，数列中包含 stop 值，反之不包含，默认是 True
# retstep  ：如果为 True 时，生成的数组中会显示间距，反之不显示
# dtype ： ndarray 的数据类型

示例：创建等差数列

• 范围 [start, stop]

import numpy as np

np.linspace(0,10,4) # 等分，四个数，范围 [0,10]

array([ 0.        ,  3.33333333,  6.66666667, 10.        ])

• 范围 [start, stop)

np.linspace(0,10,4, endpoint=False)# 不包含10了

array([0. , 2.5, 5. , 7.5])

• 范围 [start, stop)，且显示间距

np.linspace(0,10,4, endpoint=False, retstep=True) # retstep=True：显示间距

(array([0. , 2.5, 5. , 7.5]), 2.5)

5）logspace

logspace 用于创建一个于等比数列

语法格式：

numpy.logspace(start, stop, num=50, endpoint=True, base=10.0, dtype=None)
# 参数说明：
# start：序列的起始值为：base ** start
# stop ：序列的终止值为：base ** stop （若 endpoint 为 true，该值包含于数列中）
# num  ：要生成的等步长的样本数量，默认为 50
# endpoint ：该值为 ture 时，数列中包含 stop 值，反之不包含，默认是 True
# base  ：对数 log 的底数
# dtype ：ndarray 的数据类型

示例：创建等比数列

import numpy as np

np.logspace(0,9,10,base=2)  # 创建等比数列（结果：2^0,2^1,...,2^9）

array([  1.,   2.,   4.,   8.,  16.,  32.,  64., 128., 256., 512.])

6）_like

_like 像什么形状一样去创建数组，但内部的元素值根据 _ 前的内容而定。如：zeros_like、ones_like、empty_like 等

示例：

• 创建二维数组

import numpy as np

arr = np.array([[1,2,3],[4,5,6]]) # 创建二维数组
arr

array([[1, 2, 3],
       [4, 5, 6]])

• numpy.zeros_like

np.zeros_like(arr) # 像 arr 数组形状一样，里面元素全为 0

array([[0, 0, 0],
       [0, 0, 0]])

• numpy.ones_like

np.ones_like(arr)  # 像 arr 数组形状一样，里面元素全为 1

array([[1, 1, 1],
       [1, 1, 1]])

三、切片和索引

ndarray 对象的内容可以通过索引或切片来访问和修改，与 Python 中 list 的切片操作一样。

ndarray 数组可以基于 0 ~ n 的下标进行索引，并设置 start, stop 及 step 参数进行，从原数组中切割出一个新数组。

示例 - 切片和索引的使用

① 一维数组切片和索引的使用：

# 切片操作的三个参数：[start : stop : step]
# 1、开始索引 start ：开始切片的位置（结果 包含 该索引下的值）
# 2、终止索引 stop ：结束切片的位置（结果 不包含 该索引下的值）
# 3、步长 step ：切取的步长值，可正可负（默认值为1，正索引）

import numpy as np
​
arr = np.arange(12)   # 返回0~11的12个元素
print('原数组：',arr)
print('切片1 ：',arr[2:7:2]) # 索引下标范围 [2,7)，步长为 2
print('切片2 ：',arr[2:]) # 截取 从索引下标为 2 开始往后的所有值

原数组： [ 0  1  2  3  4  5  6  7  8  9 10 11]
切片1 ： [2 4 6]
切片2 ： [ 2  3  4  5  6  7  8  9 10 11]

② 二维数组切片和索引的使用：

• 使用 reshape 构建二维数组

import numpy as np

arr = np.arange(12) # 返回 0~11 的12个元素
arr = arr.reshape(4,3) # 做成 4行 3列的
arr

array([[ 0,  1,  2],
       [ 3,  4,  5],
       [ 6,  7,  8],
       [ 9, 10, 11]])

• 可通过 中括号 取里面元素（索引的使用）

arr[1] # 获取第二行（下标从 0 开始，所以下标 1 代表第二个）

array([3, 4, 5])

• 可取具体某个行的某个元素（索引的使用）

arr[1][2] # 获取第二行的第三个元素

5

• 同时取多行多列（切片操作）

print(arr[1:3, 1:3]) # 获取第 2、3行，第 2、3列 的元素
print(arr[:, 1] ) # 获取所有行的第二列

# 负索引的使用
print(arr[::-1] ) # 行进行倒序
print(arr[::-1,::-1]) # 行列都倒序

[[4 5]
 [7 8]]
[ 1  4  7 10]
[[ 9 10 11]
 [ 6  7  8]
 [ 3  4  5]
 [ 0  1  2]]
[[11 10  9]
 [ 8  7  6]
 [ 5  4  3]
 [ 2  1  0]]

③ copy 函数实现数组的复制：

• 未使用 copy 时，修改从原数组中切割出的新数组，会改变原数组

# 说明：所有切片取出来的数组，即使把它赋值给了新的变量，它仍是原来数组的视图

import numpy as np

arr = np.arange(12).reshape(4,3) # 4行3列的二维数组，元素值：0~11（共12个）
print('arr原数组元素：')
print(arr)

temp = arr[1:3, 1:3]
print('截取的temp新数组：')
print(temp)

temp[1][1] = 9   # 修改第 2 行 第 2 列的元素
print('修改后的temp新数组：')
print(temp)

print('arr原数组元素发生改变：')  # 原来的 arr 也变了
print(arr)

arr原数组元素：
[[ 0  1  2]
 [ 3  4  5]
 [ 6  7  8]
 [ 9 10 11]]
截取的temp新数组：
[[4 5]
 [7 8]]
修改后的temp新数组：
[[4 5]
 [7 9]]
arr原数组元素发生改变：
[[ 0  1  2]
 [ 3  4  5]
 [ 6  7  9]
 [ 9 10 11]]

• 使用 copy 复制数组后，修改复制后的新数组，不会改变原数组

import numpy as np

arr = np.arange(12).reshape(4,3) # 4行3列的二维数组，元素值：0~11（共12个）
print('arr原数组元素：')
print(arr)

temp = np.copy(arr[1:3, 1:3])   # 使用 copy 实现数组的复制
print('截取后的temp新数组：')
print(temp)

temp[1][1] = 9   # 修改第 2 行 第 2 列的元素
print('修改后的temp新数组：')
print(temp)

print('arr原数组元素不会改变：')  # 经过 copy 后，修改复制后的元素，不改变原数据 arr
print(arr)

arr原数组元素：
[[ 0  1  2]
 [ 3  4  5]
 [ 6  7  8]
 [ 9 10 11]]
截取后的temp新数组：
[[4 5]
 [7 8]]
修改后的temp新数组：
[[4 5]
 [7 9]]
arr原数组元素不会改变：
[[ 0  1  2]
 [ 3  4  5]
 [ 6  7  8]
 [ 9 10 11]]

图解 copy 函数的原理：

小贴士：

• 关于 python 切片操作的详细介绍，可参考： python切片操作方法小总结 by rap小浣熊

四、改变数组的维度

处理数组的一项重要工作就是改变数组的维度，包含提高数组的维度和降低数组的维度，还包括数组的转置。

Numpy 提供的大量 API 可以很轻松地完成这些数组的操作，如：

• reshape 方法：可把高维数组变低维的，也可把低维的变成高维的
• ravel 或 flatten 方法：将高维数组变成一维数组

改变数组的维度还可以：直接设置 Numpy 数组的 shape 属性（元组类型），通过 resize 方法也可以改变数组的维度。

示例 - 改变数组的维度

① reshape

• reshape 可把低维数组变成高维的（如：将二维数组变为三维的）

import numpy as np
arr = np.arange(12).reshape(4,3)   # 创建二维的数组

arr.reshape((2,3,2)) # 2个 3行 2列的 - 12个元素 （改变维度：数组元素个数与原来一样即可）

array([[[ 0,  1],
        [ 2,  3],
        [ 4,  5]],

       [[ 6,  7],
        [ 8,  9],
        [10, 11]]])

• reshape 可高维数组变低维的（如：将三维数组变为一维的）

arr.reshape((2,3,2)).reshape((12,)) # 一行12列的 一维数组

array([ 0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11])

② ravel、flatten

• ravel 与 flatten 效果一样：均可将高维数组变成一维数组

import numpy as np
arr = np.arange(12).reshape((2,3,2)) # 2个 3行 2列的 （三维数组）
print(arr)

print("arr.ravel：",arr.ravel()) # ravel：高维变一维
print("arr.flatten：",arr.flatten()) # flatten：高维变一维（与 arr.ravel 效果一样)

[[[ 0  1]
  [ 2  3]
  [ 4  5]]

 [[ 6  7]
  [ 8  9]
  [10 11]]]
arr.ravel： [ 0  1  2  3  4  5  6  7  8  9 10 11]
arr.flatten： [ 0  1  2  3  4  5  6  7  8  9 10 11]

③ resize

• resize 方法改变数组的维度

# numpy.resize(a, new_shape) 返回具有指定形状的新数组
# 参数说明：a：要调整大小的原数组；new_shape：指定要调整成的新数组形状
# 其中，如果新数组大于原数组，则新数组中会填充 a 的重复副本

import numpy as np
arr = np.arange(12)
print(arr)

print(np.resize(arr,(3,4))) # 调整 arr 数组 为 3行4列的
print(np.resize(arr,(3,6))) # 调整为 3行6列的，但由于元素个数大于原数组的，会被用原数组的元素依次填充

[ 0  1  2  3  4  5  6  7  8  9 10 11]
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
[[ 0  1  2  3  4  5]
 [ 6  7  8  9 10 11]
 [ 0  1  2  3  4  5]]

五、数组的拼接

了解数组的拼接

图解-数组的水平组合与垂直组合：

相关函数：

函数	描述
hstack	水平堆叠序列中的数组（列方向）
vstack	竖直堆叠序列中的数组（行方向）
concatenate	连接沿现有轴的数组序列

说明：

• 通过 hstack 函数可以将两个或多个数组水平组合起来形成一个数组
• 通过 vstack 函数可以将两个或多个数组垂直组合起来形成一个数组
• 其中，hstack 与 vstack 本质都是调用 concatenate

numpy.concatenate 函数用于沿指定轴连接相同形状的两个或多个数组，格式如下：

numpy.concatenate((a1, a2, ...), axis)
# 参数说明：
# a1, a2, ...指相同类型的数组
# axis 指沿着它连接数组的轴，默认为 0（垂直方向拼接）

示例 - 数组拼接的使用

① hstack

• hstack 可以将两个或多个数组水平组合起来形成一个数组

import numpy as np
a = np.array([[1,2,3],[4,5,6]])
b = np.array([['a','b','c','m'],['d','e','f','n']])
print(a)
print(b)

np.hstack([a,b]) # 水平拼接（需要行一致）

[[1 2 3]
 [4 5 6]]
[['a' 'b' 'c' 'm']
 ['d' 'e' 'f' 'n']]
array([['1', '2', '3', 'a', 'b', 'c', 'm'],
       ['4', '5', '6', 'd', 'e', 'f', 'n']], dtype='

• 通过 hstack 水平拼接时，如果拼接的行数目不同，会报错

a = np.array([[1,2,3],[4,5,6]]) # 2行3列
c = np.array([['a','b','c'],['d','e','f'],['d','e','f']]) # 3行3列
np.hstack([a,c]) # 两行三列 与 三行三列 能水平拼接吗？ 不能，会报错（需行数目准确匹配方可）

② vstack

• vstack 可以将两个或多个数组垂直组合起来形成一个数组

import numpy as np
a = np.array([[1,2,3],[4,5,6]])
b = np.array([['a','b','c'],['d','e','f']])

np.vstack([a,b]) # 垂直拼接（需要列一致）

array([['1', '2', '3'],
       ['4', '5', '6'],
       ['a', 'b', 'c'],
       ['d', 'e', 'f']], dtype='

③ concatenate

• 使用 concatenate 可按垂直方向拼接 （axis=0）

import numpy as np
a = np.array([[1,2,3],[4,5,6]])
b = np.array([['a','b','c'],['d','e','f']])

np.concatenate([a,b], axis=0)  # 垂直拼接（按行堆）

array([['1', '2', '3'],
       ['4', '5', '6'],
       ['a', 'b', 'c'],
       ['d', 'e', 'f']], dtype='

• 使用 concatenate 也可按水平方向拼接（axis=1）

np.concatenate([a,b], axis=1) # 水平拼接（按列堆）

array([['1', '2', '3', 'a', 'b', 'c', 'm'],
       ['4', '5', '6', 'd', 'e', 'f', 'n']], dtype='

• 三维数组的拼接

六、数组的分割和转置

1. split 分割

split 函数的介绍

numpy.split 函数沿特定的轴将数组分割为子数组

语法格式：

numpy.split(ary, indices_or_sections, axis)
# 参数说明：
# arry：被分割的数组
# indices_or_sections：① 若为一个整数，就用该数平均切分; ② 若为一个数组，为沿轴切分的位置
# axis：沿着哪个维度进行切分，默认为 0，横向切分。为 1 时，纵向切分

示例 - split 函数的使用

分割一维数组：

import numpy as np # 导入模块并起别名
arr = np.arange(12)
print(arr)

print(np.split(arr, 4)) # 4为整数，用该数平均切分

print(np.split(arr, [3,5])) # 传递数组进行分隔（分别在 下标3处，下标5处 分割）

[ 0  1  2  3  4  5  6  7  8  9 10 11]
[array([0, 1, 2]), array([3, 4, 5]), array([6, 7, 8]), array([ 9, 10, 11])]
[array([0, 1, 2]), array([3, 4]), array([ 5,  6,  7,  8,  9, 10, 11])]

分割二维数组：

• 垂直分割（axis=0）

import numpy as np # 导入模块并起别名
a=np.array([[1,2,3],[4,5,6],[11,12,13],[14,15,16]])
print(a,'\n')

print(np.split(a,2,axis=0)) # 垂直方向 平均切两份

[[ 1  2  3]
 [ 4  5  6]
 [11 12 13]
 [14 15 16]] 

[array([[1, 2, 3],
       [4, 5, 6]]), array([[11, 12, 13],
       [14, 15, 16]])]

• 注意：若 numpy.split(ary, indices_or_sections, axis) 中第二个参数为整数，但分割时该数无法平均分，会报错

np.split(a,2,axis=1)  # 水平方向（此处会报错：原因-无法平均切分）

• 水平方向（axis=1），平均分割

a = np.array([[1,2,3],[4,5,6],[11,12,13],[14,15,16]]).reshape(3,4)
print(a,'\n')

print(np.split(a,2,axis=1))  # 水平方向  平均切两份

[[ 1  2  3  4]
 [ 5  6 11 12]
 [13 14 15 16]] 

[array([[ 1,  2],
       [ 5,  6],
       [13, 14]]), array([[ 3,  4],
       [11, 12],
       [15, 16]])]

• 水平方向，按位置分割

np.split(a,[1],axis=1)

[array([[ 1],
        [ 5],
        [13]]),
 array([[ 2,  3,  4],
        [ 6, 11, 12],
        [14, 15, 16]])]

2. transpose 转置

图示- transpose 转置

七、算术函数

如果参与运算的两个对象都是 ndarray，并且形状相同，那么会对位，然后彼此之间进行（+ - * /）运算。

NumPy 算术函数包含简单的加减乘除：add()，subtract()，multiply() 和 divide()。

示例 - 算术函数的使用

加减法运算：

• 形状相同的两个数组进行运算（对位相加减）

import numpy as np
a = np.arange(9).reshape(3,3)
print(a)
b = np.arange(1,10).reshape(3,3)
print(b)

# 加： +、add
print('\n加法（+、add）：')
print(a + b)
print(np.add(a, b))

# 减：-、subtract
print('\n减法（-、subtract）：')
print(a-b)
print(np.subtract(a,b))

• 一个一维数组与一个多维数组进行运算（列数同：广播机制——扩充）

import numpy as np
a = np.arange(9).reshape(3,3)
print('a：\n',a)

c = np.array([2,3,4])
print('c：\n',c)

print('\n加法：')
print(a + c)

print('\n减法：')
print(a-c)

乘法运算：

• 乘法：* 或 multiply()

import numpy as np
x = np.arange(5)
print('a:',x)

print('x * 10 :',x * 10)  
print('multiply :',np.multiply(x, 10))

• 函数指定输出结果的用法（对于加、减、乘、除均适用）

import numpy as np
y = np.empty(5) # 创建一个空数组
print(y,'\n')

np.multiply(x, 10, out=y) # out: 把结果输出给某处
print(y)

八、数学函数

数学函数的介绍

NumPy 中提供了数学函数，如：

• 标准的三角函数：sin()、cos()、tan()
• 向上向下取整的函数：around()、floor()、ceil()

取整函数的说明：

• numpy.around() 函数返回指定数字的四舍五入值，语法格式如下：

numpy.around(a,decimals)
# 参数说明：
# a: 数组
# decimals: 舍入的小数位数（默认值为 0）。若为负，整数将四舍五入到小数点左侧的位置

• numpy.floor() 返回数字的下舍整数
• numpy.ceil() 返回数字的上入整数

示例 - around()、floor()、ceil()函数的使用

九、聚合函数

聚合函数的介绍

NumPy 提供了很多统计函数，用于从数组中查找最小元素，最大元素，百分位标准差和方差等。

聚合函数：

函数名	说明
np.sum()	求和
np.prod()	所有元素相乘
np.mean()	平均值
np.std()	标准差
np.var()	方差
np.median()	中数
np.power()	幂运算
np.sqrt()	开方
np.min()	最小值
np.max()	最大值
np.argmin()	最小值的下标
np.argmax()	最大值的下标
np.inf	无穷大
np.exp(10)	以 e 为底的指数
np.log(10)	对数

示例 - 聚合函数的使用

---

—— 说明：本文内容基于python3，使用工具 Jupyter Notebook 编写的代码
（本文中使用函数前的 np 代表 Numpy 的别名，每次使用前需导入该模块import numpy as np ，文中代码示例中多处省略了该语句，在实际使用时勿忘）