当前位置：首页 > news >正文

python中numpy库学习笔记(2)

news 2025/11/11 7:46:27

1.统计分析函数

1.mean/median/std/sum

1.np.mean()：计算均值

功能：求数组元素的算术平均值

2.np.median()：计算中位数

axis：指定计算维度（默认展平数组）。
keepdims：是否保留原数组维度（默认 False）

功能：求数组元素的中位数（将数据排序后位于中间的数值，对异常值不敏感）

3.np.std() / np.var()：标准差与方差

功能：std 计算标准差（数据离散程度的度量，值越大越分散）；var 计算方差（标准差的平方）。

4.np.min() / np.max()：最小值与最大值

功能：返回数组中的最小 / 最大值。

5.np.sum() / np.prod()：求和与求积

功能：sum 计算所有元素的和；prod 计算所有元素的乘积。

6.np.ptp()：极差（全距）

功能：计算最大值与最小值的差（max - min），反映数据的范围。

'''
import numpy as np#1.计算均值
data = np.array([1, 2, 3, 4, 5, 100])  # 包含一个异常值100
print(np.mean(data))  # 结果：19.166...（受异常值影响较大）#2.计算中位数
print(np.median(data))  # 结果：3.5（不受100影响，更稳健）#3.标准差和方差
data1 = np.array([1, 2, 3, 4, 5])
data2 = np.array([1, 3, 5, 7, 9])
print(np.std(data1))  # 结果：1.414（波动小）
print(np.std(data2))  # 结果：2.828（波动大）#4.求和和求积
print(np.sum([1, 2, 3]))  # 6
print(np.prod([2, 3, 4]))  # 24（2×3×4）#5.最小值和最大值
data = np.array([5, 2, 9, 1, 7])
print(np.min(data))  # 1
print(np.max(data))  # 9#6.极差
print(np.ptp(data))  # 8（9-1）'''

2.argmax/argmin

np.argmax()、np.argmin()

功能：返回数组中最大值（argmax）或最小值（argmin）所在的索引位置（默认返回第一个出现的极值索引）。

参数：axis:指定在哪个维度计算，默认None,将数组展平为一维计算

注意：

若数组有多个相同的极值，只返回第一个出现的索引。
对高维数组，axis 参数需明确（否则默认展平为一维）。
#一维数组
import numpy as np
arr = np.array([3, 1, 4, 1, 5, 9, 2, 6])# 最大值的索引（值为9，位于索引5）
print(np.argmax(arr))  # 5
# 最小值的索引（值为1，位于索引1）
print(np.argmin(arr))  # 1#多维数组
# 二维数组：每行代表一个学生的3科成绩
scores = np.array([[80, 95, 85],  # 学生A[70, 88, 92],  # 学生B[90, 75, 88]   # 学生C
])# axis=0：按列计算（每科最高分/最低分的学生索引）
print(np.argmax(scores, axis=0))  # [2, 0, 1] 
# 解释：第0列（第一科）最高分在索引2（学生C），第1列（第二科）最高分在索引0（学生A）...# axis=1：按行计算（每个学生最高分/最低分的科目索引）
print(np.argmin(scores, axis=1))  # [0, 0, 1]
# 解释：学生A最低分在索引0（第一科），学生B最低分在索引0（第一科）...

3.`np.maximum()/np.minimum()`

功能：按元素逐个比较两个数组，返回由对应位置的最大值（maximum）或最小值（minimum）组成的新数组。

要求：两个数组形状必须相同（或可广播为相同形状）。
#1.基本用法
a = np.array([1, 3, 5, 7])
b = np.array([2, 2, 6, 6])# 逐个取最大值
print(np.maximum(a, b))  # [2, 3, 6, 7]
# 逐个取最小值
print(np.minimum(a, b))  # [1, 2, 5, 6]#2.广播机制
# 数组与标量比较（标量广播为数组形状）
arr = np.array([-1, 2, -3, 4])
print(np.maximum(arr, 0))  # [0, 2, 0, 4]  # 相当于“截断负数为0”
print(np.minimum(arr, 0))  # [-1, 0, -3, 0]  # 相当于“截断正数为0”

4.np.average()

加权平均数

功能：计算数组的加权平均值（每个元素乘以对应权重后求和，再除以权重总和）。

weights：与数组同形状的权重数组（默认等权重，即等价于 np.mean()）。
axis：指定计算维度。
# 成绩加权：期中考试占30%，期末考试占70%
scores = np.array([[80, 90], [70, 85]])  # 两行分别为学生A、B的两次成绩
weights = [0.3, 0.7]  # 权重# 计算每个学生的加权平均分
print(np.average(scores, axis=1, weights=weights))  # [87.  80.5]
# 解释：学生A：80×0.3 + 90×0.7 = 87；学生B：70×0.3 + 85×0.7 = 80.5

5.方差系列函数

np.var()方差

np.std()标准差

np.cov()协方差

ddof：自由度（默认 0 为总体方差，1 为样本方差）。
axis：指定计算维度。

标准差：

功能：计算标准差（方差的平方根，与原数据单位一致）。参数与 np.var() 相同。

协方差：

功能：计算数组的协方差（衡量两个变量的联动性：正值为正相关，负值为负相关）。

输入为一维数组时，返回协方差值；输入为二维数组时，返回协方差矩阵（行代表变量，列代表协方差）。
#1.样本方差和标准差
data = np.array([1, 2, 3, 4, 5])
print(np.var(data, ddof=1))  # 2.5（样本方差）
print(np.std(data, ddof=1))  # ~1.58（样本标准差）#协方差
# 身高与体重的相关性（假设数据）
height = np.array([160, 170, 180, 175, 165])
weight = np.array([50, 60, 70, 65, 55])# 计算两个变量的协方差
print(np.cov(height, weight))
# 输出：
# [[87.5  87.5]
#  [87.5  87.5]]
# 解释：对角线上是各自的方差，非对角线是两者的协方差（正相关）

6.`np.bincount()`

1.np.bincount()

功能：对非负整数数组中每个整数出现的次数进行计数（索引为数值，值为该数值的频数）。

weights：可选，与数组同形状的权重数组，计算 “加权频数”（即每个数值的权重总和）。
minlength：指定结果数组的最小长度（不足则补 0）
#1.基础计数
# 统计投票结果（0、1、2为候选人编号）
votes = np.array([0, 0, 1, 2, 2, 2, 1])
counts = np.bincount(votes)
print(counts)  # [2, 2, 3]
# 解释：索引0（候选人0）得2票，索引1（候选人1）得2票，索引2（候选人2）得3票#2.加权计数
# 统计每个商品的销量权重总和（如销量×单价）
products = np.array([0, 0, 1, 1, 1])  # 商品编号
weights = np.array([10, 20, 5, 15, 25])  # 对应权重（如单价）
weighted_counts = np.bincount(products, weights=weights)
print(weighted_counts)  # [30. 45.]
# 解释：商品0的总权重10+20=30，商品1的总权重5+15+25=45

2.数组形状变化值不改变的函数

本质：仅改变形状，元素值和数量不变

1.np.reshape()/arr.reshape()

功能：将数组重构为指定形状（新形状的元素总数必须与原数组相同）。
本质：共享原数组数据（视图，view），修改新数组会影响原数组（除非原数组不连续，此时会创建副本）

关键参数：

newshape：目标形状（如 (2,3) 表示 2 行 3 列；-1 表示自动计算该维度大小）。
order：元素读取顺序（'C' 按行优先，'F' 按列优先，默认 'C'）。
import numpy as np
arr = np.array([1, 2, 3, 4, 5, 6])# 一维转二维（2行3列）
print(arr.reshape(2, 3))
# [[1 2 3]
#  [4 5 6]]# 用-1自动计算维度（6元素，指定列数3，行数自动为2）
print(arr.reshape(-1, 3))  # 同上# 按列优先重构（元素顺序按列读取）
print(arr.reshape(2, 3, order='F'))
# [[1 3 5]
#  [2 4 6]]

2. `np.ravel()` / `arr.ravel()`

功能：将多维数组展平为一维数组（与 reshape(-1) 等价）。
参数：order 控制展平顺序（同 reshape）。
arr = np.array([[1,2],[3,4]])
print(arr.ravel())  # [1 2 3 4]（行优先）
print(arr.ravel(order='F'))  # [1 3 2 4]（列优先）
与 flatten() 区别：ravel() 返回视图（节省内存），flatten() 返回副本（安全但耗内存）。

3.`np.transpose()` / `arr.T`

功能：数组转置（交换维度，如二维数组的行和列互换）。

arr = np.array([[1,2,3],[4,5,6]])
print(arr.T)  # 等价于 np.transpose(arr)
# [[1 4]
#  [2 5]
#  [3 6]]#transpose(axes) 的参数是新维度顺序对应的原维度索引。import numpy as np# 生成一个 2×3×4 的三维数组（元素值为索引的乘积，方便观察）
arr = np.fromfunction(lambda i, j, k: i*100 + j*10 + k, (2, 3, 4))
print("原数组形状：", arr.shape)  # 输出：(2, 3, 4)
print("原数组：\n", arr)'''
[[[  0   1   2   3][ 10  11  12  13][ 20  21  22  23]][[100 101 102 103][110 111 112 113][120 121 122 123]]]
'''#执行 transpose(1, 0, 2) 后：
transposed = arr.transpose(1, 0, 2)
print("转置后形状：", transposed.shape)  # 输出：(3, 2, 4)（交换了前两维）
print("转置后数组：\n", transposed)'''
[[[  0   1   2   3][100 101 102 103]][[ 10  11  12  13][110 111 112 113]][[ 20  21  22  23][120 121 122 123]]]
'''

3.形状不变值改变函数

1.算数运算

np.add()/subtract()/multiply()/divide()

功能：对数组元素进行加减乘除（支持广播，与 + - * / 运算符等价）。
a = np.array([1,2,3])
b = np.array([4,5,6])
print(np.add(a, b))  # [5 7 9]（等价于 a + b）
print(np.multiply(a, 2))  # [2 4 6]（广播：每个元素×2）
2.数学函数

np.sqrt()/np.exp()/np.log()/np.sin()

功能：对每个元素应用数学函数（如开方、指数、对数、三角函数）
arr = np.array([1,4,9])
print(np.sqrt(arr))  # [1. 2. 3.]（开方）
print(np.exp(np.array([0,1])))  # [1.         2.71828...]（指数函数 e^x）
3.统计转换

np.clip()/np.round()
arr = np.array([1, 5, 10, 15])
print(np.clip(arr, 3, 12))  # [3 5 10 12]（<3→3，>12→12）arr = np.array([1.234, 2.567])
print(np.round(arr, 2))  # [1.23 2.57]（保留2位小数）
4.逻辑运算

np.where()
arr = np.array([1, -2, 3, -4])
# 将负数改为0，正数保留原值
print(np.where(arr > 0, arr, 0))  # [1 0 3 0]

4.形状改变值也改变

本质：这类函数既改变数组的形状（维度或元素数量），也修改元素值，核心是 “数据筛选、聚合或重组”。

1.聚合函数（降维+值计算）

np.sum()/np.mean()/np.max()

功能：对数组沿指定维度聚合（如求和、均值），结果维度降低（形状改变），值为聚合结果。
arr = np.array([[1,2],[3,4]])
# 沿axis=0（列）求和：形状从(2,2)→(2)
print(np.sum(arr, axis=0))  # [4 6]（1+3=4，2+4=6）
# 沿axis=1（行）求均值：形状从(2,2)→(2)
print(np.mean(arr, axis=1))  # [1.5 3.5]

2.筛选函数/布尔索引

np.filter1d()：对一维数组按条件筛选（保留满足条件的元素，形状改变）

布尔索引：通过布尔数组筛选元素（更灵活，支持多维）
#1.np.filter1d()：对一维数组按条件筛选arr = np.array([1, 3, 5, 7, 9])
# 保留>4的元素
print(np.filter1d(arr, lambda x: x > 4))  # [5 7 9]（形状从(5)→(3)）#2.布尔索引
arr = np.array([[1,2],[3,4],[5,6]])
# 保留行索引为0和2的行（形状从(3,2)→(2,2)）
mask = np.array([True, False, True])
print(arr[mask])
# [[1 2]
#  [5 6]]

3.拼接与分割（形状改变，值为原数组组合 / 拆分）

1.np.concatenate()：沿指定维度拼接数组（形状由拼接方向决定）。

2.np.split()：将数组沿指定维度拆分为子数组（形状拆分）
#1.np.concatenate()a = np.array([[1,2],[3,4]])
b = np.array([[5,6]])
# 沿axis=0（行）拼接：(2,2)+(1,2)→(3,2)
print(np.concatenate([a, b], axis=0))
# [[1 2]
#  [3 4]
#  [5 6]]#2.np.split()
arr = np.array([1,2,3,4,5,6])
# 拆分为3个等长子数组
print(np.split(arr, 3))  # [array([1,2]), array([3,4]), array([5,6])]

4.矩阵相乘

1.np.matmul(a, b) 或 a @ b（推荐用于矩阵乘法）

规则：
二维数组：(m, n) @ (n, p) → (m, p)（前一个矩阵的列数必须等于后一个矩阵的行数）。
高维数组：将最后两个维度视为矩阵维度，前面的维度视为 “批次”，按批次进行矩阵乘法。例如 (k, m, n) @ (k, n, p) → (k, m, p)。

不支持广播：维度不匹配时会报错（如 (2,3) @ (2,3) 报错，因 3≠2）。
#1.矩阵相乘的案例
import numpy as np
a = np.array([[1, 2], [3, 4]])  # 2×2
b = np.array([[5, 6], [7, 8]])  # 2×2
print(a @ b)  # 等价于 np.matmul(a, b)
# 结果：
# [[19 22]  （1×5+2×7=19, 1×6+2×8=22）
#  [43 50]]  （3×5+4×7=43, 3×6+4×8=50）

5.数组的连接

连接数组：concatenate、stack、vstack、hstack

1. np.concatenate(arrays, axis=0)（最基础的连接）

功能：在指定轴上连接数组，不新增维度，要求所有数组的形状在非连接轴上必须一致。
参数：arrays 是数组列表，axis 是连接轴（0 为行方向，1 为列方向，默认 0）。

2. np.stack(arrays, axis=0)（新增维度连接）

功能：在指定轴上堆叠数组，会新增一个维度，要求所有数组形状完全相同。
应用场景：需要区分 “批次” 或 “通道” 时（如将多个图片数组堆叠成 (batch, height, width)）。

3. np.vstack(tup) 和 np.hstack(tup)（简化版连接）

vstack：垂直堆叠（沿 axis=0），等价于 concatenate(..., axis=0)，适合二维数组 “按行拼接”。
hstack：水平堆叠（沿 axis=1），等价于 concatenate(..., axis=1)，适合二维数组 “按列拼接”。
#1.基础数组连接
a = np.array([[1, 2], [3, 4]])  # 2×2
b = np.array([[5, 6]])          # 1×2（与 a 的列数相同，可沿 axis=0 连接）
print(np.concatenate([a, b], axis=0))  # 行方向连接
# 结果：
# [[1 2]
#  [3 4]
#  [5 6]]c = np.array([[7], [8]])        # 2×1（与 a 的行数相同，可沿 axis=1 连接）
print(np.concatenate([a, c], axis=1))  # 列方向连接
# 结果：
# [[1 2 7]
#  [3 4 8]]#2.新增维度连接
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
print(np.stack([a, b], axis=0))  # 新增第0维
# 结果：[[1 2 3]
#        [4 5 6]] （形状 (2,3)）print(np.stack([a, b], axis=1))  # 新增第1维
# 结果：[[1 4]
#        [2 5]
#        [3 6]] （形状 (3,2)）#3.简化版连接
a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
print(np.vstack([a, b]))  # 垂直堆叠（形状 (2,3)）
# [[1 2 3]
#  [4 5 6]]print(np.hstack([a, b]))  # 水平堆叠（形状 (6,)）
# [1 2 3 4 5 6]

6.数组的填充

np.pad(array, pad_width, mode)

功能：用于在数组边缘填充值（如补零、复制边缘值等），常用于图像处理（如卷积前补边）

参数：
pad_width：填充宽度，格式为 ((before_0, after_0), (before_1, after_1), ...)，每个元组对应一个维度的前后填充量。
mode：填充方式，如 'constant'（常数，默认 0）、'edge'（边缘值）、'reflect'（镜像）等。
格式pad(nd数组,填充位置为整数或元组(（上,下）,(左,右)),mode=,constant_values=)
填充位置：不指定则为0填充，指定一个数组，（1，2）：（上左，下右）。如果两个数组对应的是（（上,下）,(左,右)）
填充模式：
1.边缘填充(eage):将该方向最后一列作为填充版本
2.最大值填充(maximun) 最大值填充
3.平均值填充(mean) 平均值填充
arr = np.array([[1, 2], [3, 4]])  # 2×2# 每个维度前后各补1个0（总填充后 4×4）
print(np.pad(arr, pad_width=((1,1), (1,1)), mode='constant'))
# 结果：
# [[0 0 0 0]
#  [0 1 2 0]
#  [0 3 4 0]
#  [0 0 0 0]]# 按边缘值填充（上下补1行，左右补1列）
print(np.pad(arr, pad_width=((1,1), (1,1)), mode='edge'))
# 结果：
# [[1 1 2 2]
#  [1 1 2 2]
#  [3 3 4 4]
#  [3 3 4 4]]

7.数组的升维和降维

升维 / 降维：np.resize、np.expand_dims、np.squeeze

np.resize(a, new_shape)：改变数组形状，若新形状元素数多于原数组，会重复填充；少于则截断（不推荐，建议用 reshape，因 resize 可能改变数据）。
np.expand_dims(a, axis)：新增维度（升维），常用于匹配广播维度。注意：expand_dims()参数是几，那就是第几维为1
np.squeeze()：删除所有大小为 1 的维度（与 expand_dims 相反）
arr = np.array([1, 2, 3, 4])# 升维：新增第0维（形状 (1,4)）
print(np.expand_dims(arr, axis=0))  # [[1 2 3 4]]# 降维：删除长度为1的维度
arr_2d = np.array([[1, 2, 3]])  # 形状 (1,3)
print(np.squeeze(arr_2d))  # [1 2 3]（形状 (3,)）

8.数组的重复

np.tile 和 np.repeat

核心区别：tile 是 “重复整个数组”，repeat 是 “重复数组元素”。

1. np.tile(a, reps)

功能：将数组 a 作为整体，按 reps 指定的次数重复（类似 “铺瓷砖”）。
reps 为元组时，对应每个维度的重复次数。

2. np.repeat(a, repeats, axis=None)

功能：重复数组的每个元素，repeats 是每个元素的重复次数（可指定单个值或与 a 同长度的列表）。
axis 指定沿哪个维度重复（默认展平数组后重复）。
#1.np.title
a = np.array([1, 2])# 1维重复：沿第0维重复3次
print(np.tile(a, 3))  # [1 2 1 2 1 2]# 2维重复：行重复2次，列重复3次
print(np.tile(a, (2, 3)))
# [[1 2 1 2 1 2]
#  [1 2 1 2 1 2]]#2.np.repeat
a = np.array([1, 2])# 重复每个元素3次（展平）
print(np.repeat(a, 3))  # [1 1 1 2 2 2]# 沿轴0重复（二维数组示例）
b = np.array([[1, 2], [3, 4]])
print(np.repeat(b, 2, axis=0))  # 行方向重复每个元素
# [[1 2]
#  [1 2]
#  [3 4]
#  [3 4]]

5.总结与补充

函数总结：

分类	核心特点	典型函数	应用场景
形变值不变	仅改形状，值和数量不变	`reshape`/`transpose`/`ravel`	数据格式适配、维度调整
行不变值变	形状不变，值被修改	`add`/`sqrt`/`clip`/`where`	元素级运算、数据清洗
形变值也变	形状和值均改变	`sum`/`concatenate`/`sort`/`choice`	数据聚合、拼接、筛选、采样

操作类型	函数	核心用途	关键区别
矩阵相乘	`@`/`matmul`	线性代数矩阵乘法（严格维度匹配）	不支持广播，高维按批次乘
	`dot`	内积或高维灵活乘法	一维是内积，高维规则复杂
连接数组	`concatenate`	无新增维度的连接（需同形状非连接轴）	最通用，需指定 axis
	`stack`	新增维度的堆叠（需完全同形状）	用于区分批次 / 通道
填充	`pad`	边缘填充（补零、边缘值等）	支持多种填充模式，适合预处理
维度调整	`expand_dims`/`squeeze`	新增 / 删除长度为 1 的维度	用于广播或简化结构
分割数组	`split`/`vsplit`/`hsplit`	按轴分割为子数组	与连接操作对应，需指定分割点或数量
重复数组	`tile`	重复整个数组（铺瓷砖）	以数组为单位重复
	`repeat`	重复每个元素