迹忆客 专注技术分享

使用 random.randint() 方法生成 X 和 Y 之间的随机数，例如 random_int = randint(1, 10)。 randint() 方法采用 a 和 b 参数并返回指定范围内的随机整数，包括两个端点。

from random import randint, uniform, randrange


# ✅ 生成 X 和 Y 之间的随机整数
random_int = randint(1, 10)
print(random_int) # 👉️ 2

# -----------------------------------------

# ✅ 在 X 和 Y 之间生成随机浮点数

random_float = uniform(1, 10)
print(random_float) # 👉️ 9.771182999969358

# -----------------------------------------

# ✅ 生成 X 和 Y 之间的随机整数，该整数是 N 的倍数


def random_int_multiple_of_n(start, stop, n):
    return randint(start // n, stop // n) * n


print(random_int_multiple_of_n(3, 30, 3))  # 👉️ 18

第一个示例使用 random.randint() 方法生成 1 到 10 之间的随机整数。

random.randint 函数采用 2 个数字 - a 和 b 作为参数，并返回范围内的随机整数。

请注意 ，该范围是包含在内的——这意味着可以返回 a 和 b。

如果您需要在 X 和 Y 之间生成多个随机数，请使用列表理解。

在 Python 中生成 X 和 Y 之间的随机数列表

要生成 X 和 Y 之间的随机数列表：

1. 使用列表理解来迭代范围对象。
2. 使用 randint() 方法生成 X 和 Y 之间的随机数。
3. 新列表将包含指定范围内的 N 个随机数。

from random import randint


random_numbers = [
    randint(1, 10) for _ in range(3)
]

print(random_numbers)  # 👉️ [6, 1, 3]

我们使用列表理解来迭代范围对象。

列表推导用于对每个元素执行某些操作或选择满足条件的元素子集。

范围类通常用于循环特定次数。

print(list(range(3))) # 👉️ [0, 1, 2]

在每次迭代中，我们使用 randint() 方法生成 1 到 10 之间的随机整数并返回结果。

我们也可以使用 for 循环来获得相同的结果。

from random import randint

random_numbers = []

for _ in range(3):
    random_number = randint(1, 100)
    random_numbers.append(random_number)

print(random_numbers)  # 👉️ [8, 76, 90]

我们使用 for 循环迭代范围对象，在每次迭代中，我们生成一个介于 1 和 100 之间的随机数，并将结果附加到列表中。

list.append() 方法将一个项目添加到列表的末尾。

在 Python 中生成 X 和 Y 之间的随机浮点数

使用 random.uniform() 方法在 X 和 Y 之间生成随机浮点数，例如 random_float = uniform(1, 10)。 random.uniform() 方法采用 a 和 b 参数并返回 a 和 b 之间的浮点数。

from random import uniform


random_float = uniform(1, 10)
print(random_float)  # 👉️ 2.760780697104365

random_float = round(uniform(1, 10), 2)
print(random_float)  # 👉️ 4.07

random.uniform 方法接受 2 个参数 - a 和 b，并返回一个浮点数 N，满足 a <= N <= b。

换句话说，该方法生成指定范围内的浮点数。

如果需要将浮点数舍入到小数点后 N 位，可以使用 round() 函数。

round 函数采用以下 2 个参数：

• number 要四舍五入到小数点后 ndigits 精度的数字
• ndigits 小数点后的位数，运算后的数字应该有（可选）

round 函数返回四舍五入到小数点后 ndigits 精度的数字。

如果我们需要获取 X 和 Y 之间的随机浮点数列表，请使用列表推导。

from random import uniform


random_floats = [
    uniform(1, 10) for _ in range(3)
]

# 👇️ [3.1158677271609627, 4.628433939902649, 9.594889351280727]
print(random_floats)

random_floats = [
    round(uniform(1, 10), 2) for _ in range(3)
]
print(random_floats)  # 👉️ [1.52, 8.34, 7.37]

我们使用列表理解来迭代范围对象，并且在每次迭代中，我们使用 uniform() 方法生成 1 到 10 之间的随机浮点数。

在 X 和 Y 之间生成一个随机数，该数是 Z 的倍数

要在 X 和 Y 之间生成一个随机数，该数是给定数的倍数：

1. 将 X 和 Y 除以给定的数字。
2. 将结果传递给 randint() 方法以生成范围内的随机整数。
3. 将结果乘以给定的数字。

from random import randrange, randint


def random_int_multiple_of_n(start, stop, n):
    return randint(start // n, stop // n) * n


print(random_int_multiple_of_n(3, 30, 3))  # 👉️ 18

# ---------------------------------------------------

def random_int_multiple_of_n(start, stop, n):
    return randrange(start, stop + 1, n)


print(random_int_multiple_of_n(3, 30, 3))  # 👉️ 18

整数除法 / 产生一个浮点数，而整数除法 // 产生一个整数。

我们使用 floor 除法将 X 和 Y 除以 n，并将结果传递给 randint() 方法。

randint() 方法生成一个范围内的随机整数，我们将结果乘以 n。该函数可以返回的最大数量是 30。

如果需要获得 X 和 Y 之间的随机数列表，这些随机数是 Z 的倍数，则可以使用列表推导。

from random import randint


def random_int_multiple_of_n(start, stop, n):
    return randint(start // n, stop // n) * n


list_of_random_multiples = [
    random_int_multiple_of_n(5, 100, 5) for _ in range(3)
]
print(list_of_random_multiples)  # 👉️ [15, 100, 10]

另一种方法是使用带步骤的 randrange() 方法。

from random import randrange


def random_int_multiple_of_n(start, stop, n):
    return randrange(start, stop + 1, n)


print(random_int_multiple_of_n(3, 30, 3))  # 👉️ 18

random.randrange 方法返回从 range(start, stop, step) 中随机选择的元素。

from random import randrange


random_int = randrange(10)
print(random_int)  # 👉️ 7

start 值包含在内，而 stop 值不包含在内。

stop 值是唯一的（最多，但不包括），因此我们必须将其加 1 以在可能的结果中包含 30。