02. NumPy库的使用
一、NumPy库简介
NumPy 是 Numerical Python 的简称，它是 Python 数值计算中最重要的基础包之一。大多数提供科学计算的包都用 NumPy 数组对象作为数据交换的通用标准接口。NumPy 本身并没有提供建模和科学计算功能。NumPy 的部分内容和功能如下：
- ndarray，一个高效多维数组，提供快速的基于数组的算术运算和灵活的广播功能。
- 用于对整个数组数据进行快速运算的数学函数，无须编写循环。
- 用于读写磁盘数据的工具，以及用于操作内存映射文件的工具。
- 线性代数、随机数生成以及傅里叶变换功能。
- 一个 C 语言 API，用于将 NumPy 连接到用 C、C++ 或 Fortran 编写的库。
由于 NumPy 提供了一套功能强大的 C 语言 API，因此很容易将数据传递给由底层语言编写的外部库，外部库也能以 NumPy 数组的形式将数据返回给 Python。这个功能使 Python 成为封装 C、C++ 和 Fortran 代码库的首选语言，并使封装库拥有一个动态和可访问的接口。
NumPy 的核心特点之一就是其 N 维数组对象，即 ndarray，该对象是一个快速且灵活的 Python 大数据集容器。利用数组可以对整块数据做数学运算，其语法类似于标量元素之间的运算。
NumPy 是在一个连续的内存块中存储数据，独立于其它 Python 内置对象。NumPy 的 C 语言编写的算法库可以操作内存，而不必进行类型检查或其它 前期工作。比起 Python 的内置序列，NumPy 数组使用的内存更少。
NumPy 可以在整个数组上执行复杂的运算，而不需要 Python 的 for 循环，for 循环对于大型序列速度较慢。NumPy 之所以比常规的 Python 代码快，是因为 NumPy 的基于 C 语言的算法无须对 Python 代码进行解释，节省了开销。
我们可以终端中使用 pip 安装 numpy 包。默认是从国外的主站上下载，因此，我们可能会遇到网络不好的情况导致下载失败。我们可以在 pip 指令后通过 -i 指定国内镜像源下载。
pip install numpy -i https://mirrors.aliyun.com/pypi/simple
国内常用的 pip 下载源列表：
- 阿里云 https://mirrors.aliyun.com/pypi/simple
- 中国科技大学 https://pypi.mirrors.ustc.edu.cn/simple
- 清华大学 https://pypi.tuna.tsinghua.edu.cn/simple
- 中国科学技术大学 http://pypi.mirrors.ustc.edu.cn/simple
二、ndarray的创建
2.1、基本构造
创建数组最简单的办法是使用 numpy.array(数组序列) 函数。它接收任意序列型的对象（包括其它数组），然后生成一个新的包含传入数据的 NumPy 数组。
import numpy as np
array = np.array(5) # 创建0维的adarry数组
print(array)
print("数组的维度：", array.ndim) # 打印数组的维度
array = np.array([1, 2, 3]) # 创建1维的adarry数组
print(array)
print("数组的维度：", array.ndim) # 打印数组的维度
array = np.array([[1, 2, 3], [4, 5, 6]]) # 创建2维的adarry数组
print(array)
print("数组的维度：", array.ndim) # 打印数组的维度
在我们使用 numpy.array() 函数创建 ndarry，一般传入的数据都是同一种类型。如果我们传入不同类型的数据，新生成的数组中的元素会转换成同一种类型。
import numpy as np
array = np.array([1, "hello", 3.14])
print(array)
print("数组的数据类型：", array.dtype) # 打印数组的数据类型
我们在使用 numpy.array(数组序列, dtype=数据类型) 方法创建数组时，可以使用 dtype 关键字参数指定要创建数组的类型。
import numpy as np
array1 = np.array([1, 2, 3], dtype="float64")
print(array1)
print("数组的数据类型：", array1.dtype) # 打印数组的数据类型
array2 = np.array([1, 2, 3], dtype=np.int16)
print(array2)
print("数组的数据类型：", array2.dtype) # 打印数组的数据类型
我们可以使用 numpy.copy(数组) 函数 将一个数组拷贝一份新的数组。
import numpy as np
array1 = np.array([[1, 2, 3], [4, 5, 6]])
array2 = np.copy(array1)
array1[0, 0] = 10
print(array1)
print(array2)
2.2、预定义形状填充
这里，我们使用 numpy.zeros(形状元组) 函数 创建一个指定形状，元素全部为 0 的数组。
import numpy as np
array1 = np.zeros(2)
print(array1)
print(array1.dtype)
array2 = np.zeros((2, 3), dtype=int)
print(array2)
print(array2.dtype)
我们还可以使用 numpy.ones(形状元组, dtype=数据类型) 函数 创建一个全 1 的数组。
import numpy as np
array1 = np.ones(2)
print(array1)
print(array1.dtype)
array2 = np.ones((2, 3), dtype=int)
print(array2)
print(array2.dtype)
如果我们想要 创建一个空的数组，则可以使用 numpy.empty(形状元组) 函数，该生成数组中的值会是随机生成的。
import numpy as np
array1 = np.empty(2)
print(array1)
array2 = np.empty((2, 3))
print(array2)
如果我们想要 创建一个数组，并指定一个填充元素，则可以使用 numpy.full(形状元组, 填充值) 函数。
import numpy as np
array1 = np.full(2, 3)
print(array1)
array2 = np.full((2, 3), 3)
print(array2)
我们可以使用 numpy.zeros_like(数组)、numpy.empty_like(数组)、numpy.ones_like(数组)、numpy.full_like(数组, 填充值) 函数 根据一个数组生成自定形状和类型的数组。
import numpy as np
array = np.full([2, 3], 3)
array1 = np.zeros_like(array)
print(array1)
array2 = np.empty_like(array)
print(array2)
array3 = np.ones_like(array)
print(array3)
array4 = np.full_like(array, 5)
print(array4)
2.3、基于数值范围生成
我们可以使用 numpy.arange(起始值, 结束值, 步长) 来生成一个 等差数列。该函数生成的数组中 不包含结束值。
import numpy as np
array = np.arange(2, 10, 2)
print(array)
如果要生成的 步长 为 1，我们可以 省略步长 那个参数。
import numpy as np
array = np.arange(1, 10)
print(array)
如果要我们要生成 从 0 开始到指定值结束的数组，则可以 只指定一个参数，用来表示 结束值。
import numpy as np
array = np.arange(10)
print(array)
如果我们想要生成在一个区间范围内的 等间隔数列，则可以使用 numpy.linespace(起始值, 结束值, 个数) 函数。
import numpy as np
array = np.linspace(1, 10, 4)
print(array)
如果我们要生成一个 等比数列，则可以使用 numpy.logspace(起始值, 结束值, 数量, 基数) 函数。
import numpy as np
# 生成一个从2^2、2^4、2^6、2^8、2^10的5个元素的数组
array = np.logspace(2, 10, 5, base=2)
print(array)
如果我们省略 base 参数，则默认是以 10 为基数的。
import numpy as np
# 生成一个从10^1到10^5的5个元素的数组
array = np.logspace(1, 5, 5)
print(array)
2.4、特殊矩阵生成
我们可以使用 numpy.eye(行, 列, dtype="数据类型") 函数构造一个 单位矩阵。单位矩阵的主对角线的数字为 1，其它位置的数字为 0。
import numpy as np
array = np.eye(3, 4,dtype=int)
print(array)
如果要生成的矩阵的行和列相同，则只需要指定一个参数即可。
import numpy as np
array = np.eye(3, dtype=int)
print(array)
我们可以使用 numpy.diag(数据序列) 函数构造一个 对角矩阵。对角矩阵的主对角是非 0 的元素，其它位置的元素为 0。
import numpy as np
array = np.diag([1, 2, 3])
print(array)
2.5、随机矩阵生成
我们可以使用numpy.random.rand(行, 列) 函数 生成 0 到 1 之间的随机浮点数矩阵。
import numpy as np
array = np.random.rand(2, 3)
print(array)
如果我们想要 指定范围区间的随机浮点数矩阵，则可以使用 numpy.random.uniform(最小值, 最大值, 形状元组) 函数。
import numpy as np
array = np.random.uniform(1, 4, (2, 3))
print(array)
如果想要 指定范围区间的随机整数矩阵，则可以使用 numpy.random.randint(最小值, 最大值, 形状元组) 函数。
import numpy as np
array = np.random.randint(1, 4, (2, 3))
print(array)
如果我们想要生成正态分布的随机矩阵，则可以使用 numpy.random.randn(行, 列) 函数。
import numpy as np
array = np.random.randn(2, 3)
print(array)
如果我们要伪随机，即每次随机生成的矩阵都是一样的，则可以使用 numpy.random.seed(随机种子) 设置一个固定值的随机种子。
import numpy as np
np.random.seed(10) # 设置随机种子
array = np.random.randn(2, 3)
print(array)
三、ndarray的数据类型
数据类型（dtype）是一个特殊对象，它包含 ndarray 所需的将一块内存解释为特定数据类型的信息（或元数据，即关于数据的数据）。NumPy 中的数值型数据类型的命名方式相同：类型名（如 float 或 int）后面跟着用于表示各元素位数的数字。NumPy 常见的数据类型如下：
| 类型 | 说明 |
|---|---|
| bool | 布尔类型 |
| int8 | 有符号的 8 位（1 个字节）整型 |
| uint8 | 无符号的 8 位（1 个字节）整型 |
| int16 | 有符号的 16 位（2 个字节）整型 |
| uint16 | 无符号的 16 位（2 个字节）整型 |
| int32 | 有符号的 32 位（4 个字节）整型 |
| uint32 | 无符号的 32 位（4 个字节）整型 |
| int64 | 有符号的 64 位（8 个字节）整型 |
| uint64 | 无符号的 64 位（8 个字节）整型 |
| float16 | 半精度浮点数 |
| float32 | 标准的单精度浮点数，与 C 的 float 兼容 |
| float64 | 标准的双精度浮点数，与 C 的 double 和 Python 的 float 对象兼容 |
| float128 | 扩展精度浮点数 |
| complex64 | 用两个 32 位、64 位或 128 位浮点数表示的复数 |
| complex128 | 用两个 32 位、64 位或 128 位浮点数表示的复数 |
| complex256 | 用两个 32 位、64 位或 128 位浮点数表示的复数 |
| bool | 存储 True 和 False 值的布尔类型 |
| object | Python 对象类型，可以是任意 Python 对象 |
| string_ | 固定长度的 ASCII 字符串类型（每个字符 1 个字节）。例如，要创建一个长度为 10 的字符串，应使用 "S10" |
| unicode_ | 固定长度的 Unicode 类型（字节数由平台决定），与字符串的指定语法一样（如 "U10"） |
我们可以通过 ndarray 的 astype(数据类型) 方法可以 将数组从一种数据类型转换或投射成另一种数据类型。
import numpy as np
array1 = np.arange(10)
print(array1.dtype)
array2 = array1.astype("float64")
print(array2.dtype)
如果将浮点数转换成整数，则小数部分将会被截断。
import numpy as np
array1 = np.array([3.14, 2,13, 5,7, 7,5])
array2 = array1.astype("int")
print(array2)
如果某字符串数组表示的全是数字，也可以用 astype(数组类型) 将其转换为数值形式：
import numpy as np
array1 = np.array(["3.14", "2.1", "3", "5", "5.7", "7.5"])
array2 = array1.astype(np.float64)
print(array2)
由于 NumPy 专注于数值计算，因此如果没有特别指明，数据类型在大多数场景中都是
float64（浮点数）。即使新的数据类型与旧的数据类型相同，调用astype也总会创建一个新的数组（一个数据的备份）。
四、ndarray的属性
ndarray 常用属性如下：
shape # 数组的形状，行数和列数或者更高维度的尺寸
ndim # 维度数量，数组是几维的
size # 总元素个数，数组中所有元素的总数
dtype # 元素类型，数组元素的数据类型
T # 数组的转置，交换行和列
itemSize # 每个元素占用的字节数
nbytes # 数组占用的总字节数，等于元素数量乘以每个元素的字节数
flags # 内存存储方式，是否连续存储在内存中
import numpy as np
array = np.array([[1, 2, 3], [4, 5, 6]])
print("数组的形状：", array.shape)
print("数组的维度：", array.ndim)
print("数组的元素数量：", array.size)
print("数组的元素类型：", array.dtype)
print("数组的转置：", array.T)
五、索引与切片
5.1、数组的索引
在创建完数组之后，我们可以通过整数索引来访问其中的某一个元素，数组的索引是从 0 开始的。
import numpy as np
array = np.arange(10)
print(array)
print(array[0])
print(array[9])
如果使用的索引超过最大的索引会报以下错误：
IndexError: index 10 is out of bounds for axis 0 with size 10
在 NumPy 中，数组的索引同样支持负数。这个索引从右向左计数，也就是从最后的一个元素开始计数，即最后一个元素的索引是 -1，倒数第二个第二个元素的索引值为 -2，以此类推。
import numpy as np
array = np.arange(10)
print(array)
print(array[-1])
print(array[-10])
在一个二维数组中，各索引位置上的元素不再是标量而是一维数组。如果我们可以通过 数组名[行索引][列索引] 或 数组名[行索引, 列索引] 的方式访问二维数组的某一个元素。
import numpy as np
array = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(array)
print(array[1][1])
print(array[1, 1])
在多维数组中，如果省略了后面的索引，则返回对象会是低维度的 ndarray，它包含更高维度上的所有数据。
import numpy as np
array = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print(array)
print(array[1])
5.2、数组的切片
在 NumPy 中，我们同样可以使用索引来对数组进行切片。切片是从现有的列表中，获取一个子列表，不会影响原有的列表。实现切片的语法格式如下：
数组[start : end : step]
通过切片获取元素时，会包括起始位置的元素，不会包括结束位置的元素。如果不指定起始位置，默认从 0 开始，如果不指定截至位置，默认为数组的长度。
在进行切片操作时，如果指定了步长，那么将会按照步长遍历数组的元素，否则，将一个一个遍历数组。如果省略步长，默认为 1，最后的一个冒号也可以省略。
import numpy as np
array = np.arange(10)
print(array)
array1 = array[1 : 5 : 2]
print(array1)
# 如果省略步长，则默认步长为1
array2 = array[1:5]
print(array2)
# 如果省略截至位置，会一直截取到最后
array3 = array[1:]
print(array3)
# 如果省略开始位置，则会从第一个元素开始截取
array4 = array[:5]
print(array4)
如果想复制整个数组，可以将 起始位置 和 截至位置 都省略，但是中间的冒号要保留。
import numpy as np
array = np.arange(10)
print(array)
array1 = array[:]
print(array1)
步长不能为 0， 但是可以为负数，如果是负数，将从数组的后部向前取元素。
import numpy as np
array = np.arange(10)
print(array)
array1 = array[::-1]
print(array1)
在 NumPy 中，我们也可以使用 slice(开始值, 结束值, 步长) 来对数组进行切片。
import numpy as np
array = np.arange(10)
print(array)
array1 = array[slice(2, 5, 2)]
print(array1)
在 NumPy 中数组切片是原始数组的视图。这意味着数据不会被复制，视图上的任何修改都会直接反映到源数组上。如果你想得到 ndarray 切片的副本而非视图，就需要显式地复制数组。
import numpy as np
array = np.arange(10)
print(array)
array1 = array[:]
array1[0] = 10 + array1[0]
print(array)
针对二维数组，切片是沿着一个轴向选取元素的，我们可以一次传入多个切片，就像传入多个索引那样。
import numpy as np
array = np.array([[1, 2, 3, 4, 5], [6, 7, 8, 9 ,10], [11, 12, 13, 14, 15], [16, 17, 18, 19, 20]])
print(array)
print(array[1, 1 : 4])
print(array[1][1 : 4])
# 先获2行和第三行的数据，在分别对两行进行切片
print(array[1 : 3, 1 : 4])
5.3、布尔型索引
在 NumPy 中，我们可以设置逻辑条件，过滤掉那些不符合要求的数据。
import numpy as np
array = np.arange(10)
print(array)
# 支持逻辑运算符 &（与）和 |（或）
array1 = array[(array > 3) & (array < 7)]
print(array1)
import numpy as np
array = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
# 筛选大于5的元素，将结果放在一维数组中
print(array[array > 5])
# 刷选第二行大于5的元素
print(array[1][array[1] > 5])
# 刷选第二列大于5的元素
print(array[:, 1][array[:, 1] > 5])
六、ndarray的运算
如果两个数组的行和列都相等，则它们可以进行四则运算，即对应的元素依次进行四则运算。
import numpy as np
array1 = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
array2 = np.array([[1, 4, 9], [16, 25, 36], [49, 64, 81]])
print(array2 + array1)
print(array2 - array1)
print(array2 * array1)
print(array2 / array1)
如果一个数组跟一个标量进行四则运算，则对数组中的每一个元素都进行四则运算。
import numpy as np
number = 11
array = np.array([[11, 22, 33], [44, 55, 66], [77, 88, 99]])
print(array + number)
print(array - number)
print(array * number)
print(array / number)
在 NumPy 中两个二维数组通过＊相乘得到的是一个元素乘积，而矩阵乘法需要使用 @ 运算符或者 dot() 函数。只有左矩阵的列数与右矩阵的行数相同的两个矩阵才能相乘。乘积矩阵第 i 行第 j 列处的元素等于左矩阵的第 i 行与右矩阵的第 j 列对应元素乘积之和，即 \((AB)_{i, j} = \sum_{k = 1}^{n}{a_{ik}b_{kj}}\)。乘积矩阵的行数等于左矩阵的行数，列数等于右矩阵的列数。
import numpy as np
array1 = np.array([[1, 2, 3], [4, 5, 6]])
array2 = np.array([[1, 2], [3, 4], [5, 6]])
print(array1 @ array2)
print(array1.dot(array2))
print(array2 @ array1)
print(np.dot(array2, array1))
七、ndarray的常用函数
【1】、基本数学相关的函数
import numpy as np
print("sqrt(9) =", np.sqrt(9)) # 平方根
print("exp(2) =", np.exp(2)) # 指数函数，以e为底
print("log(2) =", np.log(2)) # 自然对数
print("sin(pi/2) =", np.sin(np.pi / 2)) # 正弦函数
print("cos(pi/2) =", np.cos(np.pi / 2)) # 余弦函数
print("tan(pi/4) =", np.tan(np.pi / 4)) # 正切函数
print("arcsin(0) =", np.arcsin(0)) # 反正弦函数
print("arccos(0) =", np.arccos(0)) # 反余弦函数
print("arctan(0) =", np.arctan(0)) # 反正切函数
print("abs(-2) =", np.abs(-2)) # 绝对值
print("power(2, 3) =", np.power(2, 3)) # 幂函数
print("round(2.6) =", np.round(2.6)) # 四舍五入
print("ceil(2.4) =", np.ceil(2.6)) # 向上取整
print("floor(2.6) =", np.floor(2.6)) # 向下取整
【2】、统计相关的函数
import numpy as np
array = np.arange(1, 11)
print("数组的和为:", np.sum(array)) # 求和
print("数组的平均值为:", np.mean(array)) # 计算平均值
# 中位数是指一组数据中，按大小顺序排列后位于中间位置的数值
# 如果数据的个数是奇数，则中间那个数据就是这群数据的中位数
# 如果数据的个数是偶数，则中间那2个数据的算术平均值就是这群数据的中位数
print("数组的中位数为:", np.median(array)) # 计算中位数
# 先计算每个数值与平均数的差，然后求其平方值，再把所有平方值相加后除以总数，最后再对结果进行平方根运算
print("数组的标准差为:", np.std(array)) # 计算标准差
# 一组数据中各个数值与其均值的离差平方的平均数
print("数组的方差为:", np.var(array)) # 计算方差
print("数组的最小值为:", np.min(array)) # 获取最小值
print("数组的最小值索引为:", np.argmin(array)) # 获取最小值的索引
print("数组的最大值为:", np.max(array)) # 获取最大值
print("数组的最大值索引为:", np.argmax(array)) # 获取最大值的索引
# 分位数是将一组按大小排序的数据分割成相等部分的点
# pos = 1 + (n - 1) * p ==> pos = 1 + (10 - 1) * 0.25 = 3.25
# 如果 pos 是整数：那么该位置的数据就是第 p 百分位数。
# 如果 pos 不是整数：设 k 为 pos 的整数部分，f 为小数部分。
# 则百分位数 = (1 - f) * X[k] + f * X[k+1]。其中 X[k] 是排序后第 k 个位置的数据（注意：k从1开始计数）。
# (1 - 0.25) * array[2] + 0.25 * array[3] ==> 0.75 * 3 + 0.25 * 4 ==> 3.25
print("数组的25%分位数为:", np.percentile(array, 25)) # 计算25%分位数
print("累加：", np.cumsum(array)) # 计算累加
print("累乘：", np.cumprod(array)) # 计算累乘
当我们统计相关的函数可以按 每一列（axis=0）或者 每一行（axis=1）的进行统计。
import numpy as np
array = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print("每列的最小值:", np.min(array, axis=0)) # 每列的最小值
print("每列的最大值:", np.max(array, axis=0)) # 每列的最大值
print("每行的最小值:", np.min(array, axis=1)) # 每行的最小值
print("每行的最大值:", np.max(array, axis=1)) # 每行的最大值
print("每列的平均值:", np.mean(array, axis=0)) # 每列的平均值
print("每行的平均值:", np.mean(array, axis=1)) # 每行的平均值
print("每列的中位数:", np.median(array, axis=0)) # 每列的中位数
print("每行的中位数:", np.median(array, axis=1)) # 每行的中位数
print("每列的总和:", np.sum(array, axis=0)) # 每列的范围
print("每行的总和:", np.sum(array, axis=1)) # 每行的范围
print("每列的标准差:", np.std(array, axis=0)) # 每列的标准差
print("每行的标准差:", np.std(array, axis=1)) # 每行的标准差
print("每列的方差:", np.var(array, axis=0)) # 每列的方差
print("每行的方差:", np.var(array, axis=1)) # 每行的方差
【3】、比较相关的函数
import numpy as np
array = np.arange(1, 11)
print("是否小于5", array < 5)
print("是否小于5", np.less(array, 5))
print("是否等于5", array == 5)
print("是否等于5", np.equal(array, 5))
print("是否大于5", array > 5)
print("是否大于5", np.greater(array, 5))
array1 = np.array([3, 0, 5])
array2 = np.array([3, 0, 0])
print("两个矩阵比较", np.equal(array1, array2))
print("两个矩阵进行逻辑与运算", np.logical_and(array1, array2))
print("两个矩阵进行逻辑或运算", np.logical_or(array1, array2))
print("检查矩阵是否有一个元素为真", np.any(array1))
print("检查矩阵是否所有元素为真", np.all(array1))
# where(条件, 符合条件的值, 不符合条件的值)
# 当条件为真时，取符合条件的值，否则取不符合条件的值
print("自定义条件", np.where(array1 > 3, array1, 7))
print("自定义条件", np.where(array1 > 3, "及格", "不及格"))
# select(条件, 返回结果, default=默认值)
print("自定义条件", np.select([array > 8, (array >= 6) & (array <= 8), array <= 6], ["优秀", "及格", "不及格"], default="未知"))
【4】、排序相关的函数
import numpy as np
array = np.random.randint(1, 100, 10)
print("随机生成的数组:", array)
print("排序后的数组:", np.sort(array))
print("排序后的索引:", np.argsort(array))
print("去重并排序：", np.unique(array))
array.sort()
print("排序改变原数组", array)
在排序的过程中，我们也可以按 每一列（axis=0）或者 每一行（axis=1）的进行排序。
import numpy as np
array = np.random.randint(1, 3, (3, 3))
print("随机生成的数组：\n", array)
print("按行排序后的数组：\n", np.sort(array, axis=1))
print("按行排序后的索引：\n", np.argsort(array, axis=1))
print("按行去重并排序：\n", np.unique(array, axis=1))
array.sort(axis=1)
print("按行排序改变原数组：\n", array)
【5】、其它函数
import numpy as np
array1 = np.array([1, 2, 3])
array2 = np.array([4, 5, 6])
print("两个数组拼接", np.concatenate((array1, array2)))
array = np.array([1, 2, 3, 4, 5, 6])
# 要求元素能等分，如果不能等分，会报错
print("数组切割", np.split(array, 2))
# 可以指定切割位置
print("数组切割", np.split(array, [2, 4]))
# 要求元素能等分，如果不能等分，会报错
print("调整数组形状", np.reshape(array, (2, 3)))
八、使用数组进行文件输入和输出
NumPy 能够读写磁盘上的文本数据或二进制格式的数据。我们可以使用 numpy.save("文件路径", numpy数组) 方法 将数组数据写入到硬盘中。默认情况下，数组是以未压缩的原始二进制格式保存在扩展名为 .npy 的文件中的。如果文件路径末尾没有扩展名 .npy，则该扩展名会自动加上。
import numpy as np
array = np.random.randint(1, 10, (3, 3))
np.save("numpy", array)
然后就可以通过 ndarray = numpy.load("文件路径") 方法 读取硬盘上的数组 了：
import numpy as np
array = np.load("numpy.npy")
print(array)
通过 numpy.savez("文件路径", "文件的数组名"=ndarray数组名) 方法可以 将多个数组保存到一个未压缩文件中，将 数组 以 关键字参数 的形式传入即可。如果文件路径末尾没有扩展名 .npz，则该扩展名会自动加上。
import numpy as np
array1 = np.random.randint(1, 10, (3, 3))
array2 = np.random.randint(1, 10, (3, 3))
np.savez('arrays', a=array1, b=array2)
加载 .npz 文件时，你会得到一个类似字典的对象，该对象会对各个数组进行延迟加载：
import numpy as np
arrays = np.load("arrays.npz")
print(arrays["a"])
print(arrays["b"])
如果要将数据存入已压缩的文件，可以使用 numpy.savez_compressed("文件路径", "文件的数组名"=ndarray数组名) 方法。
import numpy as np
array1 = np.random.randint(1, 10, (3, 3))
array2 = np.random.randint(1, 10, (3, 3))
np.savez_compressed('arrays', a=array1, b=array2)
浙公网安备 33010602011771号