Python循环统计：Wilcoxon符号秩检验教程

本教程聚焦于利用Python高效处理批量统计比较，特别是针对需要重复进行Wilcoxon符号秩检验的多组配对数值向量。通过将数据向量组织成列表，并结合循环结构，实现数据处理和结果收集的自动化，避免了手动编写大量重复代码，显著提高代码的可维护性和执行效率。文章详细阐述了如何通过数据结构化和循环迭代，解决重复性统计检验的自动化难题，并提供示例代码和实现步骤，展示了如何定义示例数据、组织配对向量、执行Wilcoxon检验以及存储p值。此外，还强调了数据对齐的严谨性、结果的结构化存储以及替代数据结构（如字典）的应用，旨在为数据分析和科学研究提供一套灵活且强大的解决方案。

在数据分析和科学研究中，我们经常需要对多组配对数据进行统计检验。例如，比较不同处理条件下同一指标的表现，或者在前后测量中评估某种干预的效果。当数据量较大，涉及数十甚至上百对向量时，手动为每一对数据编写统计检验代码不仅效率低下，而且极易出错。Python提供了强大的循环结构和科学计算库，能够优雅地解决这一问题。

挑战：重复性统计检验的自动化

假设我们有两组数据，每组包含多个数值向量，例如 hc_mcp, hc_pct 等和 tw_mcp, tw_pct 等。我们的目标是计算每对对应向量（如 hc_mcp 与 tw_mcp，hc_pct 与 tw_pct）之间的Wilcoxon符号秩检验p值。如果采用以下手动方式，当向量数量众多时，代码将变得冗长且难以管理：

from scipy.stats import wilcoxon

# 假设已定义 hc_mcp, tw_mcp 等向量
# res = wilcoxon(hc_mcp, tw_mcp)
# p_value = res.pvalue

# res = wilcoxon(hc_pct, tw_pct)
# p_value = res.pvalue
# ... 重复大量类似代码

这种方法显然不适用于大规模数据。为了实现自动化，我们需要一种机制来动态地访问和处理这些配对向量。

核心策略：数据结构化与循环迭代

解决上述问题的关键在于如何有效地组织数据，使其能够被循环结构访问。最直接且有效的方法是将所有同类别的向量分别放入一个列表中，并确保这些列表中的配对向量在各自列表中的索引位置是一致的。

例如，如果 hc_mcp 对应 tw_mcp，并且它们分别是 hc_list 和 tw_list 中的第一个元素，那么我们就可以通过它们的索引 0 来同时访问它们。

示例代码与实现

首先，我们定义示例数据，这些数据代表了不同测量指标（如 mcp, pct, gcc 等）在两个不同条件（hc 和 tw）下的数值。

import numpy as np
from scipy.stats import wilcoxon

# 示例数据定义
hc_mcp = [0.45, 0.43, 0.46, 0.46, 0.45, 0.39, 0.48, 0.47, 0.50, 0.45, 0.47, 0.47, 0.46]
hc_pct = [0.44, 0.48, 0.45, 0.46, 0.47, 0.37, 0.56, 0.46, 0.49, 0.53, 0.46, 0.47, 0.48]
hc_gcc = [0.51, 0.56, 0.57, 0.54, 0.55, 0.58, 0.51, 0.54, 0.55, 0.54, 0.55, 0.53, 0.54]
hc_bcc = [0.56, 0.62, 0.64, 0.63, 0.60, 0.65, 0.60, 0.64, 0.64, 0.61, 0.63, 0.58, 0.63]
hc_scc = [0.68, 0.73, 0.74, 0.71, 0.72, 0.73, 0.70, 0.72, 0.72, 0.72, 0.71, 0.67, 0.73]

tw_mcp = [0.47, 0.46, 0.44, 0.48, 0.45, 0.45, 0.46, 0.44, 0.47, 0.46, 0.50, 0.49, 0.48]
tw_pct = [0.46, 0.48, 0.45, 0.48, 0.47, 0.45, 0.46, 0.43, 0.43, 0.49, 0.49, 0.47, 0.44]
tw_gcc = [0.56, 0.56, 0.55, 0.57, 0.52, 0.56, 0.53, 0.55, 0.55, 0.55, 0.56, 0.55, 0.56]
tw_bcc = [0.62, 0.63, 0.60, 0.63, 0.61, 0.63, 0.62, 0.63, 0.63, 0.62, 0.63, 0.61, 0.65]
tw_scc = [0.71, 0.70, 0.70, 0.71, 0.68, 0.74, 0.72, 0.73, 0.70, 0.68, 0.69, 0.70, 0.71]

# 将配对向量组织成列表，确保顺序一致
list_hc = [hc_mcp, hc_pct, hc_gcc, hc_bcc, hc_scc]
list_tw = [tw_mcp, tw_pct, tw_gcc, tw_bcc, tw_scc]

# 用于存储p值的列表
p_values = []

# 遍历列表进行统计检验
for i in range(len(list_hc)):
    # 从两个列表中取出对应位置的向量
    data_hc = list_hc[i]
    data_tw = list_tw[i]

    # 执行Wilcoxon符号秩检验
    # 注意：Wilcoxon符号秩检验适用于配对样本，要求两个样本长度相同
    try:
        statistic, p_val = wilcoxon(data_hc, data_tw)
        p_values.append(p_val)
    except ValueError as e:
        print(f"Error performing Wilcoxon test for pair {i}: {e}")
        p_values.append(np.nan) # 如果出错，记录NaN

print("计算得到的p值列表：")
print(p_values)

在这个示例中：

1. 我们创建了 list_hc 和 list_tw，分别包含了所有 hc 和 tw 组的向量。关键在于，list_hc[0] (即 hc_mcp) 与 list_tw[0] (即 tw_mcp) 构成一对，list_hc[1] 与 list_tw[1] 构成另一对，以此类推。
2. 我们使用 for i in range(len(list_hc)) 循环来遍历这些列表。在每次迭代中，i 代表当前配对向量的索引。
3. 通过 list_hc[i] 和 list_tw[i]，我们能够动态地获取当前需要进行比较的两个向量。
4. scipy.stats.wilcoxon() 函数被调用以执行统计检验，并将返回的p值添加到 p_values 列表中。
5. 添加了简单的错误处理，以应对可能出现的 ValueError，例如当两个样本长度不一致时。

注意事项与最佳实践

1. 数据对齐的严谨性： 这是此方法成功的基石。务必确保 list_hc 和 list_tw 中对应位置的向量是需要进行配对比较的。如果数据来源复杂，建议在构建这些列表时进行严格的验证。

2. 结果的结构化存储： 仅仅存储p值可能不足以进行后续分析。通常，我们还需要记录检验的统计量、自由度，以及更重要的是，当前比较的名称。可以考虑使用字典或Pandas DataFrame来存储结果：

   import pandas as pd
   
   # ... (数据定义和列表创建) ...
   
   # 假设我们有对应的名称列表
   metric_names = ['mcp', 'pct', 'gcc', 'bcc', 'scc']
   
   results = [] # 存储字典形式的结果
   
   for i in range(len(list_hc)):
       data_hc = list_hc[i]
       data_tw = list_tw[i]
       metric_name = metric_names[i]
   
       try:
           statistic, p_val = wilcoxon(data_hc, data_tw)
           results.append({
               'Metric': metric_name,
               'Statistic': statistic,
               'P_value': p_val
           })
       except ValueError as e:
           print(f"Error for {metric_name}: {e}")
           results.append({
               'Metric': metric_name,
               'Statistic': np.nan,
               'P_value': np.nan
           })
   
   results_df = pd.DataFrame(results)
   print("\n结构化结果 (Pandas DataFrame):")
   print(results_df)

   使用DataFrame可以更清晰地展示每个检验的结果，便于后续的筛选、排序和报告。

3. 可扩展性： 这种基于列表和循环的方法具有极强的可扩展性。无论你有5对向量还是500对向量，核心的代码逻辑保持不变，只需确保输入列表的构建是正确的。

4. 替代数据结构：字典： 如果你的数据向量没有严格的顺序，或者你更倾向于通过名称来引用它们，可以将数据组织成字典。例如：

   data_hc_dict = {
       'mcp': hc_mcp,
       'pct': hc_pct,
       # ...
   }
   data_tw_dict = {
       'mcp': tw_mcp,
       'pct': tw_pct,
       # ...
   }
   
   # 遍历字典的键（即指标名称）
   for metric_name in data_hc_dict.keys():
       data_hc = data_hc_dict[metric_name]
       data_tw = data_tw_dict[metric_name]
       # 执行wilcoxon检验
       # ...

   这种方式通过键名匹配，避免了严格的索引依赖，提高了代码的健壮性。

总结

通过将需要进行批量统计比较的配对数值向量结构化为列表（或字典），并结合Python的 for 循环，我们可以高效地自动化重复性统计检验。这种方法不仅减少了代码量，提高了可读性和可维护性，也为处理大规模数据集提供了灵活且强大的解决方案。在实际应用中，结合Pandas等库进行结果的结构化存储，将进一步提升数据分析的效率和质量。

以上就是本文的全部内容了，是否有顺利帮助你解决问题？若是能给你带来学习上的帮助，请大家多多支持golang学习网！更多关于文章的相关知识，也可关注golang学习网公众号。