生成 0 到 9 之间的随机整数-IT科技

摘要：问题描述：如何在 Python 中生成0和9（包括）之间的随机整数？例如，0，1，2，3，4，5，6，7，8，9解决方案 1：尝试random.randrange：from random import randrange print(randrange(10)) 解决方案 2：尝试random.randint...

问题描述：

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

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

解决方案 1：

尝试random.randrange：

from random import randrange
print(randrange(10))

解决方案 2：

尝试random.randint：

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

文档指出：

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

解决方案 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)

解决方案 4：

from random import randint

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

这将生成 10 个范围在 0 到 9 之间的伪随机整数。

解决方案 5：

该模块是 Python 3.6 中的新模块。它比用于加密或安全用途的模块secrets更好。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

解决方案 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.> 随机.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.> 随机数

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.randint快得多**（快约 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在半开区间 [low, high) 内生成随机整数。
2.> np.random.uniform生成半开区间 [low, high) 内均匀分布的数字。
3.> np.random.choice在半开区间 [low, high) 内生成一个随机样本，就好像参数a是 np.arange(n)。
4.> random.randrange(stop)从范围（start、stop、step）中生成一个随机数。
5.> random.randint(a, b)返回一个随机整数 N，使得 a <= N <= b。
6.> astype(int)将 numpy 数组转换为 int 数据类型。
7.> 我选择了 size = (15,)。这将为您提供一个长度为 15 的 numpy 数组。

解决方案 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]])

解决方案 8：

虽然许多帖子演示了如何获取一个随机整数，但原始问题询问如何生成随机整数（复数）：

如何在 Python 中生成 0 到 9 之间的随机整数（含 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]

细节

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

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返回唯一选择（不重复）： 2k

另请参阅 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 中的众多分布之一转换为随机整数样本。3

示例

>>> 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即 @John Lawrence Aspden、@ST Mohammed、@SiddTheKid、@user14372、@zangw 等。2
@prashanth 提到此模块显示一个整数。3由@Siddharth
Satpathy 演示

解决方案 9：

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

from random import randint

num1= randint(0,9)

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

解决方案 10：

尝试一下random.shuffle

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

解决方案 11：

对于连续数字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

secrets.choice如果你需要“加密强度高”的功能，那么在 Python 3.6 及更新版本中还有一个：

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

解决方案 12：

如果您想使用 numpy，请使用以下命令：

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

解决方案 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]

解决方案 14：

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

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

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

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

解决方案 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]

解决方案 16：

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

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。

解决方案 17：

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

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

解决方案 18：

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

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

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

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

解决方案 19：

从随机模块的文档页面：

警告：本模块的伪随机数生成器不应用于安全目的。如果您需要加密安全的伪随机数生成器，请使用 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根据其他答案，也许还可以使用和理解。根据您的需要进行混合搭配。

解决方案 20：

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

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

例子

import quantumrand

number = quantumrand.randint(0, 9)

print(number)

输出：4

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

解决方案 21：

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

和`numpy`

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

例如，要生成 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 生成器；但是，如果您想使用random标准库中使用的梅森旋转生成器，那么您可以将其实例作为种子序列传递，default_rng()如下所示。

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

和`random`

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

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

一些计时结果1

在 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

2如果我们查看它们的源实现，random.randrange()（random.randint()因为它是前者的语法糖）使用while 循环通过方法while调用一次来生成伪随机数并使用它来索引人口。因此，如果需要生成大量伪随机数，则此 while 循环的成本会增加。_randbelow`random.choices()`random()

解决方案 22：

我在 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”或“^!~=-><”等字符即可改变要从中提取的字符池，更改范围以改变生成的字符数。

解决方案 23：

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一维的。通过一次调用来生成 12 个结果会更容易getSample：

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