介绍 Python 科学计算核心库 NumPy。阐述了其作为数值计算引擎的重要性，详细讲解了 ndarray 数组的多维性、同质性及常用属性（shape, ndim, size, dtype 等）。涵盖了 ndarray 的多种创建方法（基础、预定义、范围生成、特殊矩阵、随机数组），数据类型转换，索引与切片操作（基本、布尔索引等），以及广播机制和矩阵运算。最后总结了 NumPy 中的常用函数，包括基础数学运算、统计计算（求和、均值、方差等）、比较逻辑运算及数组处理函数（排序、去重、拼接、分割、形状调整）。
如果你正在进行数据科学或机器学习项目，那么你一定会接触到 Python，而如果你在 Python 中进行科学计算，NumPy 就是你必不可少的工具。它被誉为 Python 数值计算的'发动机'，是整个数据分析和科学计算生态系统的基石。NumPy 凭借其高效的 ndarray 数组对象，让你能在 Python 中处理大规模数据时，拥有接近 C 语言的运算速度。
在传统的 Python 列表操作中，数据存取的速度相对较慢，尤其是在需要进行大量数值计算时。NumPy 通过其多维数组（ndarray）结构，将这些计算的效率提升了一个数量级，同时极大地优化了内存使用。你将能够轻松实现高效的矩阵运算、线性代数、统计运算等，甚至无需手动编写复杂的循环代码。
举个简单的例子，假设你有一个包含成千上万的数据点的二维矩阵，使用 Python 自带的列表来存储和操作这些数据，不仅处理速度慢，而且内存占用也高。使用 NumPy 后，你可以轻松创建一个高效的 ndarray 数组，并进行一系列优化计算。
# 零维向量 arr = np.array(5) print(arr) print('arr 的维度', arr.ndim) # 数组的维度 << 5 arr 的维度 0 # 一维向量 arr = np.array([1, 2, 3]) print(arr) print('arr 的维度', arr.ndim) # 数组的维度 << [1 2 3] arr 的维度 1 # 二维矩阵 arr = np.array([[1, 2, 3], [4, 5, 6]]) print(arr) print('arr 的维度', arr.ndim) # 数组的维度 << [[1 2 3] [4 5 6]] arr 的维度 2
arr = np.array([1, 2, 'hello']) # 强制转换为同一类型 print(arr) << ['1' '2' 'hello'] arr = np.array([1, 2.5]) # 转换升维 print(arr) << [1. 2.5] # 这里显示 1.后面的小数位 0 省略
| 属性名称 | 解释 | 使用示例 |
|---|---|---|
| shape | 数组的形状：行数和列数（或更高维度的尺寸） | arr.shape |
| ndim | 维度数量：数组是维度（1 维，2 维，3 维） | arr.ndim |
| size | 总元素个数：数组中所有元素的总数 | arr.size |
| dtype | 元素类型：数组中元素的类型 | arr.dtype |
| T | 转置：和高数中概念一样 | arr.T |
arr = np.array([[1, 2, 3], [4, 5, 6]]) print(arr) print('arr 的形状', arr.shape) # 数组的形状 (返回元组 tuple) print('arr 的总元素个数', arr.size) # 数组总元素个数 print('转置', arr.T) << [[1 2 3] [4 5 6]] arr 的形状 (2, 3) arr 的总元素个数 6 转置 [[1 4] [2 5] [3 6]]
| 用途 | 方法 | |||
|---|---|---|---|---|
| 基础创建 | np.array() | np.copy() | ||
| 预定义形状填充 | np.zeros() | np.ones() | np.empty() | np.full() |
| 基于数值范围生成 | np.arange() | np.linspace() | np.logspace() | |
| 特殊矩阵生成 | np.eye() | np.diag() | ||
| 随机数组生成 | np.random.rand() | np.random.randn() | np.random.randint() | |
| 高级构造方法 | np.fromfunction() | np.loadtxt() |
list1 = [[1, 2, 3], [4, 5, 6]] arr = np.array(list1, dtype=float) # 可转成浮点型 print(arr) << [[1. 2. 3.] [4. 5. 6.]] # copy 元素和参数的数组相同，不是同一个数组 arr1 = np.copy(arr) # 复制 print(arr1) << [[1. 2. 3.] [4. 5. 6.]]
# 全 0 数组 arr = np.zeros((2,3), dtype = int) # 两行三列，默认为 float print(arr) << [[0 0 0] [0 0 0]] # 全 1 数组 arr = np.ones((2,3), dtype = int) print(arr) << [[1 1 1] [1 1 1]] # 只定义形状，里面的值是随机的 arr = np.empty((2, 3), dtype = int) print(arr) << [[1 1 1] [1 1 1]] # 固定值 arr = np.full((3,4), 5) # 第二个变量是要填充的值 print(arr) << [[5 5 5 5] [5 5 5 5]]
# 现状与已用数组一样保持一致 arr1 = np.zeros_like(arr) # 和 arr 一样形状的全 0 数组 print(arr1) arr1 = np.empty_like(arr) # 和 arr 一样形状的随机数组 print(arr1) arr1 = np.ones_like(arr) # 和 arr 一样形状的全 1 数组 print(arr1) arr1 = np.full_like(arr, 2026) # 和 arr 一样形状的固定值数组 print(arr1) << [[0 0 0 0] [0 0 0 0]] [[25895968444448860 23925768161198147 32370111954616435 14636909245562972] [18296268626853943 27303364806049904 21392493373358196 30399714103066735]] [[1 1 1 1] [1 1 1 1]] [[2026 2026 2026 2026] [2026 2026 2026 2026]]
# 等差数列 arr = np.arange(1, 10, 2) # 和列表一样 print(arr) << [1 3 5 7 9] # 等间隔数列 arr = np.linspace(0, 10, 3, dtype=int) # 起始 终止 划分的点数 print(arr) << [ 0 5 10] # 对数数列 arr = np.logspace(0, 8, 5, base=2) # 0 2 4 6 8，底是 2 的对数 print(arr) << [ 1. 4. 16. 64. 256.]
# 单位矩阵 arr = np.eye(3, dtype=int) print(arr) << [[1 0 0] [0 1 0] [0 0 1]] # 对角矩阵 arr = np.diag([5, 1, 2, 3]) # 给的是主对角线上的值 print(arr) << [[5 0 0 0] [0 1 0 0] [0 0 2 0] [0 0 0 3]]
# 生成 0 到 1 之间的随机浮点数 (均匀分布) arr = np.random.rand(2,3) print(arr) << [[0.47829244 0.03032865 0.58919664] [0.03195441 0.88274548 0.1585089 ]] # 生成指定范围区间的随机浮点数 arr = np.random.uniform(3, 6, (2,3)) print(arr) << [[3.39579473 3.12984342 3.94951508] [4.66614785 5.66716061 4.75435952]] # 生成指定范围区间的随机整数 arr = np.random.randint(3, 30, (2,3)) print(arr) << [[ 8 6 29] [24 9 13]] # 生成随机数列 (正态分布)(-3 到 3 之间) arr = np.random.randn(2,3) print(arr) << [[ 0.09770923 0.76633602 -1.26567432] [ 1.33770655 -0.43399984 -0.94372411]] # 设置随机种子 np.random.seed(20) arr = np.random.randint(1, 10, (2,5)) # 设置了随机种子后每次生成的数组保持不变
布尔类型：bool 整数：int uint 浮点数：float 复数：complex
# 基础方法 list1 = [[1, 2, 3], [4, 5, 6]] arr = np.array(list1, dtype=complex) # 可转成浮点型 print(arr) << [[1.+0.j 2.+0.j 3.+0.j] [4.+0.j 5.+0.j 6.+0.j]]
| 索引 / 切片类型 | 描述 / 用法 | 代码实例 | 运行结果 |
|---|---|---|---|
| 基本索引 | 通过整数索引直接访问元素，索引从 0 开始 | arr[1, 2] | 6（第 2 行、第 3 列的元素） |
| 行 / 列切片 | 用冒号 : 选择行或列的子集 | arr[0:2, :]（取前 2 行，所有列） | [[1,2,3], [4,5,6]] |
| 连续切片 | 从起始索引到结束索引，按步长切片（左闭右开） | arr[:, 0:3:2]（取所有行，列按步长 2 切片） | [[1,3], [4,6], [7,9]] |
| 使用 slice 函数 | 通过 slice(start, stop, step) 定义切片规则 | col_slice = slice(0, 3, 2)<br>arr[:, col_slice] | 同 '连续切片' 结果 |
| 布尔索引 | 通过布尔条件筛选元素，支持 && 、 |
# 一维 arr = np.random.randint(1,100,10) print(arr[:]) print(arr[1:8]) print(arr[slice(1,8,2)]) print(arr[(arr>10) & (arr<70)]) # 布尔索引 << [53 23 15 5 28 76 9 7 27 80] [23 15 5 28 76 9 7] [23 5 76 7] [53 23 15 28 27] # 二维 arr = np.random.randint(1,100,(4,8)) print(arr) print(arr[1:3,2:5]) # 逗号前面是控制行，后面是控制列 print(arr[(arr>50)]) # 输出的整理为一维数组 << [[76 16 55 12 5 23 7 60] [45 74 12 19 53 65 56 65] [37 49 96 59 40 38 55 93] [ 6 27 16 92 56 11 70 18]] [[12 19 53] [96 59 40]] [76 55 60 74 53 65 56 65 96 59 55 93 92 56 70]
# 算术运算：对应元素一一运算 a = np.array([1, 2, 3]) b = np.array([4, 5, 6]) print(a+b) print(a-b) print(a*b) print(a/b) << [5 7 9] [-3 -3 -3] [ 4 10 18] [0.25 0.4 0.5 ] a = np.array([[1, 2, 3], [4, 5, 6]]) print(a + 3) # 针对每一个元素操作 << [[4 5 6] [7 8 9]]
# 广播机制 # 相同维度：相同，1 a = np.array([1, 2, 3]) # 1*3 b = np.array([[4], [5], [6]]) # 3*1 ''' 扩充后的矩阵 a 1 2 3 1 2 3 1 2 3 b 4 4 4 5 5 5 6 6 6 ''' print(a+b) << [[5 6 7] [6 7 8] [7 8 9]]
# 矩阵运算 a = np.array([[1, 2, 3],[4, 5, 6],[7, 8, 9]]) b = np.array([[4, 5, 6],[7, 8, 9],[1, 2, 3]]) print(a @ b) print(type(a)) << [[ 21 27 33] [ 57 72 87] [ 93 117 141]] <class 'numpy.ndarray'>
# 计算平方根，返回浮点数 print(np.sqrt(9)) print(np.sqrt([1, 4, 9])) << 3.0 [1. 2. 3.] # 计算指数 e^x print(np.exp(1)) << 2.718281828459045 # 计算自然对数 lnx print(np.log(2)) << 0.6931471805599453 # 三角函数默认弧度制 print(np.sin(np.pi / 3)) print(np.cos(np.pi / 3)) << 0.8660254037844386 0.5 # 计算绝对值 arr = [1, -6, 6, 8, -9] print(np.abs(arr)) << [1 6 6 8 9] # 计算 a 的 b 次幂 print(np.power(arr, 3)) << [ 1 -216 216 512 -729] # 四舍六入五取偶（这里是用银行家舍入法） # 银行家舍入法：4 舍 6 入，需要舍入的数字是 5 时，会向最近的偶数靠拢 print(np.round([3.2, 4.5, 5.5, 8.1, 9.6])) << [ 3. 4. 6. 8. 10.] arr = np.array([1.6, 25.1, 4.5]) print(np.ceil(arr)) # 向上取整 print(np.floor(arr)) # 向下取整 << [ 2. 26. 5.] [ 1. 25. 4.] # 检测缺失值 s = np.isnan([1, 2, 3, np.nan]) print(s) << [False False False True]
arr = np.random.randint(1, 20, 8) << [12 16 8 16 10 16 1 7] print(arr) # 求和 print(np.sum(arr)) << 86 # 计算平均值 print(np.mean([1, 2, 4])) << 2.3333333333333335 # 计算中位数 # 奇数：排序后的中间值 # 偶数：中间的两个数的平均值 print(np.median([1, 2, 4])) print(np.median([1, 2, 4, 8])) << 2.0 3.0 print(np.var([1, 2, 3])) # 方差 print(np.std([1, 2, 3])) # 标准差 << 0.6666666666666666 0.816496580927726
# 计算最大值，最小值 arr = [2, 3, 5, 8, 1] print(np.max(arr), np.argmax(arr)) # 最大值和最大值的索引 print(np.min(arr), np.argmin(arr)) << 8 3 1 4
# 分位数 arr = [44, 47, 64, 67] print(np.median(arr)) # 中位数（这里的一个点代表一个值与数轴上的概念不同） << 55.5 # ------------------ # 44 47 64 67 # 3 17 3 print(np.percentile(arr, 25)) # 计算方式为 # 0.25*3=0.75 (在第一个和第二个之间) # (47-44)*0.75 + 44 = 46.25 << 46.25 # 0.8*3=2.4 (在第二个和第三个之间) # (67-64)*0.4 + 64 = 65.2 print(np.percentile(arr, 80)) << 65.2 # 累积和，累积积 arr = np.array([1, 2, 3]) print(np.cumsum(arr)) # 第 i 项为前 i 项之和 print(np.cumprod(arr)) # 第 i 项为前 i 项之积 << [1 3 6] [1 2 6]
arr = [3, 4, 5, 2, 1] print(np.greater(arr, 4)) # 是否大于 print(np.less(arr, 4)) # 是否小于 print(np.equal(arr, 4)) # 是否等于 print(np.equal(arr, [4, 4, 4, 4, 4])) << [False False True False False] [ True False False True True] [False True False False False] [False True False False False]
print(np.logical_and([0, 0, 1], [1, 0, 1])) print(np.logical_or([0, 0, 1], [1, 0, 1])) print(np.logical_not([0, 1])) << [False False True] [ True False True] [ True False]
# 是否至少有一个元素为 True print(np.any([0, 0, 0])) # 是否全是 True print(np.all([1, 1, 1])) << False True
# 自定义条件 arr = np.array([1, 2, 3, 4, 5]) print(np.where(arr>3, arr, 0)) # 条件，符合条件取，不符合条件取 << [0 0 0 4 5]
# 成绩判断 score = np.random.randint(1, 100, 10) print(score) print(np.where( score<60, '不及格', np.where( score<80, '良好', '优秀') )) print(np.select([score>80,(score>=60) & (score<=80), score<60], ['优秀', '良好', '不及格'], default='未知')) # 这里的 default 必须写，即使不存在这种情况 << [61 47 78 11 3 8 38 7 84 74] ['良好' '不及格' '良好' '不及格' '不及格' '不及格' '不及格' '不及格' '优秀' '良好'] ['良好' '不及格' '良好' '不及格' '不及格' '不及格' '不及格' '不及格' '优秀' '良好']
# 排序函数 arr = np.random.randint(1, 100, 10) print(arr) arr.sort() # 本地排序，相当于这个是个排序命令，返回为 None print(arr) print(np.sort(arr)) # 需要传参，不改变原始数组 << [ 4 40 62 83 91 18 70 64 42 65] [0 5 1 8 2 7 9 6 3 4] [ 4 18 40 42 62 64 65 70 83 91]
# 去重函数 arr = [1, 3, 2, 5, 5, 4] print(np.unique(arr)) # 去重后附带排序功能 << [1 2 3 4 5]
# 数组拼接函数 arr1 = np.array([1, 2, 3]) arr2 = np.array([4, 5, 6]) print(np.concatenate((arr1, arr2))) << [1 2 3 4 5 6]
# 数组分割 arr = np.array([1, 2, 3, 4, 5, 6, 7, 8]) print(np.split(arr, 4)) # 切分的份数必须等分 print(np.split(arr, [1, 3, 7])) # 按照切分位置切 << [array([1, 2]), array([3, 4]), array([5, 6]), array([7, 8])] [array([1]), array([2, 3]), array([4, 5, 6, 7]), array([8])]
# 调整数组形状 arr = np.reshape(arr, [2,4]) print(arr) << [[1 2 3 4] [5 6 7 8]]
微信公众号「极客日志」，在微信中扫描左侧二维码关注。展示文案：极客日志 zeeklog
使用加密算法（如AES、TripleDES、Rabbit或RC4）加密和解密文本明文。 在线工具，加密/解密文本在线工具，online
生成新的随机RSA私钥和公钥pem证书。 在线工具，RSA密钥对生成器在线工具，online
基于 Mermaid.js 实时预览流程图、时序图等图表，支持源码编辑与即时渲染。 在线工具，Mermaid 预览与可视化编辑在线工具，online
解析常见 curl 参数并生成 fetch、axios、PHP curl 或 Python requests 示例代码。 在线工具，curl 转代码在线工具，online
将字符串编码和解码为其 Base64 格式表示形式即可。 在线工具，Base64 字符串编码/解码在线工具，online
将字符串、文件或图像转换为其 Base64 表示形式。 在线工具，Base64 文件转换器在线工具，online