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

Question

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

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

Answer 1

尝试 random.randrange：

from random import randrange
print(randrange(10))

Answer 2

尝试 random.randint：

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

---

文档状态：

random.randint(a, b)

返回一个随机整数N，使得a <= N <= b。 randrange(a, b+1) 的别名。

Answer 3

试试这个：

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)

Answer 4

from random import randint

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

这会生成 10 个介于 0 到 9 之间的伪随机整数。

Answer 5

secrets 模块是新的Python 3.6。这比 random 更好用于加密或安全用途的模块。

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

from secrets import randbelow
print(randbelow(10))

有关详细信息，请参阅 PEP 506< /a>.

请注意，这实际上取决于用例。使用 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

Answer 6

我会尝试以下其中一项：

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.randrange、random 快得多（大约快 10 倍）。兰特。

%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 生成随机整数半开区间 [低点，高点)。

2.> np.random.uniform 生成均匀分布的数字在半开区间[最低点，最高点）。

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

4.> random.randrange(stop) 从 range(开始、停止、步骤）。

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

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

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

Answer 7

选择数组的大小（在本例中，我选择的大小为 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]])

Answer 8

虽然许多帖子演示了如何获取一个随机整数，但最初的问题是如何生成随机整数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 的演讲使用 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 中对随机整数样本的分布。³

示例

>>> 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])

_{^{1< /sup>即@John Lawrence Aspden、@ST Mohammed、@SiddTheKid、@user14372、@zangw 等人
2}@prashanth 提到此模块显示一个整数。
³由@Siddharth Satpathy演示}

Answer 9

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

from random import randint

num1= randint(0,9)

这会将变量 num1 设置为 0 和 9 之间的随机数（含）。

Answer 10

通过 random.shuffle 尝试一下

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

Answer 11

如果是连续数字 randint 或 < a href="https://docs.python.org/library/random.html#random.randrange" rel="noreferrer">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

如果您需要它“加密强度高”，还有一个 secrets.choice 在 python 3.6 及更高版本中：

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

Answer 12

如果你想使用 numpy 那么使用以下命令：

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

Answer 13

>>> 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]

Answer 14

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

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

    

如果稍后要使用计算机选择的值，则可以尝试将其放入变量中，但如果不使用，则打印函数应按如下方式工作：

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

Answer 15

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

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

输出：

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

Answer 16

最好的方法是使用 import Random 函数

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 中删除并返回任意值。

Answer 17

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

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

Answer 18

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

假设您想使用 random.random() 函数生成 a 和 a 之间的数字。代码>b。要实现此目的，只需执行以下操作：

num = (ba)*random.random() + a;

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

Answer 19

从 random 模块的文档页面：

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

random.SystemRandom，在Python 2.4 被认为是加密安全。它在撰写本文时最新的 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 来代替其他一些答案，或许还可以进行理解。根据您的需要混合搭配。

Answer 20

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

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

示例

import quantumrand

number = quantumrand.randint(0, 9)

print(number)

输出：4

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

Answer 21

对于 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' 或 '^!~=-><' 等字符要更改要从中提取的字符池，请更改范围以更改生成的字符数。

Answer 22

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

Answer 23

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

使用 numpy

如果您可以接受 numpy 依赖项，那么从版本 1.17 开始，numpy 具有 生成器，如果你想的话，它比 randint/choice 等快得多生成很多随机整数（例如超过10000个整数）。要构造它，请使用np.random.default_rng()。然后，要生成随机整数，请调用 integers() 或 choice()。如果要生成大量随机数列表（例如生成 100 万个随机整数，numpy 生成器比 numpy 的 randint 快约 3 倍，约快 40 倍），它比标准库快得多比 stdlib 的随机¹）。

例如，要生成 100 万个 0 到 9 之间的整数，可以使用以下任一方法。

import numpy as np
# option 1
numbers = np.random.default_rng().integers(0, 10, size=1000000)
# option 2
numbers = np.random.default_rng().choice(10, size=1000000)

默认使用PCG64生成器；但是，如果您想使用标准库中随机使用的 Mersenne Twister 生成器，那么您可以将其实例作为种子序列传递给 default_rng() ，如下所示接下来。

rng = np.random.default_rng(np.random.MT19937())
numbers = rng.integers(0, 10, size=1000)

使用 random

如果您仅限于标准库，并且想要生成大量随机整数，那么 random.choices() 比 快得多random.randint() 或 random.randrange().² 例如，生成 0 到 9 之间的 100 万个随机整数：

import random
numbers = random.choices(range(10), k=1000000)

---

一些计时结果¹

在 Python 3.12 和 numpy 1.26 上测试。

import timeit
import random
import numpy as np

def numpy_randint():
    return np.random.randint(0, 10, size=1000000)

def numpy_Gen_integers():
    return np.random.default_rng().integers(0, 10, size=1000000)

def numpy_Gen_choice():
    return np.random.default_rng().choice(10, size=1000000)

def random_randrange():
    return [random.randrange(10) for _ in range(1000000)]

def random_choices():
    return random.choices(range(10), k=1000000)


t1 = min(timeit.repeat(numpy_randint, number=100))      # 1.9559144999366254
t2 = min(timeit.repeat(numpy_Gen_integers, number=100)) # 0.6704635999631137
t3 = min(timeit.repeat(numpy_Gen_choice, number=100))   # 0.6696784000378102
t4 = min(timeit.repeat(random_randrange, number=100))   # 64.98768060002476
t5 = min(timeit.repeat(random_choices, number=100))     # 25.686857299879193

_{² 如果我们查看它们的源实现，random.randrange()（和 random.randint() 因为它是前者的语法糖）使用 while 循环生成伪-随机数通过_randbelow 方法，而 random.choices() 调用 random() 一次并将其用于 对总体进行索引。因此，如果需要生成大量伪随机数，则该 while 循环的成本就会增加。}