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

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
1
2
3
4
5

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

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

图示

使用

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

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

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

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

numpy.ndarray
1

小贴士

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

二、数组的创建

知识补充 - 获取 shape 形状

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

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

(10,)
1

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

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

10
1

1. array 创建

array 函数的介绍

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

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

语法格式：

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

参数说明：

示例 - array 函数的使用

创建一维数组：

• 使用 array 创建一维数组

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

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

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

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

---------------------------------------------------------------------------
AttributeError                 Traceback (most recent call last)
<ipython-input-8-6a829e60bb92> in <module>()
      1 my_list = [1,2,3,4,5]
----> 2 my_list.shape

AttributeError: 'list' object has no attribute 'shape'
1
2
3
4
5
6
7

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

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

(5,)
1

创建二维数组：

• 使用 array 创建二维数组

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

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

array 中参数的使用：

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

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

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

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

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

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

2. arange 创建

arange 函数的介绍

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

语法格式：

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

参数说明：

示例 - arange 函数的使用

创建数组：

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

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

print(np.arange(10)) # 返回 0~9
print(np.arange(10.0)) # 输出：使用输入数据的类型（且不包含10.0）
print(np.arange(10.5)) # 输出范围：不会关心.5,会向下取整
1
2
3
4
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.]
1
2
3

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

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

arange 函数创建二维数组：

• array 与 arrange 可联合使用

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

(3, 3)
1

b  # 输出创建后的数组
1

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

3. random 随机数生成

random 模块的介绍

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

random 的常用方法：

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

① random 函数的使用：

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

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

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

arr = np.random.random(size=10)
arr
1
2
3
4
5
6
7

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

• 查看形状

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

(10,)
1

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

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

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]])
1
2
3

② randint 函数的使用：

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

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

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

---------------------------------------------------------
TypeError                          Traceback (most recent call last)
Input In [24], in <cell line: 1>()
----> 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)
1
2
3
4
5
6
7
8

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

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

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

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

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

2
1

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

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

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

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

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

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

③ randn 函数的使用：

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

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

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

np.random.randn()
1
2
3
4
5
6
7

0.19650183392918344
1

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

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

array([-0.1174755,  0.2220789])
1

自我解惑：

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

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

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

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

• 生成三维的数组

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

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]]])
1
2
3
4
5
6
7

小贴士：关于 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))
1
2
3
4

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]]])
1
2
3
4
5

⑤ 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())   
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

使用默认种子生成随机数： 0.8428717811661656
使用默认种子生成随机数： 0.019591591046518753
使用整数 42 种子生成随机数： 0.3745401188473625
使用默认种子生成随机数： 0.9507143064099162
使用整数 42 种子生成随机数： 0.3745401188473625
1
2
3
4
5

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
6
7

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

4. ndarray 对象

ndarray 对象的介绍

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

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

ndarray 内部的组成：

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

ndarray 对象属性：

示例 - ndarray 对象属性的使用

5. 其他方式创建

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

1）zeros

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

语法格式：

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

示例：创建数组

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)
1
2
3
4
5
6
7
8
9
10

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

2）ones

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

语法格式：

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

示例：创建数组

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
2
3
4
5
6
7
8
9
10

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

3）empty

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

语法格式：

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

示例：创建数组

import numpy as np

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

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

b = np.empty((4,2)) 
print(b)
1
2
3
4
5
6
7
8
9

[[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]]
1
2
3
4
5
6
7

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 的数据类型
1
2
3
4
5
6
7
8

示例：创建等差数列

• 范围 [start, stop]

import numpy as np

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

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

• 范围 [start, stop)

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

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

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

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

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

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 的数据类型
1
2
3
4
5
6
7
8

示例：创建等比数列

import numpy as np

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

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

6）_like

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

示例：

• 创建二维数组

import numpy as np

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

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

• numpy.zeros_like

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

array([[0, 0, 0],
       [0, 0, 0]])
1
2

• numpy.ones_like

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

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

三、切片和索引

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 开始往后的所有值
1
2
3
4
5
6
7
8
9
10
11

原数组： [ 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]
1
2
3

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

• 使用 reshape 构建二维数组

import numpy as np

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

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

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

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

array([3, 4, 5])
1

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

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

5
1

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

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

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

[[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]]
1
2
3
4
5
6
7
8
9
10
11

③ 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)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

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]]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

• 使用 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)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

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]]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

图解 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个元素 （改变维度：数组元素个数与原来一样即可）
1
2
3
4

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

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

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

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

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

② 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 效果一样)
1
2
3
4
5
6

[[[ 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]
1
2
3
4
5
6
7
8
9

③ 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列的，但由于元素个数大于原数组的，会被用原数组的元素依次填充
1
2
3
4
5
6
7
8
9
10

[ 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]]
1
2
3
4
5
6
7

五、数组的拼接

了解数组的拼接

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

相关函数：

说明：

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

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

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

示例 - 数组拼接的使用

① 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
7

[[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='<U11')
1
2
3
4
5
6

• 通过 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]) # 两行三列 与 三行三列 能水平拼接吗？ 不能，会报错（需行数目准确匹配方可）
1
2
3

② 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]) # 垂直拼接（需要列一致）
1
2
3
4
5

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

③ 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)  # 垂直拼接（按行堆）
1
2
3
4
5

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

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

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

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

• 三维数组的拼接

六、数组的分割和转置

1. split 分割

split 函数的介绍

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

语法格式：

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

示例 - 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处 分割）
1
2
3
4
5
6
7

[ 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])]
1
2
3

分割二维数组：

• 垂直分割（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

[[ 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]])]
1
2
3
4
5
6
7
8

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

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

[[ 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]])]
1
2
3
4
5
6
7
8
9

• 水平方向，按位置分割

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

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

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))
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

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

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)
1
2
3
4
5
6
7
8
9
10
11
12

乘法运算：

• 乘法：* 或 multiply()

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

print('x * 10 :',x * 10)  
print('multiply :',np.multiply(x, 10))
1
2
3
4
5
6

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

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

np.multiply(x, 10, out=y) # out: 把结果输出给某处
print(y)
1
2
3
4
5
6

八、数学函数

数学函数的介绍

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

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

取整函数的说明：

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

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

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

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

九、聚合函数

聚合函数的介绍

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

聚合函数：

示例 - 聚合函数的使用

---

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