在日常的 Python 编程生涯中，我们经常会遇到需要处理随机数据的情况。无论是为了进行单元测试以覆盖各种边界条件，还是为了通过数据模拟来构建模型，甚至仅仅是为了做一个有趣的小游戏，生成一个包含随机数的列表都是一项非常基础且重要的技能。Python 为我们提供了强大而灵活的工具来实现这一目标，但你是否知道，根据不同的应用场景——比如是否允许重复、对性能的要求如何——选择不同的方法会带来天壤之别呢？在这篇文章中，我们将深入探讨在 Python 中生成随机数列表的多种方法，不仅会展示代码，更会带你理解它们背后的工作原理，助你做出最明智的选择。
目录
为什么生成随机数列表如此重要？
在我们开始深入代码之前，不妨先想一想为什么我们需要这么做。通常有两种主要的需求场景：
- 唯一性验证：我们需要从大量的数据中随机抽取一部分，且不希望有重复。比如抽奖系统，或者从大数据集中随机选取样本进行训练。
- 概率模拟：我们需要模拟现实世界的随机事件，这时候允许重复是必要的，比如模拟掷骰子或者模拟网络流量。
Python 内置的 INLINECODEfc42928e 模块已经足够应对大多数情况，而在处理大规模数据时，强大的 INLINECODEc6608d78 库则是我们的不二之选。让我们逐一探索这些方法，看看在实际应用中该如何选择。
方法一：使用 random.sample() – 生成不重复的随机数
当我们需要确保列表中的每个数字都是唯一的时，random.sample() 是首选方案。它的工作原理类似于“洗牌后抽取”，这意味着一旦一个数字被选中，它就不会再次出现。
代码示例
import random
# 定义我们想要的随机数范围和数量
start_range = 1
end_range = 100
count = 5 # 我们需要5个随机数
# 生成唯一的随机数列表
# range(1, 101) 创建了一个从1到100的序列
# random.sample 从这个序列中提取了5个不重复的元素
unique_random_numbers = random.sample(range(start_range, end_range + 1), count)
print(f"生成的唯一随机数列表: {unique_random_numbers}")
深度解析
- 核心逻辑：INLINECODEc4763c4e 函数接受两个参数：一个是总体（在这里是一个范围对象），另一个是想要提取的样本数量 INLINECODE1e22099d。重要的是，INLINECODE5b6f83c3 的值不能超过总体的长度，否则 Python 会抛出 INLINECODE55b2769c。
- 底层机制：你可以把它想象成从帽子里面抽纸条。如果帽子里有 100 张纸条，你抽了 5 张，那么这 5 张纸条上的数字肯定是不一样的。
- 适用场景：这种“无放回抽样”非常适合用于生成随机测试用例的 ID，或者在数据科学中进行分层采样。
常见错误处理
如果你尝试从更小的范围中提取更多的样本，例如从 10 个数字中取 11 个，程序会报错。为了写出健壮的代码，我们可以这样处理：
import random
def get_safe_random_sample(population_range, k):
"""安全地生成随机样本，处理数量超出的情况"""
start, end = population_range
population_size = end - start + 1
if k > population_size:
print(f"警告：请求的数量 {k} 大于范围大小 {population_size}。将返回全部范围内的数字。")
k = population_size
return random.sample(range(start, end + 1), k)
# 演示：试图从 1-10 中取 15 个数字
result = get_safe_random_sample((1, 10), 15)
print(result)
方法二：列表推导式与 random.randint() – 经典的随机组合
如果我们允许列表中出现重复的数字（即“有放回抽样”），那么列表推导式配合 random.randint() 是最直观、最符合 Python 风格的做法。
代码示例
import random
# 设定参数
n_numbers = 5
min_val = 1
max_val = 100
# 使用列表推导式生成随机数列表
# random.randint(a, b) 生成一个 a 到 b 之间的整数（包含端点）
random_list = [random.randint(min_val, max_val) for _ in range(n_numbers)]
print(f"允许重复的随机数列表: {random_list}")
为什么选择这种方法？
这种方法的可读性极高。它明确地告诉读者：“我们要执行 INLINECODE8e831396 函数 INLINECODE19d34eff 次，并将结果收集到一个列表中。”这里的 _ 是一个约定俗成的变量名，表示我们在循环中并不关心具体的迭代次数值，只关心循环执行的次数。
实际应用场景：模拟数据
想象一下你需要为一个压力测试脚本生成 10,000 个随机的用户 ID。这种方法简单且有效：
import random
def generate_test_user_ids(count):
# 模拟生成 5 位数的随机用户 ID
return [random.randint(10000, 99999) for _ in range(count)]
# 快速生成 10 个测试 ID
test_ids = generate_test_user_ids(10)
print("测试用户 IDs:", test_ids)
方法三：使用 random.choices() – 高效的“有放回”选择
虽然列表推导式很棒，但在 Python 3.6+ 中，random.choices() 提供了一种更现代、通常也更快的方式来生成允许重复的随机列表。它不仅支持整数，还可以处理任何序列，并且允许你设置权重。
代码示例
import random
# 基本用法：生成 k 个随机数
n = 5
population = range(1, 101)
# random.choices 的 k 参数指定了最终列表的长度
choices_list = random.choices(population, k=n)
print(f"使用 random.choices 生成的列表: {choices_list}")
进阶技巧：加权随机
random.choices() 真正强大的地方在于它支持权重。这意味着你可以让某些数字出现的概率比其他数字更高。这在模拟真实世界场景（如正态分布模拟）时非常有用。
import random
# 定义一个简单的场景：模拟考试得分分布
# 假设大多数人得分在 70-90 之间，极少人得分极低或极高
scores = [60, 70, 80, 90, 100]
# 定义对应的权重（权重越高，被选中的概率越大）
weights = [5, 20, 50, 20, 5]
# 生成 10 个随机分数
weighted_scores = random.choices(scores, weights=weights, k=10)
print(f"加权后的模拟考试分数: {weighted_scores}")
2026 工程化视角：性能基准测试与最佳实践
在我们最近的几个高性能后端项目中，我们发现选择错误的随机数生成方法可能会导致严重的性能瓶颈。在 2026 年的硬件环境下，虽然 CPU 性能强劲，但数据密集型操作（如 AI 模型的数据预处理）对性能的要求依然苛刻。让我们通过对比来看一看，为什么在处理大规模数据时我们需要谨慎选择。
性能大比拼：Python 原生 vs NumPy
为了模拟真实场景，我们将尝试生成 10,000,000（一千万）个随机整数。这是我们在构建推荐系统特征工程时经常遇到的数据量级。
import random
import numpy as np
import time
# 测试数据量
DATA_SIZE = 10_000_000
print(f"正在生成 {DATA_SIZE:,} 个随机数...")
# --- 测试 Python 原生方法 ---
# 注意：对于这种规模，列表推导式可能已经达到 Python 的单线程性能极限
start_time = time.time()
try:
python_list = [random.randint(1, 100) for _ in range(DATA_SIZE)]
python_duration = time.time() - start_time
print(f"Python 原生耗时: {python_duration:.4f} 秒")
except MemoryError:
print("Python 原生方法：内存溢出（对于极大的列表，Python 对象开销很大）")
python_duration = float(‘inf‘) # 标记为无穷大以便后续计算
# --- 测试 NumPy 方法 (推荐) ---
# NumPy 在底层使用 C 语言操作，内存占用极小，且支持向量化操作
start_time = time.time()
numpy_arr = np.random.randint(1, 101, size=DATA_SIZE)
numpy_duration = time.time() - start_time
print(f"NumPy 耗时: {numpy_duration:.4f} 秒")
# 性能计算
if python_duration != float(‘inf‘):
speedup = python_duration / numpy_duration
print(f"
结论: NumPy 比 Python 原生快了约 {speedup:.1f} 倍，且内存占用仅为后者的 1/8 到 1/10。")
else:
print("
结论: 对于大规模数据，NumPy 是唯一可行的选择（避免内存溢出）。")
我们的经验之谈：在生产环境中，只要数据量超过 100,000，我们就强烈建议使用 NumPy。这不仅是为了计算速度，更是为了内存效率。Python 的原生列表是一个指向对象的指针数组，每个整数都是一个完整的 PyObject，包含引用计数、类型信息等。而 NumPy 数组直接在内存块中存储原始的 C 类型数值（如 int64），这种紧凑性使得现代 CPU 的缓存命中率大大提高。
AI 辅助开发：现代工作流中的“氛围编程”
在 2026 年，作为开发者的我们并不孤单。我们有了 AI 结对编程伙伴（如 GitHub Copilot, Cursor Windsurf, Zed）。在我们编写这段随机数生成代码时，我们如何利用 AI 来提升效率，同时保持对代码的掌控力？这就是所谓的 Vibe Coding（氛围编程）——让 AI 处理繁琐的模板，而我们专注于业务逻辑。
场景：快速生成 Mock 数据
假设我们需要为一个物联网 项目生成一批带有时间戳的随机传感器读数。我们可以直接向 AI 描述需求：“创建一个包含时间戳和随机温度（20-30度）的数据列表，使用 Pandas DataFrame 格式。”
虽然 AI 能生成代码，但作为资深开发者，我们必须知道如何审查生成的代码。以下是 AI 可能生成的代码，以及我们需要注意的关键点：
import pandas as pd
import numpy as np
from datetime import datetime, timedelta
# AI 生成的代码示例
# 我们需要检查：是否使用了高性能的 numpy？随机种子是否设置？
def generate_sensor_data(count=1000):
# 1. 设置随机种子（关键！）：确保测试的可复现性
# 如果不设置 seed，每次运行生成的数据不同，难以调试
np.random.seed(42)
# 2. 生成时间范围（使用 numpy 的 datetime64 更加高效）
start_time = datetime.now()
# 使用 timedelta 进行向量化时间计算
time_stamps = [start_time + timedelta(seconds=i) for i in range(count)]
# 3. 生成随机温度数据
# 使用正态分布模拟真实波动，而不是单纯的 randint
# loc: 均值, scale: 标准差
temperatures = np.random.normal(loc=25.0, scale=2.0, size=count)
# 4. 转换为 DataFrame
df = pd.DataFrame({
‘timestamp‘: time_stamps,
‘temperature‘: temperatures
})
return df
# 运行并查看结果
sensor_df = generate_sensor_data(10)
print(sensor_df.head())
审查重点：你可能会注意到，AI 生成了使用 numpy.random.normal 的代码。这比单纯的随机整数更有意义，因为它模拟了真实世界的物理波动。在审查 AI 代码时，我们要特别关注随机种子的设置。在微服务架构中，如果多个节点需要生成一致的模拟数据用于测试，没有种子的随机数会导致分布式调试变得极其困难。
方法四：使用 NumPy – 数据科学与高性能的首选
当我们需要生成数百万甚至上亿个随机数时，标准库的 random 模块可能会显得力不从心。这时，我们需要请出 Python 科学计算生态系统的基石——NumPy。NumPy 的随机数生成器是用 C 语言实现的，速度极快，且提供了丰富的统计分布功能。
代码示例
import numpy as np
# 设定随机种子以保证结果可复现（这在科研和调试中非常重要）
np.random.seed(42)
# 定义参数
size = 5 # 生成 5 个随机数
low = 1
high = 101 # NumPy 的 randint 高值是开区间，所以是 101 才能包含 100
# 使用 NumPy 生成随机整数数组
arr = np.random.randint(low, high, size=size)
# 如果我们需要 Python 原生列表，使用 .tolist()
result_list = arr.tolist()
print(f"NumPy 生成的数组: {arr}")
print(f"转换后的列表: {result_list}")
进阶：使用新的 Generator API
注意：从 NumPy 1.17+ 开始，官方推荐使用新的 INLINECODE448356e6 API（INLINECODE926d6549），而不是上面展示的遗留 np.random.RandomState。这是一个在 2026 年必须遵循的最佳实践。
import numpy as np
# 使用新的 Generator 接口（推荐）
# 这里的 BitGenerator 是 PCG64，比旧的 MT199317 性能更好且统计特性更优
rng = np.random.default_rng(seed=42)
# 生成随机数
arr_new = rng.integers(low=1, high=101, size=5)
print(f"使用新 API 生成的数组: {arr_new}")
为什么要切换到新 API？
新的 default_rng 使用了更快的算法（PCG64），并且在并行计算环境下的随机性质量更高。作为现代开发者，我们应该主动拥抱这些变化。
方法五：使用 random.shuffle() – 洗牌法
除了“生成”一个全新的随机列表，有时我们手里已经有一组有序的数据（比如 1 到 100），我们只需要从中随机拿出一部分。这时，random.shuffle() 就非常有用了。
代码示例
import random
def get_lotto_numbers(pool_size, pick_count):
"""模拟从 pool_size 个号码中随机选取 pick_count 个号码"""
# 1. 创建号码池
pool = list(range(1, pool_size + 1))
# 2. 原地打乱列表顺序
# 注意：shuffle 是原地操作，不返回新列表，会改变原始变量
random.shuffle(pool)
# 3. 切片取前 n 个元素
return pool[:pick_count]
# 模拟从 35 个球中抽取 5 个
winning_numbers = get_lotto_numbers(35, 5)
print(f"本期中奖号码: {winning_numbers}")
安全性警告：不要用 random() 处理密码
最后，但同样重要的一点，是关于安全性。本文讨论的所有方法（INLINECODEdc3439af, INLINECODE08ad4fef）生成的都是伪随机数（PRNG）。这意味着只要知道种子和算法，攻击者就可以预测下一个随机数是什么。
红线规则：如果你正在生成以下内容，请绝对不要使用上述方法：
- 重置密码的 Token
- Session ID 或 CSRF Token
- API 密钥或盐值
解决方案：请务必使用 Python 的 secrets 模块。
import secrets
# 安全地生成一个 10 位的数字安全码
secure_code = secrets.randbelow(1_000_000_0000)
print(f"安全验证码: {secure_code}")
# 从列表中安全地选择
api_keys = ["key_a", "key_b", "key_c"]
selected_key = secrets.choice(api_keys)
print(f"选中的密钥: {selected_key}")
总结
在这篇文章中，我们深入探讨了从简单的脚本编写到高性能工程应用的随机数生成策略。回顾一下，我们的决策指南非常清晰：
- 追求极致性能和大数据处理：首选 NumPy (新 API)，它是现代数据科学和高性能计算的引擎。
- 日常脚本与唯一性需求：
random.sample()仍然是处理无放回抽样的优雅之选。 - 简单的有放回抽样：列表推导式直观易懂，适合阅读性强的小规模逻辑；
random.choices()则提供了加权等高级功能。
希望这篇文章不仅帮你掌握了具体的 Python 技巧，更能让你理解在不同规模下如何做出最明智的技术选择。随着 2026 年技术的不断演进，掌握这些底层原理将使你在 AI 辅助编程的浪潮中依然保持核心竞争力。去试试这些代码吧，看看哪种方法最适合你的项目！