① 元素类型必须相同
- 一个数组只有一个
dtype - 写的时候混了不同类型,NumPy 会自动“向上提升”成同一种
- 好处:每个元素占一样多的字节,能等距排布
NumPy 与 ndarray · 数组的创建 · 属性与访问 · 布尔索引 · 数组运算(转置 / 点积 / 广播)· 统计运算与 axis · 排序与变形 · 成绩表综合案例 · 教材股票拓展案例 · AI 渗透(7 个知识模块 + 1 个交互演示区 + 46 段实测代码 + 17 张插图 + 12 个动态演示图 + 6 个交互面板)
Lesson Overview · 从"一个数一个数地算"到"一整批数一起算"
前六章我们都在用单个数据干活:一个变量、一个列表、一个字典。可现实里的数据是成批的——一个班 40 个人的成绩、一张 1000 行 20 列的表、一张 224×224 的图片。用 for 循环一个元素一个元素地算,代码又长又慢。这一章的主角 NumPy 就是来解决这件事的:它提供一个叫 ndarray 的多维数组对象,让你能把一整批数当成一个对象来算——这叫"向量化"。
这一章的分量很重:第 8 章 pandas 的 DataFrame 底下就是 NumPy 数组,第 9 章 matplotlib 画的所有图也是从数组来的。再往后,机器学习的 scikit-learn、深度学习的 PyTorch,张量(Tensor)的设计思想跟 ndarray 是同一套。所以这一章不是"多学一个库",而是换一种看待数据的方式。
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 变形拼接;⑧ 能独立完成"成绩表"这种多小问的综合题。
点击节点可跳转到对应讲解位置,点击三角可展开 / 收起分支。
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 的三条规矩 · 导入与第一个数组 · 打印与查看的两个坑
从这一章开始,我们处理的对象从“几个数”变成“成千上万个 数”。第 6 章负责把数据从文件里读进内存;读进来之后,数据在程序里就是一大堆数字。如果还是用列表一个个装、用 for 循环一个个算,数据量一上来就会慢到没法用。NumPy 就是为这件事准备的:它提供一个专门装数字的容器 ndarray,以及一整套“整块算”的运算规则。
这一模块先回答三个问题:为什么要把列表换成数组(1.1)、数组有哪些必须遵守的规矩(1.2)、怎么创建并查看第一个数组(1.3、1.4)。整个第 7 章,乃至第 8 章 pandas、第 9 章可视化,都建立在这个容器之上。
先做一个看起来很简单、结果却很让人意外的实验:给一个列表“乘 2”。
nums = [1, 2, 3] nums * 2 # [1, 2, 3, 1, 2, 3] nums + 2 # TypeError:列表不能加数字 # 想要 [2, 4, 6],只能再手写循环 [x * 2 for x in nums]
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 是“复制一遍”,数组的 * 2 才是“每个元素各乘 2”——这一个差别,就是 NumPy 存在的理由* 是“重复”,数组的 * 是“逐元素乘”。想要数学意义上的整体运算,就得先把数据变成数组。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
int64 数组只要 8 MB。数据量越大,这个差距越致命——这也是为什么“数据一大就上 NumPy”。更实际的理由是生态:pandas 的每一列底层就是一个 ndarray;scikit-learn 的输入要求是数组或能转成数组的结构;PyTorch 的 Tensor 和 ndarray 几乎可以无缝互转。学会 ndarray,等于拿到后面所有工具的“通用货币”。
(高, 宽, 3) 的数组,一批图片是 (批大小, 高, 宽, 3) 的数组,一句话的嵌入向量是一个 (768,) 的数组。今天在 NumPy 里把 shape 和索引弄明白,后面看 PyTorch 代码才不会是天书。* 2 是重复,数组的 * 2 是逐元素乘;NumPy 提供数组对象与向量化运算,代码短、速度快、省内存,是 pandas / scikit-learn / PyTorch 的共同地基。课件把 ndarray 的特点总结成两句:存储相同类型的数据、数组的维度和大小要事先确定。再补上第三条——它天生支持多维。这三条不是随便定的,它们正好换来 1.1 里说的“快”和“省”。下面逐条看。
dtypeappend,想加元素只能造一个新数组把这三条和列表放在一起对照,区别就清楚了。注意表格里“运算”那两行——那是 1.1 里最直观的差别。
| 对比项 | Python 列表 list | NumPy 数组 ndarray |
|---|---|---|
| 元素类型 | 可以混,int、str、对象随便放 | 必须统一,整个数组只有一个 dtype |
| 长度 | 随时 append / remove,长度会变 | 创建时固定,改长度只能新建一个 |
| 内存布局 | 指针数组 + 一堆分散的对象 | 一整块连续内存,元素等距排列 |
* 2 的含义 | 把整段重复一次,长度翻倍 | 每个元素各乘 2,长度不变 |
+ 2 的含义 | 直接报 TypeError | 每个元素各加 2 |
| 求和写法 | sum(nums),还行 | arr.sum(),一行且更快 |
| 适合装什么 | 少量、结构复杂、类型杂的数据 | 大量、同类型的数值(成绩、价格、像素、向量) |
“连续内存”到底长什么样?下图把两种结构画出来:列表是“一排指针,指向散落在各处的对象”;数组是“一整条等宽的传送带,旁边挂一张纸条写着它是怎么排的”。
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]
[1, 2, 3.5] 里混了整数和小数,整个数组被提升成 float64;[1, 2, '3'] 里混进了字符串,于是所有元素都变成字符串,数字 1 也变成了 '1'。这不是 bug,是“类型必须相同”这条规矩在起作用:NumPy 会找一种能装下所有元素的类型。所以建模、计算时一定要保证数组里都是数字,不然算出来的结果会让你莫名其妙。用 NumPy 的第一步永远是导入。惯例写法是 import numpy as np——np 是全世界通用的别名,别人的代码、教程、公司项目都这么写,跟着写就不会错。导入之后,用 np.array() 把列表变成数组。
创建好之后第一件事是“看它一眼”。这里有一个教材和屏幕不一致的细节,很多同学第一次看会以为自己的输出错了:课件和书上写的是 array([1, 2, 3]),而你 print 出来是 [1 2 3]——没有逗号,也没有 array 这个词。两个都对,只是“给谁看”不一样。
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);交互式环境里直接敲 arr | array([1, 2, 3]) | repr(),给“程序员看”的精确格式 |
arr.tolist() | [1, 2, 3](真正的 Python 列表,带逗号) | tolist(),数组转回列表 |
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])。第一个数组跑通了,接下来最容易踩的坑都在“输出”上。这两个坑不影响计算结果,但会让你的输出难看、甚至对不上课件,考试时也容易误判。
坑一:把 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)。
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() 是最直接的造法:把现成的 Python 数据“倒”进数组。它接受列表,也接受元组;传一个嵌套列表就得到二维数组,外面的列表是行,里面的列表是列。
类型(dtype)默认自动推断:全是整数就是 int64,出现小数就是 float64。如果推断的结果不是你想要的,用 dtype= 明确指定——指定成 int 时,小数部分会被直接截断(不是四舍五入),这一点很容易掉坑。
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 会截断小数);嵌套列表每层长度必须一致,否则直接报错。如果数据不是现成的,而是“从 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 个点)。
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。做数据分析时经常需要“先摆一个空表,再往里填数”——比如先建一个 10×5 的成绩表,再去逐格赋值。这类需求就用占位函数:zeros() 全 0、ones() 全 1、full() 填任意值、eye() 造单位矩阵(对角线是 1、其余是 0)。
它们的参数都是 shape:传一个整数表示一维(长度为几),传一个元组表示多维(每维多长)。这里有个新手必踩的坑——np.zeros(3) 和 np.zeros((2, 3)) 都对,但 np.zeros(2, 3) 是错的,那会被理解成传了两个参数。
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。数组造好之后,形状不一定合适。比如 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) 就是“拉平”。
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 说的“大小固定”的延续。
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 的“视图”概念,如果不弄明白,后面做数据清洗时“改着改着原数据就变了”会一直困扰你。
NumPy 对象的属性不用加括号(它们不是函数),直接点出来就行。最重要的三个是:shape(形状)、ndim(维度数)、size(元素总数),再加一个 dtype(元素类型)。
三个数的关系非常好记:ndim 就是 shape 这个元组里有几个数;size 就是 shape 里各维相乘。一维数组的 shape 写成 (10,)——注意那个逗号,它是元组的标记,不是笔误,少了逗号就变成普通括号里的一个数了。
shape 告诉你每维多长,ndim 告诉你几维,size 告诉你一共几个数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 说明元素类型。属性不加括号。访问一维数组的写法是 数组名[下标]。和列表完全一样:下标从 0 开始,所以 a[3] 取的是第 4 个元素;a[-1] 表示倒数第一个,a[-2] 是倒数第二个。负下标是“从右往左数”,用熟了非常方便。
| 数组 a | 10 | 12 | 14 | 16 | 18 | 20 |
|---|---|---|---|---|---|---|
| 正下标 | 0 | 1 | 2 | 3 | 4 | 5 |
| 负下标 | -6 | -5 | -4 | -3 | -2 | -1 |
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。只取一个元素用索引,取一段就用切片。写法是 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] 覆盖的范围——连续的一段:
| 0 | 1 | 2 | 3 | 4 | 5 | |
|---|---|---|---|---|---|---|
| a | 10 | 12 | 14 | 16 | 18 | 20 |
| 负下标 | -6 | -5 | -4 | -3 | -2 | -1 |
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 新手最容易翻车的地方。下面用代码证明给你看。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();② 做完切片后要修改它——先想清楚“我是要改原数组,还是只要改这一段”,要改原数组就用视图(这是 NumPy 省内存的设计),只改自己就 copy;③ 判断方法很简单:np.shares_memory(a, s) 返回 True 就是视图。a[start:stop:step] 左闭右开;a[:3]、a[::2]、a[::-1] 是常用写法;切片是视图,和原数组共享内存,改切片会改原数组,要独立副本必须 .copy()。切片只能取“连续的一段”(或者按固定间隔取)。如果我要的是不连续的几个位置——比如第 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[3]、a[-1]、a[0:3]、a[[1, 2, 5]] 各自从数组里取出哪几个数:
a[[1, 2, 5]] 按“位置清单”一次取多个不连续元素,可以乱序、可以重复;得到的是副本,改它不影响原数组。这一模块一共学了四种从数组里取数的写法。它们看起来只差几个符号,语义却完全不同,考试和上机最容易混。下面这张表把它们一次对齐——写代码前扫一眼,能省掉大半调试时间。
| 写法 | 例子 | 取到什么 | 视图还是副本 | 能乱序 / 重复吗 |
|---|---|---|---|---|
| 单个索引 | a[3]、a[-1] | 一个元素(numpy 标量) | 标量,谈不上视图 | — |
| 切片 | a[0:3]、a[::2]、a[::-1] | 一段连续或等间隔的元素 | 视图(共享内存) | 不能乱序,不能重复 |
| 列表下标 | a[[1, 2, 5]] | 指定位置的若干个元素 | 副本(独立内存) | 可以乱序,可以重复 |
| 布尔掩码 | a[a > 15] | 条件为 True 的那些元素 | 副本 | 按条件自动筛选 |
表格最后一行是下一个模块(4.3 布尔索引)的内容,现在只要记住“它也是副本”就够了。上机前先过一遍下面这份自测清单:
a = np.arange(10, 21, 2),a[-1] 是 ______,a[-3] 是 ______。(答案:20;16)a[1:4] 取到几个元素?分别是哪几个?(答案:3 个,12、14、16)s = a[1:4]; s[0] = 0 之后,a[1] 变成多少?为什么?(答案:0,因为切片是视图)b = a[[0, 2]]; b[0] = 0 之后,a[0] 变了吗?(答案:没变,列表下标是副本)a[::-1] 的结果改动不影响原数组,应该怎么写?(答案:a[::-1].copy())a[i] 取一个(标量)、a[i:j] 取一段(视图)、a[[...]] 取任意位置(副本)、a[mask] 按条件筛(副本,下一模块细讲)。a[行, 列] 两个下标定位 · a[0] 是整行 · a[:, 0] 是整列 · 冒号 : 表示这一维全要 · 布尔掩码先造再挑
第三个模块里我们只跟一维数组打交道,一个下标就能指到某个元素。二维数组不一样了:它是一张表格,横着有行、竖着有列,要指到一个具体的格子,就得给两样信息——第几行、第几列。所以访问二维数组的基本写法是 a[行, 列];如果只给一个数字,NumPy 会理解成“你只限定了行”,把它交给你一整行。
除了“按坐标拿”,还有一种更常用的拿法:按条件拿。比如“把这 20 个分数里大于 80 的全挑出来”,用下标一个个挑太笨了,NumPy 的做法是先算出一个布尔数组(一串 True / False),再用这串 True / False 去原数组里“筛”。这就是本模块的第二个重点——布尔索引。
二维数组的每个元素由两个下标确定,写在同一对方括号里,中间用逗号隔开: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] 才是一次性定位,一步到位。
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 2 3 4]),第二次在这个一维数组上取下标 1。而 a[0, 1] 是 NumPy 一次定位,直接算偏移、不产生中间结果。数据量大、在循环里反复取的时候,这个差别会变成真金白银的时间。a[行, 列],都从 0 开始;只给一个下标 a[0] 拿到的是整行(一维数组);想拿单个元素,两个下标一个都不能少。二维数组的每一个维度都能像一维那样“切”,两个维度之间还是用逗号隔开:a[行怎么取, 列怎么取]。冒号 : 的意思是“这一维我全要”——一个冒号占了位置,就等于把这一维原样留下。下面用这个 3×4 的数组举例:a = np.array([[1, 2, 3, 4], [5, 6, 7, 8], [9, 10, 11, 12]])。
a[0:2]:行取前两行,列没写就相当于第二维全要 → 形状 (2, 4);a[:, 0]:行全要、列只要第 0 列 → 整列,是一维数组,形状 (3,);a[:, [0, 2]]:行全要、列按列表挑第 0、2 列 → 形状 (3, 2);a[0:2, 1:]:行取前两行、列从下标 1 到最后 → 形状 (2, 3)。下面这张矩阵图把两个方向分开标了出来:绿色那一整行是 a[0](横着取一整行),橙色那一整列是 a[:, 0](竖着取一整列)。同样都是一维结果,方向却差 90 度——区别只有一个:逗号左边管行、右边管列。
| 列 0 | 列 1 | 列 2 | 列 3 | |
|---|---|---|---|---|
| 行 0 | 1 | 2 | 3 | 4 |
| 行 1 | 5 | 6 | 7 | 8 |
| 行 2 | 9 | 10 | 11 | 12 |
a[0](横着取,形状 (4,)) · 橙色整列 = a[:, 0](竖着取,形状 (3,)) · 两个方向差 90 度有一个特别容易忽略的细节:a[:, 0] 和 a[:, 0:1] 看着差不多,形状却不一样。用整数下标取一列,第二维就被“压掉”了,结果是一维的 (3,);用切片 0:1 取,第二维还在,结果是二维的 (3, 1)。这一点在后面的拼接、矩阵乘法里会直接影响能不能算,先记住“整数下标降维、切片保维”。
| 1 |
| 5 |
| 9 |
整数下标把第 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));切片是视图,改它会改原数组。逐个算下标太累,现实中的需求往往是“把满足某个条件的元素都挑出来”。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]。下图就是这个“掩码 → 结果”的映射。
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()(或 @)。这两个符号长得像、结果差得远,是这门课最容易翻车的地方,第五节会把同一对数组两种算法摆在一起对照。
转置的意思很朴素:把行和列换过来。原来第 0 行,转置后就变成第 0 列;原来第 1 行,变成第 1 列。写法就是在数组后面加一个 .T:a2.T。
形状怎么变?记住一句话:把 shape 元组前后颠倒。原来 (2, 3)(2 行 3 列),转置后就是 (3, 2)(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 完全一样。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。如果你拿 * 去算“矩阵乘矩阵”,程序不会报错,只会安安静静给你一个完全错误的结果——这种错最难查。下一节用同一对数组把两种乘法摆在一起看。+ - * / ** // % 全部逐元素运算,要求形状相同(或能广播);数组和标量算时标量自动铺到每个位置;* 是逐元素相乘,不是矩阵乘法。矩阵乘法在 NumPy 里由 np.dot() 完成,也可以写成运算符 @(Python 3.5 起支持),两者结果完全一样。它的算法是“左边的行 × 右边的列,乘完再相加”:结果的第 i 行第 j 列,等于左边第 i 行和右边第 j 列对应相乘再求和。
两种情形要分清(课件 7.2 的原文):
[1, 2, 1] 和 [3, 4, 5] → 1×3 + 2×4 + 1×5 = 16。(m, k) 乘 (k, n),结果是 (m, n)。左边矩阵的列数必须等于右边矩阵的行数(都是 k),否则接不上、直接报错。下面用同一对 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。
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(逐元素)完全是两回事。逐元素运算要求形状相同,可有时候我们偏偏想让形状不一样的数组算——比如一个 (3, 3) 的矩阵,每一行都加上同一个 [100, 200, 300]。难道要先把 [100, 200, 300] 复制成三行吗?不用。NumPy 有一套广播(broadcasting)规则,会“概念上”把这个短数组铺开,用不着真的复制内存。
拿 (3, 3) + (3,) 试:从右往左比,最右边那个 3 和 3 相等——过;左边 (3,) 没有第二维了,相当于 1——过。于是短数组被“复制”到每一行,结果形状是 (3, 3)。这就是为什么 (3,3) + (3,) 能算。
1 2 3 4 5 6 7 8 9
100 200 300 100 200 300 100 200 300
反例更能说明规则:(3, 3) + (2,) 从右往左比,3 和 2 既不相等、也没有一个是 1,规则不满足,直接报错。下面两栏对照,把“过”和“不过”摆在一起。
从右往左对齐:
3 3
3 ← 左边缺这一维,按 1 看
每一对:3=3 相等,3 与 1 里有一个 1
→ 可以广播,结果形状 (3, 3)
从右往左对齐:
3 3
2 ← 3 与 2 既不相等也不是 1
→ ValueError: operands could not be
broadcast together with shapes
(3,3) (2,)
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)
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,)
ValueError;(3,3)+(3,) → (3,3),(3,1)*(1,4) → (3,4)。它是“选学但重要”,因为后面 pandas、机器学习里到处都是它。12 个统计函数(sum / mean / max / argmax / std / cumsum…)· axis=0 压行、axis=1 压列 · 用统计函数做成绩小结 · 打印陷阱
“统计”是数据分析最日常的动作:这一列的平均分多少?最高分是谁?波动大不大?NumPy 把这些算好了,函数名也直白:np.sum 求和、np.mean 平均、np.max 最大……难点不在名字,在二维数组的 axis:同一个 np.sum(a),加不加参数、参数写 0 还是 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 几乎不动。
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
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
sum / prod 汇总,min / max / mean / percentile 找位置(另补 median 对照),argmax / argmin 给下标,std / var 量波动,cumsum / cumprod 给“到目前为止”的累计;多数函数用 np.xxx(x) 或 x.xxx() 两种写法都行,但 np.percentile / np.median 只有函数写法。一维数组没什么好选的,只有一个方向。二维数组有两个轴:第 0 轴是行方向,第 1 轴是列方向。做统计的时候要告诉 NumPy“沿哪个轴缩”,这个参数就是 axis。
不写 axis 时,NumPy 把整个数组拍平了算,得到一个数。写了 axis,就是“把那一维压掉”,结果里少一维、每个剩下的位置出一个数:
axis=0:沿第 0 轴(行方向)把行压掉 → 每一列出一个数,结果是 4 个数,形状 (4,)(3 行 4 列的矩阵);axis=1:沿第 1 轴(列方向)把列压掉 → 每一行出一个数,结果是 3 个数,形状 (3,)。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 是你要压掉的那一维。把 axis 用起来,一张成绩表能一次算出好几份小结。假设 3 名学生考了 4 门课,成绩表 s 是 3 行 4 列——行是学生,列是课程。这时候 axis 的语义就有了业务含义:
np.mean(s, axis=0) → 每门课的平均分(4 个数)np.max(s, axis=0) → 每门课的最高分np.max(s, axis=1) → 每名学生的最高分(3 个数)np.sum(s, axis=1) → 每名学生的总分还有一个细节:np.argmax(s) 不写 axis 时,会把整张表拍平成一维再找最大值的位置,得到的是一个“压平后的下标”。想把它还原成“第几行第几列”,用整除和取余就行:行 = 下标 // 列数,列 = 下标 % 列数。下面 demo 里算的就是这个。
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=1 得每名学生的统计(最高 / 最低 / 总分);argmax 不写 axis 给的是压平后的下标,用 下标 // 列数 和 下标 % 列数 还原行列。最后讲一个几乎所有新手都会撞上的显示问题。单独打印一个 numpy 标量是没问题的——print(np.mean(x)) 会老老实实打出 20.75,因为它走的是字符串转换。可一旦把这个标量放进列表再打印,Python 会去调它的 repr(),于是输出变成 [np.float64(20.75), np.int64(27), np.int64(10)]——一串带着类型名的丑东西。写作业、做报告、把结果贴进文档时,这个尾巴非常碍眼。
NumPy 2.x 对这一点比旧版更“诚实”(旧版里 repr 少了类型名),所以这个坑现在更容易碰到。两类解法,按场景选:
float(np.mean(x))、int(np.max(x)),需要两位小数就再套 round(..., 2);arr.tolist(),它会把每个元素都转成 Python 原生数;如果只是想看看数组内容,直接 print(arr) 也干净(得到 [19 14 25] 这种样式)。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),但一般没必要。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 框架里长什么样。装完你会发现,综合题的四问其实就是四句“把数据压成什么形状”的选择题。
排序是数据处理的第一个动作:排名次、找最大、取前 N 名,底下都是排序。NumPy 给了两个入口,长得几乎一样,但改不改原数组完全是两回事:
np.sort(x) 是 NumPy 的函数——名字前面是 np.,必须把数组当参数传进去;它返回一个排好序的新数组,x 一个元素都不动。x.sort() 是 ndarray 的方法——名字前面是数组自己,不用再传数组;它原地排序,把 x 里的元素位置直接改掉,返回值是 None。y = np.sort(x) # x 不动,y 是新数组 print(x) # 还是原来的顺序 print(y) # 从小到大排好了
x.sort() # 不返回数组,x 自己变了
print(x) # 已经是排好序的
y = x.sort() # ✗ 这样写 y 是 None
# 不是排好序的数组
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 才是同一列上下排,元素的列号不变、行号变。
| x | 0 | 1 | 2 |
|---|---|---|---|
| 0 | 0 | 4 | 3 |
| 1 | 2 | 2 | 1 |
| np.sort(x) | 0 | 1 | 2 |
|---|---|---|---|
| 0 | 0 | 3 | 4 |
| 1 | 1 | 2 | 2 |
| axis=0 | 0 | 1 | 2 |
|---|---|---|---|
| 0 | 0 | 2 | 1 |
| 1 | 2 | 4 | 3 |
三张表的行号、列号是原来的下标。默认排序时,每一行自己排自己的(第 0 行的 4 和 3 换了位置,第 1 行的 1 跑到最前);axis=0 时,每一列上下排自己的(第 0 列 0、2 不变,第 1 列 4、2 变成 2、4,第 2 列 3、1 变成 1、3)。
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]]
np.argsort(x)——它返回的是下标而不是分数,按这个下标去原数组里取,就能把“值”和“人”重新对上。7.3 找总分前三名,用的正是它。np.sort(x) 是函数,返回排好序的新数组、原数组不动;x.sort() 是方法,原地排序、返回 None。二维排序必须想清楚 axis:默认 axis=-1(二维时是每行内部排),axis=0 才是同一列上下排。要保留元素原来的位置,用 np.argsort。数组的形状经常“不合用”:模型要 (样本数, 特征数),你手上是一长条;两个月的销量分在两个数组里,要接成一个。NumPy 里这两类活儿分得很清楚——变形不改变元素个数(只换一种“看法”),拼接会改变元素个数(真的多了东西)。
-1 占位,让 NumPy 自己算那一维ValueErrorravel() 尽量返回视图(连续内存时是视图,非连续时会自动复制),改视图会动到原数组flatten() 返回副本,随便改concatenate 沿指定轴拼vstack 竖向加行、hstack 横向加列append 末尾追加,每次新建数组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,否则它不知道该怎么猜。
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 里“切片是视图不是副本”是同一个道理。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) 横向接。
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 门课的成绩,成绩范围均为 50~100 分,学号分别为 100~109,要求利用 NumPy 数组完成以下操作。”但它把整章用得上的东西全串了一遍:建数组 → axis 统计 → 点积加权 → 排序取前三。四小问层层递进,每一问都在回答同一个问题——这次要压掉哪一维。
先把课件那张表原样敲进一个二维数组:每一行是一名学生、每一列是一门课。这个“行 = 样本、列 = 特征”的摆放方式不是随便定的,它是数据分析里最通用的约定——后面 pandas 的 DataFrame、机器学习的训练集,全是这个方向。
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]]
要算“每门课”的统计量,就是把这 10 名学生叠起来算:同一个位置的 10 个分数归约成 1 个数,5 门课得到 5 个数。scores 的形状是 (10, 5),第 0 维是学生、第 1 维是课程,所以 axis=0 压掉的正是“学生”这一维,结果长度是 5。
axis=0 是“沿行方向压下去”——把 10 行压成 1 行,留下 5 列,每列一个数。课件把这句说成“按行统计”,意思是把行压掉,不是“每行算一个”,读的时候要分清。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.70 | 98 | 52 |
| 数学 | 76.60 | 97 | 52 |
| 英语 | 67.30 | 98 | 50 |
| 生物 | 79.80 | 99 | 52 |
| 历史 | 68.90 | 85 | 50 |
这张表就是 avg / hi / lo 三个数组的样子,和上面 demo 的输出逐字一致。读表时可以顺便下个结论:生物平均最高(79.8)、英语平均最低(67.3);最高分全表 99 分(生物,学生 105),最低分 50 分(英语、历史)。
换个问法,axis 就跟着换。“每个学生”是一行一算:把一行里的 5 门课压成 1 个数,10 行得到 10 个数,所以这次压掉的是第 1 维(课程),写 axis=1。顺手用 np.argmax(scores, axis=1) 把“最高分是哪一门课”也查出来——argmax 返回的是下标(0~4),拿它去索引课程名列表就行。
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 自然就定了,比背“按行还是按列”可靠得多。最后一问最简单也最像“真实业务”: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 个总分
总分[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 个权重",
一一相乘再相加 —— 点积的定义。
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
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 排下标,再拿下标去学号数组里取人。
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 名 | 100 | 83.9 | order[-1] = 0 → ids[0] = 100 |
| 第 2 名 | 105 | 82.45 | order[-2] = 5 → ids[5] = 105 |
| 第 3 名 | 106 | 74.5 | order[-3] = 6 → ids[6] = 106 |
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 的活儿。工具换了,思路一模一样。
np.array 建 10×5 的表、axis=0 得每门课的统计、axis=1 得每个学生的统计、np.dot(scores, weight.T) 把 5 门成绩按权重压成 1 个总分、np.argsort 找出前三名。想清楚“要压掉哪一维”,axis 就不会写错;想清楚“要升序还是降序”,argsort 的那一刀就不会切反。课件最后一题是成绩表,教材第 7 章还配了一个更“业务”的案例:4 只股票、5 个交易日的涨跌幅,按 15% / 20% / 25% / 40% 的配置比例组成一个投资组合,问“每个交易日的组合收益率是多少、5 天总共赚(亏)了多少”。它把这一章学的东西又串了一遍,而且多出三个以前没露面的工具:np.where(布尔索引的“位置版”)、np.matmul(矩阵乘法的另一种写法)、np.argmin + divmod(把压平的下标还原成行列)。
np.random.seed(25),生成 (4, 5) 的随机数后先 np.round(..., 2)、再 / 100,得到形如 -0.0115(即 −1.15%)的“小数形式涨跌幅”。下面用三段代码把它跑一遍;同样的数据也放在本页下方的「配套代码与数据下载」里(股票涨跌幅数据.csv),可以直接下载对照。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
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 日”。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 定位最小涨幅。数据文件可在本页下载区取用。这一章学的 ndarray,在 AI 工程里有一个几乎一模一样的“亲戚”——PyTorch 的 Tensor(张量)。两者不是“像”,而是同构:形状、类型、索引、切片、广播、点积、按轴归约,一套概念两边通用,连函数名都大半重合。学会 ndarray,等于提前学会了 Tensor 的 80%;剩下 20% 里最要紧的那一点,是 Tensor 多了一个“算在哪”的属性。
| 要做的事 | NumPy(ndarray) | PyTorch(Tensor) |
|---|---|---|
| 看形状 | a.shape | t.shape |
| 看元素类型 | a.dtype | t.dtype |
| 看算在哪 | 只能在内存(CPU) | t.device:cpu / cuda |
| 取一块 | a[0, 1:3] | t[0, 1:3] |
| 逐元素运算 | a * 2 + 1 | t * 2 + 1 |
| 矩阵乘 | np.dot(a, b) / a @ b | t @ 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(开算)。
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。
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 逐字对齐
对应 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 节)。
点上面的按钮试试
对应 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。
点上面的按钮试试
对应 7.3 节(课件课后题)。成绩表固定:scores.shape = (10, 5),行是学生(学号 100—109),列是语文 / 数学 / 英语 / 生物 / 历史。改这 5 个权重,页面会实时检查“权重和是不是 1”,点按钮就能算出 np.dot(scores, weight) 的 10 个加权总分,并列出前三名。总分是 100 分制,权重和必须等于 1,否则算出来的数没有意义。
点上面的按钮试试
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 个模块示例代码、作业答案和使用说明打成一个 zip,解压后直接可用。
复习用:下面每一条都能自己讲出来,这一章就算过关
ndarray:多维、同类型、定长数组import numpy as npprint 数组是 [1 2 3](元素间无逗号)np.array(列表):从列表 / 嵌套列表创建np.arange(起, 止, 步):不含止np.linspace(起, 止, 个数):含两端np.zeros / ones / full(shape, 值)、np.eye(n)reshape(2, 3) 改形状;-1 让 NumPy 自己算ValueErrorshape 形状元组、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 @ bdot = 内积(一个数);(m,k)·(k,n) = (m,n)ValueErrormin / max / mean / sum / std / var / argmax / argminaxis=0:沿第 0 轴压掉行 → 每列出一个数axis=1:沿第 1 轴压掉列 → 每行出一个数argmax() 返回的是下标不是值np.sort(x) 返回新数组,不改原数组x.sort() 原地排序,原数组被改axis,np.sort 默认 axis=-1reshape 改形状;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)(返回新数组) |
arange 和 linspace 各生成 0~1 之间的 11 个点,比较两者差别;再生成一个 4×5 的随机整数矩阵(1~100,固定种子),打印 shape / ndim / size 与全表最大 / 最小 / 平均。np.arange(1, 51).reshape(5, 10),分别取出:第 2 行、第 3 列、右下角 2×3 的子块、所有大于 40 的元素、所有是 3 的倍数的元素(提示:布尔索引 + %)。axis=0)、每个学生总分(axis=1)、每门课最高分及其学生下标(argmax)、总分排名前三的学号。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 处理下标列表);变量名要能读懂。
np.arange(1, 10, 3) 和 np.linspace(1, 10, 3) 分别得到什么?a 的 shape 是 (4, 6),那么它的 ndim 和 size 各是多少?a[:, 2] 得到几个数?a * b 和 np.dot(a, b) 有什么区别?举一个两者结果不同的例子。np.mean(a, axis=0) 得到几个数?分别代表什么?axis=1 呢?np.sort(x) 和 x.sort() 有什么本质区别?