Python 大数据分析基础 · 第 7 次课

第 7 章 NumPy 数值计算

NumPy 与 ndarray · 数组的创建 · 属性与访问 · 布尔索引 · 数组运算(转置 / 点积 / 广播)· 统计运算与 axis · 排序与变形 · 成绩表综合案例 · 教材股票拓展案例 · AI 渗透(7 个知识模块 + 1 个交互演示区 + 46 段实测代码 + 17 张插图 + 12 个动态演示图 + 6 个交互面板)

中华女子学院4 学时(讲授 1 + 上机 3)授课人:孙琪翔2026-11-13 · 第 11 周
导

本讲导览

Lesson Overview · 从"一个数一个数地算"到"一整批数一起算"

前六章我们都在用单个数据干活:一个变量、一个列表、一个字典。可现实里的数据是成批的——一个班 40 个人的成绩、一张 1000 行 20 列的表、一张 224×224 的图片。用 for 循环一个元素一个元素地算,代码又长又慢。这一章的主角 NumPy 就是来解决这件事的:它提供一个叫 ndarray 的多维数组对象,让你能把一整批数当成一个对象来算——这叫"向量化"。

这一章的分量很重:第 8 章 pandas 的 DataFrame 底下就是 NumPy 数组,第 9 章 matplotlib 画的所有图也是从数组来的。再往后,机器学习的 scikit-learn、深度学习的 PyTorch,张量(Tensor)的设计思想跟 ndarray 是同一套。所以这一章不是"多学一个库",而是换一种看待数据的方式。

本课主线:同一件事,两种做法 以前:列表 + for 循环 nums = [1, 2, 3, 4, 5] result = [] for x in nums: result.append(x * 2) 一行一行地搬运,数据一多就慢 现在:NumPy 数组 import numpy as np arr = np.array([1, 2, 3, 4, 5]) result = arr * 2 → [ 2 4 6 8 10] 一句话算完,底层是 C 循环 这一章学会四件事,第 8、9 章和后面的分析全靠它 ① 造数组 ② 取数据 ③ 整批算 ④ 按轴汇总
本课主线:列表只能"逐个搬运",数组能"整批运算"——这就是向量化,数据分析效率的分水岭

四节课时怎么排

第 1 讲 · 45 分钟
NumPy 与数组入门
为什么要 NumPy · ndarray 的三条规矩 · 创建数组的五种方式 · shape / ndim / size
上机一 · 45 分钟
把数据取出来
一维索引与切片 · 二维两级下标 · `:` 的用法 · 布尔索引挑元素 · 视图 vs 副本
上机二 · 45 分钟
整批算一遍
转置 T · 逐元素运算 · dot 矩阵乘法 · 广播 · 统计函数与 axis
上机三 · 45 分钟
成绩表综合实战
排序与变形 · 10 名学生 5 门课成绩表 · 每门课统计 / 每人统计 / 加权总分 / 前三名
学习目标:① 说清 NumPy 数组和 Python 列表的三点不同(同类型、定长、支持多维),知道"向量化"是什么意思;② 会用 array / arange / linspace / zeros / ones / full / eye / reshape 造出需要的数组;③ 会用 shape / ndim / size / dtype 看清一个数组;④ 会用索引、切片、列表下标、布尔索引把想要的数据取出来,并且知道切片是视图这个坑;⑤ 会做转置、逐元素运算、dot 点积,分得清 * 和矩阵乘法的区别;⑥ 会用 min / max / mean / sum / std / argmax 做统计,并说清 axis=0 和 axis=1 分别沿哪个方向;⑦ 会用 sort 排序、reshape/ravel/concatenate 变形拼接;⑧ 能独立完成"成绩表"这种多小问的综合题。

本课地图

本章知识点总览

点击节点可跳转到对应讲解位置,点击三角可展开 / 收起分支。

第 7 章 NumPy 数值计算
▶NumPy 与数组入门模块一—三
为什么需要 NumPy:列表的局限与向量化
ndarray 的三条规矩:同类型 / 定长 / 多维
导入与第一个数组
打印与查看:两个高频小坑
array():从列表、元组创建
arange() 与 linspace():含不含端点
zeros / ones / full / eye
reshape():改形状不改数据
shape / ndim / size / dtype
一维索引
一维切片:切片是视图
列表作为下标(花式索引)
四种访问方式速查
▶访问与运算模块四—六
二维索引:a[行, 列]
二维切片与冒号 :
布尔索引:a[a > 15]
转置 T
逐元素运算:* 不是矩阵乘法
点积 dot 与矩阵乘法
广播(选学)
常用统计函数
axis=0 与 axis=1
用统计函数做成绩小结
打印陷阱:别让 np.float64 混进列表
▶操作与综合应用模块七
排序:np.sort() 与 x.sort()
变形与拼接
综合案例:10 名学生 5 门课成绩表
拓展案例:股票投资组合分析(选学)
AI 渗透:ndarray 与张量
说明:本章依据课程课件《7-Numpy 数值计算新》(21 页)与《Python 编程与数据分析基础》(陈洁、刘姝,清华大学出版社)第 7 章整理,并按教学进度表「CH7 Numpy 数值计算:数组的创建与访问 · 数组运算 · 数组操作 · Numpy 数据分析应用(讲授 1 + 上机 3 = 4 学时)」做了扩充。页面中每段代码都是在本机真实运行后回填的结果(Python 3.14 / NumPy 2.5),运行结果默认隐藏,点"运行"才显示。
先记住四句话:① 数组是一整批同类型数,用 np.array() 造出来;② 用下标取数据,a[行, 列] 两个数字定位一个元素,: 表示"这一维全要";③ 运算整批一起做,a * 2 是每个元素乘 2,np.dot 才是矩阵乘法;④ axis 是你要压掉的那一维——axis=0 把行压掉(每列出一个数),axis=1 把列压掉(每行出一个数)。
最容易栽的四个坑:① 以为 a * b 是矩阵乘法——它其实是逐元素相乘,矩阵乘法要用 np.dot(a, b) 或 a @ b;② 以为切片是"复制一份"——切片是视图,改切片会改到原数组(要副本用 .copy());③ np.arange(0, 5) 得到 [0 1 2 3 4] 不含 5,而 np.linspace(0, 5, 5) 两端都含;④ axis=0 和 axis=1 记反了——本章会用图表、动画和交互面板反复确认这一个点。
一

NumPy 与 ndarray 本章起点

为什么需要 NumPy · ndarray 的三条规矩 · 导入与第一个数组 · 打印与查看的两个坑

从这一章开始,我们处理的对象从“几个数”变成“成千上万个 数”。第 6 章负责把数据从文件里读进内存;读进来之后,数据在程序里就是一大堆数字。如果还是用列表一个个装、用 for 循环一个个算,数据量一上来就会慢到没法用。NumPy 就是为这件事准备的:它提供一个专门装数字的容器 ndarray,以及一整套“整块算”的运算规则。

这一模块先回答三个问题:为什么要把列表换成数组(1.1)、数组有哪些必须遵守的规矩(1.2)、怎么创建并查看第一个数组(1.3、1.4)。整个第 7 章,乃至第 8 章 pandas、第 9 章可视化,都建立在这个容器之上。

1.1 为什么需要 NumPy

先做一个看起来很简单、结果却很让人意外的实验:给一个列表“乘 2”。

Python 列表:* 表示“重复”
nums = [1, 2, 3]
nums * 2        # [1, 2, 3, 1, 2, 3]
nums + 2        # TypeError:列表不能加数字
# 想要 [2, 4, 6],只能再手写循环
[x * 2 for x in nums]
NumPy 数组:* 表示“逐元素乘”
arr = np.array([1, 2, 3])
arr * 2         # [2 4 6]
arr + 2         # [3 4 5]
arr ** 2        # [1 4 9]
# 整块算,一行写完,不用循环

结果不是 [2, 4, 6],而是 [1, 2, 3, 1, 2, 3]。因为在 Python 里,列表的 * 被定义成重复(把整个列表复制几份接在一起),+ 被定义成拼接。列表根本不知道“每个元素”这个概念——它只是一个装对象的口袋。想逐元素乘 2,只能自己写循环或列表推导式。

NumPy 的数组不一样。它把“一整块同类型的数字”当成一个整体,于是 arr * 2 的含义是每个元素都乘 2,arr + 2 是每个元素都加 2。这种“不写循环、整块算”的方式叫向量化(vectorization)。循环并没有消失——它被交给 NumPy 内部用 C 写的代码去跑,所以代码更短,速度还更快。

同样是「乘 2」,两种类型给出两种答案 Python 列表:* 表示「重复」 nums = [1, 2, 3] nums * 2 → 整段复制一遍接在后面,元素变成 6 个 1 2 3 1 2 3 想要 [2, 4, 6]?只能再手写一层循环 [x * 2 for x in nums] NumPy 数组:* 表示「逐元素乘」 arr = np.array([1, 2, 3]) arr * 2 → 每个元素各自乘 2,元素个数不变 2 4 6 结果 [2 4 6];arr ** 2 得到 [1 4 9];arr.sum() 直接求和 arr * 2 → [2 4 6] 向量化(vectorization):写「整块运算」,循环交给底层 C 代码去跑 代码更短 · 速度快几倍到几十倍 · 内存只存同类型数值,省得多 pandas 的列、scikit-learn 的特征矩阵、PyTorch 的 Tensor,底层都是这个 ndarray
图 7-1 列表的 * 2 是“复制一遍”,数组的 * 2 才是“每个元素各乘 2”——这一个差别,就是 NumPy 存在的理由
一句话记住:列表的 * 是“重复”,数组的 * 是“逐元素乘”。想要数学意义上的整体运算,就得先把数据变成数组。
列表做不了数学,数组可以:乘 2、加 2、平方、求和
import numpy as np

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

print('列表 * 2:', nums * 2)
try:
    print(nums + 2)
except TypeError as e:
    print('列表 + 2 报错:', e)

print('数组 * 2:', arr * 2)
print('数组 + 2:', arr + 2)
print('数组 ** 2:', arr ** 2)
print('数组求和:', arr.sum())
运行结果(实测)
列表 * 2: [1, 2, 3, 1, 2, 3]
列表 + 2 报错: can only concatenate list (not "int") to list
数组 * 2: [2 4 6]
数组 + 2: [3 4 5]
数组 ** 2: [1 4 9]
数组求和: 6
顺带算一笔内存账:100 万个整数,用列表存大约要 36 MB(每个元素一个 28 字节的 int 对象,外加列表里 8 字节的指针),用 int64 数组只要 8 MB。数据量越大,这个差距越致命——这也是为什么“数据一大就上 NumPy”。

更实际的理由是生态:pandas 的每一列底层就是一个 ndarray;scikit-learn 的输入要求是数组或能转成数组的结构;PyTorch 的 Tensor 和 ndarray 几乎可以无缝互转。学会 ndarray,等于拿到后面所有工具的“通用货币”。

和 AI 的关系:大模型里的“张量(Tensor)”就是多维数组的另一个名字。图像是一张 (高, 宽, 3) 的数组,一批图片是 (批大小, 高, 宽, 3) 的数组,一句话的嵌入向量是一个 (768,) 的数组。今天在 NumPy 里把 shape 和索引弄明白,后面看 PyTorch 代码才不会是天书。
✅ 本节小结:列表的 * 2 是重复,数组的 * 2 是逐元素乘;NumPy 提供数组对象与向量化运算,代码短、速度快、省内存,是 pandas / scikit-learn / PyTorch 的共同地基。

1.2 ndarray 对象的三条规矩

课件把 ndarray 的特点总结成两句:存储相同类型的数据、数组的维度和大小要事先确定。再补上第三条——它天生支持多维。这三条不是随便定的,它们正好换来 1.1 里说的“快”和“省”。下面逐条看。

① 元素类型必须相同

  • 一个数组只有一个 dtype
  • 写的时候混了不同类型,NumPy 会自动“向上提升”成同一种
  • 好处:每个元素占一样多的字节,能等距排布

② 大小固定

  • 创建那一刻,元素个数就定死了
  • 没有 append,想加元素只能造一个新数组
  • 好处:内存一次分配好,不用边加边扩容

③ 支持多维

  • 一维是一条线,二维是一张表,三维是一叠表
  • 每一维叫一个轴(Axis),从 0 开始编号
  • 好处:表格、图像、一批样本都能用一个对象表示

把这三条和列表放在一起对照,区别就清楚了。注意表格里“运算”那两行——那是 1.1 里最直观的差别。

对比项Python 列表 listNumPy 数组 ndarray
元素类型可以混,int、str、对象随便放必须统一,整个数组只有一个 dtype
长度随时 append / remove,长度会变创建时固定,改长度只能新建一个
内存布局指针数组 + 一堆分散的对象一整块连续内存,元素等距排列
* 2 的含义把整段重复一次,长度翻倍每个元素各乘 2,长度不变
+ 2 的含义直接报 TypeError每个元素各加 2
求和写法sum(nums),还行arr.sum(),一行且更快
适合装什么少量、结构复杂、类型杂的数据大量、同类型的数值(成绩、价格、像素、向量)

“连续内存”到底长什么样?下图把两种结构画出来:列表是“一排指针,指向散落在各处的对象”;数组是“一整条等宽的传送带,旁边挂一张纸条写着它是怎么排的”。

同一组数,两种存法:散着放 vs 整齐排 Python 列表:指针数组 + 分散的对象 nums 指针 指针 指针 PyObject 头 28 字节 1 PyObject 头 28 字节 2 PyObject 头 28 字节 3 每个数字都是独立对象:8 字节指针 + 28 字节对象头 值在内存里七零八落,遍历时 CPU 要不停跳转 ndarray:一整块连续内存 + 一点元信息 1 2 3 每格 8 字节 连续排列 shape = (3,)   ndim = 1   size = 3 dtype = int64  strides = (8,) 这张“纸条”告诉 NumPy:从哪读、每次跨几步、读几个 运算时从头到尾扫一遍,正好顺着 CPU 缓存走 快,是因为排得整齐——不是因为有魔法 列表 = 一堆盒子 + 一堆地址;数组 = 一条整齐的传送带 + 一张说明纸条
图 7-2 “元素类型相同 + 大小固定”换来的是连续内存——这才是 NumPy 比列表快的根本原因
类型统一与大小固定:混着写会被提升,想加元素只能新建
import numpy as np

a = np.array([1, 2, 3])
b = np.array([1, 2, 3.5])
c = np.array([1, 2, '3'])

print('a 的 dtype:', a.dtype)
print('b 的 dtype:', b.dtype)
print('c 的 dtype:', c.dtype)
print('b 的内容:', b)
print('c 的内容:', c)
print('数组有 append 吗:', hasattr(a, 'append'))
print('np.append 其实返回新数组:', np.append(a, 4))
print('原来的 a 还是:', a)
运行结果(实测)
a 的 dtype: int64
b 的 dtype: float64
c 的 dtype: <U21
b 的内容: [1.  2.  3.5]
c 的内容: ['1' '2' '3']
数组有 append 吗: False
np.append 其实返回新数组: [1 2 3 4]
原来的 a 还是: [1 2 3]
看清楚 dtype 的变化:[1, 2, 3.5] 里混了整数和小数,整个数组被提升成 float64;[1, 2, '3'] 里混进了字符串,于是所有元素都变成字符串,数字 1 也变成了 '1'。这不是 bug,是“类型必须相同”这条规矩在起作用:NumPy 会找一种能装下所有元素的类型。所以建模、计算时一定要保证数组里都是数字,不然算出来的结果会让你莫名其妙。
✅ 本节小结:ndarray 三条规矩——元素类型必须相同(不同就自动提升)、大小创建时固定(没有 append)、支持多维(每一维叫一个轴)。换来的是等距、连续、可整块运算的内存布局,这就是它比列表快的原因。

1.3 导入与第一个数组

用 NumPy 的第一步永远是导入。惯例写法是 import numpy as np——np 是全世界通用的别名,别人的代码、教程、公司项目都这么写,跟着写就不会错。导入之后,用 np.array() 把列表变成数组。

创建好之后第一件事是“看它一眼”。这里有一个教材和屏幕不一致的细节,很多同学第一次看会以为自己的输出错了:课件和书上写的是 array([1, 2, 3]),而你 print 出来是 [1 2 3]——没有逗号,也没有 array 这个词。两个都对,只是“给谁看”不一样。

第一个数组:print、type、repr、tolist 各看到什么
import numpy as np

arr = np.array([1, 2, 3])
print('直接 print:', arr)
print('类型:', type(arr))
print('repr 回显:', repr(arr))
print('转回列表:', arr.tolist())

print('二维数组:')
print(np.array([[1, 2, 3], [4, 5, 6]]))
运行结果(实测)
直接 print: [1 2 3]
类型: <class 'numpy.ndarray'>
repr 回显: array([1, 2, 3])
转回列表: [1, 2, 3]
二维数组:
[[1 2 3]
 [4 5 6]]
写法屏幕上看到底层走的是
print(arr)[1 2 3](没有逗号)str(),给“人看”的友好格式
repr(arr);交互式环境里直接敲 arrarray([1, 2, 3])repr(),给“程序员看”的精确格式
arr.tolist()[1, 2, 3](真正的 Python 列表,带逗号)tolist(),数组转回列表
所以别再怀疑自己:课件第 5 页写的 array([1, 2, 3]) 是交互式环境(IDLE / Jupyter)的回显,相当于 repr;你在脚本里用 print,看到的就是 [1 2 3]。两种输出都没错,考试写哪种都算对,但你自己跑代码时以 print 的结果为准。

在往下走之前,先用一段动画把“数组长什么样”建立起来:一维数组和二维数组分别是什么形状,shape、ndim、size 这三个数分别指什么,轴(Axis)又是怎么编号的。这三样东西下一模块还要正式讲,现在先混个脸熟。

🎬 动态演示:数组的形状、维度与大小
✅ 本节小结:import numpy as np 是惯例;np.array([1, 2, 3]) 创建数组,type() 显示 numpy.ndarray;print(arr) 得到 [1 2 3](没有逗号),交互式回显或 repr 才显示成 array([1, 2, 3])。

1.4 打印与查看:两个高频小坑

第一个数组跑通了,接下来最容易踩的坑都在“输出”上。这两个坑不影响计算结果,但会让你的输出难看、甚至对不上课件,考试时也容易误判。

坑一:把 numpy 标量塞进列表。NumPy 2.x 里,numpy 的标量(np.float64、np.int64)显示成 np.float64(1.5) 这种带类型名的样子。单独 print 一个标量没问题(走 str,显示成 1.5),可一旦放进列表里,就会跟着列表的格式打出 [np.float64(1.5)]——非常丑,而且和你想要的 [1.5] 不是一回事。

坑二:浮点数的“尾巴”。0.1 + 0.2 在计算机里不等于 0.3,数组求和时会打出 0.6000000000000001 这样一长串。要展示两位小数,用 np.round(x, 2) 或 round(float(x), 2)。

两个输出坑:np.float64 污染列表、浮点尾巴
import numpy as np

arr = np.array([0.1, 0.2, 0.3])
print('直接求和:', arr.sum())
print('保留两位:', np.round(arr.sum(), 2))

v = np.float64(1.5)
print('放进列表(丑):', [v])
print('先转 float(对):', [float(v)])
print('切一片再 tolist:', arr[:2].tolist())
print('数组本身:', arr)
运行结果(实测)
直接求和: 0.6000000000000001
保留两位: 0.6
放进列表(丑): [np.float64(1.5)]
先转 float(对): [1.5]
切一片再 tolist: [0.1, 0.2]
数组本身: [0.1 0.2 0.3]
输出三句话,背下来:① 展示数组 → 直接 print(arr),想看到“带逗号的列表”就 print(arr.tolist());② 展示单个标量 → 先 float() / int(),再用 round(float(x), 2) 控制小数位;③ 永远不要在 print([...]) 里直接混 numpy 标量,会打出 np.float64(...)。
顺手记一个查看三件套:print(arr) 看内容、arr.shape 看形状、arr.dtype 看类型。这三个信息拿到,一个数组就基本摸清了——下一模块正式讲它们。
✅ 本节小结:展示用 print(arr) 或 arr.tolist(),单个标量先 float();别把 numpy 标量直接放进列表(会打出 np.float64(...));小数展示用 np.round / round(float(x), 2) 去掉浮点尾巴。
二

数组的创建 四种造法

array 从数据建 · arange / linspace 按规律生成 · zeros / ones / full / eye 占位 · reshape 改形状

上一模块解决的问题是“为什么要用数组”,这一模块解决“数组从哪来”。实际写代码时,数组的来源无非两类:手里已经有数据(列表、元组、文件里读出来的内容),用 array() 搬进来;手里只有规律(从 0 到 100、5 个等分点、一个全 0 的占位表),用 arange / linspace / zeros 这类函数生成。最后再学 reshape,把造好的数组改成需要的形状。

这四个小节是一套“组合拳”:数据 → 生成 → 占位 → 改形。后面做成绩表、做矩阵运算,第一步都是它们。

先看一眼四种造法的「结果对照」,让下面几个函数先有个位置感,再逐个拆开讲:

四种创建方式,四种「填空题」 ① np.array() np.array([1, 2, 3]) 1 2 3 形状 (3,) dtype int64 来源:已有的列表 / 元组 用途 把现成数据变成数组 ② np.arange() np.arange(0, 10, 3) 0 3 6 9 形状 (4,) 不含 10 来源:起点 + 步长 用途 整数序列、编号、坐标 ③ np.zeros() np.zeros(3) 0. 0. 0. 形状 (3,) dtype float64 来源:只给形状 用途 先占位,再逐格填数 ④ np.linspace() np.linspace(0, 1, 5) 0 .25 .5 .75 1 形状 (5,) 含两端 来源:起点 + 终点 + 个数 用途 绘图坐标、均匀采样 已有数据 → array;要指定步长 → arange;要占位 → zeros / ones;要固定个数等分 → linspace 注意:zeros / ones / eye 默认 dtype 是 float64,要整数必须写 dtype=int
图 7-3 四种创建方式的「结果对照表」——先想清楚手里有什么,再决定用哪个函数

2.1 array():从列表 / 元组创建

np.array() 是最直接的造法:把现成的 Python 数据“倒”进数组。它接受列表,也接受元组;传一个嵌套列表就得到二维数组,外面的列表是行,里面的列表是列。

类型(dtype)默认自动推断:全是整数就是 int64,出现小数就是 float64。如果推断的结果不是你想要的,用 dtype= 明确指定——指定成 int 时,小数部分会被直接截断(不是四舍五入),这一点很容易掉坑。

从列表、元组、嵌套列表建数组,并控制 dtype
import numpy as np

print('列表建数组:', np.array([1, 2, 3]))
print('元组也行:', np.array((4, 5, 6)))
print('指定整数类型:', np.array([1.7, 2.2], dtype=int))
print('指定浮点类型:', np.array([1, 2], dtype=float))

print('嵌套列表 → 二维数组:')
print(np.array([[1, 2, 3], [4, 5, 6]]))

print('自动推断:', np.array([1, 2, 3]).dtype)
print('二维的形状:', np.array([[1, 2, 3], [4, 5, 6]]).shape)
运行结果(实测)
列表建数组: [1 2 3]
元组也行: [4 5 6]
指定整数类型: [1 2]
指定浮点类型: [1. 2.]
嵌套列表 → 二维数组:
[[1 2 3]
 [4 5 6]]
自动推断: int64
二维的形状: (2, 3)

嵌套列表有一个硬要求:每一层的长度必须一样。这来自 1.2 的“大小固定”——二维数组是矩形表格,不允许某一行少几个元素。如果写歪了,NumPy 会直接报错,而不是像列表那样将就着存。

故意写错:嵌套列表各行长度不一致
import numpy as np

rows = [[1, 2, 3], [4, 5]]
print('第一行长度:', len(rows[0]))
print('第二行长度:', len(rows[1]))

a = np.array(rows)        # 两行长度不同,这里会报错
print(a)
运行结果(实测)
第一行长度: 3
第二行长度: 2
Traceback (most recent call last):
  File "<pyshell>", line 7, in <module>
    a = np.array(rows)        # 两行长度不同,这里会报错
ValueError: setting an array element with a sequence. The requested array has an inhomogeneous shape after 1 dimensions. The detected shape was (2,) + inhomogeneous part.
两种类型要分清:[1, 2, 3] 是列表,(1, 2, 3) 是元组,两者都能传给 array();而 [[1, 2], [3, 4]] 是“列表里套列表”,才表示二维。写代码时括号千万别配错——np.array(1, 2, 3) 是错的,那是传了三个参数。
✅ 本节小结:array() 能从列表、元组、嵌套列表创建数组;dtype 会自动推断,也能用 dtype= 指定(指定成 int 会截断小数);嵌套列表每层长度必须一致,否则直接报错。

2.2 arange() 与 linspace():按规律生成

如果数据不是现成的,而是“从 0 到 10、每次加 3”这样的规律,用 np.arange();如果是“把 0 到 1 平均分成 5 个点”这样的要求,用 np.linspace()。这两个函数长得像,边界含不含却完全不同,是考试和上机最常见的一对易混点。

函数参数含义含不含终点 stop结果个数由谁决定
np.arange(start, stop, step)起点、终点、步长不含 stop(和 range 一样)由步长算出来
np.arange(stop)只给终点,起点默认 0、步长默认 1不含 stop就是 stop 个(0 到 stop-1)
np.linspace(start, stop, num)起点、终点、点的个数含两端就是 num 个

下面这张图把两个函数放在同一条 0~10 的数轴上:arange(0, 10, 3) 是“从 0 出发每次迈 3 步”,走到 9 就停,10 进不来(共 4 个点);linspace(0, 10, 3) 是“把 0 到 10 均匀切成 3 个点”,0 和 10 都在里面(共 3 个点)。

arange 回答「迈多大步」,linspace 回答「要几个点」 np.arange(0, 10, 3) → [0 3 6 9],共 4 个 0 3 6 9 10 不含 每次 +3 np.linspace(0, 10, 3) → [0 5 10],共 3 个 0 5 10 等分成 2 段 记法:arange 的第三个参数是“步长”,linspace 的第三个参数是“个数”;一个不含 stop,一个含两端。
图 7-4 同样从 0 到 10:arange 用步长切(9 之后就到头了),linspace 用个数分(0 和 10 都在里面)
arange 不含 stop,linspace 含两端:跑一遍看长度
import numpy as np

print('arange(10, 21, 2):', np.arange(10, 21, 2))
print('arange(0, 10, 3):', np.arange(0, 10, 3))
print('arange(5):', np.arange(5))
print('arange(0, 1, 0.25):', np.arange(0, 1, 0.25))
print('linspace(0, 1, 5):', np.linspace(0, 1, 5))
print('linspace(0, 10, 3):', np.linspace(0, 10, 3))
print('看长度:', len(np.arange(0, 1, 0.25)), 'vs', len(np.linspace(0, 1, 5)))
运行结果(实测)
arange(10, 21, 2): [10 12 14 16 18 20]
arange(0, 10, 3): [0 3 6 9]
arange(5): [0 1 2 3 4]
arange(0, 1, 0.25): [0.   0.25 0.5  0.75]
linspace(0, 1, 5): [0.   0.25 0.5  0.75 1.  ]
linspace(0, 10, 3): [ 0.  5. 10.]
看长度: 4 vs 5
浮点步长要小心:arange 用小数当步长时,累积的浮点误差可能让最后一个数“差一点点”没取到,或者多取一个。要生成固定个数的等分点,一律用 linspace,别用 arange;arange 留给整数步长最稳。
✅ 本节小结:arange(start, stop, step) 按步长取点、不含 stop;linspace(start, stop, num) 按个数等分、含两端。要固定个数用 linspace,要固定步长用 arange。

2.3 zeros / ones / full / eye

做数据分析时经常需要“先摆一个空表,再往里填数”——比如先建一个 10×5 的成绩表,再去逐格赋值。这类需求就用占位函数:zeros() 全 0、ones() 全 1、full() 填任意值、eye() 造单位矩阵(对角线是 1、其余是 0)。

它们的参数都是 shape:传一个整数表示一维(长度为几),传一个元组表示多维(每维多长)。这里有个新手必踩的坑——np.zeros(3) 和 np.zeros((2, 3)) 都对,但 np.zeros(2, 3) 是错的,那会被理解成传了两个参数。

占位四件套:zeros / ones / full / eye
import numpy as np

print('zeros(3):', np.zeros(3))
print('zeros((2, 3)):')
print(np.zeros((2, 3)))
print('ones(3, dtype=int):', np.ones(3, dtype=int))
print('full((2, 2), 7):')
print(np.full((2, 2), 7))
print('eye(3):')
print(np.eye(3))
print('zeros 的默认类型:', np.zeros(3).dtype)
运行结果(实测)
zeros(3): [0. 0. 0.]
zeros((2, 3)):
[[0. 0. 0.]
 [0. 0. 0.]]
ones(3, dtype=int): [1 1 1]
full((2, 2), 7):
[[7 7]
 [7 7]]
eye(3):
[[1. 0. 0.]
 [0. 1. 0.]
 [0. 0. 1.]]
zeros 的默认类型: float64
默认类型是浮点:np.zeros(3) 得到的是 [0. 0. 0.] 而不是 [0 0 0],因为 zeros / ones / eye 的默认 dtype 是 float64。要当整数用,写 np.zeros(3, dtype=int);full 的类型跟着填充值走(np.full((2, 2), 7) 里填的是整数 7,所以是整数数组)。

把这四种方式串起来看一遍——动画里一步步对比 array / arange / zeros / linspace 各自生成什么、边界含不含:

🎬 动态演示:四种创建方式的结果对比
✅ 本节小结:占位四件套——zeros 全 0、ones 全 1、full 填定值、eye 单位矩阵;参数是 shape(整数=一维,元组=多维);默认 dtype 是 float64,要整数必须写 dtype=int。

2.4 reshape:改形状不改数据

数组造好之后,形状不一定合适。比如 arange(6) 得到一条 6 个元素的线,但你要的是一张 2 行 3 列的表——这时用 reshape()。它的作用是换一种“读法”:数据本身一个不动,只是把“怎么分行、怎么分列”重新规定一遍。

reshape(2, 3) 就是 2 行 3 列;reshape(3, -1) 里的 -1 表示“这一维我不想算,你自己推”——NumPy 会用总元素数除以另一维,算出 6 ÷ 3 = 2。所以 reshape(3, -1) 和 reshape(3, 2) 等价。一维的 reshape(-1) 就是“拉平”。

reshape 改形状:2×3、3×2、-1 自动推断
import numpy as np

a = np.arange(6)
print('原数组:', a)

print('reshape(2, 3):')
print(a.reshape(2, 3))

print('reshape(3, -1):')
print(a.reshape(3, -1))

print('reshape(-1) 拉平:', a.reshape(-1))
print('原数组没变:', a)
运行结果(实测)
原数组: [0 1 2 3 4 5]
reshape(2, 3):
[[0 1 2]
 [3 4 5]]
reshape(3, -1):
[[0 1]
 [2 3]
 [4 5]]
reshape(-1) 拉平: [0 1 2 3 4 5]
原数组没变: [0 1 2 3 4 5]

reshape 有一条铁律:元素总数必须前后相等。6 个元素可以变成 2×3、3×2、1×6、6×1,但不能变成 4×2(那需要 8 个位置)——多一个少一个都会直接报错。这条规矩正是 1.2 说的“大小固定”的延续。

故意写错:6 个元素塞不进 4×2
import numpy as np

a = np.arange(6)
print('元素个数:', a.size)
print('3 × 2 =', 3 * 2, ',位置够')
print('4 × 2 =', 4 * 2, ',位置不够')

print(a.reshape(4, 2))    # 这里会报错
运行结果(实测)
元素个数: 6
3 × 2 = 6 ,位置够
4 × 2 = 8 ,位置不够
Traceback (most recent call last):
  File "<pyshell>", line 8, in <module>
    print(a.reshape(4, 2))    # 这里会报错
ValueError: cannot reshape array of size 6 into shape (4,2)
一句话记住:reshape 只改“怎么读”,不改“是什么”。元素还是那些元素、顺序也没变,只是换了个行列的排法;所以元素总数必须守恒,-1 只是让 NumPy 帮你算那一维。
✅ 本节小结:reshape 只改形状、不改数据;-1 表示让 NumPy 自己算那一维;元素总数必须和原数组相等,否则抛 ValueError;原数组不会被改动。
三

数组属性与一维访问 高频考点

shape / ndim / size · 索引与切片 · 切片是视图不是副本 · 列表下标(花式索引)

数组造出来了,接下来的问题永远是同一个:怎么把我要的那几个数取出来。这一模块先学会看数组的“身份证”(形状、维度、大小、类型),再学三种取数方式:单个索引、切片、列表下标。最后一种藏着本课最容易被忽略的坑——切片是视图,不是副本。

这四小节是后面二维访问、布尔索引、统计运算的语法底座。尤其是 3.3 的“视图”概念,如果不弄明白,后面做数据清洗时“改着改着原数据就变了”会一直困扰你。

3.1 三个属性:shape / ndim / size

NumPy 对象的属性不用加括号(它们不是函数),直接点出来就行。最重要的三个是:shape(形状)、ndim(维度数)、size(元素总数),再加一个 dtype(元素类型)。

三个数的关系非常好记:ndim 就是 shape 这个元组里有几个数;size 就是 shape 里各维相乘。一维数组的 shape 写成 (10,)——注意那个逗号,它是元组的标记,不是笔误,少了逗号就变成普通括号里的一个数了。

一个 2×3 的数组,四个属性各说一件事 a2 = np.array([[1, 2, 3], [4, 5, 6]]) 列 0 列 1 列 2 行 0 行 1 1 2 3 4 5 6 2 行 × 3 列 → 6 个元素 shape 形状 (2, 3) 每一维有多长 ndim 维度数 2 一共几个维度(轴) size 元素总数 6 一共几个数 dtype 元素类型 int64 每个元素是什么类型 size = 2 × 3 = 6   ndim = len(shape) = 2 记住这三句话,看任何数组先报一遍 shape / ndim / size,就不会迷路
图 7-5 shape 告诉你每维多长,ndim 告诉你几维,size 告诉你一共几个数
一维与二维数组的属性对照:shape、ndim、size、dtype
import numpy as np

a1 = np.arange(10)
a2 = np.array([[1, 2, 3], [4, 5, 6]])

print('a1.shape:', a1.shape)
print('a1.ndim:', a1.ndim)
print('a1.size:', a1.size)
print('a2.shape:', a2.shape)
print('a2.ndim:', a2.ndim)
print('a2.size:', a2.size)
print('a2.dtype:', a2.dtype)
print('两维相乘:', a2.shape[0] * a2.shape[1])
运行结果(实测)
a1.shape: (10,)
a1.ndim: 1
a1.size: 10
a2.shape: (2, 3)
a2.ndim: 2
a2.size: 6
a2.dtype: int64
两维相乘: 6
为什么 a2.shape[0] 能取出 2:因为 shape 是元组,元组当然可以用下标取。所以“第 0 维多长”就是 shape[0],“第 1 维多长”就是 shape[1]。shape 是元组而不是函数,这也是为什么写 a2.shape() 会报错。
✅ 本节小结:shape 是元组(一维写成 (10,),逗号不能省)、ndim 是维数、size 是元素总数,三者满足 ndim = len(shape)、size = 各维相乘;dtype 说明元素类型。属性不加括号。

3.2 一维索引

访问一维数组的写法是 数组名[下标]。和列表完全一样:下标从 0 开始,所以 a[3] 取的是第 4 个元素;a[-1] 表示倒数第一个,a[-2] 是倒数第二个。负下标是“从右往左数”,用熟了非常方便。

数组 a101214161820
正下标012345
负下标-6-5-4-3-2-1
正下标与负下标:a[0]、a[3]、a[-1]、a[-2]
import numpy as np

a = np.arange(10, 21, 2)
print('a:', a)
print('a[0]:', a[0])
print('a[3]:', a[3])
print('a[-1]:', a[-1])
print('a[-2]:', a[-2])
print('两端的值相加:', a[0] + a[-1])
运行结果(实测)
a: [10 12 14 16 18 20]
a[0]: 10
a[3]: 16
a[-1]: 20
a[-2]: 18
两端的值相加: 30

下标不能超出范围。长度为 6 的数组,合法下标是 0~5(或 -6~-1),写 a[6] 就会抛 IndexError。注意这个错误和列表的报错一样,但它比列表“更严格”——数组没有 append,也就没有“越界就往后加”这种可能性。

故意写错:下标越界
import numpy as np

a = np.arange(10, 21, 2)
print('a:', a)
print('长度:', a.size)
print('合法下标:0 到', a.size - 1)
print(a[6])               # 越界,这里会报错
运行结果(实测)
a: [10 12 14 16 18 20]
长度: 6
合法下标:0 到 5
Traceback (most recent call last):
  File "<pyshell>", line 7, in <module>
    print(a[6])               # 越界,这里会报错
IndexError: index 6 is out of bounds for axis 0 with size 6
✅ 本节小结:一维索引 a[i] 从 0 开始,a[-1] 是最后一个、a[-2] 是倒数第二个;索引返回一个 numpy 标量;下标超出范围会抛 IndexError。

3.3 一维切片

只取一个元素用索引,取一段就用切片。写法是 a[start:stop:step],规则和列表的切片一致:左闭右开,包含 start、不包含 stop。省略 start 表示从头开始,省略 stop 表示取到末尾,step 控制步长,写成负数就是从后往前取。

写法取到哪些元素结果
a[0:3]下标 0、1、2[10 12 14]
a[:3]从头开始,到下标 3 之前[10 12 14]
a[2:]从下标 2 一直到末尾[14 16 18 20]
a[::2]从头到尾,每 2 个取 1 个[10 14 18]
a[::-1]步长为 -1:整个倒过来[20 18 16 14 12 10]

用矩阵表格看更直观。下面这张表就是数组 a = np.arange(10, 21, 2),蓝色三格正好是 a[0:3] 覆盖的范围——连续的一段:

012345
a101214161820
负下标-6-5-4-3-2-1
切片的四种常用写法:取前 3 个、隔一个取一个、倒序
import numpy as np

a = np.arange(10, 21, 2)
print('a:', a)
print('a[0:3]:', a[0:3])
print('a[:3]:', a[:3])
print('a[2:]:', a[2:])
print('a[::2]:', a[::2])
print('a[::-1]:', a[::-1])
print('a[1:5:2]:', a[1:5:2])
运行结果(实测)
a: [10 12 14 16 18 20]
a[0:3]: [10 12 14]
a[:3]: [10 12 14]
a[2:]: [14 16 18 20]
a[::2]: [10 14 18]
a[::-1]: [20 18 16 14 12 10]
a[1:5:2]: [12 16]
本课最高频的坑:切片是「视图」,不是「副本」!
s = a[0:3] 并没有把数据复制一份给你,它只是给原数组的同一块内存又起了个名字、划了个范围。所以你改 s[0],原数组 a[0] 跟着变;反过来改 a,s 里看到的也变。这一点和列表切片(列表切片是浅拷贝)完全相反,是 NumPy 新手最容易翻车的地方。下面用代码证明给你看。
证明切片是视图:改切片 → 原数组跟着变;.copy() 才是独立副本
import numpy as np

a = np.arange(10, 21, 2)
s = a[0:3]
print('改之前 a:', a)
s[0] = 99
print('改 s[0] 之后 a:', a)
print('共享内存吗:', np.shares_memory(a, s))

c = a[0:3].copy()
c[0] = -1
print('改 copy 之后 a:', a)
print('copy 的内容:', c)
运行结果(实测)
改之前 a: [10 12 14 16 18 20]
改 s[0] 之后 a: [99 12 14 16 18 20]
共享内存吗: True
改 copy 之后 a: [99 12 14 16 18 20]
copy 的内容: [-1 12 14]
什么时候要 copy:① 想把一段数据单独拿出来加工、又不想污染原数据——先 .copy();② 做完切片后要修改它——先想清楚“我是要改原数组,还是只要改这一段”,要改原数组就用视图(这是 NumPy 省内存的设计),只改自己就 copy;③ 判断方法很简单:np.shares_memory(a, s) 返回 True 就是视图。
✅ 本节小结:切片 a[start:stop:step] 左闭右开;a[:3]、a[::2]、a[::-1] 是常用写法;切片是视图,和原数组共享内存,改切片会改原数组,要独立副本必须 .copy()。

3.4 列表作为下标(花式索引)

切片只能取“连续的一段”(或者按固定间隔取)。如果我要的是不连续的几个位置——比如第 1、第 2、第 5 个——就用“列表作为下标”,官方叫花式索引(fancy indexing):a[[1, 2, 5]]。

方括号里那个列表是“位置清单”,NumPy 按清单把对应位置的元素挑出来,组成一个新数组。清单可以乱序。(a[[5, 0, 1]] 就按 5、0、1 的顺序给你。)也可以重复。(a[[0, 0, 0]] 就给你三个一模一样的首元素,长度跟着清单走。)这两点是切片做不到的。

列表下标:挑选、乱序、重复,而且拿到的是副本
import numpy as np

a = np.arange(10, 21, 2)
print('a:', a)
print('a[[1, 2, 5]]:', a[[1, 2, 5]])
print('乱序 a[[5, 0, 1]]:', a[[5, 0, 1]])
print('重复 a[[0, 0, 0]]:', a[[0, 0, 0]])

f = a[[0, 1]]
f[0] = 77
print('改副本之后 a:', a)
print('副本 f:', f)
运行结果(实测)
a: [10 12 14 16 18 20]
a[[1, 2, 5]]: [12 14 20]
乱序 a[[5, 0, 1]]: [20 10 12]
重复 a[[0, 0, 0]]: [10 10 10]
改副本之后 a: [10 12 14 16 18 20]
副本 f: [77 12]

把“切片”和“列表下标”放在同一张图里对照,区别一眼就能看出来:

切片取「一段」,列表下标取「任意几个」 a 0 1 2 3 4 5 10 12 14 16 18 20 -6 -5 -4 -3 -2 -1 a[0:3] 10 12 14 视图 view:共享内存,改它等于改 a a 0 1 2 3 4 5 10 12 14 16 18 20 a[[1, 2, 5]] 12 14 20 副本 copy:复制数据,改它不影响 a ① 切片取「连续区间」,列表下标取「任意位置」;② 切片是视图,列表下标是副本 ③ 列表下标可以乱序(a[[5, 0, 1]])、可以重复(a[[0, 0, 0]]),切片做不到
图 7-6 同样的数组,两种取法:切片是“划一段”(共享内存),列表下标是“按清单挑”(复制数据)
为什么列表下标返回副本:因为你挑出来的位置不连续,NumPy 没法用“一个起点 + 一个步长”描述这块内存,只能新建一个数组把数据抄进去。所以它天然是副本——这也意味着花式索引比切片更占内存,但更自由。

最后用动画把这一模块的四种访问方式连起来过一遍:a[3]、a[-1]、a[0:3]、a[[1, 2, 5]] 各自从数组里取出哪几个数:

🎬 动态演示:一维索引与切片
✅ 本节小结:列表下标 a[[1, 2, 5]] 按“位置清单”一次取多个不连续元素,可以乱序、可以重复;得到的是副本,改它不影响原数组。

3.5 四种访问方式速查

这一模块一共学了四种从数组里取数的写法。它们看起来只差几个符号,语义却完全不同,考试和上机最容易混。下面这张表把它们一次对齐——写代码前扫一眼,能省掉大半调试时间。

写法例子取到什么视图还是副本能乱序 / 重复吗
单个索引a[3]、a[-1]一个元素(numpy 标量)标量,谈不上视图—
切片a[0:3]、a[::2]、a[::-1]一段连续或等间隔的元素视图(共享内存)不能乱序,不能重复
列表下标a[[1, 2, 5]]指定位置的若干个元素副本(独立内存)可以乱序,可以重复
布尔掩码a[a > 15]条件为 True 的那些元素副本按条件自动筛选

表格最后一行是下一个模块(4.3 布尔索引)的内容,现在只要记住“它也是副本”就够了。上机前先过一遍下面这份自测清单:

一个口诀:冒号是“划段”,列表是“点名”,掩码是“按条件筛”。划段的是视图(省内存、会联动),点名和筛选的是副本(独立、安全)。
✅ 本节小结:速查——a[i] 取一个(标量)、a[i:j] 取一段(视图)、a[[...]] 取任意位置(副本)、a[mask] 按条件筛(副本,下一模块细讲)。
四

二维访问与布尔索引 必会基本功

a[行, 列] 两个下标定位 · a[0] 是整行 · a[:, 0] 是整列 · 冒号 : 表示这一维全要 · 布尔掩码先造再挑

第三个模块里我们只跟一维数组打交道,一个下标就能指到某个元素。二维数组不一样了:它是一张表格,横着有行、竖着有列,要指到一个具体的格子,就得给两样信息——第几行、第几列。所以访问二维数组的基本写法是 a[行, 列];如果只给一个数字,NumPy 会理解成“你只限定了行”,把它交给你一整行。

除了“按坐标拿”,还有一种更常用的拿法:按条件拿。比如“把这 20 个分数里大于 80 的全挑出来”,用下标一个个挑太笨了,NumPy 的做法是先算出一个布尔数组(一串 True / False),再用这串 True / False 去原数组里“筛”。这就是本模块的第二个重点——布尔索引。

4.1 二维索引:两个数字定位

二维数组的每个元素由两个下标确定,写在同一对方括号里,中间用逗号隔开:a[0, 1] 表示第 0 行第 1 列。两个下标都从 0 开始,所以 a[1, 1] 拿到的是第 2 行第 2 列那个格子,不是第 1 行第 1 列的。

最容易踩的坑是只给一个下标。a[0] 不是“第 0 行的第一个元素”,而是“第 0 行的全部元素”,拿到的还是一个一维数组 [1 2 3 4]——它的形状是 (4,),还能接着往下索引,比如 a[0][1] 确实能拿到 2。但 NumPy 不推荐这种“分两步走”的写法:a[0][1] 是先把整行取出来、再在整行上取一次,a[0, 1] 才是一次性定位,一步到位。

二维数组靠两个下标定位:先看行,再看列 列 0 列 1 列 2 列 3 行 0 行 1 行 2 1 2 3 4 5 6 7 8 9 10 11 12 第 0 轴 axis=0 · 行 第 1 轴 axis=1 · 列 a[0] → 整行 [1 2 3 4] a[1,1] → 6(单个元素) a[-1] → 最后一行(行 2) ① 两个下标都从 0 开始:a[1,1] 是第 2 行第 2 列,不是第 1 行第 1 列。 ② 只写一个下标 a[0],拿到的是整行(一维数组),不是这一行的第一个元素。 ③ 冒号 : 表示“这一维全要”:a[:, 0] 是整列,a[0:2] 是前两行。
图 7-7 二维数组的行列坐标:左边是第 0 轴(行方向),上边是第 1 轴(列方向),一个格子要两个下标才指得准
a[0] 取整行、a[1,1] 取单个元素:一维和二维的差别就在下标的个数
import numpy as np

a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
print('整个数组 a:')
print(a)
print('a[0] 取整行:', a[0])
print('a[0] 的形状:', a[0].shape)
print('a[1,1] 取单个元素:', int(a[1, 1]))
print('a[2,0] 取单个元素:', int(a[2, 0]))
print('a[-1] 取最后一行:', a[-1])
print('a[1] 取第 1 行:', a[1])
运行结果(实测)
整个数组 a:
[[ 1  2  3  4]
 [ 5  6  7  8]
 [ 9 10 11 12]]
a[0] 取整行: [1 2 3 4]
a[0] 的形状: (4,)
a[1,1] 取单个元素: 6
a[2,0] 取单个元素: 9
a[-1] 取最后一行: [ 9 10 11 12]
a[1] 取第 1 行: [5 6 7 8]
🎬 动态演示:二维数组的两级下标
a[0][1] 和 a[0, 1] 结果一样,为什么推荐后者?因为 a[0][1] 是两次操作:第一次 a[0] 取出整行(一维数组 [1 2 3 4]),第二次在这个一维数组上取下标 1。而 a[0, 1] 是 NumPy 一次定位,直接算偏移、不产生中间结果。数据量大、在循环里反复取的时候,这个差别会变成真金白银的时间。
✅ 本节小结:二维数组用两个下标定位——a[行, 列],都从 0 开始;只给一个下标 a[0] 拿到的是整行(一维数组);想拿单个元素,两个下标一个都不能少。

4.2 二维切片与 : 的用法

二维数组的每一个维度都能像一维那样“切”,两个维度之间还是用逗号隔开:a[行怎么取, 列怎么取]。冒号 : 的意思是“这一维我全要”——一个冒号占了位置,就等于把这一维原样留下。下面用这个 3×4 的数组举例:a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])。

下面这张矩阵图把两个方向分开标了出来:绿色那一整行是 a[0](横着取一整行),橙色那一整列是 a[:, 0](竖着取一整列)。同样都是一维结果,方向却差 90 度——区别只有一个:逗号左边管行、右边管列。

列 0列 1列 2列 3
行 01234
行 15678
行 29101112
绿色整行 = a[0](横着取,形状 (4,)) · 橙色整列 = a[:, 0](竖着取,形状 (3,)) · 两个方向差 90 度

有一个特别容易忽略的细节:a[:, 0] 和 a[:, 0:1] 看着差不多,形状却不一样。用整数下标取一列,第二维就被“压掉”了,结果是一维的 (3,);用切片 0:1 取,第二维还在,结果是二维的 (3, 1)。这一点在后面的拼接、矩阵乘法里会直接影响能不能算,先记住“整数下标降维、切片保维”。

a[:, 0] → 一维,形状 (3,)

1
5
9

整数下标把第 1 维“压掉”了,只剩一列数。

a[:, 0:1] → 二维,形状 (3, 1)

1
5
9

切片保留了第 1 维,所以还是“3 行 1 列”的二维表。

行切片、整列、指定列、行+列组合切片,一次看全
import numpy as np

a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
print('a[0:2] 前两行:')
print(a[0:2])
print('a[:, 0] 第 0 列:', a[:, 0])
print('a[:, [0, 2]] 只要第 0、2 列:')
print(a[:, [0, 2]])
print('a[0:2, 1:] 前两行 + 后两列:')
print(a[0:2, 1:])
print('a[[0, 2]] 取第 0、2 两行:')
print(a[[0, 2]])
print('a[0, 2] 取第 0 行第 2 列:', int(a[0, 2]))
print('a[:, 0] 的形状:', a[:, 0].shape, ' a[:, 0:1] 的形状:', a[:, 0:1].shape)
运行结果(实测)
a[0:2] 前两行:
[[1 2 3 4]
 [5 6 7 8]]
a[:, 0] 第 0 列: [1 5 9]
a[:, [0, 2]] 只要第 0、2 列:
[[ 1  3]
 [ 5  7]
 [ 9 11]]
a[0:2, 1:] 前两行 + 后两列:
[[2 3 4]
 [6 7 8]]
a[[0, 2]] 取第 0、2 两行:
[[ 1  2  3  4]
 [ 9 10 11 12]]
a[0, 2] 取第 0 行第 2 列: 3
a[:, 0] 的形状: (3,)  a[:, 0:1] 的形状: (3, 1)

还有一个必须回头提醒的点:第三个模块讲过切片是视图不是副本。二维也一样——a[:, 0] 取出来的这一列,和原数组共用同一块内存。你要是把它改了,原数组跟着变。

改切片会影响原数组:二维切片同样是视图
import numpy as np

a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])
col = a[:, 0]                 # 切片取出来的是视图,不是副本
print('a[:, 0] 取出来:', col)
col[0] = 100                  # 改这个视图
print('改完 col[0] 之后,a 变成:')
print(a)
print('原数组也被改了 —— 这就是视图,不是复制')
运行结果(实测)
a[:, 0] 取出来: [1 5 9]
改完 col[0] 之后,a 变成:
[[100   2   3   4]
 [  5   6   7   8]
 [  9  10  11  12]]
原数组也被改了 —— 这就是视图,不是复制
想让切片与原数组彻底分开,就显式复制:col = a[:, 0].copy()。切片(含 :)得到的是视图,而“列表当下标”(花式索引,如 a[:, [0, 2]])和布尔索引(a[a > 15])得到的都是副本——这是 NumPy 一个非常容易记混的规矩:切片能省内存但会牵连原数组,花式索引与布尔索引安全但要多花一份内存。
✅ 本节小结:a[行, 列] 两个维度各写一段,: 表示这一维全要;a[0:2] 前两行、a[:, 0] 整列、a[:, [0, 2]] 指定列。整数下标会降维((3,)),切片保维((3, 1));切片是视图,改它会改原数组。

4.3 布尔索引:用条件挑元素

逐个算下标太累,现实中的需求往往是“把满足某个条件的元素都挑出来”。NumPy 的布尔索引分两步走:先对数组做一次比较运算,得到一串 True / False(长度和原数组一样,这叫掩码);再把这串 True / False 塞进方括号里,NumPy 就按 True 的位置把元素挑出来。

例如 a = np.arange(10, 21, 2) 得到 [10 12 14 16 18 20]。a > 15 会逐元素判断,得到 [False False False True True True];把这个布尔数组放进方括号 a[a > 15],True 那三个位置对应的元素就被挑了出来,结果是 [16 18 20]。下图就是这个“掩码 → 结果”的映射。

布尔索引:先算出一串 True / False,再按 True 的位置挑 a = 10 12 14 16 18 20 下标 0 1 2 3 4 5 a > 15 = False False False True True True 只留下 True 的位置 a[a > 15] = 16 18 20 False 的位置被丢掉,True 的位置按原顺序留下 —— 结果长度 = True 的个数(这里是 3 个),形状从 (6,) 变成 (3,)。 掩码的长度必须和原数组一致(6 个 True / False 对 6 个数),否则 NumPy 不知道该挑谁。
图 7-8 布尔索引的两步:a > 15 造出掩码,a[a > 15] 按掩码挑选
🎬 动态演示:布尔索引:先造掩码,再挑选
单条件、多条件、统计满足条件的个数:布尔索引的三种常用写法
import numpy as np

a = np.arange(10, 21, 2)
print('a =', a)
print('a > 15 得到布尔数组:', a > 15)
print('a[a > 15] 挑出满足条件的:', a[a > 15])
print('a[a % 3 == 0]:', a[a % 3 == 0])
# 多条件:每个条件都要加括号,用 & | 连接
print('(a > 10) & (a < 20):', a[(a > 10) & (a < 20)])
print('(a == 10) | (a == 20):', a[(a == 10) | (a == 20)])
print('掩码里 True 的个数:', int((a > 15).sum()))
运行结果(实测)
a = [10 12 14 16 18 20]
a > 15 得到布尔数组: [False False False  True  True  True]
a[a > 15] 挑出满足条件的: [16 18 20]
a[a % 3 == 0]: [12 18]
(a > 10) & (a < 20): [12 14 16 18]
(a == 10) | (a == 20): [10 20]
掩码里 True 的个数: 3
多条件必须用 & | ~,而且每个条件都要加括号。写 a[a > 10 and a < 20] 会直接报 ValueError——Python 的 and 只想得到“一个整体是真还是假”,它没法对整张数组逐元素判断;而 & 是 NumPy 重载过的按位与,会逐元素算。还有优先级问题:& 的优先级比比较运算符高,不写括号的话 a > 10 & a < 20 会被理解成 a > (10 & a) < 20,结果要么报错要么离谱。规矩就一条:一个条件一对括号,中间用 & 或 | 连。
✅ 本节小结:布尔索引分两步——a > 15 得到同长度的 True / False 掩码,a[a > 15] 按掩码挑出元素;结果是一维数组、长度等于 True 的个数,原数组不变;多条件用 & / | / ~ 且每个条件加括号。
五

数组的运算 易错:* 不是矩阵乘法

转置 a.T · 逐元素加减乘除(+ - * / **)· 点积 np.dot / @ · 广播(选学但重要)

课件把“数组的运算”拆成三块:转置、点积、统计运算。统计运算(sum / mean / axis 那一套)内容多,单独放到第六模块讲;这一模块先把前两块讲透,再加一个 NumPy 里非常实用、但规则要单独记的广播。

先说一句最重要的:NumPy 里的 * 不是矩阵乘法,它是逐元素相乘——两个数组同一位置的数各自相乘。矩阵乘法是 np.dot()(或 @)。这两个符号长得像、结果差得远,是这门课最容易翻车的地方,第五节会把同一对数组两种算法摆在一起对照。

5.1 转置 T

转置的意思很朴素:把行和列换过来。原来第 0 行,转置后就变成第 0 列;原来第 1 行,变成第 1 列。写法就是在数组后面加一个 .T:a2.T。

形状怎么变?记住一句话:把 shape 元组前后颠倒。原来 (2, 3)(2 行 3 列),转置后就是 (3, 2)(3 行 2 列)。元素一个不多一个不少,只是换了摆放方式。下图把“行变列”这件事画了出来:蓝色那一行转置后成了蓝色那一列。

转置 T:把第 i 行搬到第 i 列,(2, 3) 变成 (3, 2) a2(2 行 3 列) 1 2 3 5 6 7 shape = (2, 3) a2.T 交换两个轴 1 5 2 6 3 7 shape = (3, 2) 蓝色那一行(1 2 3)转置后变成蓝色那一列(1 2 3);橙色那一行变成橙色那一列。元素没变,位置换了。 一维数组的转置:没有第二个轴可交换,所以 a1.T 还是 a1,形状仍是 (3,),内容一点不变。
图 7-9 转置前后:形状 (2, 3) → (3, 2),每一行搬到同号的那一列上
🎬 动态演示:转置就是交换两个轴
一维转置不变、二维 (2,3) 变 (3,2):形状和内容一起看
import numpy as np

a1 = np.array([1, 2, 3])
print('一维 a1:', a1, ' 形状:', a1.shape)
print('一维 a1.T:', a1.T, ' 形状:', a1.T.shape)

a2 = np.array([[1, 2, 3], [5, 6, 7]])
print('a2 的形状:', a2.shape)
print(a2)
print('a2.T 的形状:', a2.T.shape)
print(a2.T)
print('转置两次又回来了:', bool((a2.T.T == a2).all()))
运行结果(实测)
一维 a1: [1 2 3]  形状: (3,)
一维 a1.T: [1 2 3]  形状: (3,)
a2 的形状: (2, 3)
[[1 2 3]
 [5 6 7]]
a2.T 的形状: (3, 2)
[[1 5]
 [2 6]
 [3 7]]
转置两次又回来了: True
✅ 本节小结:a.T 把行和列换过来,形状元组前后颠倒((2, 3) → (3, 2));一维数组没有第二个轴可交换,a1.T 和 a1 完全一样。

5.2 逐元素运算(* 不是矩阵乘法!)

NumPy 最让人舒服的地方,就是运算符可以直接对整张数组用:a + b、a - b、a * b、a / b、a ** 2……它们全都是逐元素算的——第 0 个跟第 0 个算、第 1 个跟第 1 个算,各算各的,互不干扰。这就是第一个模块说的“向量化”:不用写 for 循环,一行搞定。

因为都是逐元素,所以默认要求两个数组形状完全相同。[1, 2, 3] 加 [10, 20, 30],得到 [11, 22, 33];形状不一样就会报错(除非能广播,见 5.4)。

七个常用运算符

  • + -:加减,逐元素
  • *:逐元素相乘
  • /:除,结果一定是浮点
  • **:乘方,a ** 2 是各自平方
  • // %:整除、取余

数组和标量也能算

a * 2 是每个元素都乘 2;a + 10 是每个都加 10。标量会自动“铺”到每一个元素上——这是最简单的广播。

形状必须配得上

逐元素运算要求两边形状相同(或能广播)。(3,) 和 (3,) 可以,(3,) 和 (4,) 直接报错。

加减乘除与标量:所有运算符都是逐元素的
import numpy as np

a = np.array([1, 2, 3])
b = np.array([10, 20, 30])
print('a + b =', a + b)
print('a - b =', a - b)
print('a * b =', a * b)        # 逐元素相乘,不是矩阵乘法
print('b / a =', b / a)
print('a ** 2 =', a ** 2)
print('a * 2(跟标量算)=', a * 2)
print('b // 7 =', b // 7)
print('b % 7 =', b % 7)
运行结果(实测)
a + b = [11 22 33]
a - b = [ -9 -18 -27]
a * b = [10 40 90]
b / a = [10. 10. 10.]
a ** 2 = [1 4 9]
a * 2(跟标量算)= [2 4 6]
b // 7 = [1 2 4]
b % 7 = [3 6 2]
再强调一次:* 是逐元素乘,不是矩阵乘法。数学课上写的矩阵乘法,在 NumPy 里是 np.dot(a, b) 或 a @ b,不是 a * b。如果你拿 * 去算“矩阵乘矩阵”,程序不会报错,只会安安静静给你一个完全错误的结果——这种错最难查。下一节用同一对数组把两种乘法摆在一起看。
✅ 本节小结:+ - * / ** // % 全部逐元素运算,要求形状相同(或能广播);数组和标量算时标量自动铺到每个位置;* 是逐元素相乘,不是矩阵乘法。

5.3 点积 dot / matmul

矩阵乘法在 NumPy 里由 np.dot() 完成,也可以写成运算符 @(Python 3.5 起支持),两者结果完全一样。它的算法是“左边的行 × 右边的列,乘完再相加”:结果的第 i 行第 j 列,等于左边第 i 行和右边第 j 列对应相乘再求和。

两种情形要分清(课件 7.2 的原文):

下面用同一对 2×2 数组把公式算给你看:x = [[1, 2], [3, 4]]、y = [[5, 6], [7, 8]]。结果第 0 行第 0 列 = x 的行 0(1, 2)乘 y 的列 0(5, 7)= 1×5 + 2×7 = 19;第 1 行第 1 列 = 3×6 + 4×8 = 50。

dot 是“行乘列再相加”:x 的第 0 行 × y 的第 0 列 = 19 x(2×2) 1 2 3 4 · y(2×2) 5 6 7 8 = x · y(2×2) 19 22 43 50 结果[0][0] = x 的第 0 行 · y 的第 0 列 = 1×5 + 2×7 = 5 + 14 = 19 结果[1][1] = x 的第 1 行 · y 的第 1 列 = 3×6 + 4×8 = 18 + 32 = 50 形状要对得上:(m, k) 乘 (k, n) 得 (m, n) —— 这里 x 的列数 2 正好等于 y 的行数 2。 同一对数组换成 x * y(逐元素)得到 [[5, 12], [21, 32]] —— 跟上面完全是两码事。
图 7-10 dot 的“行 × 列”:结果第 i 行第 j 列,等于左边第 i 行与右边第 j 列对应相乘再相加
🎬 动态演示:* 逐元素 与 dot 矩阵乘法
同一对数组:* 逐元素 vs np.dot 矩阵乘;外加一维内积和课件那道 (2,3)·(3,2)
import numpy as np

x = np.array([[1, 2], [3, 4]])
y = np.array([[5, 6], [7, 8]])
print('同一对数组,两种乘法:')
print('x * y(逐元素):')
print(x * y)
print('np.dot(x, y)(矩阵乘法):')
print(np.dot(x, y))
print('x @ y 与 np.dot 等价:', bool((x @ y == np.dot(x, y)).all()))

a = np.array([1, 2, 1])
b = np.array([3, 4, 5])
print('一维 dot = 内积:1*3 + 2*4 + 1*5 =', int(np.dot(a, b)))

m = np.array([[1, 0, 1], [0, 1, 1]])      # (2,3)
n = np.array([[4, 1], [2, 2], [2, 4]])    # (3,2)
print('(2,3) 乘 (3,2) 得 (2,2):')
print(np.dot(m, n))
运行结果(实测)
同一对数组,两种乘法:
x * y(逐元素):
[[ 5 12]
 [21 32]]
np.dot(x, y)(矩阵乘法):
[[19 22]
 [43 50]]
x @ y 与 np.dot 等价: True
一维 dot = 内积:1*3 + 2*4 + 1*5 = 16
(2,3) 乘 (3,2) 得 (2,2):
[[6 5]
 [4 6]]
np.dot 和 @ 到底用哪个?本课两个都用,算出来的东西一模一样。习惯上:写公式、讲课、跟数学对照时用 np.dot(a, b),因为它长得像函数调用、一眼能看出是点积;写代码、做成绩加权这种连续运算时用 a @ b,短。有一点要留意:对一维数组,np.dot 给内积(一个数);对多维数组,新版本 NumPy 更推荐 @(矩阵乘语义更严格),np.dot 在三维以上会有一些历史包袱。本课只涉及一维和二维,两种写法放心用。
✅ 本节小结:一维 × 一维的 np.dot 是内积(结果是数);(m, k) 乘 (k, n) 得 (m, n),左边列数必须等于右边行数;np.dot(a, b) 与 a @ b 等价,和 a * b(逐元素)完全是两回事。

5.4 广播(选学但重要) 选学但重要

逐元素运算要求形状相同,可有时候我们偏偏想让形状不一样的数组算——比如一个 (3, 3) 的矩阵,每一行都加上同一个 [100, 200, 300]。难道要先把 [100, 200, 300] 复制成三行吗?不用。NumPy 有一套广播(broadcasting)规则,会“概念上”把这个短数组铺开,用不着真的复制内存。

广播的两条规则

  1. 从最右边的维度开始,逐个往左对齐比较形状;
  2. 每一对维度,要么相等,要么其中一个是 1(或者一方压根没有这一维),否则就报错。

拿 (3, 3) + (3,) 试:从右往左比,最右边那个 3 和 3 相等——过;左边 (3,) 没有第二维了,相当于 1——过。于是短数组被“复制”到每一行,结果形状是 (3, 3)。这就是为什么 (3,3) + (3,) 能算。

m(3,3)
1  2  3
4  5  6
7  8  9
row(3,)→ 概念上铺到每一行
100  200  300
100  200  300
100  200  300

反例更能说明规则:(3, 3) + (2,) 从右往左比,3 和 2 既不相等、也没有一个是 1,规则不满足,直接报错。下面两栏对照,把“过”和“不过”摆在一起。

能广播:(3, 3) + (3,)
从右往左对齐:
  3  3
     3      ← 左边缺这一维,按 1 看
每一对:3=3 相等,3 与 1 里有一个 1
→ 可以广播,结果形状 (3, 3)
不能广播:(3, 3) + (2,)
从右往左对齐:
  3  3
     2      ← 3 与 2 既不相等也不是 1
→ ValueError: operands could not be
  broadcast together with shapes
  (3,3) (2,)
🎬 动态演示:广播:形状不同也能算
(3,3) 加 (3,) 和加 (3,1):短的一方怎么铺开,结果形状是多少
import numpy as np

m = np.arange(9).reshape(3, 3)
print('m 的形状:', m.shape)
print(m)
row = np.array([100, 200, 300])
print('row 的形状:', row.shape)
print('m + row(row 被铺到每一行):')
print(m + row)

col = np.array([[10], [20], [30]])
print('col 的形状:', col.shape)
print('m + col(col 被铺到每一列):')
print(m + col)
print('(3,1) 乘 (1,4) 广播成:', (np.arange(3).reshape(3, 1) * np.arange(1, 5)).shape)
运行结果(实测)
m 的形状: (3, 3)
[[0 1 2]
 [3 4 5]
 [6 7 8]]
row 的形状: (3,)
m + row(row 被铺到每一行):
[[100 201 302]
 [103 204 305]
 [106 207 308]]
col 的形状: (3, 1)
m + col(col 被铺到每一列):
[[10 11 12]
 [23 24 25]
 [36 37 38]]
(3,1) 乘 (1,4) 广播成: (3, 4)
形状对不上会怎样:(3,3) 加 (2,) 直接报 ValueError
import numpy as np

m = np.ones((3, 3))
bad = np.array([1, 2])
print('m 的形状:', m.shape, ' bad 的形状:', bad.shape)
print('从右往左对齐,3 和 2 既不相等、也没有 1,不能广播:')
print(m + bad)
运行结果(实测,故意报错)
m 的形状: (3, 3)  bad 的形状: (2,)
从右往左对齐,3 和 2 既不相等、也没有 1,不能广播:
Traceback (most recent call last):
  File "<pyshell>", line 7, in <module>
    print(m + bad)
ValueError: operands could not be broadcast together with shapes (3,3) (2,)
✅ 本节小结:广播让形状不同的数组也能逐元素算——从右往左对齐,每一对维度相等、或其中一个是 1、或一方缺这一维,才广播得动,否则 ValueError;(3,3)+(3,) → (3,3),(3,1)*(1,4) → (3,4)。它是“选学但重要”,因为后面 pandas、机器学习里到处都是它。
六

统计运算与 axis 本课最大难点

12 个统计函数(sum / mean / max / argmax / std / cumsum…)· axis=0 压行、axis=1 压列 · 用统计函数做成绩小结 · 打印陷阱

“统计”是数据分析最日常的动作:这一列的平均分多少?最高分是谁?波动大不大?NumPy 把这些算好了,函数名也直白:np.sum 求和、np.mean 平均、np.max 最大……难点不在名字,在二维数组的 axis:同一个 np.sum(a),加不加参数、参数写 0 还是 1,结果的长度完全不一样。这一节把它一次讲清。

6.1 常用统计函数

课件 7.2 列了 12 个统计函数,下面这张表把它们用同一组数据 x = [19, 14, 25, 10, 27, 26, 27, 18](8 个整数,就是课件里的例子)全部算了一遍,结果都是实测值——你可以拿它当“参考答案表”用。

函数作用x = [19, 14, 25, 10, 27, 26, 27, 18] 上的结果
np.sum(x)求和(累加全部)166
np.prod(x)连乘(所有数相乘)22687938000
np.min(x)最小值10
np.max(x)最大值27
np.mean(x)平均值(sum ÷ size)20.75
np.percentile(x, 75)百分位数:排在 75% 位置上的数26.25
np.argmax(x)最大值所在的下标4(27 第一次出现在下标 4)
np.argmin(x)最小值所在的下标3
np.std(x)标准差:数离平均值平均有多远6.08
np.var(x)方差:标准差的平方36.94
np.cumsum(x)累加:每个位置给出“到目前为止的和”[19 33 58 68 95 121 148 166]
np.cumprod(x)累乘:每个位置给出“到目前为止的积”19 266 6650 66500 …(越往后越大)
两处容易抄错的地方。① 课件表里的 percentile 印成了 percentitle,正确的函数名是 np.percentile,多一个 t 就会 AttributeError。② argmax / argmin 给的是下标不是值:x 里 27 出现了两次(下标 4 和 6),argmax 给第一个,也就是 4。另外,除 np.percentile(以及页面补充对照的 np.median)外,其余函数都有同名方法写法:x.sum()、x.mean()…… np.sum(x) 与 x.sum() 结果一样;差别在于方法能直接带 axis 参数:x.sum(axis=0),而函数写法要写成 np.sum(x, axis=0)。但要特别注意:np.percentile 和 np.median 没有 ndarray 方法,x.percentile(75) / x.median() 会直接 AttributeError,只能写函数形式。

光看数字不够直观。下面这张图把 8 个数摆到一条数轴上,再把 min、mean、median、max 的位置标出来——统计量其实就是数轴上的几个“位置”:min 在最左、max 在最右、mean 是“重心”、median 是“正中间”。看图你就明白为什么 27 出现两次会把 mean 往右拽、而 median 几乎不动。

统计量 = 同一串数上的几个位置:min、mean、median、max x = [19, 14, 25, 10, 27, 26, 27, 18](8 个整数,27 出现两次,两个点挨在一起) 10 15 20 25 30 min = 10 mean ≈ 20.75 median = 22 max = 27 标准差 ≈ 6.08:8 个数平均离均值 20.75 有 6.08 那么远 max = 27 这种极端值会把 mean 往右拽;median 只数“排第几”,所以更抗极端值。 std = 6.08 就是 var = 36.94 开平方:数越集中,标准差越小,说明成绩越整齐。
图 7-11 8 个数在数轴上的位置,以及 min / mean / median / max 各自的落点
课件那 8 个数:最小、最大、求和、平均、中位、标准差、方差、位置
import numpy as np

x = np.array([19, 14, 25, 10, 27, 26, 27, 18])
print('x =', x)
print('np.min 最小值:', int(np.min(x)), ' np.argmin 最小值位置:', int(np.argmin(x)))
print('np.max 最大值:', int(np.max(x)), ' np.argmax 最大值位置:', int(np.argmax(x)))
print('np.sum 求和:', int(np.sum(x)))
print('np.mean 平均:', float(np.mean(x)))
print('np.median 中位数:', float(np.median(x)))
print('np.std 标准差:', round(float(np.std(x)), 2))
print('np.var 方差:', round(float(np.var(x)), 2))
print('np.percentile 75% 分位:', float(np.percentile(x, 75)))
运行结果(实测)
x = [19 14 25 10 27 26 27 18]
np.min 最小值: 10  np.argmin 最小值位置: 3
np.max 最大值: 27  np.argmax 最大值位置: 4
np.sum 求和: 166
np.mean 平均: 20.75
np.median 中位数: 22.0
np.std 标准差: 6.08
np.var 方差: 36.94
np.percentile 75% 分位: 26.25
cumsum 累加、cumprod 累乘、prod 连乘、percentile 三个分位
import numpy as np

x = np.array([19, 14, 25, 10, 27, 26, 27, 18])
print('原数组 x:', x)
print('np.cumsum 累加:', np.cumsum(x))
print('np.cumprod 累乘(后面数太大,只看到第 4 个):', np.cumprod(x)[:4])
print('np.prod 连乘前 4 个:', int(np.prod(x[:4])))
print('np.percentile(x, 25):', float(np.percentile(x, 25)))
print('np.percentile(x, 50) 就是中位数:', float(np.percentile(x, 50)))
print('np.percentile(x, 80):', float(np.percentile(x, 80)))
运行结果(实测)
原数组 x: [19 14 25 10 27 26 27 18]
np.cumsum 累加: [ 19  33  58  68  95 121 148 166]
np.cumprod 累乘(后面数太大,只看到第 4 个): [   19   266  6650 66500]
np.prod 连乘前 4 个: 66500
np.percentile(x, 25): 17.0
np.percentile(x, 50) 就是中位数: 22.0
np.percentile(x, 80): 26.6
✅ 本节小结:课件里的 12 个统计函数各管一件事——sum / prod 汇总,min / max / mean / percentile 找位置(另补 median 对照),argmax / argmin 给下标,std / var 量波动,cumsum / cumprod 给“到目前为止”的累计;多数函数用 np.xxx(x) 或 x.xxx() 两种写法都行,但 np.percentile / np.median 只有函数写法。

6.2 axis:沿哪个方向缩

一维数组没什么好选的,只有一个方向。二维数组有两个轴:第 0 轴是行方向,第 1 轴是列方向。做统计的时候要告诉 NumPy“沿哪个轴缩”,这个参数就是 axis。

不写 axis 时,NumPy 把整个数组拍平了算,得到一个数。写了 axis,就是“把那一维压掉”,结果里少一维、每个剩下的位置出一个数:

一句话记牢:axis 就是你要“压掉”的那一维。压掉第 0 维(3 行),剩下的是 4 列 → 4 个数;压掉第 1 维(4 列),剩下的是 3 行 → 3 个数。先想“哪个方向被压没了”,再看结果剩几个数,比背“按行还是按列”靠谱得多。
axis=0 压掉行(每列出一个数),axis=1 压掉列(每行出一个数) 列 0 列 1 列 2 列 3 行 0 行 1 行 2 1 2 3 4 5 6 7 8 9 10 11 12 axis=0 · 把行压掉 15 18 21 24 每列一个数 → 一共 4 个(形状 (4,)) 10 26 42 axis=1 → 每行一个数 一共 3 个 形状 (3,) 压掉第 0 维(3 行)→ 每列剩下 1 个数,共 4 个;压掉第 1 维(4 列)→ 每行剩下 1 个数,共 3 个。 一句话:axis 就是你要压掉的那一维 —— axis=0 压行、axis=1 压列。
图 7-12 axis 的两个方向:左边向下是 axis=0(压行,每列出一个数),右边向右是 axis=1(压列,每行出一个数)
🎬 动态演示:axis=0 与 axis=1 到底沿哪个方向
同一个 3×4 数组:不写 axis、axis=0、axis=1 三种结果的长度不一样
import numpy as np

a = np.arange(1, 13).reshape(3, 4)     # 3 行 4 列
print('a 的形状:', a.shape)
print(a)
print('不写 axis(整个数组一起算):', int(np.sum(a)))
print('axis=0:把 3 行压掉,每列出一个数')
print(np.sum(a, axis=0), '→ 形状', np.sum(a, axis=0).shape)
print('axis=1:把 4 列压掉,每行出一个数')
print(np.sum(a, axis=1), '→ 形状', np.sum(a, axis=1).shape)
print('每列平均 axis=0:', np.round(np.mean(a, axis=0), 2))
print('每行最大 axis=1:', np.max(a, axis=1))
print('每列最小 axis=0:', np.min(a, axis=0))
运行结果(实测)
a 的形状: (3, 4)
[[ 1  2  3  4]
 [ 5  6  7  8]
 [ 9 10 11 12]]
不写 axis(整个数组一起算): 78
axis=0:把 3 行压掉,每列出一个数
[15 18 21 24] → 形状 (4,)
axis=1:把 4 列压掉,每行出一个数
[10 26 42] → 形状 (3,)
每列平均 axis=0: [5. 6. 7. 8.]
每行最大 axis=1: [ 4  8 12]
每列最小 axis=0: [1 2 3 4]
为什么这里最容易记反?因为“按行统计 / 按列统计”这两种说法在课本和网上都用,但指的不是同一件事。课件里写“axis=0 按第 1 个维度统计,按行统计;axis=1 按第 2 个维度统计,按列统计”,说的其实是“沿哪个方向走”——axis=0 沿着行往下走、axis=1 沿着列往右走。可一旦你要判断结果里有几个数,就得反过来看“哪一维被压掉”:axis=0 压掉行,结果是“每列一个数”(4 个);axis=1 压掉列,结果是“每行一个数”(3 个)。做题、写代码时只认后一句,别让“按行 / 按列”四个字把你带反。拿不准就用 .shape 验证:np.sum(a, axis=0).shape 一定是 (a.shape[1],),np.sum(a, axis=1).shape 一定是 (a.shape[0],)。
✅ 本节小结:不写 axis 就是把整个数组算成一个数;axis=0 沿第 0 轴压掉行,每列出一个数(结果长度 = 列数);axis=1 沿第 1 轴压掉列,每行出一个数(结果长度 = 行数);记法就一句:axis 是你要压掉的那一维。

6.3 用统计函数做成绩小结

把 axis 用起来,一张成绩表能一次算出好几份小结。假设 3 名学生考了 4 门课,成绩表 s 是 3 行 4 列——行是学生,列是课程。这时候 axis 的语义就有了业务含义:

axis=0:按“课程”汇总

  • 把 3 名学生压掉,每门课剩 1 个数
  • np.mean(s, axis=0) → 每门课的平均分(4 个数)
  • np.max(s, axis=0) → 每门课的最高分
  • 适合回答“这门课大家考得怎么样”

axis=1:按“学生”汇总

  • 把 4 门课压掉,每名学生剩 1 个数
  • np.max(s, axis=1) → 每名学生的最高分(3 个数)
  • np.sum(s, axis=1) → 每名学生的总分
  • 适合回答“这个学生考得怎么样”

还有一个细节:np.argmax(s) 不写 axis 时,会把整张表拍平成一维再找最大值的位置,得到的是一个“压平后的下标”。想把它还原成“第几行第几列”,用整除和取余就行:行 = 下标 // 列数,列 = 下标 % 列数。下面 demo 里算的就是这个。

3×4 成绩表一次算清:每门课平均、每名学生最高与总分、全表最高分在哪
import numpy as np

# 3 名学生、4 门课:行 = 学生,列 = 课程
s = np.array([[88, 92, 76, 90],
              [72, 85, 68, 79],
              [95, 60, 82, 98]])
print('成绩表形状:', s.shape)
print(s)
print('每门课平均(axis=0):', np.round(np.mean(s, axis=0), 2))
print('每个学生最高(axis=1):', np.max(s, axis=1))
print('每个学生总分(axis=1):', np.sum(s, axis=1))
print('全表最高分:', int(np.max(s)))
flat = int(np.argmax(s))              # argmax 给的是压平后的位置
print('全表最高分的位置:', flat, '→ 第', flat // 4, '行第', flat % 4, '列')
运行结果(实测)
成绩表形状: (3, 4)
[[88 92 76 90]
 [72 85 68 79]
 [95 60 82 98]]
每门课平均(axis=0): [85.   79.   75.33 89.  ]
每个学生最高(axis=1): [92 85 98]
每个学生总分(axis=1): [346 304 335]
全表最高分: 98
全表最高分的位置: 11 → 第 2 行第 3 列
“行是学生还是课程”这件事,自己得先定死。本课和课件都约定行 = 学生、列 = 课程,于是 axis=0 压掉学生、按课程汇总;如果哪天你把表转置成“行 = 课程”,那 axis 的含义就跟着反过来。真实项目里第一步永远是看清数据表的行列各代表什么,然后再决定 axis 写几——这比背公式重要得多。
✅ 本节小结:成绩表行 = 学生、列 = 课程时,axis=0 得每门课的统计(平均 / 最高 / 最低),axis=1 得每名学生的统计(最高 / 最低 / 总分);argmax 不写 axis 给的是压平后的下标,用 下标 // 列数 和 下标 % 列数 还原行列。

6.4 打印陷阱:别让 np.float64 混进列表

最后讲一个几乎所有新手都会撞上的显示问题。单独打印一个 numpy 标量是没问题的——print(np.mean(x)) 会老老实实打出 20.75,因为它走的是字符串转换。可一旦把这个标量放进列表再打印,Python 会去调它的 repr(),于是输出变成 [np.float64(20.75), np.int64(27), np.int64(10)]——一串带着类型名的丑东西。写作业、做报告、把结果贴进文档时,这个尾巴非常碍眼。

NumPy 2.x 对这一点比旧版更“诚实”(旧版里 repr 少了类型名),所以这个坑现在更容易碰到。两类解法,按场景选:

np.float64(...) 是从哪冒出来的:三种正确写法对照
import numpy as np

x = np.array([19, 14, 25, 10, 27, 26, 27, 18])
print('直接打印一个 numpy 标量(没问题):', np.mean(x))
print('掉进坑里:', [np.mean(x), np.max(x), np.min(x)])   # 列表里混了 numpy 标量
print('正确做法 1:先转成 Python 数 ——', [float(np.mean(x)), int(np.max(x)), int(np.min(x))])
print('正确做法 2:要按列表展示数组,用 .tolist() ——', np.array([19, 14, 25]).tolist())
print('数组直接 print 也是干净的:', np.array([19, 14, 25]))
运行结果(实测)
直接打印一个 numpy 标量(没问题): 20.75
掉进坑里: [np.float64(20.75), np.int64(27), np.int64(10)]
正确做法 1:先转成 Python 数 —— [20.75, 27, 10]
正确做法 2:要按列表展示数组,用 .tolist() —— [19, 14, 25]
数组直接 print 也是干净的: [19 14 25]
同一个坑还有两个变种。① 浮点误差尾巴:np.mean([0.1, 0.2, 0.3]) 可能打出 0.20000000000000004 这种,看着像算错了,其实是二进制浮点的正常误差——要展示就 round(float(v), 2) 或 np.round(x, 2)。② 大数组被省略:数组元素一多,print 会显示成 [ 1 2 3 ... 98 99 100],中间用省略号带过,这不是数据丢了,只是 NumPy 帮你省屏幕。想全看,用 np.set_printoptions(threshold=np.inf),但一般没必要。
✅ 本节小结:numpy 标量单独 print 正常,放进列表就会打出 np.float64(...) / np.int64(...);标量先 float() / int(),数组要列表形式就 .tolist();浮点误差尾巴用 round 收掉。这几条是交作业时的“体面分”。
七

数组操作与综合案例 本课重点

排序(函数 vs 方法、axis)· 变形与拼接(reshape / ravel / flatten / concatenate / vstack / hstack)· 课件课后题:10 名学生 5 门课成绩表 · 教材拓展案例:股票组合收益分析 · AI 渗透:ndarray 与 Tensor

这一节是本章的收口。前面六节把 NumPy 拆成了零件:怎么建数组、怎么访问、怎么运算、怎么按 axis 统计。这一节先把最后两个“数组级”的操作补齐——排序和变形与拼接,再把所有零件装进课件里那道成绩表的综合题,最后抬头看一眼:这些东西在 AI 框架里长什么样。装完你会发现,综合题的四问其实就是四句“把数据压成什么形状”的选择题。

本模块主线:排序(谁能拿名次)→ 变形与拼接(把数据换成需要的形态)→ 综合案例(成绩表:建表 → axis=0 → axis=1 → 加权总分 → 前三名)→ 拓展案例(教材股票组合:np.where / matmul / argmin + divmod)→ AI 渗透(ndarray → Tensor → GPU 张量,同一套语法)。

7.1 排序:函数 vs 方法

排序是数据处理的第一个动作:排名次、找最大、取前 N 名,底下都是排序。NumPy 给了两个入口,长得几乎一样,但改不改原数组完全是两回事:

np.sort(x) 函数:给一份排好序的副本
y = np.sort(x)      # x 不动,y 是新数组
print(x)            # 还是原来的顺序
print(y)            # 从小到大排好了
x.sort() 方法:就地改自己
x.sort()            # 不返回数组,x 自己变了
print(x)            # 已经是排好序的
y = x.sort()        # ✗ 这样写 y 是 None
                    #   不是排好序的数组
课件 slide16 复现:np.sort(x) 不动原数组,x.sort() 原地改
import numpy as np

np.random.seed(10)                             # 固定随机种子,结果可复现
x = np.round(np.random.rand(6) * 50, 2)        # 6 个 0~50 的随机小数
print('原始 x      =', x.tolist())

y = np.sort(x)                                 # 函数:返回新数组
print('np.sort(x)  =', y.tolist())
print('x 没被改动   =', x.tolist())

ret = x.sort()                                 # 方法:原地排序
print('x.sort() 的返回值 =', ret)               # None
print('x 被改成     =', x.tolist())
运行结果(实测)
原始 x      = [38.57, 1.04, 31.68, 37.44, 24.93, 11.24]
np.sort(x)  = [1.04, 11.24, 24.93, 31.68, 37.44, 38.57]
x 没被改动   = [38.57, 1.04, 31.68, 37.44, 24.93, 11.24]
x.sort() 的返回值 = None
x 被改成     = [1.04, 11.24, 24.93, 31.68, 37.44, 38.57]
最容易踩的坑:y = x.sort() 不会报错,但 y 是 None,后面 y[0] 就会崩。要“既排序又留下原数组”,写 y = np.sort(x);要“就地改”,写 x.sort() 然后继续用 x。

一维数组排序不用想方向,二维就必须说清楚沿哪个轴排。规则和统计函数一致:np.sort 的默认是 axis=-1,也就是“最后一维”——二维时等于 axis=1,在每一行内部从小到大排,一行的元素始终留在这一行里;axis=0 才是同一列上下排,元素的列号不变、行号变。

x012
0043
1221
np.sort(x)012
0034
1122
axis=0012
0021
1243

三张表的行号、列号是原来的下标。默认排序时,每一行自己排自己的(第 0 行的 4 和 3 换了位置,第 1 行的 1 跑到最前);axis=0 时,每一列上下排自己的(第 0 列 0、2 不变,第 1 列 4、2 变成 2、4,第 2 列 3、1 变成 1、3)。

课件 slide17 复现:二维排序,默认 axis=-1,指定 axis=0 结果完全不同
import numpy as np

x = np.array([[0, 4, 3],
              [2, 2, 1]])
print('原数组 x:')
print(x)

print('np.sort(x):默认 axis=-1,等于 axis=1,每一行内部排')
print(np.sort(x))

print('np.sort(x, axis=0):同一列上下排')
print(np.sort(x, axis=0))

x.sort(axis=0)                                  # 方法版原地排
print('x.sort(axis=0) 之后,x 自己被改了:')
print(x)
运行结果(实测)
原数组 x:
[[0 4 3]
 [2 2 1]]
np.sort(x):默认 axis=-1,等于 axis=1,每一行内部排
[[0 3 4]
 [1 2 2]]
np.sort(x, axis=0):同一列上下排
[[0 2 1]
 [2 4 3]]
x.sort(axis=0) 之后,x 自己被改了:
[[0 2 1]
 [2 4 3]]
🎬 动态演示:sort 的 axis 与“方法 vs 函数”
排序丢了“原来的位置”怎么办?排完序只剩大小关系,谁原来在哪一行就不知道了。想保留位置信息,用 np.argsort(x)——它返回的是下标而不是分数,按这个下标去原数组里取,就能把“值”和“人”重新对上。7.3 找总分前三名,用的正是它。
✅ 本节小结:np.sort(x) 是函数,返回排好序的新数组、原数组不动;x.sort() 是方法,原地排序、返回 None。二维排序必须想清楚 axis:默认 axis=-1(二维时是每行内部排),axis=0 才是同一列上下排。要保留元素原来的位置,用 np.argsort。

7.2 变形与拼接

数组的形状经常“不合用”:模型要 (样本数, 特征数),你手上是一长条;两个月的销量分在两个数组里,要接成一个。NumPy 里这两类活儿分得很清楚——变形不改变元素个数(只换一种“看法”),拼接会改变元素个数(真的多了东西)。

改形状:reshape

  • 元素总数必须相等,只换行列
  • -1 占位,让 NumPy 自己算那一维
  • 总数对不上 → ValueError

拉平:ravel / flatten

  • 都得到一维数组,元素顺序一样
  • ravel() 尽量返回视图(连续内存时是视图,非连续时会自动复制),改视图会动到原数组
  • flatten() 返回副本,随便改

拼接:concatenate 家族

  • concatenate 沿指定轴拼
  • vstack 竖向加行、hstack 横向加列
  • append 末尾追加,每次新建数组
reshape:只换形状不换数据,-1 让 NumPy 自己算那一维
import numpy as np

a = np.arange(12)                               # 0 ~ 11,共 12 个数
print('a =', a.tolist())
print('a.shape =', a.shape)

b = a.reshape(3, 4)                             # 3 行 4 列
print('reshape(3, 4) 之后:')
print(b)
print('b.shape =', b.shape)

c = b.reshape(-1)                               # -1:这一维让 NumPy 自己算
print('reshape(-1) 拉回一维:', c.tolist())

d = b.reshape(2, -1)                            # 2 行,列数自己算 → 6
print('reshape(2, -1) 的形状:', d.shape)
运行结果(实测)
a = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
a.shape = (12,)
reshape(3, 4) 之后:
[[ 0  1  2  3]
 [ 4  5  6  7]
 [ 8  9 10 11]]
b.shape = (3, 4)
reshape(-1) 拉回一维: [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]
reshape(2, -1) 的形状: (2, 6)

数据还是那 12 个数、还是那个顺序,只是“怎么切行”变了。reshape(2, -1) 里那个 -1 是占位符:12 个数排 2 行,一行就是 6 个,NumPy 替你算。一条数组里只能有一个 -1,否则它不知道该怎么猜。

ravel 是视图、flatten 是副本:改一下就知道差别
import numpy as np

a = np.array([[1, 2, 3],
              [4, 5, 6]])
r = a.ravel()                                   # 展平,返回视图
f = a.flatten()                                 # 展平,返回副本
print('ravel()   =', r.tolist())
print('flatten() =', f.tolist())

r[0] = 99                                       # 改视图 → 原数组跟着变
print('改 r[0] 之后 a:')
print(a)

f[1] = 88                                       # 改副本 → 原数组不受影响
print('改 f[1] 之后 f:', f.tolist())
print('同一时刻 a 还是:')
print(a)
运行结果(实测)
ravel()   = [1, 2, 3, 4, 5, 6]
flatten() = [1, 2, 3, 4, 5, 6]
改 r[0] 之后 a:
[[99  2  3]
 [ 4  5  6]]
改 f[1] 之后 f: [1, 88, 3, 4, 5, 6]
同一时刻 a 还是:
[[99  2  3]
 [ 4  5  6]]
视图和副本的区别,本质是“省不省内存”:ravel() 在内存连续时不复制数据,只换一个“一维”的壳,所以改它会顺带改到原数组,胜在省内存(非连续数组会先复制一份,此时改了不影响原数组);flatten() 一律把数据整份复制一遍,怎么改都影响不到原数组,胜在安全。这和 3.3 里“切片是视图不是副本”是同一个道理。
vstack 竖着摞(加行)、hstack 横着接(加列)
import numpy as np

a = np.array([[1, 2],
              [3, 4]])
b = np.array([[5, 6]])

print('a 的形状:', a.shape, ' b 的形状:', b.shape)
print('np.vstack((a, b)):竖着摞,行数变 3')
print(np.vstack((a, b)))

c = np.array([[7],
              [8]])
print('c 的形状:', c.shape)
print('np.hstack((a, c)):横着接,列数变 3')
print(np.hstack((a, c)))
运行结果(实测)
a 的形状: (2, 2)  b 的形状: (1, 2)
np.vstack((a, b)):竖着摞,行数变 3
[[1 2]
 [3 4]
 [5 6]]
c 的形状: (2, 1)
np.hstack((a, c)):横着接,列数变 3
[[1 2 7]
 [3 4 8]]

vstack 和 hstack 是 concatenate 的两个常用特例:vstack 相当于 concatenate(axis=0),竖着摞、行数变多;hstack 相当于 concatenate(axis=1),横着接、列数变多。拼接的唯一硬要求是“除了拼接的那一维,其余维度必须一样”——(2, 2) 能和 (1, 2) 竖向摞,但不能和 (3, 3) 横向接。

concatenate 指定 axis 拼,append 末尾追加(每次都返回新数组)
import numpy as np

x = np.array([1, 2, 3])
y = np.array([4, 5, 6])
print('一维 concatenate:', np.concatenate((x, y)).tolist())

m = np.array([[1, 2], [3, 4]])
n = np.array([[5, 6], [7, 8]])
print('axis=0:按行拼,行数从 2 变 4')
print(np.concatenate((m, n), axis=0))
print('axis=1:按列拼,列数从 2 变 4')
print(np.concatenate((m, n), axis=1))

print('append 返回新数组:', np.append(x, 7).tolist())
print('原数组 x 没变:', x.tolist())
运行结果(实测)
一维 concatenate: [1, 2, 3, 4, 5, 6]
axis=0:按行拼,行数从 2 变 4
[[1 2]
 [3 4]
 [5 6]
 [7 8]]
axis=1:按列拼,列数从 2 变 4
[[1 2 5 6]
 [3 4 7 8]]
append 返回新数组: [1, 2, 3, 7]
原数组 x 没变: [1, 2, 3]
np.append 不是列表的 append——它不会在原数组后面加东西,而是返回一个新数组。所以它和 np.sort 一样属于“函数派”:原数组不动,结果在返回值里。循环里反复 np.append 会一次次复制数据,数据量大时要改用列表收集、最后一次性 np.array。
✅ 本节小结:reshape 只改形状不改数据,元素总数必须匹配,-1 可以占位让它自己算;ravel 尽量返回视图(连续时是视图、非连续时会自动复制)、flatten 一律返回副本——要不要改原数组,心里得有数;concatenate 沿现有轴拼,vstack 竖向加行、hstack 横向加列,append 每次新建一个数组。变形不改变元素个数,拼接会改变。

7.3 综合案例:10 名学生 5 门课的成绩表(课件课后题)

课件 7.3 后面这道题,标题只有一行:“假设有一张成绩表,记录了 10 位学生的语文、数学、英语、生物、历史 5 门课的成绩,成绩范围均为 50~100 分,学号分别为 100~109,要求利用 NumPy 数组完成以下操作。”但它把整章用得上的东西全串了一遍:建数组 → axis 统计 → 点积加权 → 排序取前三。四小问层层递进,每一问都在回答同一个问题——这次要压掉哪一维。

scores:10 行 × 5 列的成绩表(行是学生,列是课程) 学号 语文 数学 英语 生物 历史 100 98 82 61 95 83 101 80 54 56 87 56 102 72 95 55 52 81 103 57 97 54 64 85 104 78 77 76 76 56 105 70 93 81 99 71 106 92 91 50 56 69 107 52 65 80 91 85 108 76 52 62 82 53 109 52 60 98 96 50 axis=0 axis=1 axis=0:压掉“学生”这一维 mean / max / min 各得 5 个数 形状 (10, 5) → (5,) 平均分:72.7 76.6 67.3 79.8 68.9 答第(2)问:每门课考得怎么样 axis=1:压掉“课程”这一维 max / min 各得 10 个数 形状 (10, 5) → (10,) 最高分:98 87 95 97 78 99 92 91 82 98 答第(3)问:每个学生偏不偏科 每一行是一名学生(学号 100–109),每一列是一门课程(语文 / 数学 / 英语 / 生物 / 历史) axis=0 从上往下一列一列地压:10 行压成 1 行,5 列 → 5 个统计值 axis=1 从左往右一行一行地压:5 列压成 1 列,10 行 → 10 个统计值
图 7-13 成绩表的数据形态:行 = 学生(学号 100–109),列 = 课程(5 门);axis=0 压行得每门课的统计,axis=1 压列得每个学生的统计

(1)把成绩存进数组

先把课件那张表原样敲进一个二维数组:每一行是一名学生、每一列是一门课。这个“行 = 样本、列 = 特征”的摆放方式不是随便定的,它是数据分析里最通用的约定——后面 pandas 的 DataFrame、机器学习的训练集,全是这个方向。

(1)建数组:10 行 × 5 列,行是学生、列是课程
import numpy as np

scores = np.array([
    [98, 82, 61, 95, 83],   # 学生 100
    [80, 54, 56, 87, 56],   # 学生 101
    [72, 95, 55, 52, 81],   # 学生 102
    [57, 97, 54, 64, 85],   # 学生 103
    [78, 77, 76, 76, 56],   # 学生 104
    [70, 93, 81, 99, 71],   # 学生 105
    [92, 91, 50, 56, 69],   # 学生 106
    [52, 65, 80, 91, 85],   # 学生 107
    [76, 52, 62, 82, 53],   # 学生 108
    [52, 60, 98, 96, 50],   # 学生 109
])
print('scores.shape =', scores.shape, ' ndim =', scores.ndim, ' size =', scores.size)
print('学生数 =', scores.shape[0], ' 课程数 =', scores.shape[1])
print(scores)
运行结果(实测)
scores.shape = (10, 5)  ndim = 2  size = 50
学生数 = 10  课程数 = 5
[[98 82 61 95 83]
 [80 54 56 87 56]
 [72 95 55 52 81]
 [57 97 54 64 85]
 [78 77 76 76 56]
 [70 93 81 99 71]
 [92 91 50 56 69]
 [52 65 80 91 85]
 [76 52 62 82 53]
 [52 60 98 96 50]]
🎬 动态演示:成绩表的数据形态——行是学生,列是课程

(2)每门课的平均分、最高分、最低分:axis=0

要算“每门课”的统计量,就是把这 10 名学生叠起来算:同一个位置的 10 个分数归约成 1 个数,5 门课得到 5 个数。scores 的形状是 (10, 5),第 0 维是学生、第 1 维是课程,所以 axis=0 压掉的正是“学生”这一维,结果长度是 5。

一句话记 axis:axis=0 是“沿行方向压下去”——把 10 行压成 1 行,留下 5 列,每列一个数。课件把这句说成“按行统计”,意思是把行压掉,不是“每行算一个”,读的时候要分清。
(2)五门课的平均 / 最高 / 最低:axis=0,10 行压成 1 行
import numpy as np

scores = np.array([[98, 82, 61, 95, 83], [80, 54, 56, 87, 56],
                   [72, 95, 55, 52, 81], [57, 97, 54, 64, 85],
                   [78, 77, 76, 76, 56], [70, 93, 81, 99, 71],
                   [92, 91, 50, 56, 69], [52, 65, 80, 91, 85],
                   [76, 52, 62, 82, 53], [52, 60, 98, 96, 50]])
courses = ['语文', '数学', '英语', '生物', '历史']

avg = np.mean(scores, axis=0)        # 压掉学生这一维 → 5 个数
hi = np.max(scores, axis=0)
lo = np.min(scores, axis=0)
for i in range(5):
    print(f'{courses[i]}  平均 {float(avg[i]):.2f}  最高 {int(hi[i])}  最低 {int(lo[i])}')
运行结果(实测)
语文  平均 72.70  最高 98  最低 52
数学  平均 76.60  最高 97  最低 52
英语  平均 67.30  最高 98  最低 50
生物  平均 79.80  最高 99  最低 52
历史  平均 68.90  最高 85  最低 50
课程平均分(axis=0)最高分最低分
语文72.709852
数学76.609752
英语67.309850
生物79.809952
历史68.908550

这张表就是 avg / hi / lo 三个数组的样子,和上面 demo 的输出逐字一致。读表时可以顺便下个结论:生物平均最高(79.8)、英语平均最低(67.3);最高分全表 99 分(生物,学生 105),最低分 50 分(英语、历史)。

(3)每个学生的最高分、最低分:axis=1

换个问法,axis 就跟着换。“每个学生”是一行一算:把一行里的 5 门课压成 1 个数,10 行得到 10 个数,所以这次压掉的是第 1 维(课程),写 axis=1。顺手用 np.argmax(scores, axis=1) 把“最高分是哪一门课”也查出来——argmax 返回的是下标(0~4),拿它去索引课程名列表就行。

(3)每个学生的最高 / 最低:axis=1,5 列压成 1 个;再查最高分是哪门课
import numpy as np

scores = np.array([[98, 82, 61, 95, 83], [80, 54, 56, 87, 56],
                   [72, 95, 55, 52, 81], [57, 97, 54, 64, 85],
                   [78, 77, 76, 76, 56], [70, 93, 81, 99, 71],
                   [92, 91, 50, 56, 69], [52, 65, 80, 91, 85],
                   [76, 52, 62, 82, 53], [52, 60, 98, 96, 50]])
ids = np.arange(100, 110)             # 学号:100 ~ 109
courses = ['语文', '数学', '英语', '生物', '历史']

top = np.max(scores, axis=1)          # 压掉课程这一维 → 10 个数
low = np.min(scores, axis=1)
best = np.argmax(scores, axis=1)      # 最高分落在第几列
for i in range(10):
    print(f'学生{int(ids[i])}  最高 {int(top[i])}({courses[int(best[i])]})  最低 {int(low[i])}')
运行结果(实测)
学生100  最高 98(语文)  最低 61
学生101  最高 87(生物)  最低 54
学生102  最高 95(数学)  最低 52
学生103  最高 97(数学)  最低 54
学生104  最高 78(语文)  最低 56
学生105  最高 99(生物)  最低 70
学生106  最高 92(语文)  最低 50
学生107  最高 91(生物)  最低 52
学生108  最高 82(生物)  最低 52
学生109  最高 98(英语)  最低 50
两问的区别只有一句话:问“每门课怎么样”→ 压掉学生 → axis=0,结果 5 个数;问“每个学生怎么样”→ 压掉课程 → axis=1,结果 10 个数。先想清楚“结果要几个数、每个数代表谁”,axis 自然就定了,比背“按行还是按列”可靠得多。

(4)加权总分与总分前三名:dot + argsort

最后一问最简单也最像“真实业务”:5 门课的占比分别是 25%、25%、20%、15%、15%,问每个学生的总分。这不是普通的求和——每门课要先乘自己的权重再相加,也就是“这一行的 5 个成绩”和“5 个权重”配对相乘再求和,正是点积。scores 是 (10, 5),把 weight 当 (5,) 的向量,np.dot(scores, weight) 一次就把 10 个人全算完,结果形状 (10,)。

形状推演
scores              (10, 5)
weight              (5,)
weight.T            (5,)     一维转置还是自己

np.dot(scores, weight.T)
      (10, 5) · (5,)  →  (10,)

10 名学生 × 5 门课  →  10 个总分
第 1 名的总分怎么算出来的
总分[0] = 98×0.25 + 82×0.25 + 61×0.20
                    + 95×0.15 + 83×0.15
       = 24.5 + 20.5 + 12.2 + 14.25 + 12.45
       = 83.9

"一行 5 个成绩"配"5 个权重",
一一相乘再相加 —— 点积的定义。
(4)加权总分:np.dot(scores, weight.T),一行算出一个总分
import numpy as np

scores = np.array([[98, 82, 61, 95, 83], [80, 54, 56, 87, 56],
                   [72, 95, 55, 52, 81], [57, 97, 54, 64, 85],
                   [78, 77, 76, 76, 56], [70, 93, 81, 99, 71],
                   [92, 91, 50, 56, 69], [52, 65, 80, 91, 85],
                   [76, 52, 62, 82, 53], [52, 60, 98, 96, 50]])
weight = np.array([0.25, 0.25, 0.20, 0.15, 0.15])
ids = np.arange(100, 110)

total = np.dot(scores, weight.T)         # (10, 5) · (5,) → (10,)
print('每位学生的加权总分:')
for i in range(10):
    print(f'学生{int(ids[i])}  {round(float(total[i]), 2)}')
运行结果(实测)
每位学生的加权总分:
学生100  83.9
学生101  66.15
学生102  72.7
学生103  71.65
学生104  73.75
学生105  82.45
学生106  74.5
学生107  71.65
学生108  64.65
学生109  69.5
🎬 动态演示:成绩表加权总分——10×5 矩阵 · 5 维权重点积
两个容易写错的地方:① weight 是一维数组,weight.T 还是它自己,所以 np.dot(scores, weight) 和 np.dot(scores, weight.T) 结果完全相同——课件写 .T 是为了强调“行配权重的列”这层对应关系;② 这里不能用 scores * weight:* 是逐元素乘(第 5.2 节讲过),广播之后得到的是 10×5 的新表,不是 10 个总分,还得再 sum(axis=1),而 dot 一步到位。

总分算出来了,题目最后一句是“查询最高的 3 个总分”。只问分数时,直接 np.sort(total)[-3:] 就够了;但题目如果还要连“是谁”一起给出(前三名),np.sort 只拿到 3 个分数,拿不到学号——分数是找到了,人丢了。这时要用 np.argsort 排下标,再拿下标去学号数组里取人。

总分前三名:argsort 排下标 → 取 [-3:] → 再 [::-1] 翻成降序
import numpy as np

scores = np.array([[98, 82, 61, 95, 83], [80, 54, 56, 87, 56],
                   [72, 95, 55, 52, 81], [57, 97, 54, 64, 85],
                   [78, 77, 76, 76, 56], [70, 93, 81, 99, 71],
                   [92, 91, 50, 56, 69], [52, 65, 80, 91, 85],
                   [76, 52, 62, 82, 53], [52, 60, 98, 96, 50]])
weight = np.array([0.25, 0.25, 0.20, 0.15, 0.15])
ids = np.arange(100, 110)
total = np.dot(scores, weight.T)

order = np.argsort(total)                # 升序排的是"下标"
print('argsort 的结果(升序下标):', order.tolist())

top3 = order[-3:][::-1]                  # 取最后 3 个,再倒过来 = 前三名
print('总分前三名:')
for rank, i in enumerate(top3, 1):
    print(f'第{rank}名  学号 {int(ids[i])}  总分 {round(float(total[i]), 2)}')
运行结果(实测)
argsort 的结果(升序下标): [8, 1, 9, 7, 3, 2, 4, 6, 5, 0]
总分前三名:
第1名  学号 100  总分 83.9
第2名  学号 105  总分 82.45
第3名  学号 106  总分 74.5
名次学号加权总分怎么从 argsort 得到
第 1 名10083.9order[-1] = 0 → ids[0] = 100
第 2 名10582.45order[-2] = 5 → ids[5] = 105
第 3 名10674.5order[-3] = 6 → ids[6] = 106
加权总分 = 成绩矩阵 · 权重向量:一行 5 个成绩 → 一个总分 scores (10, 5) ← 每行 = 1 名学生 ← 每列 = 1 门课程 共 10 行 × 5 列 = 50 个成绩 (这里只画了 3 行示意) · weight (5,) 0.25 0.25 0.20 0.15 0.15 语文 数学 英语 生物 历史 5 个权重加起来 = 1 = total (10,) 每人一个总分 83.9 66.15 72.7 71.65 73.75 82.45 74.5 71.65 64.65 69.5 下标 0~4 是第一排 5 位学生,5~9 是第二排 ① np.argsort(total) → 升序排出来的下标,不是分数   [8, 1, 9, 7, 3, 2, 4, 6, 5, 0] ② 取 [-3:] 得到最大的三个(还是升序)→ 再 [::-1] 翻成降序 → [0, 5, 6]   ids[[0, 5, 6]] = [100, 105, 106] 第 1 名 学号 100 总分 83.9 第 2 名 学号 105 总分 82.45 第 3 名 学号 106 总分 74.5
图 7-14 加权总分的流程:10×5 的成绩矩阵点乘 5 维权重向量,得到 10 个总分;再用 argsort 把分数换回学号,取出前三名
直接 np.sort(total)[-3:] 只拿到分数、拿不到人:argsort 才有位置信息
import numpy as np

scores = np.array([[98, 82, 61, 95, 83], [80, 54, 56, 87, 56],
                   [72, 95, 55, 52, 81], [57, 97, 54, 64, 85],
                   [78, 77, 76, 76, 56], [70, 93, 81, 99, 71],
                   [92, 91, 50, 56, 69], [52, 65, 80, 91, 85],
                   [76, 52, 62, 82, 53], [52, 60, 98, 96, 50]])
weight = np.array([0.25, 0.25, 0.20, 0.15, 0.15])
ids = np.arange(100, 110)
total = np.dot(scores, weight.T)

print('直接排序取后三个:', np.round(np.sort(total)[-3:], 2).tolist())
print('→ 分数是有了,但不知道是谁的')

order = np.argsort(total)
print('argsort 的下标:', order.tolist())
print('用下标去学号里取人:', ids[order[-3:][::-1]].tolist())
print('再用同一批下标取分:', np.round(total[order[-3:][::-1]], 2).tolist())
运行结果(实测)
直接排序取后三个: [74.5, 82.45, 83.9]
→ 分数是有了,但不知道是谁的
argsort 的下标: [8, 1, 9, 7, 3, 2, 4, 6, 5, 0]
用下标去学号里取人: [100, 105, 106]
再用同一批下标取分: [83.9, 82.45, 74.5]

这四小问合起来,就是一条完整的数据处理链:建表(np.array)→ 按列看(axis=0)→ 按行看(axis=1)→ 加权合成(dot)→ 排名(argsort)。把这五步的名字记住,后面学 pandas 时你会发现——groupby 干的是 axis=0 的活儿,apply 干的是 axis=1 的活儿,sort_values 干的是 argsort 的活儿。工具换了,思路一模一样。

配套视频黑马程序员 · 第 124 讲 数据分析案例步骤1-文件读取B站 · 该讲是数据分析入门,NumPy 部分以此做前置铺垫:先把数据从文件读进来,才谈得上用数组去算
✅ 本节小结:这道课后题把整章串成了一条线——np.array 建 10×5 的表、axis=0 得每门课的统计、axis=1 得每个学生的统计、np.dot(scores, weight.T) 把 5 门成绩按权重压成 1 个总分、np.argsort 找出前三名。想清楚“要压掉哪一维”,axis 就不会写错;想清楚“要升序还是降序”,argsort 的那一刀就不会切反。

7.4 拓展案例:股票投资组合分析(教材案例 · 选学)

课件最后一题是成绩表,教材第 7 章还配了一个更“业务”的案例:4 只股票、5 个交易日的涨跌幅,按 15% / 20% / 25% / 40% 的配置比例组成一个投资组合,问“每个交易日的组合收益率是多少、5 天总共赚(亏)了多少”。它把这一章学的东西又串了一遍,而且多出三个以前没露面的工具:np.where(布尔索引的“位置版”)、np.matmul(矩阵乘法的另一种写法)、np.argmin + divmod(把压平的下标还原成行列)。

数据怎么来?教材用随机数模拟 4 只股票 5 天的涨跌幅:固定种子 np.random.seed(25),生成 (4, 5) 的随机数后先 np.round(..., 2)、再 / 100,得到形如 -0.0115(即 −1.15%)的“小数形式涨跌幅”。下面用三段代码把它跑一遍;同样的数据也放在本页下方的「配套代码与数据下载」里(股票涨跌幅数据.csv),可以直接下载对照。
教材案例:4 只股票 × 5 个交易日 → 组合收益率 stocks (4, 5) 涨跌幅(小数) 股票 02-01 02-02 02-03 02-04 02-05 A B C D 0.01110.0025-0.0066-0.0094-0.0027 -0.01150.0055-0.00190.0017-0.0040 -0.0029-0.0116-0.00160.0026-0.0101 0.0006-0.00520.0060-0.00400.0101 matmul weight (4,) 0.15 0.20 0.25 0.40 每日组合收益率 r1 = weight · stocks (5,) 02-01 −0.00112 02-02 −0.003505 02-03 +0.00063 02-04 −0.00202 02-05 +0.00031 × 100 万 → 总和 = −5705.0 元 ① 布尔索引 + np.where stocks<-0.01 → 3 个值 / 位置 (1,0)(2,1)(2,4) ② np.sort + axis axis=0 按交易日排 · axis=1 按股票排 ③ argmin + divmod 最小涨幅 -0.0116 → 压平下标 11 → divmod(11,5)=(2,1)
图 7-15 教材股票案例的数据流:4×5 的涨跌幅矩阵乘 4 维权重得到 5 个每日收益率,再按 100 万本金折算并求和

(1)先把数据造出来:4 只股票 × 5 个交易日

固定种子生成 4×5 的涨跌幅矩阵,顺带查一个单值(B 股票 2/3)
import numpy as np

np.random.seed(25)                              # 固定种子:每次运行结果一样
stocks = np.random.rand(4, 5) * 3 - 1.5         # 4 只股票 × 5 个交易日,范围 [-1.5, 1.5)
stocks = np.round(stocks, 2)                    # 先保留两位小数
stocks = stocks / 100                           # 再除以 100,换成“小数形式”的涨跌幅

print('形状 / 维度 / 元素个数:', stocks.shape, stocks.ndim, stocks.size)
print(stocks)
print('B 股票 2021-02-03 的涨跌幅:', stocks[1, 2])
运行结果(实测)
形状 / 维度 / 元素个数: (4, 5) 2 20
[[ 0.0111  0.0025 -0.0066 -0.0094 -0.0027]
 [-0.0115  0.0055 -0.0019  0.0017 -0.004 ]
 [-0.0029 -0.0116 -0.0016  0.0026 -0.0101]
 [ 0.0006 -0.0052  0.006  -0.004   0.0101]]
B 股票 2021-02-03 的涨跌幅: -0.0019

(2)条件筛选、切片与排序:把想要的涨幅找出来

布尔索引找“跌幅超过 1%”、np.where 给位置、切片取 C/D 股票、两种 axis 排序
import numpy as np

np.random.seed(25)
stocks = np.round(np.random.rand(4, 5) * 3 - 1.5, 2) / 100

mask = stocks < -0.01                           # 跌幅超过 1% 的位置
print('跌幅小于 -0.01 的涨跌幅:', stocks[mask])
rows, cols = np.where(mask)                     # 布尔掩码的“位置版”:分别给出行、列下标
print('对应行下标:', rows, ' 列下标:', cols)
print('C、D 股票在 2 月 2 日—2 月 5 日的涨跌幅:')
print(stocks[2:, 1:])
print('按交易日排序(axis=0,每天 4 只股票从低到高):')
print(np.sort(stocks, axis=0))
print('按每只股票排序(axis=1,每只股票 5 天从低到高):')
print(np.sort(stocks, axis=1))
运行结果(实测)
跌幅小于 -0.01 的涨跌幅: [-0.0115 -0.0116 -0.0101]
对应行下标: [1 2 2]  列下标: [0 1 4]
C、D 股票在 2 月 2 日—2 月 5 日的涨跌幅:
[[-0.0116 -0.0016  0.0026 -0.0101]
 [-0.0052  0.006  -0.004   0.0101]]
按交易日排序(axis=0,每天 4 只股票从低到高):
[[-0.0115 -0.0116 -0.0066 -0.0094 -0.0101]
 [-0.0029 -0.0052 -0.0019 -0.004  -0.004 ]
 [ 0.0006  0.0025 -0.0016  0.0017 -0.0027]
 [ 0.0111  0.0055  0.006   0.0026  0.0101]]
按每只股票排序(axis=1,每只股票 5 天从低到高):
[[-0.0094 -0.0066 -0.0027  0.0025  0.0111]
 [-0.0115 -0.004  -0.0019  0.0017  0.0055]
 [-0.0116 -0.0101 -0.0029 -0.0016  0.0026]
 [-0.0052 -0.004   0.0006  0.006   0.0101]]
教材这里写的是 stocks[2:, 1:4],只取到 2 月 2 日、3 日、4 日三天;本页按题目原文“2 月 2 日至 5 日”改成 stocks[2:, 1:],取到 4 天(列下标 1—4)。两种写法都能跑,区别只是“要不要包含 2 月 5 日”。

(3)组合收益率与“最小涨幅在哪”:matmul + argmin + divmod

加权收益率 = 权重 · 涨跌幅矩阵;再乘本金算总收益,最后用 divmod 还原最小涨幅的位置
import numpy as np

np.random.seed(25)
stocks = np.round(np.random.rand(4, 5) * 3 - 1.5, 2) / 100
weight = np.array([0.15, 0.20, 0.25, 0.40])     # A~D 四只股票的配置比例

daily = np.matmul(weight, stocks)               # 每天的组合加权收益率:4 只股票按权重加权
print('每日组合收益率:', daily)
print('按 100 万本金折算,每日收益(元):', daily * 1000000)
print('5 个交易日总收益(元):', np.sum(daily * 1000000))

pos = np.argmin(stocks)                         # 最小涨幅在“压平”后的数组里是第几个
print('最小涨幅:', np.min(stocks), ' 压平下标:', pos)
print('还原成行列(行, 列):', divmod(int(pos), stocks[0].size))
运行结果(实测)
每日组合收益率: [-0.00112  -0.003505  0.00063  -0.00202   0.00031 ]
按 100 万本金折算,每日收益(元): [-1120. -3505.   630. -2020.   310.]
5 个交易日总收益(元): -5705.0
最小涨幅: -0.0116  压平下标: 11
还原成行列(行, 列): (2, 1)
这个案例多学了三件事:① np.where(mask) 返回两个数组(行下标、列下标),它和 a[mask] 是同一件事的两种用法——一个要“值”,一个要“位置”;② np.matmul(A, B) 与 np.dot(A, B) 在二维/一维混合时结果相同,A @ B 也是同一个函数,记住一个就够;③ np.argmin 返回的是压平后的线性下标,divmod(线性下标, 列数) 一下就还原出(行,列)——这是把“一维下标”和“二维位置”互相换算的标准做法。
✅ 本节小结:教材股票案例把本章工具串成一条业务链——np.random.seed(25) 造 4×5 涨跌幅 → 布尔索引 / np.where 找跌幅 → 切片取指定股票与日期 → np.sort(axis=0/1) 两种方向排序 → np.matmul(weight, stocks) 算每日组合收益率 → 乘本金求和得 5 日总收益 → np.argmin + divmod 定位最小涨幅。数据文件可在本页下载区取用。

7.5 AI 渗透:为什么 AI 框架全用数组

这一章学的 ndarray,在 AI 工程里有一个几乎一模一样的“亲戚”——PyTorch 的 Tensor(张量)。两者不是“像”,而是同构:形状、类型、索引、切片、广播、点积、按轴归约,一套概念两边通用,连函数名都大半重合。学会 ndarray,等于提前学会了 Tensor 的 80%;剩下 20% 里最要紧的那一点,是 Tensor 多了一个“算在哪”的属性。

要做的事NumPy(ndarray)PyTorch(Tensor)
看形状a.shapet.shape
看元素类型a.dtypet.dtype
看算在哪只能在内存(CPU)t.device:cpu / cuda
取一块a[0, 1:3]t[0, 1:3]
逐元素运算a * 2 + 1t * 2 + 1
矩阵乘np.dot(a, b) / a @ bt @ b / torch.matmul
按轴归约a.mean(axis=0)t.mean(dim=0)
排序(函数 / 方法)np.sort(a)(返回新数组)/ a.sort()(原地,返回 None)torch.sort(t)(返回 (values, indices),不是原地)
改形状a.reshape(3, 4)t.reshape(3, 4) / t.view

唯一的“翻译成本”是两个词:NumPy 叫 axis,PyTorch 叫 dim;NumPy 习惯写函数 np.xxx,PyTorch 大多挂在 torch.xxx 或者干脆做成方法。剩下的语法几乎可以逐字照抄——这也是为什么几乎所有 AI 教材都默认你已经会 NumPy。

那 GPU 张量又是什么?ndarray 住在内存里,只能用 CPU 算;Tensor 多一个 device,可以搬到显卡的显存里,用几千个核心同时算。搬家的动作就是一句 t.to('cuda'),搬过去之后形状、索引、点积的写法一点不变——变的是速度,不是语法。7.3 那行 np.dot(scores, weight) 是 10×5 乘 5,如果放大成 4096×4096 乘 4096×4096,就是 Transformer 里一次前向的基本动作。

至于数据预处理为什么全都用 NumPy,原因很实在:① 所有读数据的库最后都给你 ndarray——np.loadtxt 读文本、pandas 的 .values、PIL / OpenCV 读图片都是;② 预处理动作全是数组操作——归一化是广播、切分训练集是切片、拼 batch 是 vstack、打乱顺序是花式索引;③ 转成 Tensor 几乎不花代价——torch.from_numpy(a) 与 ndarray 共享同一块内存,不复制数据。所以标准流程是:磁盘 → NumPy(在 CPU 上洗数据)→ Tensor(进模型)→ GPU(开算)。

AI 链路:数据从磁盘到显卡,中间每一段都是数组的形状 ① 磁盘数据 csv / 图片 / 日志 一堆字节,程序读不懂 第 6 章干的活 ② ndarray np.loadtxt / np.array 同类型 · 定长 · 连续内存 本章前六个模块干的活 ③ 预处理 归一化 / 切片 / reshape 结果还是 ndarray 广播、视图、拼接全用上 ④ Tensor(CPU) torch.from_numpy(a) 与 ndarray 共享内存 零拷贝,不用复制数据 ⑤ GPU 张量 t.to('cuda') 进显存,几千核并行 前向 / 反向都在这里算 ndarray 怎么用,Tensor 就怎么用:x.shape、x[0]、x*2、x @ w、x.mean(axis=0)、sort(x) 区别只有一个:Tensor 多了 device 字段(cpu / cuda),能在显卡上并行;ndarray 只能在内存里算 7.3 那行 np.dot(scores, weight) 放大到 4096×4096,就是 Transformer 一次前向的基本动作
图 7-16 ndarray → Tensor → GPU 张量的 AI 链路:中间的数据清洗、归一化、切 batch 全用 NumPy 完成,进入模型前才转成张量
ndarray 就是 CPU 上的张量:同一套 shape / 广播 / 点积 / 归约
import numpy as np

# 下面每一行的写法,在 PyTorch 里只差一个 torch. 前缀,语义完全一样
x = np.array([[1.0, 2.0, 3.0],
              [4.0, 5.0, 6.0]])
print('shape =', x.shape, ' dtype =', x.dtype)

print('逐元素 x + 1(广播):')
print(x + 1)

print('按列求均值 axis=0:', np.round(x.mean(axis=0), 2).tolist())

w = np.array([0.5, 0.5, 0.5])
print('矩阵乘向量 dot:', np.round(np.dot(x, w), 2).tolist())

z = np.array([2.0, 1.0, 0.1])
e = np.exp(z - np.max(z))                   # 减去最大值,防止溢出
print('手写 softmax:', np.round(e / np.sum(e), 4).tolist())
运行结果(实测)
shape = (2, 3)  dtype = float64
逐元素 x + 1(广播):
[[2. 3. 4.]
 [5. 6. 7.]]
按列求均值 axis=0: [2.5, 3.5, 4.5]
矩阵乘向量 dot: [3.0, 7.5]
手写 softmax: [0.659, 0.2424, 0.0986]

最后这段 softmax 值得多看一眼:它先减最大值(防止 exp 溢出),再取指数,最后除以总和——三步全是逐元素运算加整数组归约,没有一步需要 for 循环。这就是 NumPy 的“向量化”思想:把一条一条数据变成一整块矩阵,让运算一次作用在所有元素上。7.3 里用 np.dot 一行算完 10 个总分,和这里是同一种思维方式,只是数据规模从 10 变成 10 万、从 CPU 换成 GPU。

回头看 NumPy 与 AI 的关系:ndarray 和 PyTorch 的 Tensor 是同构的——同样的 shape / dtype,同样的索引切片、广播、点积、按轴归约,连 np.sort(x) / x.sort() 这种“函数 / 方法”的区分都能对应到 torch.sort(t)(两者都返回新结果,不承诺原地)。GPU 张量只是给 Tensor 多了个 device(cpu / cuda),搬上显存之后写法一个都不改,变的只是并行度和显存限制。至于数据预处理为什么全用 NumPy:所有读数据的库最后都交给你一个 ndarray,清洗、归一化、切分、拼 batch 全是数组操作,而 torch.from_numpy() 又和 ndarray 共享内存、零拷贝——NumPy 是数据进模型之前的“通用语言”,这一章学的就是这门语言。
✅ 本节小结:ndarray 与 Tensor 同构——shape / dtype / 索引 / 广播 / dot / axis 归约一套通用,只有 axis 改叫 dim;GPU 张量只多一个 device,.to('cuda') 之后写法不变;数据预处理阶段全用 NumPy,因为所有读数据的库都产出 ndarray,from_numpy 又能零拷贝转成张量。学会 NumPy,就是拿到了进 AI 框架的入场券。
八

交互演示区

改参数、点按钮,立刻看结果 · 浏览器内 JS 模拟,输出已与 Python 3.14 + NumPy 2.5.2 逐字对齐

演示一:数组创建器(array / arange / linspace / zeros / ones)

对应 2.1—2.4 节。选一种创建方式、填参数,立刻看到生成结果以及 shape / ndim / size / dtype。注意 arange 不含 stop、linspace 含两端;zeros / ones 的 dtype 默认是 float64;array 里有小数就会变成 float64。结果统一用 arr.tolist() 显示,这样不会出现 numpy 打印时的对齐空格。

点上面的按钮试试

演示二:索引切片模拟器(一维 / 二维)

对应 3.2—4.2 节。选一个样本数组,输入下标表达式:一维可以写 3、-1、0:3、[1,2,5]、::-1;二维要用逗号分成“行, 列”两部分,如 1,1、:,0、0:2, 1:、:, [0,2]。点按钮看取到的到底是标量还是数组、shape 变成多少;越界会给出 numpy 的 IndexError 原文。注意:切片是视图、列表下标是副本(3.3、3.4 节)。

点上面的按钮试试

演示三:axis 统计器(sum / mean / max / min / std)

对应 6.2 节。下面可以改矩阵(每行一组数字,行之间换行,列之间用逗号或空格分隔);选统计函数和 axis,看结果到底是几个数:axis=0 把行压掉,每列出一个数;axis=1 把列压掉,每行出一个数;不写 axis 就把整个数组压成一个数。np.std 算的是总体标准差(ddof=0);浮点结果(mean / std 以及浮点矩阵的 sum / max / min)保留 4 位小数。
说明:本面板把输入的每一行都当矩阵的一行,只写一行时按 (1, n) 的二维矩阵处理(等价 np.array([[…]]));numpy 里“一维数组”的 axis=0 结果是标量、axis=1 会报错,两种情形不一样。

点上面的按钮试试

演示四:运算对照器(* 逐元素 vs np.dot)

对应 5.2—5.3 节。两个数组都能改:一维用逗号分隔;二维每行用分号隔开,例如 1, 0, 1; 0, 1, 1。点按钮同时算 a * b 和 np.dot(a, b):* 是“同一个位置的元素各自相乘”,dot 是“行 × 列再相加”。两个数组形状(2,3)和(3,2)时,* 会报错,dot 却能算出(2,2)——这正是它们最大的区别。

点上面的按钮试试

演示五:广播模拟器(形状不同也能算吗)

对应 5.4 节。选两个形状,看 numpy 的广播规则:先把两个形状从右往左对齐、缺的维补 1,然后逐维判断“相等,或者其中一个是 1”;全部能对上就广播成每一维的最大值,只要有一维对不上就抛 ValueError。能广播时,面板还会用一组连续的示例数据真的算一次 A + B。

点上面的按钮试试

演示六:成绩加权总分(10 名学生 × 5 门课)

对应 7.3 节(课件课后题)。成绩表固定:scores.shape = (10, 5),行是学生(学号 100—109),列是语文 / 数学 / 英语 / 生物 / 历史。改这 5 个权重,页面会实时检查“权重和是不是 1”,点按钮就能算出 np.dot(scores, weight) 的 10 个加权总分,并列出前三名。总分是 100 分制,权重和必须等于 1,否则算出来的数没有意义。

权重和 = 1.000 ✓
点上面的按钮试试
这些面板都是照抄 Python + NumPy 的算法用 JS 重写的:arange 不含 stop、linspace 含两端、reshape 的维度推断、* 与 np.dot 的区别、广播判定(从右往左、相等或为 1)、axis 语义(axis=0 每列出一个数)、np.std 的总体标准差、加权总分的点积,都和 Python 3.14 + NumPy 2.5.2 实际跑出来的结果逐字对齐。把面板里的数据复制到上面任意一段示例代码里再跑一遍,输出是一样的。
九

配套代码与数据下载

课件与教材数据 + 7 个模块示例代码 + 课后作业参考答案,下载到本机就能跑

本页 7 个模块的示例代码都整理成了可直接运行的 .py 文件,课件课后题的成绩表、教材「股票分析」的涨跌幅数据也一并放出来了。建议把数据文件和代码文件下载到同一个文件夹,在命令行执行 python 文件名.py 就能跑;页面上的代码也可以直接点「复制代码」拷到自己的编辑器。

使用提示:① 运行环境 pip install numpy(本页实测 Python 3.14.7 + numpy 2.5.2);② 页面示例的随机数都固定了种子(0 / 10 / 25),下载的代码运行结果与页面一致;③ 页面上标注「故意报错」的示例(下标越界 / 广播失败 / reshape 元素数不匹配)没有收进 .py,因为这些例子运行会中断,请直接在页面上看;④ 运行时报 ModuleNotFoundError: No module named 'numpy',先执行 pip install numpy。

一、数据文件(课件课后题 + 教材案例)

文件名(点击下载)内容大小
学生成绩表.csv 课件「【课后题】10 位学生 5 门课成绩表」原始数据(10 行 × 5 门课),配 numpy 综合练习;UTF-8。 232 B
股票涨跌幅数据.csv 教材第 7 章「股票分析」案例数据:4 只股票 × 5 个交易日(2021-02-01 ~ 02-05)的涨跌幅,小数形式(0.0111 = +1.11%),固定随机种子 25,与页面示例一致;UTF-8。 262 B

二、示例代码(按模块整理,可直接运行)

文件名(点击下载)内容大小
示例代码_模块1_NumPy与ndarray.py 模块 1「NumPy 与 ndarray」的全部示例代码(4 段):列表 vs 数组 · ndarray 的三条规矩 · 第一个 NumPy 数组 · 打印与类型陷阱。 2.3 KB
示例代码_模块2_数组的创建.py 模块 2「数组的创建」的全部示例代码(4 段):np.array 建数组 · arange / linspace · zeros / ones / full · reshape。 2.4 KB
示例代码_模块3_属性与一维访问.py 模块 3「属性与一维访问」的全部示例代码(5 段):shape / ndim / size / dtype · 一维索引 · 切片 · 视图与副本 · 花式索引。 2.5 KB
示例代码_模块4_二维访问与布尔索引.py 模块 4「二维访问与布尔索引」的全部示例代码(4 段):二维索引 · 二维切片 · 视图 · 布尔索引。 2.7 KB
示例代码_模块5_数组的运算.py 模块 5「数组的运算」的全部示例代码(4 段):转置 T · 逐元素运算 · 点积 dot · 广播机制。 2.8 KB
示例代码_模块6_统计运算与axis.py 模块 6「统计运算与 axis」的全部示例代码(5 段):常用统计函数 · 累计运算 · axis 参数 · 成绩表按行 / 按列统计 · 打印控制。 4.0 KB
示例代码_模块7_数组操作与综合.py 模块 7「数组操作与综合」的全部示例代码(16 段):排序 sort · reshape / ravel · concat · 成绩表综合案例 · 加权总分 · 前三名 · 教材股票组合案例(np.where / matmul / argmin + divmod) · 张量。 12.0 KB

三、课后作业参考答案

文件名(点击下载)内容大小
第7章_课后作业_参考答案.py 课后作业参考答案:① 数组基本功(arange vs linspace、4×5 随机矩阵统计);② np.arange(1, 51).reshape(5, 10) 的五种取法;③ 8×4 成绩矩阵统计(axis / argmax / 前三名);④ 课件成绩表加权总分 + 两个思考问;附教材「股票分析」8 个小问。自包含只依赖 numpy,直接运行。 14.6 KB

四、一次打包下载

第7章_代码与数据_资料包.zip21.6 KB · 全部文件

把上面的数据、7 个模块示例代码、作业答案和使用说明打成一个 zip,解压后直接可用。

⬇ 下载 第7章_代码与数据_资料包.zip(21.6 KB)

解压后建议先看 README_使用说明.md;运行示例前确认已安装 numpy。
说明:数据文件与页面示例完全一致(随机种子固定,可复现);下载的示例代码与页面上的代码逐段对应(其中排除了页面上标注「故意报错」的 4 段,这些示例运行会中断,请到页面查看)。若发现文件缺失或代码跑不通,欢迎反馈。
结

知识点总结卡 · 易错清单 · 作业

复习用:下面每一条都能自己讲出来,这一章就算过关

一、知识点总结卡

NumPy 与 ndarray

  • NumPy = Numerical Python,开源科学计算库
  • 核心对象 ndarray:多维、同类型、定长数组
  • 导入惯例:import numpy as np
  • 列表只能"逐个搬运",数组可以"整批运算"(向量化)
  • 是 pandas / matplotlib / sklearn / PyTorch 的共同底座
  • print 数组是 [1 2 3](元素间无逗号)

创建数组

  • np.array(列表):从列表 / 嵌套列表创建
  • np.arange(起, 止, 步):不含止
  • np.linspace(起, 止, 个数):含两端
  • np.zeros / ones / full(shape, 值)、np.eye(n)
  • reshape(2, 3) 改形状;-1 让 NumPy 自己算
  • 元素总数必须匹配,否则 ValueError

属性与访问

  • shape 形状元组、ndim 维数、size 元素数、dtype 类型
  • 一维:a[3]、a[-1];切片 a[0:3]、a[::2]、a[::-1]
  • 切片是视图,改切片会改原数组;要副本用 .copy()
  • a[[1,2,5]] 列表下标:可选乱序 / 重复,得到副本
  • 二维:a[行, 列];a[0] 是整行;a[:,0] 是整列
  • a[a > 15] 布尔索引:先造掩码再挑选

运算

  • a.T 转置:交换两个轴;一维转置不变
  • + - * / ** 都是逐元素运算
  • * 不是矩阵乘法!矩阵乘法用 np.dot(a, b) 或 a @ b
  • 一维·一维 dot = 内积(一个数);(m,k)·(k,n) = (m,n)
  • 广播:形状从右往左对齐,相等或其中一个是 1 就能算
  • 形状不兼容会报 ValueError

统计与 axis

  • min / max / mean / sum / std / var / argmax / argmin
  • 不写 axis:对整个数组算,得到一个数
  • axis=0:沿第 0 轴压掉行 → 每列出一个数
  • axis=1:沿第 1 轴压掉列 → 每行出一个数
  • 一句话:axis 就是你要压掉的那一维
  • argmax() 返回的是下标不是值

排序与变形

  • np.sort(x) 返回新数组,不改原数组
  • x.sort() 原地排序,原数组被改
  • 二维排序要指定 axis,np.sort 默认 axis=-1
  • reshape 改形状;ravel 拉平(尽量返回视图)、flatten 拉平(返回副本)
  • np.concatenate / vstack / hstack 拼接
  • np.argsort(x) 返回排序后的下标,取前几名很好用

二、易错清单(都在这台机器上真实踩过)

现象 / 报错原因正确做法
a * b 的结果跟手算的矩阵乘法对不上 * 是逐元素相乘 矩阵乘法用 np.dot(a, b) 或 a @ b
改了切片,原数组跟着变了 切片是视图不是副本 要独立副本用 a[0:3].copy()
np.arange(0, 5) 里没有 5 arange 是"含头不含尾" 要含 5 用 arange(0, 6),或换 linspace(0, 5, 6)(linspace 含两端)
axis=0、axis=1 结果跟预期反了 把"沿哪个轴"理解成了"结果有几行" 记住 axis 是压掉的那一维:axis=0 压行 → 每列一个数
ValueError: operands could not be broadcast together 两个数组形状无法广播 用 reshape 调成可广播形状;先看 a.shape 和 b.shape
ValueError: cannot reshape array of size 6 into shape (4,) 元素总数不匹配 元素数 6,只能拆成 1×6 / 2×3 / 3×2 / 6×1
IndexError: index 5 is out of bounds for axis 0 with size 5 下标越界(长度为 5,最大下标是 4) 下标从 0 开始;倒序访问用负数 a[-1]
打印出来是 [np.float64(1.5), np.float64(2.5)] 把 numpy 标量放进了 Python 列表 转成普通数:arr.tolist() 或 float(v)
np.array([1, 2.5, 'a']) 全变成了字符串 数组要求元素同类型,会自动向上统一 混合类型不要放进同一个数组;分别存或用结构化数组
两次运行结果不一样 用了 np.random 却没固定种子 先 np.random.seed(0),结果可复现
一维数组 a.T 好像没变化 一维只有 1 个轴,转置没有可交换的对象 一维转置就是它自己;要当"行向量"用 a.reshape(1, -1)
用 x.sort() 后 x 变了才知道被改 方法是原地排序 不想改原数组就用 np.sort(x)(返回新数组)

三、课后作业(四题,都要"用数组算",不许写 for 循环逐元素处理)

本章作业

  1. 数组基本功:用 arange 和 linspace 各生成 0~1 之间的 11 个点,比较两者差别;再生成一个 4×5 的随机整数矩阵(1~100,固定种子),打印 shape / ndim / size 与全表最大 / 最小 / 平均。
  2. 索引练习:给定 np.arange(1, 51).reshape(5, 10),分别取出:第 2 行、第 3 列、右下角 2×3 的子块、所有大于 40 的元素、所有是 3 的倍数的元素(提示:布尔索引 + %)。
  3. 成绩统计:自己造一个 8 名学生 × 4 门课的整数成绩矩阵(60~100,固定种子),输出:每门课平均分(axis=0)、每个学生总分(axis=1)、每门课最高分及其学生下标(argmax)、总分排名前三的学号。
  4. 综合:把课件成绩表(10 名学生 5 门课)的加权总分算出来,再回答两问:① 加权总分比简单平均分更适合衡量什么?② 如果把语文权重从 0.25 提到 0.40、数学降到 0.10,谁的名次变化最大?用代码算,不要用眼看。
  5. 教材拓展 · 股票组合:用 np.random.seed(25) 生成 4 只股票 × 5 个交易日的涨跌幅(np.round(np.random.rand(4, 5) * 3 - 1.5, 2) / 100),权重 [0.15, 0.20, 0.25, 0.40]:① 用布尔索引 + np.where 找出“跌幅超过 1%”的位置;② 用 np.matmul(weight, stocks) 算每日组合收益率,再按 100 万本金算 5 个交易日的总收益;③ 用 np.argmin + divmod 找出最小涨幅落在哪只股票、哪一天。数据文件在本页「配套代码与数据下载」里。

提交要求:每题给出代码 + 运行结果截图;不允许用 for 循环逐元素计算(统计排名时可以 sorted 处理下标列表);变量名要能读懂。

四、下讲预告

第 8 次课 · 第 8 章 Pandas 数据处理与分析
Series 与 DataFrame · 数据导入与导出 · 数据清洗与预处理 · 查询 / 分组 / 透视 · 连接与合并 —— 真正开始"处理表格"
进入第 8 次课 →
本章自测(不查资料,先自己在纸上写)
  1. NumPy 数组和 Python 列表,最少说出三点不同。
  2. np.arange(1, 10, 3) 和 np.linspace(1, 10, 3) 分别得到什么?
  3. 一个数组 a 的 shape 是 (4, 6),那么它的 ndim 和 size 各是多少?a[:, 2] 得到几个数?
  4. a * b 和 np.dot(a, b) 有什么区别?举一个两者结果不同的例子。
  5. 二维数组 np.mean(a, axis=0) 得到几个数?分别代表什么?axis=1 呢?
  6. np.sort(x) 和 x.sort() 有什么本质区别?
  7. 为什么说"切片是视图"是个坑?怎么避免踩到?