TOPSIS综合评价模型：原理、Python实现与实战应用-编程实验室

1. 项目概述：TOPSIS综合评价模型与Python实现

在数据分析、项目评估、决策支持等众多领域，我们常常面临一个经典难题：如何从一堆各有优劣的方案中，科学、客观地选出一个“最佳”的？无论是评选优秀员工、评估供应商绩效，还是选择投资项目，单一指标往往无法全面反映真实情况。这时候，综合评价模型就成了我们的得力工具。而TOPSIS法，正是其中一种直观、有效且应用极其广泛的方法。

TOPSIS，全称“逼近理想解排序法”，它的核心思想非常符合人类的直觉：最好的方案应该离理想中的最优解最近，同时离最劣解最远。想象一下你在挑选一款手机，你心中有一个各项参数都拉满的“梦幻机”（正理想解），也有一个各项参数都垫底的“淘汰机”（负理想解）。TOPSIS就是通过计算每款真实手机与这两个“虚拟标杆”的距离，来给所有手机排个名次，距离“梦幻机”越近、距离“淘汰机”越远的，排名就越高。

这个方法之所以备受青睐，尤其是在数学建模竞赛和实际业务分析中，是因为它原理清晰、计算过程规范、结果易于解释，并且能够很好地处理多指标、量纲不统一的数据。今天，我们就来深入拆解TOPSIS的每一个步骤，并用Python从头实现一套完整、健壮、可复用的代码。这套代码不仅包含了标准的计算流程，还会融入我在多次实战中总结出的数据预处理技巧、权重处理方法以及结果解读的注意事项，让你拿到手就能用，用了就能出可靠的结果。

2. TOPSIS模型的核心原理与步骤拆解

要写好代码，必须先吃透原理。TOPSIS的计算过程是一个环环相扣的链条，每一步都有其数学意义和实际考量。下面我们将其分解为六个核心步骤，并探讨每个步骤背后的“为什么”。

2.1 构建原始评价矩阵

这是所有评价工作的起点。假设我们有m个待评价对象（例如m个城市、m个方案），每个对象有n个评价指标（例如GDP、人口、绿化率等）。那么，我们就可以构建一个m行×n列的原始数据矩阵，记作X。

对象\指标 | 指标1 | 指标2 | ... | 指标n ---------|------|------|-----|------ 对象A | x11 | x12 | ... | x1n 对象B | x21 | x22 | ... | x2n ... | ... | ... | ... | ... 对象M | xm1 | xm2 | ... | xmn

关键点：原始数据的质量直接决定最终结果的可靠性。务必确保数据准确、完整。对于缺失值，常见的处理方式有删除、均值填充、插值法等，需要根据数据缺失机制和业务背景谨慎选择。

2.2 数据标准化处理

原始数据矩阵X通常存在两个问题：量纲不统一和指标类型不同。GDP以“亿元”为单位，人口以“万人”为单位，绿化率是百分比，直接计算距离没有意义。因此，我们需要消除量纲影响，将数据转化为无量纲的纯数值。最常用的方法是向量归一化，也称为“余弦归一化”。

对于矩阵X中的每一个元素x_{ij}，其标准化值z_{ij}计算公式为：z_{ij} = x_{ij} / sqrt( sum_{i=1}^{m} x_{ij}^2 )

这个公式的本质是，将每个指标下的所有数据都除以该指标所有数据平方和的平方根。经过处理，每个指标下数据的平方和为1。

为什么用这个方法？这种方法能保留原始数据中各指标间的变异信息（即区分度），同时严格地将数据压缩到[0,1]区间（实际上，由于分母是平方和的开方，z_{ij}通常小于1）。它比简单的“最小-最大归一化”更稳定，不易受极端值影响。

2.3 确定指标权重并构建加权矩阵

不同的评价指标重要性不同。在手机评测中，处理器性能的权重可能比收音机功能的权重要高得多。因此，我们需要为每个指标赋予一个权重w_j，且满足sum(w_j) = 1。

权重的确定本身就是一个子课题，常见方法有：

主观赋权法：如德尔菲法、层次分析法（AHP）。依赖专家经验，适用于指标重要性有明显主观倾向的领域。
客观赋权法：如熵权法、CRITIC法。完全基于数据本身的离散程度和冲突性来计算权重，避免了主观性。

确定权重向量W = [w1, w2, ..., wn]后，将标准化矩阵Z的每一列（即每一个指标）乘以其对应的权重，得到加权标准化矩阵V。v_{ij} = w_j * z_{ij}

实操心得：在实际项目中，我推荐“主客观结合”。先用熵权法等客观方法算出一个基准权重，再邀请业务专家根据这个基准进行微调。这样既尊重了数据规律，又融入了业务智慧，结果更容易被各方接受。

2.4 确定正负理想解

这是TOPSIS思想的精髓所在。我们需要在加权标准化矩阵V中，虚拟出两个“极端”对象。

正理想解（A+）：由每个指标在m个对象中的最优值构成。对于效益型指标（越大越好，如利润），取最大值；对于成本型指标（越小越好，如成本），取最小值。
负理想解（A-）：由每个指标在m个对象中的最劣值构成。对于效益型指标，取最小值；对于成本型指标，取最大值。

用公式表示：A+ = [ max(v_{i1}), max(v_{i2}), ..., max(v_{in}) ]（效益型）A- = [ min(v_{i1}), min(v_{i2}), ..., min(v_{in}) ]（效益型）

注意事项：在代码实现中，必须清晰地指明每个指标的类型（效益型或成本型），这是后续计算正确与否的关键。一个常见的错误是混淆了指标类型，导致结果完全相反。

2.5 计算各方案到理想解的距离

我们使用欧几里得距离（即直线距离）来衡量每个真实对象与正负理想解的差距。

对象i到正理想解A+的距离S_i+：S_i+ = sqrt( sum_{j=1}^{n} (v_{ij} - A+_j)^2 )
对象i到负理想解A-的距离S_i-：S_i- = sqrt( sum_{j=1}^{n} (v_{ij} - A-_j)^2 )

为什么用欧氏距离？因为它是最直观、最常用的距离度量方式，几何意义明确。在有些变体中，也会使用曼哈顿距离或其他距离，但欧氏距离是标准TOPSIS的默认选择。

2.6 计算相对贴近度并排序

最后一步，计算每个评价对象与理想解的相对贴近度C_i。C_i = S_i- / (S_i+ + S_i-)

从公式可以看出：

S_i-越大，说明离最差解越远，这是好事。
S_i+越小，说明离最优解越近，这也是好事。
因此，C_i的取值范围在 [0, 1] 之间。C_i越接近1，说明该对象越接近正理想解，同时越远离负理想解，综合评价越高。

我们根据C_i值对所有对象进行降序排序，C_i值最大者即为最优方案。

3. Python代码实现与逐行解析

理解了原理，我们就可以动手编写代码了。下面我将呈现一个模块化、注释清晰的完整实现，并附上关键步骤的解析和避坑指南。

import numpy as np import pandas as pd def topsis(data, weights, impacts, normalization='vector'): """ TOPSIS综合评价算法实现 Parameters: ----------- data : ndarray or DataFrame 原始评价矩阵，m个对象（行）和n个指标（列）。 weights : list or ndarray 指标权重向量，长度需等于指标数n，且和为1。 impacts : list 指标影响方向列表，长度为n。元素为'+'表示效益型（越大越好），为'-'表示成本型（越小越好）。 normalization : str, optional 标准化方法，默认为'vector'（向量归一化）。可选'minmax'（极差归一化）。 Returns: -------- result_df : DataFrame 包含原始数据、标准化数据、正负理想解距离、贴近度及排名的结果DataFrame。 rank : ndarray 对象的排序索引（从优到劣）。 """ # ========== 步骤1：数据准备与校验 ========== # 将输入转换为numpy数组以便计算 if isinstance(data, pd.DataFrame): raw_data = data.values index = data.index.tolist() columns = data.columns.tolist() else: raw_data = np.array(data) index = [f'方案_{i+1}' for i in range(raw_data.shape[0])] columns = [f'指标_{j+1}' for j in range(raw_data.shape[1])] m, n = raw_data.shape # m个对象，n个指标 # 输入校验 if len(weights) != n: raise ValueError(f"权重向量长度({len(weights)})与指标数({n})不匹配！") if not np.isclose(sum(weights), 1.0): raise ValueError("权重向量之和必须为1！") if len(impacts) != n: raise ValueError(f"影响方向列表长度({len(impacts)})与指标数({n})不匹配！") if not all(i in ['+', '-'] for i in impacts): raise ValueError("影响方向列表元素只能为'+'（效益型）或'-'（成本型）！") weights = np.array(weights).reshape(1, -1) # 重塑为1行n列，便于广播计算 # ========== 步骤2：数据标准化 ========== if normalization == 'vector': # 向量归一化 (余弦归一化) norm = np.sqrt(np.sum(raw_data ** 2, axis=0)) # 防止除零错误，如果某列全为0，则归一化后仍为0 norm[norm == 0] = 1 normalized_data = raw_data / norm elif normalization == 'minmax': # 极差归一化，将数据缩放到[0,1] min_vals = raw_data.min(axis=0) max_vals = raw_data.max(axis=0) ranges = max_vals - min_vals ranges[ranges == 0] = 1 # 防止除零错误 normalized_data = (raw_data - min_vals) / ranges else: raise ValueError("normalization参数只能是'vector'或'minmax'") # ========== 步骤3：构建加权标准化矩阵 ========== weighted_data = normalized_data * weights # ========== 步骤4：确定正负理想解 ========== # 根据指标类型，确定每列是取最大值还是最小值作为正理想解 ideal_best = np.zeros(n) ideal_worst = np.zeros(n) for j in range(n): column = weighted_data[:, j] if impacts[j] == '+': # 效益型 ideal_best[j] = np.max(column) ideal_worst[j] = np.min(column) else: # 成本型 ideal_best[j] = np.min(column) ideal_worst[j] = np.max(column) # ========== 步骤5：计算距离 ========== # 计算每个对象到正理想解的距离 dist_to_best = np.sqrt(np.sum((weighted_data - ideal_best) ** 2, axis=1)) # 计算每个对象到负理想解的距离 dist_to_worst = np.sqrt(np.sum((weighted_data - ideal_worst) ** 2, axis=1)) # ========== 步骤6：计算相对贴近度 ========== # 防止分母为零，如果某个对象与正负理想解距离均为0（理论上罕见），则贴近度设为0 denominator = dist_to_best + dist_to_worst denominator[denominator == 0] = np.finfo(float).eps # 加一个极小值 closeness = dist_to_worst / denominator # ========== 步骤7：排序与结果整理 ========== # 按贴近度降序排序（越大越好） rank_order = np.argsort(-closeness) # 排名（从1开始） ranking = np.empty_like(rank_order) ranking[rank_order] = np.arange(1, m + 1) # 构建结果DataFrame result_df = pd.DataFrame({ **{col: raw_data[:, i] for i, col in enumerate(columns)}, # 原始数据 **{f'Norm_{col}': normalized_data[:, i] for i, col in enumerate(columns)}, # 标准化数据 'Dist_to_Best': dist_to_best, 'Dist_to_Worst': dist_to_worst, 'Closeness': closeness, 'Rank': ranking }, index=index) return result_df, rank_order # ========== 示例：使用模拟数据测试 ========== if __name__ == '__main__': # 模拟数据：4个方案，3个指标 np.random.seed(42) # 固定随机种子，确保结果可复现 data = np.array([ [80, 70, 90], # 方案A [60, 90, 80], # 方案B [90, 60, 70], # 方案C [70, 80, 85] # 方案D ]) # 假设指标1和3是效益型（+），指标2是成本型（-，例如缺陷率，越低越好） impacts = ['+', '-', '+'] # 假设权重为[0.3, 0.4, 0.3] weights = [0.3, 0.4, 0.3] # 使用函数计算 result, rank_idx = topsis(data, weights, impacts, normalization='vector') print("原始数据与评价结果：") print(result) print("\n方案优劣排序（从优到劣）：") for i, idx in enumerate(rank_idx): print(f"第{i+1}名: 方案{chr(65+idx)} (贴近度: {result.iloc[idx]['Closeness']:.4f})")

代码关键点解析与避坑指南：

输入校验是专业性的体现：代码开头对权重和、指标类型、数据形状进行了严格检查。在实际应用中，数据来源多样，这些校验能提前暴露问题，避免得到错误结果后大海捞针式地排查。
标准化方法的选择：我提供了两种最常用的标准化方法。vector（默认）更通用稳健；minmax会将所有数据线性映射到[0,1]，但受极端值影响大。选择哪种取决于数据分布和业务需求。
防止除零错误：在标准化和计算贴近度时，都对分母可能为零的情况做了处理。这是保证代码鲁棒性的必备操作，否则遇到特殊数据（如某指标所有值相同）程序会崩溃。
广播（Broadcasting）技巧：weighted_data = normalized_data * weights这行代码利用了NumPy的广播机制。因为weights被重塑为(1, n)，而normalized_data是(m, n)，相乘时weights会自动沿第0轴（对象轴）复制m次，实现了每列数据乘以其对应权重的效果，比写循环高效优雅得多。
结果的可解释性：返回的DataFrame不仅包含最终排名和贴近度，还包含了中间计算过程（标准化值、两个距离）。这非常有利于结果分析和验证。当业务方对排名有疑问时，你可以清晰地展示每个方案在每一步的“得分”和“差距”，增强了模型的说服力。

4. 权重确定：熵权法的Python实现

上面我们假设权重是已知的。但在很多场景下，我们需要从数据本身客观地推导权重。熵权法是一种经典的客观赋权法，其原理是：指标的信息熵越小，其值的变异程度越大，提供的信息量越多，在综合评价中所起的作用越大，权重也应越高。

下面我们实现熵权法，并将其集成到TOPSIS流程中。

def entropy_weight(data): """ 使用熵权法计算指标权重。 Parameters: ----------- data : ndarray 原始评价矩阵，m个对象（行）和n个指标（列）。假设所有指标均为效益型或已正向化。 Returns: -------- weights : ndarray 计算得到的权重向量，长度为n。 """ # 数据标准化（比重标准化） m, n = data.shape # 防止数据中有非正数，进行非负平移（熵权法要求数据>0） if np.any(data <= 0): data = data - np.min(data, axis=0) + 1e-6 # 平移并加一个极小值 # 计算第j个指标下，第i个对象的特征比重 p = data / np.sum(data, axis=0, keepdims=True) # 计算第j个指标的熵值 # 当p_ij=0时，根据极限，p_ij * ln(p_ij) = 0，用np.where处理 with np.errstate(divide='ignore', invalid='ignore'): entropy = -np.sum(p * np.log(p), axis=0) / np.log(m) # 熵值可能由于计算误差略微超过1，将其限制在[0,1] entropy = np.clip(entropy, 0, 1) # 计算差异系数（信息效用值） d = 1 - entropy # 计算权重 weights = d / np.sum(d) return weights # 集成熵权法的TOPSIS流程示例 if __name__ == '__main__': # 使用同样的模拟数据，但假设我们不知道权重 data = np.array([ [80, 70, 90], [60, 90, 80], [90, 60, 70], [70, 80, 85] ]) # 注意：熵权法默认所有指标为效益型。如果数据中有成本型指标，需要先正向化。 # 假设第二个指标是成本型，我们先将其正向化（取倒数或负向变换，这里用简单取负） # 更常见的正向化方法是：对于成本型指标C，正向化值 = max(C) - C 或 1/C (当C>0) data_positive = data.copy() # 假设第2列（索引1）是成本型，使用 max - value 方法正向化 cost_col_idx = 1 data_positive[:, cost_col_idx] = np.max(data[:, cost_col_idx]) - data[:, cost_col_idx] print("正向化后的数据（用于熵权法计算）：") print(data_positive) # 计算熵权 ew_weights = entropy_weight(data_positive) print(f"\n通过熵权法计算得到的权重：{ew_weights}") print(f"权重和：{np.sum(ew_weights):.6f}") # 应非常接近1 # 使用计算出的权重进行TOPSIS评价 # 注意：TOPSIS函数中需要传入原始数据和原始指标类型 impacts = ['+', '-', '+'] # 原始指标类型 result_ew, rank_ew = topsis(data, ew_weights, impacts) print("\n--- 基于熵权法权重的TOPSIS评价结果 ---") print(result_ew[['Closeness', 'Rank']])

熵权法使用心得：

数据正向化是前提：熵权法认为数值越大越好。如果原始数据中有成本型指标，必须先进行正向化处理，否则计算出的权重会完全错误。常用的正向化方法有“取倒数”（要求数据全为正）或“最大值减去原值”。
熵权法的局限性：它完全依赖数据本身的离散程度。如果某个指标在所有评价对象上数值几乎一样（离散程度小），其熵值就大，权重会非常小。这有时与业务常识相悖（例如，“安全事故数”这个指标，可能所有企业都是0，离散度为0，熵权法会赋予其0权重，但这显然不合理）。因此，纯客观的熵权法结果需要结合业务判断进行审视。
与TOPSIS的衔接：在集成流程中，一个易错点是：用于熵权法计算的数据是正向化后的，但传入TOPSIS函数的数据应是原始数据，并正确指定impacts参数。TOPSIS内部会根据impacts来处理指标类型。

5. 实战案例：供应商综合评价

让我们用一个更贴近实际的案例来串联所有知识点。假设某公司需要从5家供应商（S1-S5）中选择一家长期合作伙伴。评价指标有4个：

产品质量合格率（%）：效益型，越大越好。
平均交货周期（天）：成本型，越小越好。
报价（万元）：成本型，越小越好。
售后服务评分（5分制）：效益型，越大越好。

原始数据如下：

import pandas as pd # 定义数据 supplier_data = pd.DataFrame({ '合格率(%)': [99.5, 98.0, 99.8, 97.5, 99.0], '交货周期(天)': [10, 15, 7, 12, 9], '报价(万元)': [120, 105, 130, 100, 115], '售后评分': [4.5, 4.0, 4.8, 3.9, 4.3] }, index=['S1', 'S2', 'S3', 'S4', 'S5']) impacts = ['+', '-', '-', '+'] # 指标类型 print("供应商原始数据：") print(supplier_data)

步骤一：主观权重设定假设采购部专家根据经验，给出主观权重：weights_subjective = [0.35, 0.25, 0.25, 0.15]。质量被看得最重，其次是交货和价格，售后相对次要。

步骤二：熵权法计算客观权重

# 由于交货周期和报价是成本型，需要正向化后才能用熵权法 data_for_entropy = supplier_data.copy() # 成本型指标正向化：max - value data_for_entropy['交货周期(天)'] = data_for_entropy['交货周期(天)'].max() - data_for_entropy['交货周期(天)'] data_for_entropy['报价(万元)'] = data_for_entropy['报价(万元)'].max() - data_for_entropy['报价(万元)'] ew_weights = entropy_weight(data_for_entropy.values) print(f"\n熵权法计算的客观权重：{ew_weights}") # 输出可能类似于：[0.28, 0.30, 0.25, 0.17]

观察：熵权法可能给“交货周期”和“报价”这种在不同供应商间差异明显的指标更高的权重，而“合格率”大家都很高且接近，权重可能略低。这与主观感受可能有差异。

步骤三：主客观结合确定最终权重一种简单的结合方式是加权平均。例如，取主观权重占60%，客观权重占40%。

weights_subjective = np.array([0.35, 0.25, 0.25, 0.15]) weights_combined = 0.6 * weights_subjective + 0.4 * ew_weights weights_combined = weights_combined / np.sum(weights_combined) # 归一化，确保和为1 print(f"\n主客观结合权重（主观60%，客观40%）：{weights_combined}")

步骤四：执行TOPSIS评价

final_weights = weights_combined result_df, rank_order = topsis(supplier_data.values, final_weights, impacts, normalization='vector') result_df.index = supplier_data.index print("\n========== 供应商TOPSIS综合评价结果 ==========") print(result_df[['Dist_to_Best', 'Dist_to_Worst', 'Closeness', 'Rank']].round(4)) print("\n供应商综合排名（从优到劣）：") for rank, supplier_idx in enumerate(rank_order): supplier_name = supplier_data.index[supplier_idx] closeness = result_df.iloc[supplier_idx]['Closeness'] print(f"第{rank+1}名: {supplier_name} (贴近度: {closeness:.4f})")

结果分析与业务解读：假设最终排名是 S3 > S1 > S5 > S2 > S4。

S3排名第一：可能其“合格率”最高且“交货周期”最短的优势，在加权后战胜了其“报价”较高的劣势。这反映了在设定的权重体系下，公司更看重质量和交货速度。
S4排名最后：虽然“报价”最低，但“合格率”和“售后评分”也最低，综合表现不佳。
决策建议：可以选择S3作为首要合作伙伴。同时，可以分析S1和S5的详细得分，它们可能是合格的备选。对于S2和S4，除非在某些特定指标上有不可替代性，否则不予考虑。

这个案例展示了如何将TOPSIS从一个单纯的数学算法，落地为一个包含数据预处理、权重确定、计算分析和业务解读的完整决策支持流程。

6. 常见问题、进阶技巧与避坑指南

在实际使用中，你可能会遇到以下问题。这里我总结了一份“避坑清单”和进阶技巧。

6.1 指标类型与正向化处理

问题：原始数据中同时存在效益型、成本型、区间型等指标，如何处理？解决方案：

效益型：越大越好，无需处理。
成本型：越小越好。在TOPSIS中，通过设定impacts='-'即可，算法内部会处理。如果要用熵权法，则需先正向化（如正向值 = max - 原值或1/原值）。
区间型：期望值落在某个特定区间[a, b]内最好。需要先将其转化为效益型。常用公式：正向值 = 1 - max( (a - 原值), (原值 - b), 0 ) / max( |a - min|, |b - max| )其中min和max是该指标在所有对象中的最小值和最大值。
固定型：期望值越接近某个固定值c越好。可转化为成本型：正向值 = -|原值 - c|（绝对值越小越好）。

重要提示：正向化处理应在数据标准化之前进行。顺序是：原始数据 -> 指标正向化 -> 数据标准化 -> TOPSIS计算。

6.2 权重和为1的强制处理

问题：通过AHP或专家打分法得到的初始权重和可能不为1。解决方案：必须进行归一化。

raw_weights = np.array([0.4, 0.5, 0.3]) # 假设专家打分 normalized_weights = raw_weights / np.sum(raw_weights) print(normalized_weights) # [0.3333, 0.4167, 0.2500]

6.3 结果灵敏度分析

问题：权重或数据微小的变化会导致排名剧烈变动吗？模型结果稳定吗？解决方案：进行灵敏度分析。

权重扰动：将每个权重在±10%范围内随机波动多次，重新计算排名，观察排名变化的频率。如果某个对象的排名经常变动，说明结果对该指标权重敏感，决策时需要谨慎。
蒙特卡洛模拟：假设权重服从某个分布（如以原始权重为均值的正态分布），进行大量随机抽样并计算排名，统计每个对象成为第一名的概率。

def sensitivity_analysis(data, impacts, base_weights, n_iterations=1000, variation=0.1): """简单的权重灵敏度分析""" m = data.shape[0] win_counts = np.zeros(m) np.random.seed(0) for _ in range(n_iterations): # 在基础权重附近随机扰动 perturbed_weights = base_weights * (1 + variation * (2 * np.random.rand(len(base_weights)) - 1)) perturbed_weights = perturbed_weights / np.sum(perturbed_weights) # 重新归一化 _, rank_order = topsis(data, perturbed_weights, impacts) winner_idx = rank_order[0] # 第一名 win_counts[winner_idx] += 1 win_prob = win_counts / n_iterations return win_prob # 使用之前供应商案例的数据和结合权重 win_probs = sensitivity_analysis(supplier_data.values, impacts, final_weights, n_iterations=5000) for i, prob in enumerate(win_probs): print(f"供应商 {supplier_data.index[i]} 成为最佳的概率: {prob:.2%}")

这个分析能告诉你，在权重存在一定不确定性的情况下，当前评选出的“最优”是否真的稳健。

6.4 处理极端值与数据分布

问题：数据中存在极端大或极端小的值，对标准化结果和熵权法影响巨大。解决方案：

数据清洗：在分析前，识别并处理异常值。可以使用箱线图、3σ原则等方法。
稳健的标准化：可以考虑使用“小数定标标准化”或“对数转换”来减弱极端值的影响。
考虑其他方法：如果数据分布极度偏斜，可以考虑使用基于秩次的非参数方法（如秩和比法）作为补充或替代。

6.5 代码优化与大数据处理

问题：当评价对象（m）或指标（n）数量极大时（例如上万行数据），计算效率如何？解决方案：上述代码使用NumPy向量化操作，效率已经很高。对于超大规模数据，还可以：

避免循环：确保所有操作都是数组层面的，如我们代码中所做。
使用更高效的线性代数库：如使用scipy.linalg.norm计算距离。
分块处理：如果数据大到内存无法容纳，可以考虑分块读取和计算。

最后，记住TOPSIS是一个相对评价方法，它告诉你在一组方案里谁相对更好，但不代表这个“更好”的方案在绝对意义上就足够好。它输出的“贴近度”是一个相对值，不能跨不同评价对象集进行比较。在实际应用中，结合绝对阈值（例如，贴近度低于0.6的方案不予考虑）或与其他评价方法（如模糊综合评价、DEA）结合使用，能让你的决策更加科学和可靠。