NumPy通用函数（ufunc）

数据分析专题 · 逐元素快速运算

专题：Python数据分析系统学习

关键词：数据分析, NumPy, ufunc, 通用函数, 聚合, 矢量化, np.where, 数学函数

一、ufunc概述

通用函数（ufunc）是NumPy的核心组件之一，全称为"universal function"。它的本质是对ndarray数组执行逐元素（element-wise）运算的函数，速度远快于Python原生循环。ufunc的底层使用C语言实现，充分利用了CPU的SIMD指令集，在数据量大时性能优势尤其明显。

ufunc的核心思想是矢量化（vectorization）——将原本需要写循环的逐元素操作，替换为对整个数组的一次性调用。这既让代码更简洁、更接近数学表达式，也大幅提升了运行速度。NumPy提供了大量内置ufunc，涵盖算术运算、三角函数、指数对数、位运算、比较运算等各个方面。

性能提示：在对大规模数据进行数学运算时，使用ufunc比使用Python原生for循环快数十倍甚至上百倍。矢量化是高效数据分析和科学计算的基石。

ufunc根据操作数的数量分为一元ufunc（接收一个数组）和二元ufunc（接收两个数组）。此外，ufunc还拥有若干强大的方法，如reduce、accumulate、outer等，能够实现更复杂的数据处理逻辑。

下面首先来看ufunc的基本使用方法。

import numpy as np # 检查一个函数是否为ufunc print(isinstance(np.add, np.ufunc)) # True print(isinstance(np.sin, np.ufunc)) # True print(isinstance(np.sum, np.ufunc)) # False（不是ufunc，但ufunc有类似功能） # ufunc的常用属性 print("np.add.nin:", np.add.nin) # 输入参数个数：2 print("np.add.nout:", np.add.nout) # 输出参数个数：1 print("np.add.nargs:", np.add.nargs) # 总参数个数：3（2输入+1输出） print("np.add.types:", np.add.types) # 支持的数据类型列表 print("np.add.identity:", np.add.identity) # 单位元素：0

二、一元ufunc

一元ufunc接收一个输入数组，对每个元素执行相同运算后返回一个新数组。它们是最基本的数学函数，覆盖了平方根、指数、对数、三角函数、舍入函数等各类操作。

2.1 数学运算函数

numpy.sqrt用于计算每个元素的平方根，numpy.exp计算自然指数e^x，numpy.log计算自然对数ln(x)，numpy.abs或numpy.absolute计算绝对值。这些函数都要求输入为数值类型，且会对结果自动进行类型推断。

arr = np.array([1, 4, 9, 16, 25], dtype='float64') # 平方根 print("sqrt:", np.sqrt(arr)) # 输出: sqrt: [1. 2. 3. 4. 5.] # 自然指数 print("exp:", np.exp(arr[:5])) # 输出: exp: [2.71828183e+00 5.45981500e+01 2.00855369e+03 ...] # 自然对数 print("log:", np.log(arr)) # 输出: log: [0. 0.69314718 1.09861229 1.38629436 1.60943791] # 绝对值 neg = np.array([-3, -2, -1, 0, 1, 2, 3]) print("abs:", np.abs(neg)) # 输出: abs: [3 2 1 0 1 2 3] # 以10为底的对数、以2为底的对数 print("log10:", np.log10(arr)) print("log2:", np.log2(arr))

2.2 三角函数

NumPy提供全套三角函数：numpy.sin、numpy.cos、numpy.tan，以及它们的反函数numpy.arcsin、numpy.arccos、numpy.arctan。角度以弧度为单位。这些函数在信号处理、图像变换、物理模拟等场景中应用广泛。

angles = np.array([0, np.pi/6, np.pi/4, np.pi/3, np.pi/2]) print("sin:", np.sin(angles)) # 输出: sin: [0. 0.5 0.70710678 0.8660254 1. ] print("cos:", np.cos(angles)) # 输出: cos: [1.00000000e+00 8.66025404e-01 7.07106781e-01 5.00000000e-01 ...] print("tan:", np.tan(angles)) # 输出: tan: [0.00000000e+00 5.77350269e-01 1.00000000e+00 1.73205081e+00 ...] # 弧度与角度转换 degrees = np.degrees(angles) print("degrees:", degrees) # 输出: degrees: [ 0. 30. 45. 60. 90.] print(np.radians(degrees)) # 输出: [0. 0.52359878 0.78539816 1.04719755 1.57079633]

2.3 舍入函数

数据分析中经常需要对浮点数进行舍入处理。numpy.ceil向上取整，numpy.floor向下取整，numpy.round四舍五入到指定小数位。numpy.trunc截断小数部分。这些函数在金额计算、统计报表、数据离散化等场景中十分常用。

data = np.array([3.14, -1.618, 2.718, -0.577, 1.414]) print("原始数据:", data) # ceil：向上取整（往正无穷方向） print("ceil:", np.ceil(data)) # 输出: ceil: [ 4. -1. 3. -0. 2.] # floor：向下取整（往负无穷方向） print("floor:", np.floor(data)) # 输出: floor: [ 3. -2. 2. -1. 1.] # round：四舍五入（默认保留0位小数） print("round:", np.round(data)) # 输出: round: [ 3. -2. 3. -1. 1.] # round 指定小数位数 precise = np.array([3.14159, 2.71828, 1.41421]) print("round(2):", np.round(precise, decimals=2)) # 输出: round(2): [3.14 2.72 1.41] # trunc：截断小数部分，等价于向零取整 print("trunc:", np.trunc(data)) # 输出: trunc: [ 3. -1. 2. -0. 1.]

注意：np.round对于恰好为0.5的小数采用"银行家舍入"（奇进偶不进），而不是简单的"四舍五入"。例如np.round(2.5)=2.0，np.round(3.5)=4.0。这种舍入方式在统计中更为无偏。

2.4 符号函数

numpy.sign返回每个元素的符号指示：正数为1，负数为-1，零为0。numpy.negative返回数值的相反数。这两个函数在判断数据方向、处理正负分类时经常用到。

arr = np.array([10, -5, 0, -8, 3]) print("sign:", np.sign(arr)) # 输出: sign: [ 1 -1 0 -1 1] print("negative:", np.negative(arr)) # 输出: negative: [-10 5 0 8 -3]

三、二元ufunc

二元ufunc接收两个输入数组，对它们的对应元素执行运算后返回一个新数组。NumPy的广播机制允许两个数组形状不完全一致时仍能进行运算。最常见的二元ufunc是算术运算符的底层实现：np.add、np.subtract、np.multiply、np.divide和np.power。

3.1 基本算术运算

a = np.array([1, 2, 3, 4, 5]) b = np.array([5, 4, 3, 2, 1]) print("add:", np.add(a, b)) # [6 6 6 6 6] print("subtract:", np.subtract(a, b)) # [-4 -2 0 2 4] print("multiply:", np.multiply(a, b)) # [5 8 9 8 5] print("divide:", np.divide(a, b)) # [0.2 0.5 1. 2. 5. ] print("power:", np.power(a, b)) # [1 16 27 16 5] # 整数除法（floor_divide）和取模（mod） print("floor_divide:", np.floor_divide(a, b)) # [0 0 1 2 5] print("mod:", np.mod(a, b)) # [1 2 0 0 0] # 对应的运算符重载版本 print("a + b:", a + b) print("a ** b:", a ** b) print("a // b:", a // b) print("a % b:", a % b)

3.2 比较与逻辑运算

NumPy的比较运算符也是ufunc，包括np.greater、np.less、np.equal、np.not_equal等。它们的返回结果是布尔数组，在条件筛选和数据对比中至关重要。np.maximum和np.minimum则返回元素级的两数较大值和较小值。

a = np.array([1, 5, 3, 8, 2]) b = np.array([4, 2, 3, 6, 5]) # 元素级比较 print("greater:", np.greater(a, b)) # [False True False True False] print("less:", np.less(a, b)) # [ True False False False True] print("equal:", np.equal(a, b)) # [False False True False False] # 元素级最大值/最小值 print("maximum:", np.maximum(a, b)) # [4 5 3 8 5] print("minimum:", np.minimum(a, b)) # [1 2 3 6 2] # 对应的运算符 print("a > b:", a > b) print("a == b:", a == b) # logical_and / logical_or / logical_not cond1 = a > 2 cond2 = b < 5 print("cond1:", cond1) print("cond2:", cond2) print("logical_and:", np.logical_and(cond1, cond2)) # 输出: logical_and: [False True True True False]

四、ufunc的高级方法

ufunc除了可以逐元素运算外，还提供了几个非常强大的方法：reduce、accumulate、reduceat和outer。这些方法将ufunc的能力从逐元素运算扩展到了聚合、累积、分段约简和外积计算等场景。

4.1 reduce：归约操作

reduce沿指定轴反复应用ufunc，将数组缩减为单一值（或沿某轴缩减）。np.add.reduce相当于求和，np.multiply.reduce相当于连乘，np.maximum.reduce相当于求最大值。这是ufunc实现聚合功能的基础。

arr = np.array([1, 2, 3, 4, 5]) # add.reduce 等价于 np.sum print("add.reduce:", np.add.reduce(arr)) # 15 # multiply.reduce 连乘 print("multiply.reduce:", np.multiply.reduce(arr)) # 120（1*2*3*4*5） # maximum.reduce 等价于 np.max print("maximum.reduce:", np.maximum.reduce(arr)) # 5 # 二维数组沿不同轴reduce mat = np.array([[1, 2, 3], [4, 5, 6]]) print("沿轴0reduce:", np.add.reduce(mat, axis=0)) # [5 7 9] print("沿轴1reduce:", np.add.reduce(mat, axis=1)) # [6 15]

4.2 accumulate：累积操作

accumulate保存reduce的中间结果，返回一个与原数组形状相同的数组。它实现了前缀和（prefix sum）和前缀积的功能。np.cumsum就是基于add.accumulate实现的。

arr = np.array([1, 2, 3, 4, 5]) # add.accumulate 等价于 np.cumsum print("add.accumulate:", np.add.accumulate(arr)) # 输出: [1 3 6 10 15] # multiply.accumulate 等价于 np.cumprod print("multiply.accumulate:", np.multiply.accumulate(arr)) # 输出: [1 2 6 24 120] # 实际应用：计算收益率的累积乘积 returns = np.array([1.02, 1.01, 0.99, 1.03, 1.005]) cumulative = np.multiply.accumulate(returns) print("累积收益率:", cumulative) # 输出: [1.02 1.0302 1.019898 1.05049494 1.05574742]

4.3 reduceat：分段归约

reduceat在指定的间隔点上对数组执行分段reduce。它接收一个数组和一个索引列表，对索引所划定的每个区间分别做reduce。这在分组聚合、滑动窗口类计算中非常实用。

arr = np.array([10, 20, 30, 40, 50, 60, 70, 80]) indices = np.array([0, 3, 5, 7]) # 在索引 [0,3)、[3,5)、[5,7)、[7:] 各区间分别求和 result = np.add.reduceat(arr, indices) print("reduceat结果:", result) # 解释： # indices[0]=0 → sum(arr[0:3]) = 10+20+30 = 60 # indices[1]=3 → sum(arr[3:5]) = 40+50 = 90 # indices[2]=5 → sum(arr[5:7]) = 60+70 = 130 # indices[3]=7 → sum(arr[7:]) = 80 = 80 # 降低最高分和最低分后求平均分（去掉一个最高一个最低） scores = np.array([88, 92, 75, 96, 83, 91, 79]) sorted_scores = np.sort(scores) trimmed_mean = np.add.reduce(sorted_scores[1:-1]) / len(sorted_scores[1:-1]) print("去掉最高最低的平均分:", trimmed_mean)

4.4 outer：外积操作

outer对两个数组的所有元素进行"两两组合"运算，返回一个二维数组。结果[i,j]等于a[i]与b[j]的运算值。np.outer是np.multiply.outer的特例。outer在构建核函数、计算距离矩阵时非常有用。

a = np.array([1, 2, 3]) b = np.array([10, 20, 30]) # add.outer 与矩阵加法类似 print("add.outer:") print(np.add.outer(a, b)) # [[11 21 31] # [12 22 32] # [13 23 33]] # multiply.outer 矩阵外积 print("multiply.outer:") print(np.multiply.outer(a, b)) # [[10 20 30] # [20 40 60] # [30 60 90]] # 实际应用：构建欧氏距离矩阵 points = np.array([1, 2, 3]) diff = np.subtract.outer(points, points) squared_dist = diff ** 2 print("距离矩阵（平方）:") print(squared_dist)

五、聚合函数

聚合函数对数组进行整体或沿特定轴的统计计算。虽然np.sum、np.mean等并非ufunc类型（它们属于NumPy的通用函数），但它们的底层实现高度优化，且与ufunc的reduce方法有内在联系。下面介绍最常用的聚合函数及其用法。

5.1 基本聚合函数

NumPy提供了一整套聚合函数：np.sum求和、np.mean求均值、np.std求标准差、np.var求方差、np.min求最小值、np.max求最大值。这些函数都支持axis参数指定计算轴，以及keepdims参数保持维度。

arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]]) print("sum:", np.sum(arr)) # 45 print("mean:", np.mean(arr)) # 5.0 print("std:", np.std(arr)) # 2.581988897471611 print("var:", np.var(arr)) # 6.666666666666667 print("min:", np.min(arr)) # 1 print("max:", np.max(arr)) # 9 # 沿轴聚合 print("沿轴0求和（每列）:", np.sum(arr, axis=0)) # [12 15 18] print("沿轴1求和（每行）:", np.sum(arr, axis=1)) # [6 15 24] # keepdims 保持维度 print("keepdims=True:", np.sum(arr, axis=1, keepdims=True)) # [[6] # [15] # [24]]

5.2 索引聚合函数

np.argmin和np.argmax返回最小值/最大值所在的位置（扁平索引或沿轴的索引）。这在数据分析中经常用于寻找最优值的位置，比如查找价格最低的日期、得分最高的样本等。

arr = np.array([3, 7, 1, 9, 4, 6, 2, 8, 5]) print("argmin（最小值索引）:", np.argmin(arr)) # 2（值为1） print("argmax（最大值索引）:", np.argmax(arr)) # 3（值为9） # 二维数组argmax mat = np.array([[1, 5, 3], [7, 2, 9], [4, 6, 8]]) print("全局argmax:", np.argmax(mat)) # 5 (扁平索引, 值为9) print("沿轴0argmax:", np.argmax(mat, axis=0)) # [1 2 1] print("沿轴1argmax:", np.argmax(mat, axis=1)) # [1 2 2] # 使用 unravel_index 将扁平索引转换为多维索引 flat_idx = np.argmax(mat) multi_idx = np.unravel_index(flat_idx, mat.shape) print("多维索引:", multi_idx) # (1, 2)

5.3 其他聚合函数

np.median计算中位数，np.percentile计算百分位数，np.any和np.all进行布尔逻辑聚合。np.nonzero返回非零元素的索引数组。这些函数在探索性数据分析（EDA）中几乎每天都会用到。

data = np.array([1, 2, 3, 4, 5, 6, 7, 8, 9, 10]) print("median:", np.median(data)) # 5.5 print("percentile(25):", np.percentile(data, 25)) # 3.25 print("percentile(75):", np.percentile(data, 75)) # 7.75 bool_arr = np.array([True, False, True, True]) print("any:", np.any(bool_arr)) # True print("all:", np.all(bool_arr)) # False # nonzero 返回非零元素的索引 arr = np.array([0, 2, 0, 5, 0, 7]) print("nonzero:", np.nonzero(arr)) # (array([1, 3, 5]),) # 在数据清洗中非常实用的统计 data_with_nan = np.array([1, 2, np.nan, 4, np.nan, 6]) print("isnan:", np.isnan(data_with_nan)) # 输出: [False False True False True False]

小结：聚合函数是数据分析中最高频的操作之一。理解axis参数的本质——它指定了"沿哪个轴坍缩"，是掌握NumPy聚合的关键。axis=0意味沿着行的方向坍缩（结果对应列），axis=1意味沿着列的方向坍缩（结果对应行）。

六、nan-safe函数

真实数据中经常包含缺失值（NaN，Not a Number）。标准的聚合函数np.sum、np.mean等遇到NaN时会返回NaN，导致计算结果无效。NumPy提供了一组nan-safe函数（nan-aware functions），它们会自动跳过NaN值，仅对有效数据进行计算。

data = np.array([1, 2, np.nan, 4, np.nan, 6, 7, 8, np.nan, 10]) # 普通聚合函数遇到NaN会失效 print("np.sum:", np.sum(data)) # nan print("np.mean:", np.mean(data)) # nan print("np.std:", np.std(data)) # nan # nan-safe函数自动跳过NaN print("nansum:", np.nansum(data)) # 38.0 print("nanmean:", np.nanmean(data)) # 4.75 (38/8) print("nanstd:", np.nanstd(data)) # 2.947... print("nanvar:", np.nanvar(data)) # 8.6875 print("nanmin:", np.nanmin(data)) # 1.0 print("nanmax:", np.nanmax(data)) # 10.0 print("nanmedian:", np.nanmedian(data)) # 5.0

6.1 二维数组的nan处理

对于二维数组或更高维数据，nan-safe函数同样支持axis参数，可以沿指定轴进行计算。这在处理表格数据时非常关键——每列可能有不同比例的缺失值，我们需要按列而非整体进行统计。

matrix = np.array([[1, np.nan, 3], [4, 5, np.nan], [np.nan, 8, 9]]) # 整体nanmean print("整体nanmean:", np.nanmean(matrix)) # 5.0 # 按列（沿轴0）计算nanmean print("按列nanmean:", np.nanmean(matrix, axis=0)) # [2.5 6.5 6. ] # 按行（沿轴1）计算nanmean print("按行nanmean:", np.nanmean(matrix, axis=1)) # [2. 4.5 8.5] # 实际场景：处理带缺失值的数据集 sensor_data = np.array([ [25.3, 26.1, np.nan, 24.8, 25.9], [np.nan, 27.2, 26.8, np.nan, 26.5], [24.9, 25.7, 25.1, 26.0, np.nan] ]) # 计算每个传感器的平均值（排除NaN） sensor_means = np.nanmean(sensor_data, axis=1) print("各传感器均值:", sensor_means) # 计算每天的平均温度（排除NaN） daily_means = np.nanmean(sensor_data, axis=0) print("每日温度均值:", daily_means)

注意：虽然nan-safe函数非常方便，但在缺失值比例很高时需要谨慎解读结果。例如，如果一列数据中90%都是NaN，那么基于剩余10%的nanmean可能无法代表整体分布。在实际项目中，通常会先评估缺失比例，再决定是使用nan函数、填充缺失值还是删除特征。

6.2 缺失值计数

实际工作中，统计每列有多少缺失值通常是第一步。将np.isnan和np.sum结合使用，即可快速统计缺失值数量。这对于数据质量评估至关重要。

data_2d = np.array([[1, np.nan, 3, np.nan], [4, 5, np.nan, np.nan], [7, 8, 9, np.nan]]) # 统计每个位置的缺失情况 nan_mask = np.isnan(data_2d) print("缺失值掩码:") print(nan_mask) # 统计每列缺失值的数量 nan_count_per_col = np.sum(nan_mask, axis=0) print("每列缺失数:", nan_count_per_col) # 统计每行缺失值的数量 nan_count_per_row = np.sum(nan_mask, axis=1) print("每行缺失数:", nan_count_per_row) # 填充缺失值（用列均值填充是常用策略） col_means = np.nanmean(data_2d, axis=0) print("列均值:", col_means) # 使用 np.where 进行条件填充 filled = np.where(np.isnan(data_2d), col_means, data_2d) print("填充后的数据:") print(filled)

七、条件函数：np.where 与 np.clip

np.where和np.clip是数据分析中最实用的两个条件函数。np.where基于条件从两个数组中选取元素，np.clip将数值限制在指定范围内。它们在数据清洗、异常值处理、特征工程等环节中应用广泛。

7.1 np.where：三目运算符的矢量化版本

np.where(condition, x, y)等价于"如果condition为真，取x对应位置的值，否则取y对应位置的值"。当只传入condition一个参数时，np.where返回满足条件的元素的索引。np.where的核心价值在于它将条件逻辑矢量化——无需写循环，整个数组的操作一步完成。

arr = np.array([-5, -3, -1, 0, 1, 3, 5]) # 将负数替换为0，正数保持不变 result = np.where(arr > 0, arr, 0) print("将负数置0:", result) # 输出: [0 0 0 0 1 3 5] # 三值逻辑：负数→-1, 零→0, 正数→1 sign_vector = np.where(arr > 0, 1, np.where(arr < 0, -1, 0)) print("符号向量:", sign_vector) # 输出: [-1 -1 -1 0 1 1 1] # 单参数形式：返回满足条件的索引 indices = np.where(arr > 0) print(">0的索引:", indices) # 输出: (array([4, 5, 6]),) # 二维数组的where索引 mat = np.array([[1, 0, 3], [0, 5, 0], [7, 0, 9]]) rows, cols = np.where(mat > 0) print("行索引:", rows) print("列索引:", cols) print("对应的值:", mat[rows, cols]) # 实际应用：阈值分类 scores = np.array([45, 78, 92, 33, 60, 88, 71, 55]) grades = np.where(scores >= 90, 'A', np.where(scores >= 80, 'B', np.where(scores >= 70, 'C', np.where(scores >= 60, 'D', 'F')))) print("成绩等级:", grades) # 输出: ['F' 'C' 'A' 'F' 'D' 'B' 'C' 'F']

7.2 np.clip：数值裁剪

np.clip将数组中的所有元素限制在指定的[lower, upper]区间内。小于lower的值会被替换为lower，大于upper的值会被替换为upper。裁剪（clipping）是处理异常值的经典方法之一——不删除数据，也不完全忽略，而是将其压缩到合理边界。np.clip在图像处理中尤其常用（将像素值限制在0-255范围）。

data = np.array([-100, -50, -10, 0, 10, 50, 100, 200, 500]) # 将数据限制在 -20 到 80 之间 clipped = np.clip(data, -20, 80) print("原始数据:", data) print("裁剪后:", clipped) # 输出: [-20 -20 -10 0 10 50 80 80 80] # 只限制下界（相当于剔除下限异常值） lower_clip = np.clip(data, 0, None) print("下限裁剪:", lower_clip) # 输出: [ 0 0 0 0 10 50 100 200 500] # np.clip 的实际应用：基于百分位数的异常值裁剪 # 这是数据预处理中非常经典的操作 np.random.seed(42) sample = np.random.randn(1000) * 100 + 50 # 模拟数据 p1, p99 = np.percentile(sample, [1, 99]) print("1%分位数:", p1, "99%分位数:", p99) # 将异常值裁剪到1%和99%分位数之间 clean_data = np.clip(sample, p1, p99) print("裁剪前范围:", sample.min(), "-", sample.max()) print("裁剪后范围:", clean_data.min(), "-", clean_data.max())

7.3 np.where 与 np.clip 的组合应用

在实际数据分析项目中，np.where和np.clip经常配合使用，形成完整的数据预处理管线。下面展示一个综合示例：处理包含异常值和缺失值的传感器数据。

# 综合示例：传感器数据清洗 sensor = np.array([25.3, 28.7, -999, 26.1, 9999, 27.5, np.nan, 25.8, -1, 26.9]) # 第一步：标记无效值（包括NaN和显著异常值） # 使用np.isnan检测NaN，使用绝对值阈值检测异常值 is_nan = np.isnan(sensor) is_outlier = np.abs(sensor) > 1000 # 第二步：使用条件替换处理这些无效值 # 对有效值保留原值，对无效值用中位数填充 valid_mask = ~is_nan & ~is_outlier valid_data = sensor[valid_mask] median_val = np.nanmedian(valid_data) print("有效数据中位数:", median_val) # 第三步：统一处理所有无效值 # 先用np.where替换异常值和NaN为中位数 cleaned = np.where(is_nan | is_outlier, median_val, sensor) print("清洗后:", cleaned) # 第四步：再用np.clip将值限制在合理物理范围 # 假设该传感器合理范围为 [20, 30] final_data = np.clip(cleaned, 20, 30) print("最终数据:", final_data)

八、ufunc与广播机制

广播（broadcasting）是ufunc在处理不同形状数组时的核心机制。它允许ufunc在形状不完全匹配的数组之间执行运算，无需手动复制数据。广播遵循三条规则：如果维度不同，在较小的数组前面补1；如果某个维度大小为1，沿该维度复制；如果维度大小既不是1也不匹配，则报错。

理解广播对于正确使用ufunc至关重要。很多看似复杂的矢量化操作，归根结底都是ufunc配合广播的结果。下面通过几个典型例子来说明。

# 标量广播：标量被广播到数组的每个元素 arr = np.array([1, 2, 3, 4, 5]) print(arr + 10) # [11 12 13 14 15] print(arr * 2) # [2 4 6 8 10] # 一维广播到二维：行向量自动沿行方向复制 row = np.array([1, 2, 3]) mat = np.array([[10, 20, 30], [40, 50, 60]]) print(mat + row) # [[11 22 33] # [41 52 63]] # 列向量广播 col = np.array([[10], [20], [30]]) row_2 = np.array([1, 2, 3]) print(col + row_2) # [[11 12 13] # [21 22 23] # [31 32 33]] # 实用技巧：用广播实现数据标准化（z-score） data = np.random.randn(5, 3) mean = np.mean(data, axis=0) std = np.std(data, axis=0) standardized = (data - mean) / std print("标准化后每列均值（应≈0）:", np.round(np.mean(standardized, axis=0), 10)) print("标准化后每列标准差（应≈1）:", np.round(np.std(standardized, axis=0), 10))

思考：ufunc的广播机制为什么高效？因为NumPy在底层用C语言循环实现"虚似复制"（virtual duplication），并不真正在内存中复制数据，而是通过步长（stride）技巧让同一个物理内存位置对应多个逻辑位置。这既节省了内存，又充分利用了CPU缓存。

九、ufunc性能对比

为了直观感受ufunc的性能优势，下面用代码对比原生Python循环和NumPy ufunc的执行时间。在数据规模较大时，ufunc的加速比可以达到两个数量级以上。这也是为什么在数据分析领域提倡"矢量化"思维——能用ufunc绝不用循环。

import time n = 10_000_000 arr = np.random.randn(n) # 原生Python循环 start = time.time() result_py = [np.sin(x) for x in arr[:1000000]] # 只取100万做对比，否则太慢 t_py = time.time() - start # NumPy ufunc start = time.time() result_np = np.sin(arr) # 直接处理1000万条数据 t_np = time.time() - start print(f"Python循环(100万条): {t_py:.4f}秒") print(f"NumPy ufunc(1000万条): {t_np:.4f}秒") print(f"ufunc加速比(估计): {t_py / t_np * 10:.0f}倍") # 如果再对比二元运算 a = np.random.randn(n) b = np.random.randn(n) # Python循环 start = time.time() c_py = [a[i] + b[i] for i in range(1000000)] t_py2 = time.time() - start # ufunc start = time.time() c_np = np.add(a, b) t_np2 = time.time() - start print(f"Python加法循环(100万条): {t_py2:.4f}秒") print(f"NumPy add(1000万条): {t_np2:.4f}秒") print(f"加速比(估计): {t_py2 / t_np2 * 10:.0f}倍")

为什么ufunc这么快？三个层面的优化叠加：第一，C语言实现避免了Python解释器开销；第二，内存连续布局利用了CPU缓存局部性原理；第三，NumPy在编译时启用SIMD指令集，实现单指令多数据流的并行计算。这意味着一次CPU指令可以同时处理多个数据元素。

十、核心要点总结

1. ufunc的本质：对ndarray进行逐元素快速运算的C语言实现函数，核心机制是矢量化。

2. 一元ufunc：sqrt/exp/log/abs/sin/cos/ceil/floor/round等，接收一个数组，逐元素运算。

3. 二元ufunc：add/subtract/multiply/divide/power/maximum/minimum等，接收两个数组，配合广播机制。

4. ufunc方法：reduce（归约）、accumulate（累积）、reduceat（分段归约）、outer（外积），扩展了ufunc的能力边界。

5. 聚合函数：sum/mean/std/min/max/argmin/argmax，配合axis参数实现按轴计算。

6. nan-safe函数：nansum/nanmean/nanstd等，自动跳过NaN值，是处理真实世界脏数据的必备工具。

7. 条件函数：np.where实现矢量化条件选择，np.clip实现数值边界裁剪，两者组合可构建完整的数据清洗管线。

8. 广播机制：ufunc处理不同形状数组的核心规则，是矢量化操作的理论基础。

9. 性能优势：相比Python原生循环，ufunc通常有数十到上百倍的加速效果。

十一、进一步思考

掌握了ufunc的基本用法之后，可以从以下几个方向继续深入：第一，学习如何用np.frompyfunc和np.vectorize将自定义Python函数包装为类ufunc函数（注意这些并非真正的ufunc，性能不如内置ufunc）；第二，探索NumPy的底层C API，了解如何编写自定义ufunc扩展；第三，结合Pandas DataFrame，理解ufunc在表格数据上的应用模式。

在实际工作中，ufunc的最佳实践可以概括为一句话：遇到循环，先想ufunc。无论是特征工程、数据清洗、统计计算还是模型评估，先用ufunc和广播机制思考能否矢量化解决。这不仅能写出更简洁的代码，更能充分利用硬件性能，尤其在大数据场景下收益显著。

从更宏观的视角看，ufunc体现了"数组编程"（array programming）的核心哲学——让操作作用于整个数据集而非单个元素。这种思维方式源于APL语言，经MATLAB普及，在NumPy中达到顶峰，并影响了TensorFlow、PyTorch等现代深度学习框架。掌握ufunc，不仅是在学习一个库的API，更是在建立一种高效的数据思维范式。

推荐练习：找一个真实数据集（如房价数据、股票历史数据），尝试纯用NumPy（不借助Pandas）完成完整的数据清洗、特征工程和统计描述流程。重点关注缺失值处理（np.where + nan函数）、异常值裁减（np.clip）、数据标准化（广播机制）等环节。在实践中体会矢量化思维的力量。