如何用Numpy或原生Python生成指定范围且总和固定的n个随机浮点数？

合法性检查逻辑 #

首先必须判断目标总和是否在边界可覆盖的范围内：

• 最小可能总和：n * lower（所有数取下界）
• 最大可能总和：n * upper（所有数取上界）
  如果目标总和不在[n*lower, n*upper]区间内，直接抛出ValueError。

原生Python实现 #

以下自定义函数基于均匀分布生成随机数，通过迭代调整确保所有数值在边界内且总和符合要求：

import random

def generate_constrained_floats(n, lower, upper, target_sum):
    # 合法性校验
    min_total = n * lower
    max_total = n * upper
    if not (min_total <= target_sum <= max_total):
        raise ValueError("目标总和超出边界可达到的范围")
    
    # 生成初始随机数
    nums = [random.uniform(lower, upper) for _ in range(n)]
    current_sum = sum(nums)
    delta = target_sum - current_sum
    
    # 初步调整总和
    nums = [x + delta / n for x in nums]
    
    # 迭代修正边界溢出
    while True:
        exceeded = []
        deficit = []
        total_excess = 0.0
        total_deficit = 0.0
        
        # 标记并修正超出边界的数值
        for i, num in enumerate(nums):
            if num > upper:
                excess = num - upper
                exceeded.append((i, excess))
                total_excess += excess
                nums[i] = upper
            elif num < lower:
                diff = lower - num
                deficit.append((i, diff))
                total_deficit += diff
                nums[i] = lower
        
        # 无溢出则退出循环
        if not exceeded and not deficit:
            break
        
        # 分配溢出值到未超限的位置
        if total_excess > 0:
            available_indices = [i for i, num in enumerate(nums) if num < upper]
            if not available_indices:
                raise ValueError("无法调整到满足所有约束")
            per_index = total_excess / len(available_indices)
            for i in available_indices:
                nums[i] += per_index
        elif total_deficit > 0:
            available_indices = [i for i, num in enumerate(nums) if num > lower]
            if not available_indices:
                raise ValueError("无法调整到满足所有约束")
            per_index = total_deficit / len(available_indices)
            for i in available_indices:
                nums[i] -= per_index
    
    # 浮点精度微调，确保总和完全匹配
    final_sum = sum(nums)
    if abs(final_sum - target_sum) > 1e-9:
        nums[-1] += target_sum - final_sum
    
    return nums

Numpy实现（高效批量生成） #

针对大规模数据，用Numpy实现更高效：

import numpy as np

def generate_constrained_floats_np(n, lower, upper, target_sum):
    min_total = n * lower
    max_total = n * upper
    if not (min_total <= target_sum <= max_total):
        raise ValueError("目标总和超出边界可达到的范围")
    
    # 生成初始均匀分布数组
    nums = np.random.uniform(lower, upper, size=n)
    current_sum = nums.sum()
    delta = target_sum - current_sum
    
    # 初步调整总和
    nums += delta / n
    
    # 迭代修正边界溢出
    while True:
        mask_upper = nums > upper
        mask_lower = nums < lower
        
        if not np.any(mask_upper) and not np.any(mask_lower):
            break
        
        # 处理上限溢出
        if np.any(mask_upper):
            excess = nums[mask_upper] - upper
            total_excess = excess.sum()
            nums[mask_upper] = upper
            available_mask = ~mask_upper
            if not np.any(available_mask):
                raise ValueError("无法调整到满足所有约束")
            nums[available_mask] += total_excess / available_mask.sum()
        
        # 处理下限不足
        if np.any(mask_lower):
            deficit = lower - nums[mask_lower]
            total_deficit = deficit.sum()
            nums[mask_lower] = lower
            available_mask = ~mask_lower
            if not np.any(available_mask):
                raise ValueError("无法调整到满足所有约束")
            nums[available_mask] -= total_deficit / available_mask.sum()
    
    # 微调浮点精度
    nums[-1] += target_sum - nums.sum()
    
    return nums.tolist()

使用示例 #

1. 生成4个[-10.0, 2.0]之间、总和为0的浮点数：

print(generate_constrained_floats(4, -10.0, 2.0, 0.0))
# 示例输出（随机结果）：[-1.0, -1.5, 1.75, 1.75]

2. 生成5个[-10.0, 1.0]之间、总和为1.0的浮点数：

print(generate_constrained_floats(5, -10.0, 1.0, 1.0))
# 示例输出（随机结果）：[0.5, -0.5, 0.0, 0.0, 1.0]

3. 非法场景（无法生成）：

generate_constrained_floats(3, -2.0, -1.0, 1.0)
# 抛出 ValueError: 目标总和超出边界可达到的范围

内容的提问来源于stack exchange，提问作者oakca