生成 0 到 9 之间的随机整数答案

【问题标题】：Generate random integers between 0 and 9生成 0 到 9 之间的随机整数
【发布时间】：2011-04-29 03:43:38
【问题描述】：

如何在 Python 中生成 0 到 9（含）之间的随机整数？

例如，0、1、2、3、4、5、6、7、8、9

【问题讨论】：

0-9 的“随机”一代的漂亮风格点

标签： python random integer

【解决方案1】：

secrets 模块是 Python 3.6 中的新模块。这比 random 模块在密码学或安全方面的使用要好。

随机打印 0-9 范围内的整数：

from secrets import randbelow
print(randbelow(10))

详情请见PEP 506。

请注意，这实际上取决于用例。使用random 模块，您可以设置随机种子，这对伪随机但可重现的结果很有用，而secrets 模块则无法做到这一点。

random 模块也更快（在 Python 3.9 上测试）：

>>> timeit.timeit("random.randrange(10)", setup="import random")
0.4920286529999771
>>> timeit.timeit("secrets.randbelow(10)", setup="import secrets")
2.0670733770000425

【讨论】：

这将改善答案，应该添加。如果可用，应始终添加更具安全意识的答案。
假设secrets 会比random 慢得多是否合理？一定有缺点的地方。
@MarkRansom 查看编辑

【解决方案2】：

您可以尝试从 Python 导入 random 模块，然后让它在九个数字之间进行选择。这真的很基础。

import random
numbers = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]

如果您以后要使用它，您可以尝试将计算机选择的值放入变量中，但如果没有，打印功能应该这样工作：

choice = random.choice(numbers)
print(choice)

【讨论】：

【解决方案3】：

您需要random python 模块，它是您的标准库的一部分。使用代码...

from random import randint

num1= randint(0,9)

这会将变量 num1 设置为介于 0 和 9 之间的随机数。

【讨论】：

也可以选择randrange(10)。

【解决方案4】：

我想我会用quantumrand 添加这些答案，它使用了 ANU 的量子数生成器。不幸的是，这需要互联网连接，但如果您关心数字的“随机性”，那么这可能会很有用。

https://pypi.org/project/quantumrand/

例子

import quantumrand

number = quantumrand.randint(0, 9)

print(number)

输出：4

文档有很多不同的示例，包括掷骰子和列表选择器。

【讨论】：

谁能指望有互联网连接？ :) 你可以添加代码来捕获连接异常，在这种情况下只返回标准的random.randrange(10)。
ANU 网站声称它是“真正的随机”。这个宇宙中没有“真正的随机”这样的东西，尤其是那些通过互联网发送的数字。

【解决方案5】：

我会尝试以下方法之一：

1.> numpy.random.randint

import numpy as np
X1 = np.random.randint(low=0, high=10, size=(15,))

print (X1)
>>> array([3, 0, 9, 0, 5, 7, 6, 9, 6, 7, 9, 6, 6, 9, 8])

2.> numpy.random.uniform

import numpy as np
X2 = np.random.uniform(low=0, high=10, size=(15,)).astype(int)

print (X2)
>>> array([8, 3, 6, 9, 1, 0, 3, 6, 3, 3, 1, 2, 4, 0, 4])

3.> numpy.random.choice

import numpy as np
X3 = np.random.choice(a=10, size=15 )

print (X3)
>>> array([1, 4, 0, 2, 5, 2, 7, 5, 0, 0, 8, 4, 4, 0, 9])

4.> random.randrange

from random import randrange
X4 = [randrange(10) for i in range(15)]

print (X4)
>>> [2, 1, 4, 1, 2, 8, 8, 6, 4, 1, 0, 5, 8, 3, 5]

5.> random.randint

from random import randint
X5 = [randint(0, 9) for i in range(0, 15)]

print (X5)
>>> [6, 2, 6, 9, 5, 3, 2, 3, 3, 4, 4, 7, 4, 9, 6]

速度：

► np.random.uniform 和 np.random.randint 比 np.random.choice, random 快得多（快约 10 倍）。 randrange, random.randint .

%timeit np.random.randint(low=0, high=10, size=(15,))
>> 1.64 µs ± 7.83 ns per loop (mean ± std. dev. of 7 runs, 1000000 loops each)

%timeit np.random.uniform(low=0, high=10, size=(15,)).astype(int)
>> 2.15 µs ± 38.6 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

%timeit np.random.choice(a=10, size=15 )
>> 21 µs ± 629 ns per loop (mean ± std. dev. of 7 runs, 10000 loops each)

%timeit [randrange(10) for i in range(15)]
>> 12.9 µs ± 60.4 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

%timeit [randint(0, 9) for i in range(0, 15)]
>> 20 µs ± 386 ns per loop (mean ± std. dev. of 7 runs, 100000 loops each)

注意事项：

1.> np.random.randint 在半开区间 [low, high) 上生成随机整数。

2.> np.random.uniform 在半开区间 [low, high) 上生成均匀分布的数字。

3.> np.random.choice 在半开区间 [low, high) 上生成一个随机样本，就好像参数 a 是 np.arange(n)。

4.> random.randrange(stop) 从范围（开始、停止、步进）中生成一个随机数。

5.> random.randint(a, b) 返回一个随机整数 N，使得 a

6.> astype(int) 将 numpy 数组转换为 int 数据类型。

7.> 我选择了 size = (15,)。这将为您提供一个长度为 15 的 numpy 数组。

【讨论】：

ModuleNotFoundError: No module named 'numpy'
如果出现该错误，您是否安装了 numpy (pip install numpy) 并使用 import numpy as np 导入了它？

【解决方案6】：

试试：

from random import randrange
print(randrange(10))

文档： https://docs.python.org/3/library/random.html#random.randrange

【讨论】：

请注意，这些是伪随机数，它们不是加密安全的。在您不希望攻击者猜测您的数字的任何情况下都不要使用它。使用secrets 模块获得更好的随机数。参考：docs.python.org/3/library/random.html
特别是，secrets 应该优先于 random 模块中的默认伪随机数生成器使用，该生成器是为建模和模拟而设计的，而不是安全或密码学。
为了避免任何人必须导航到秘密模块来完成此操作：import secretssecrets.randbelow(10)
请注意，secrets 模块是在 Python 3.6 版本中首次添加的

【解决方案7】：

虽然许多帖子演示了如何获得一个随机整数，但最初的问题询问如何生成随机整数s（复数）：

如何在 Python 中生成 0 到 9（含）之间的随机整数？

为了清楚起见，这里我们演示如何获取多个随机整数。

给定

>>> import random


lo = 0
hi = 10
size = 5

代码

多个随机整数

# A
>>> [lo + int(random.random() * (hi - lo)) for _ in range(size)]
[5, 6, 1, 3, 0]

# B
>>> [random.randint(lo, hi) for _ in range(size)]
[9, 7, 0, 7, 3]

# C
>>> [random.randrange(lo, hi) for _ in range(size)]
[8, 3, 6, 8, 7]

# D
>>> lst = list(range(lo, hi))
>>> random.shuffle(lst)
>>> [lst[i] for i in range(size)]
[6, 8, 2, 5, 1]

# E
>>> [random.choice(range(lo, hi)) for _ in range(size)]
[2, 1, 6, 9, 5]

随机整数样本

# F
>>> random.choices(range(lo, hi), k=size)
[3, 2, 0, 8, 2]

# G
>>> random.sample(range(lo, hi), k=size)
[4, 5, 1, 2, 3]

详情

一些帖子演示了如何在本地生成多个随机整数。¹以下是一些解决隐含问题的选项：

A：random.random 返回[0.0, 1.0) 范围内的随机浮点数
B：random.randint 返回一个随机整数N 使得a <= N <= b
C：random.randrange 别名为randint(a, b+1)
D：random.shuffle 就地打乱序列
E：random.choice 从非空序列中返回一个随机元素
F：random.choices 从总体中返回 k 选择（有替换，Python 3.6+）
G：random.sample 从总体中返回 k 唯一选择（无需替换）：²

另请参阅 R. Hettinger 的 talk 关于使用 random 模块中的示例进行分块和别名的文章。

下面是标准库和 Numpy 中一些随机函数的对比：

| | random                | numpy.random                     |
|-|-----------------------|----------------------------------|
|A| random()              | random()                         |
|B| randint(low, high)    | randint(low, high)               |
|C| randrange(low, high)  | randint(low, high)               |
|D| shuffle(seq)          | shuffle(seq)                     |
|E| choice(seq)           | choice(seq)                      |
|F| choices(seq, k)       | choice(seq, size)                |
|G| sample(seq, k)        | choice(seq, size, replace=False) |

您还可以将 Numpy 中的众多 distributions 之一快速转换为随机整数样本。³

例子

>>> np.random.normal(loc=5, scale=10, size=size).astype(int)
array([17, 10,  3,  1, 16])

>>> np.random.poisson(lam=1, size=size).astype(int)
array([1, 3, 0, 2, 0])

>>> np.random.lognormal(mean=0.0, sigma=1.0, size=size).astype(int)
array([1, 3, 1, 5, 1])

_{¹即@John Lawrence Aspden、@ST Mohammed、@SiddTheKid、@user14372、@zangw 等。}_{²@prashanth 提到这个模块显示一个整数。}_{³由@Siddharth Satpathy 演示}

【讨论】：

【解决方案8】：

通过random.shuffle试试这个

>>> import random
>>> nums = range(10)
>>> random.shuffle(nums)
>>> nums
[6, 3, 5, 4, 0, 1, 2, 9, 8, 7]

【讨论】：

这不是正确答案，应该删除。

【解决方案9】：

OpenTURNS 不仅允许模拟随机整数，还允许使用UserDefined 定义的类定义相关分布。

以下模拟了分布的 12 种结果。

import openturns as ot
points = [[i] for i in range(10)]
distribution = ot.UserDefined(points) # By default, with equal weights.
for i in range(12):
    x = distribution.getRealization()
    print(i,x)

打印出来：

0 [8]
1 [7]
2 [4]
3 [7]
4 [3]
5 [3]
6 [2]
7 [9]
8 [0]
9 [5]
10 [9]
11 [6]

括号在那里是因为x 是一维的Point。在一次调用 getSample 时生成 12 个结果会更容易：

sample = distribution.getSample(12)

会产生：

>>> print(sample)
     [ v0 ]
 0 : [ 3  ]
 1 : [ 9  ]
 2 : [ 6  ]
 3 : [ 3  ]
 4 : [ 2  ]
 5 : [ 6  ]
 6 : [ 9  ]
 7 : [ 5  ]
 8 : [ 9  ]
 9 : [ 5  ]
10 : [ 3  ]
11 : [ 2  ]

关于这个主题的更多细节在这里：http://openturns.github.io/openturns/master/user_manual/_generated/openturns.UserDefined.html

【讨论】：

【解决方案10】：

来自random 模块的文档页面：

警告：此模块的伪随机生成器不应用于安全目的。如果您使用 os.urandom() 或 SystemRandom 需要一个加密安全的伪随机数生成器。

random.SystemRandom，在 Python 2.4 中引入，被认为是cryptographically secure。在撰写本文时，它仍可在 Python 3.7.1 中使用。

>>> import string
>>> string.digits
'0123456789'
>>> import random
>>> random.SystemRandom().choice(string.digits)
'8'
>>> random.SystemRandom().choice(string.digits)
'1'
>>> random.SystemRandom().choice(string.digits)
'8'
>>> random.SystemRandom().choice(string.digits)
'5'

除了string.digits，range 可以用于其他一些答案以及理解。根据您的需要混合搭配。

【讨论】：

很好的验证过程

【解决方案11】：

这更像是一种数学方法，但它 100% 的时间都有效：

假设您想使用random.random() 函数生成介于a 和b 之间的数字。为此，只需执行以下操作：

num = (b-a)*random.random() + a;

当然，你可以生成更多的数字。

【讨论】：

这会生成一个float 值。获取纯整数：num = int(round((b-a)*random.random(),1)) + a

【解决方案12】：

生成 0 到 9 之间的随机整数。

import numpy
X = numpy.random.randint(0, 10, size=10)
print(X)

输出：

[4 8 0 4 9 6 9 9 0 7]

【讨论】：

【解决方案13】：

from random import randint

x = [randint(0, 9) for p in range(0, 10)]

这会生成 0 到 9 范围内的 10 个伪随机整数。

【讨论】：

在试运行 2,500 行 (row_count) 时，我只想要 10 行 (RANDOM_LIMIT)，所以我根据这个答案使用了 random_row_nos = [randint(1, row_count) for p in range(0, RANDOM_LIMIT)]，它第一次就奏效了！

【解决方案14】：

如果是连续数字，randint 或 randrange 可能是最好的选择，但如果您在一个序列中有多个不同的值（即 list），您也可以使用 choice：

>>> import random
>>> values = list(range(10))
>>> random.choice(values)
5

choice 也适用于非连续样本中的一项：

>>> values = [1, 2, 3, 5, 7, 10]
>>> random.choice(values)
7

如果您需要它“加密强大”，那么在 python 3.6 和更新版本中还有一个 secrets.choice：

>>> import secrets
>>> values = list(range(10))
>>> secrets.choice(values)
2

【讨论】：

如果我们想要序列中的更多数字怎么办？
如果他们不应该更换：random.sample。通过替换，您可以使用带有 choice 的理解：例如，对于包含 3 个带有替换的随机值的列表：[choice(values) for _ in range(3)]

【解决方案15】：

>>> import random
>>> random.randrange(10)
3
>>> random.randrange(10)
1

要获得十个样本的列表：

>>> [random.randrange(10) for x in range(10)]
[9, 0, 4, 0, 5, 7, 4, 3, 6, 8]

【讨论】：

【解决方案16】：

我在 Python 3.6 上运气更好

str_Key = ""                                                                                                
str_RandomKey = ""                                                                                          
for int_I in range(128):                                                                                    
      str_Key = random.choice('0123456789')
      str_RandomKey = str_RandomKey + str_Key

只需添加 'ABCD' 和 'abcd' 或 '^!~=->

【讨论】：

Nitpick：str_RandomKey 不是原始海报所需的整数。

【解决方案17】：

最好的方法是使用导入随机函数

import random
print(random.sample(range(10), 10))

或没有任何库导入：

n={} 
for i in range(10):
    n[i]=i

for p in range(10):
    print(n.popitem()[1])

这里的popitems 从字典n 中删除并返回一个任意值。

【讨论】：

【解决方案18】：

如果您想使用 numpy，请使用以下内容：

import numpy as np
print(np.random.randint(0,10))

【讨论】：

你可以告诉一些关于“numpy”的事情。
是的。感谢您的链接。但我的意思是，您可以通过在引用两行代码之前提供详细信息来改进您的答案；喜欢出于什么原因有人更愿意使用它而不是已经内置的东西。无论如何，你没有义务这样做。

【解决方案19】：

random.sample是另一个可以使用的

import random
n = 1 # specify the no. of numbers
num = random.sample(range(10),  n)
num[0] # is the required number

【讨论】：

【解决方案20】：

选择数组的大小（在本例中，我选择大小为 20）。然后，使用以下内容：

import numpy as np   
np.random.randint(10, size=(1, 20))

您可以期望看到以下形式的输出（每次运行时都会返回不同的随机整数；因此您可以期望输出数组中的整数与下面给出的示例不同)。

array([[1, 6, 1, 2, 8, 6, 3, 3, 2, 5, 6, 5, 0, 9, 5, 6, 4, 5, 9, 3]])

【讨论】：

了解 Numpy 如何生成指定大小的随机数组也很有帮助，而不仅仅是单个随机数。（文档：numpy.random.randint）

【解决方案21】：

import random
print(random.randint(0,9))

random.randint(a, b)

返回一个随机整数 N，使得 a

文档：https://docs.python.org/3.1/library/random.html#random.randint

【讨论】：

至于3.8 仍然“返回一个随机整数N，使得a <= N <= b。randrange(a, b+1) 的别名”@Yly

【解决方案22】：

试试这个：

from random import randrange, uniform

# randrange gives you an integral value
irand = randrange(0, 10)

# uniform gives you a floating-point value
frand = uniform(0, 10)

【讨论】：