Numpy

numpy库是Python语言的一个第三方库，支持大量的维度数组与矩阵运算，此外也针对数组运算提供大量的数学函数库。numpy最重要的一个特点是其N维数组对象（ndarray），它是一系列同类型数据的集合，数组元素用整数索引，序号从0开始。ndarrary中的每个元素在内存中使用相同的大小块，每个元素是数据类型对象的对象（称为dtype）。

1. numpy 创建数组

1. 从Python列表创建

import numpy as np
# 一维数组
a = np.array([1, 2, 3])
print(a)

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

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

2. 使用内置函数创建

1. np.zeros

• 功能：创建一个指定形状且元素全为 0 的数组。

• 语法：

np.zeros(shape, dtype=float, order='C')

• shape：数组的形状，是一个整数或者整数元组。例如 (2, 3) 表示创建一个 2 行 3 列的二维数组。
• dtype：可选参数，指定数组的数据类型，默认是 float。

• order：可选参数，指定数组在内存中的存储顺序，'C' 表示按行存储，'F' 表示按列存储。

• 示例代码中的使用：

import numpy as np

zeros_array = np.zeros((2, 3))
print(zeros_array)

这段代码创建了一个 2 行 3 列的二维数组，元素全为 0，数据类型为默认的 float。

2. np.ones

• 功能：创建一个指定形状且元素全为 1 的数组。

• 语法：

np.ones(shape, dtype=float, order='C')

• 参数含义与 np.zeros 相同。

• 示例代码中的使用：

import numpy as np

ones_array = np.ones((2, 3))
print(ones_array)

这段代码创建了一个 2 行 3 列的二维数组，元素全为 1，数据类型为默认的 float。

3. np.arange

• 功能：创建一个等差数列的一维数组。

• 语法：

np.arange([start, ]stop, [step, ]dtype=None)

• start：可选参数，数列的起始值，默认是 0。
• stop：数列的终止值（不包含在数列中）。
• step：可选参数，数列的步长，默认是 1。

• dtype：可选参数，指定数组的数据类型。

• 示例代码中的使用：

import numpy as np

arange_array = np.arange(0, 10, 2)
print(arange_array)

这段代码创建了一个从 0 开始（包含），到 10 结束（不包含），步长为 2 的等差数列一维数组 [0, 2, 4, 6, 8]。

4. np.linspace

• 功能：创建一个指定区间内的等间隔数组。

• 语法：

np.linspace(start, stop, num=50, endpoint=True, retstep=False, dtype=None)

• start：区间的起始值。
• stop：区间的终止值。
• num：可选参数，生成的样本数量，默认是 50。
• endpoint：可选参数，布尔值，指示是否包含终止值，默认是 True。
• retstep：可选参数，布尔值，指示是否返回步长，默认是 False。

• dtype：可选参数，指定数组的数据类型。

• 示例代码中的使用：

import numpy as np

linspace_array = np.linspace(0, 10, 5)
print(linspace_array)

这段代码创建了一个从 0 到 10（包含）的等间隔数组，共包含 5 个元素 [ 0. 2.5 5. 7.5 10. ]。

5. np.reshape

• 功能：改变数组的形状，而不改变数组中的数据。

• 语法：

np.reshape(a, newshape, order='C')

• a：要改变形状的数组。
• newshape：新的形状，可以是一个整数或者整数元组。新形状的元素总数必须与原数组的元素总数相同。

• order：可选参数，指定数组在内存中的存储顺序，'C' 表示按行存储，'F' 表示按列存储。

• 示例代码：

import numpy as np

# 创建一个一维数组
original_array = np.arange(12)
print("原数组:", original_array)

# 将一维数组转换为 3 行 4 列的二维数组
reshaped_array = np.reshape(original_array, (3, 4))
print("重塑后的数组:\n", reshaped_array)

在这个示例中，我们首先创建了一个包含 12 个元素的一维数组，然后使用 np.reshape 函数将其转换为一个 3 行 4 列的二维数组。

此外，数组对象本身也有 reshape 方法，使用方式类似：

import numpy as np

original_array = np.arange(12)
reshaped_array = original_array.reshape((3, 4))
print(reshaped_array)

6. np.empty

• 功能：创建一个指定形状的数组，数组元素的值是未初始化的随机值。

• 语法

python np.empty(shape, dtype=float, order='C')

• shape：必需参数，用于指定数组的形状，可以是一个整数或者整数元组。例如，(2, 3) 表示创建一个 2 行 3 列的二维数组。
• dtype：可选参数，用于指定数组的数据类型，默认是 float。

• order：可选参数，指定数组在内存中的存储顺序，'C' 表示按行存储（C 风格），'F' 表示按列存储（Fortran 风格），默认是 'C'。

• 示例：

import numpy as np
empty_arr = np.empty((2, 3))
print(empty_arr)

7. np.full

• 功能：创建一个指定形状的数组，数组元素被填充为指定的值。

• 语法

python np.full(shape, fill_value, dtype=None, order='C')

• shape：必需参数，指定数组的形状，可以是一个整数或者整数元组。
• fill_value：必需参数，用于指定填充数组元素的值。
• dtype：可选参数，指定数组的数据类型，若未指定，会根据 fill_value 自动推断。

• order：可选参数，指定数组在内存中的存储顺序，'C' 表示按行存储（C 风格），'F' 表示按列存储（Fortran 风格），默认是 'C'。

• 示例：

import numpy as np
full_arr = np.full((2, 3), 5)
print(full_arr)

8. np.eye

• 功能：创建单位矩阵的函数。单位矩阵是主对角线上元素全为 1，其余元素都为 0 的方阵。

• 语法

python np.eye(N, M=None, k=0, dtype=<class 'float'>, order='C', *, like=None)

• N：代表输出矩阵的行数。
• M（可选）：代表输出矩阵的列数。若未提供，默认值等于 N，即生成方阵。
• k（可选）：主对角线的索引。k=0 是主对角线；k > 0 是主对角线右上方的对角线；k < 0 是主对角线左下方的对角线。默认值为 0。
• dtype（可选）：输出矩阵的数据类型，默认是 float。
• order（可选）：在内存中存储多维数据的顺序，有 'C'（C 风格）和 'F'（Fortran 风格）两种选择，默认是 'C'。
• like（可选）：用于创建与指定对象类似的对象，这是一个高级用法，通常无需使用。

9. np.random

10. np.sort

用于对数组进行排序。它能按照指定的轴对数组元素进行升序排序，并且提供了多种使用方式。

np.sort(a, axis=-1, kind=None, order=None)

参数说明

• a：输入的数组，即需要进行排序的数组。

• axis（可选）：指定排序的轴。默认值为 -1，表示沿最后一个轴进行排序。若 axis=None，则会将数组扁平化后再进行排序。

• kind（可选）：指定排序算法，可取值为 'quicksort'（快速排序）、'mergesort'（归并排序）、'heapsort'（堆排序）、'stable'（稳定排序），默认使用快速排序。

• order（可选）：如果数组是结构化数组，可通过该参数指定按照哪些字段进行排序。

11. np.split

将数组分割成多个子数组，若无法均匀分割会抛出错误。返回一个排序后的新数组。

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

• ary：待分割的输入数组。

• indices_or_sections：若为整数，代表要把数组分割成的子数组数量，此时数组长度必须能被该整数整除；若为一维数组，则数组中的元素指定了分割点的位置。

• axis（可选）：指定沿着哪个轴进行分割，默认值为 0，表示按行分割。

12. np.arry_split

将一个数组分割成多个子数组。与 np.split 函数不同的是，当数组不能被均匀分割时，np.array_split 会尽量让子数组的大小接近，也就是允许子数组的长度不完全相同。返回一个包含分割后子数组的列表。

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

• ary：需要进行分割的输入数组。
• indices_or_sections：若为整数，代表要将数组分割成的子数组数量；若为一维数组，则数组中的元素指定了分割点的位置。
• axis（可选）：指定沿着哪个轴进行分割，默认值为 0，表示按行分割。

13. np.repeat

对数组中的元素进行重复操作，从而生成一个新的数组。

numpy.repeat(a, repeats, axis=None)

参数说明

• a：输入的数组，即需要对其元素进行重复操作的数组。
• repeats：重复的次数。若 repeats 是一个整数，则数组中的每个元素都会重复该次数；若 repeats 是一个数组，则其长度必须与 a 的长度（在指定轴上）相同，repeats 数组中的每个元素对应 a 中相应位置元素的重复次数。
• axis（可选）：指定重复操作沿着哪个轴进行。默认值为 None，此时会将数组扁平化后再进行重复操作；若指定了 axis，则会在该轴上进行重复操作。

14. np.fill_diagonal

将数组的主对角线元素填充为指定的值。

函数原型

np.fill_diagonal(a, val, wrap=False)

参数说明

• a：这是一个必需的参数，代表要操作的输入数组，该数组必须是二维的。
• val：同样是必需参数，它表示要填充到主对角线上的值，可以是一个标量（如整数、浮点数等）。
• wrap：此为可选参数，是一个布尔值，默认值为 False。当 wrap = True 时，会处理非方阵的情况，使得对角线可以 “环绕” 数组；当 wrap = False 时，对于非方阵只会填充到对角线的最短长度。

返回值

该函数没有返回值，它会直接修改输入数组 a 的主对角线元素。

15.np.vstack

语法

numpy.vstack(tup)

参数

• tup：这是一个元组，其中包含了要进行堆叠的多个数组。这些数组必须是相同数据类型，并且除了要堆叠的轴（这里是垂直方向，即行）之外，其他维度的形状必须一致。例如，要堆叠的数组的列数必须相同。

返回值

函数会返回一个新的数组，该数组是将输入的多个数组在垂直方向上堆叠后得到的结果。返回数组的数据类型与输入数组的数据类型相同。

16. np.hstack

语法

numpy.hstack(tup)

参数

• tup：这是一个元组，其中包含了要进行堆叠的多个数组。这些数组的数据类型需一致，且除了水平方向（列）之外的其他维度（通常指行数）的形状必须相同。

返回值

函数会返回一个新数组，它是将输入的多个数组在水平方向上堆叠后的结果，返回数组的数据类型和输入数组的数据类型相同。

17. flatten()

将多维数组转换为一维数组。

2. numpy的属性

1. ndim

该属性用于返回数组的维度数。

import numpy as np

# 创建一维数组
arr1 = np.array([1, 2, 3])
print("一维数组的维度数:", arr1.ndim)

# 创建二维数组
arr2 = np.array([[1, 2, 3], [4, 5, 6]])
print("二维数组的维度数:", arr2.ndim)

2. shape

此属性返回一个元组，该元组展示了数组在每个维度上的大小。

import numpy as np

arr = np.array([[1, 2, 3], [4, 5, 6]])
print("数组的形状:", arr.shape)

3. size

该属性返回数组中元素的总数。

import numpy as np

arr = np.array([[1, 2, 3], [4, 5, 6]])
print("数组元素的总数:", arr.size)

4. dtype

此属性返回数组中元素的数据类型。

import numpy as np

arr = np.array([1, 2, 3], dtype=np.float64)
print("数组元素的数据类型:", arr.dtype)

5. itemsize

该属性返回数组中每个元素的字节大小。

import numpy as np

arr = np.array([1, 2, 3], dtype=np.float64)
print("数组每个元素的字节大小:", arr.itemsize)

6. data

此属性返回一个缓冲区对象，该对象指向数组的数据起始位置。通常在实际使用中较少直接用到。

import numpy as np

arr = np.array([1, 2, 3])
print("数组的数据起始位置:", arr.data)

7. T

ndarray.T 属性返回数组的转置，即交换数组的行和列。

import numpy as np

arr = np.array([[1, 2, 3], [4, 5, 6]])
print("原数组:")
print(arr)
print("转置后的数组:")
print(arr.T)

3. 索引和切片

1. 索引

索引能够让你访问数组里特定位置的元素。NumPy 支持多种索引方式，具体如下：

整数索引

import numpy as np

# 创建一维数组
arr1 = np.array([1, 2, 3, 4, 5])
print("一维数组的第 3 个元素：", arr1[2])

# 创建二维数组
arr2 = np.array([[1, 2, 3], [4, 5, 6]])
print("二维数组第 2 行第 3 列的元素：", arr2[1, 2])

布尔索引

借助布尔数组来选取元素，布尔数组的长度要和被索引数组的相应维度长度一致。

import numpy as np

arr = np.array([1, 2, 3, 4, 5])
mask = arr > 3
print("大于 3 的元素：", arr[mask])

整数数组索引

使用整数数组来指定要选取的元素的索引。

import numpy as np

arr = np.array([10, 20, 30, 40, 50])
indices = np.array([1, 3])
print("索引为 1 和 3 的元素：", arr[indices])

2. 切片

切片用于选取数组中的一部分元素，其基本语法是 [start:stop:step]，其中 start 代表起始位置，stop 代表结束位置（不包含该位置的元素），step 代表步长。

一维数组切片

import numpy as np

arr = np.array([1, 2, 3, 4, 5])
print("从第 2 个元素到第 4 个元素：", arr[1:4])
print("从第 1 个元素开始，每隔一个元素选取：", arr[::2])

二维数组切片

import numpy as np

arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
print("选取前两行和前两列的元素：")
print(arr[:2, :2])

4. 基础运算

1. 基本算术运算

这些函数能对数组元素执行加、减、乘、除等基本操作。

• np.add(x1, x2)：对两个数组x1和x2对应元素相加。
• np.subtract(x1, x2)：用x1的元素减去x2对应元素。
• np.multiply(x1, x2)：将两个数组对应元素相乘。
• np.divide(x1, x2)：把x1元素除以x2对应元素。
• np.power(x1, x2)：计算x1的元素以x2对应元素为指数的幂。
• np.mod(x1, x2)：求x1元素除以x2对应元素的余数。
• np.reciprocal(a)：返回a每个元素的倒数。

2. 矩阵运算

适合进行矩阵乘法、求逆等线性代数运算。

• np.dot(x1, x2)：计算两个数组的点积。对于二维数组，就是矩阵乘法。
• np.matmul(x1, x2)：专门用于矩阵乘法，在处理高维数组时遵循特定广播规则。
• np.linalg.inv(x)：求方阵x的逆矩阵。
• np.linalg.det(x)：计算方阵x的行列式。
• np.linalg.solve(A,b)：求解线性方程组 (Ax = b)，其中 A 是系数矩阵，b 是常数向量，x 是待求解的未知向量。
• np.linalg.svd(x)：对矩阵进行奇异值分解。
• np.linalg.eig(x)：矩阵的特征值和特征向量。
• transpose()：对矩阵转置的方法

3. 比较运算

用于比较数组元素，返回布尔型数组。

• np.equal(x1, x2)：判断两个数组对应元素是否相等。
• np.not_equal(x1, x2)：判断两个数组对应元素是否不相等。
• np.greater(x1, x2)：判断x1元素是否大于x2对应元素。
• np.greater_equal(x1, x2)：判断x1元素是否大于等于x2对应元素。
• np.less(x1, x2)：判断x1元素是否小于x2对应元素。
• np.less_equal(x1, x2)：判断x1元素是否小于等于x2对应元素。

4. 逻辑运算

可对布尔型数组进行逻辑操作。

• np.logical_and(x1, x2)：对两个布尔型数组进行逻辑与运算。
• np.logical_or(x1, x2)：对两个布尔型数组进行逻辑或运算。
• np.logical_not(x)：对布尔型数组进行逻辑非运算。

5. 三角函数

• np.sin(x)、np.cos(x)、np.tan(x)：分别计算数组x中每个元素的正弦、余弦和正切值。
• np.arcsin(x)、np.arccos(x)、np.arctan(x)：分别计算数组x中每个元素的反正弦、反余弦和反正切值。

6. 指数和对数函数

• np.exp(x)：计算数组x中每个元素的自然指数 ex。
• np.log(x)：计算数组x中每个元素的自然对数 ln(x)。
• np.log10(x)：计算数组x中每个元素的以 10 为底的对数。

7. 舍入函数

• np.round(x, decimals)：将数组x中的元素四舍五入到指定的小数位数decimals。
• np.floor(x)：返回数组x中每个元素的向下取整值。
• np.ceil(x)：返回数组x中每个元素的向上取整值。

8. 统计函数

• np.mean(x)：计算数组x中所有元素的平均值。
• np.cumsum(x)：计算数组x中元素的累加和。
• np.median(x)：计算数组x中所有元素的中位数。
• np.std(x)：计算数组x中所有元素的标准差。
• np.var(x)：计算数组x中所有元素的方差。
• np.min(x)、np.max(x)：分别返回数组x中所有元素的最小值和最大值。

9. 其他常用函数

• np.sqrt(x)：计算数组x中每个元素的平方根。
• np.abs(x)：计算数组x中每个元素的绝对值。
• np.sign(x)：返回数组x中每个元素的符号，正数返回 1，负数返回 -1，零返回 0。
• np.amin(x)：计算数组x中的最小值。二维数组中可以添加axis关键字，值为0时按行查找每列最小值，值为1时按列查找每行最小值，并返回列表类型。
• np.amax(x)：计算数组x中的最大值。二维数组中可以添加axis关键字，值为0时按行查找每列最大值，值为1时按列查找每行最大值，并返回列表类型。

5. Broadcasting广播

广播是 NumPy 里用于对不同形状的数组执行算术运算的一种强大机制。当两个数组形状不同时，广播机制能够让它们进行运算，前提是这些数组的形状要满足一定规则。

1. 广播规则

• 若两个数组的维度数量不同，维度较少的数组会在其形状的左侧补 1，直到维度数量相同。
• 对于每个维度，数组的大小要么相同，要么其中一个为 1。
• 若所有维度都满足上述条件，则可以进行广播运算。

import numpy as np

# 示例1：数组和标量的广播
arr = np.array([1, 2, 3])
scalar = 2
result1 = arr + scalar
print("数组和标量广播相加的结果:")
print(result1)

# 示例2：不同形状数组的广播
arr1 = np.array([[1, 2, 3], [4, 5, 6]])
arr2 = np.array([1, 2, 3])
result2 = arr1 + arr2
print("\n不同形状数组广播相加的结果:")
print(result2)

在示例 2 中，arr2 的形状是 (3,)，arr1 的形状是 (2, 3)。根据广播规则，arr2 会在左侧补 1，变为 (1, 3)，接着在第一个维度上进行复制，成为 (2, 3)，如此就能和 arr1 进行相加运算了。

在 NumPy 中，标量Scalars指的是单个数值。你可以对 ndarray 和标量开展各种数学运算。

import numpy as np

arr = np.array([1, 2, 3])
scalar = 2

# 数组和标量相加
result_add = arr + scalar
print("数组和标量相加的结果:")
print(result_add)

# 数组和标量相乘
result_mul = arr * scalar
print("\n数组和标量相乘的结果:")
print(result_mul)