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

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

例如，

0

，

1

，

2

，

3

，

4

，

5

，

6

，

7

，

8

，

9

，

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)

尝试：

文档：


返回一个随机整数N，使得
这将生成10个范围为0到9（包括0到9）的伪随机整数。
请尝试通过
random.shuffle执行此操作

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

该模块是Python 3.6中的新模块。这比用于加密或安全的模块要好

要随机打印0-9范围内的整数，请执行以下操作：

from secrets import randbelow
print(randbelow(10))

有关详细信息，请参阅。
如果要使用numpy，请使用以下命令：

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

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

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

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

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

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

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

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

在这里，如果是连续数字或可能是最佳选择，则从字典中删除并返回任意值，但如果序列中有多个不同的值（即
列表
），则还可以使用：

选项
也适用于非连续样本中的一个项目：

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

如果您需要“加密性强”，python 3.6及更新版本中还有一个：

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

对于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”或“^！~=->
要获取十个样本的列表，请执行以下操作：

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

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

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

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

给定的

>>> import random


lo = 0
hi = 10
size = 5

代码

多重随机整数





随机整数样本



详细信息

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


A：返回范围
[0.0，1.0）
B：返回一个随机整数
N
，以便
a生成0到9之间的随机整数

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

输出：

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

我会尝试以下方法之一：

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

1.>

2.>

3.>

4.>

5.>

速度：

► np.random.UNIQUE和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.>在半开区间[low，high]上生成随机整数

2.>在半开放区间[低、高]上生成均匀分布的数字

3.>在半开放区间[low，high]上生成一个随机样本，就像参数
a
是np.arange（n）一样

4.>从范围（开始、停止、步骤）生成一个随机数

5.>返回一个随机整数N，这样I就选择了size=（15，）。这将为您提供一个长度为15的numpy数组

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

假设您想使用
random.random（）
函数在
a
和
b
之间生成一个数字。要实现此目的，只需执行以下操作：

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

num=（b-a）*random.random（）+a；

当然，您可以生成更多数字。
从模块的文档页面：

警告：此模块的伪随机生成器不应为空
用于安全目的。如果需要，请使用os.URADOM（）或SystemRandom
需要加密安全的伪随机数生成器

，它是在Python2.4中引入的。在编写本文时，它在Python3.7.1中仍然可用

导入字符串
>>>字符串。数字
'0123456789'
>>>随机输入
>>>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
可以用于其他答案，也可以用于理解。根据需要进行混合和匹配。
OpenTURNS不仅可以模拟随机整数，还可以定义与
用户定义的
定义类相关的分布

下面模拟分布的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
是一维中的
点。
只需调用
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  ]

关于这个主题的更多细节在这里：
我想我应该用使用ANU量子数生成器的
quantumrand
来补充这些答案。不幸的是，这需要一个互联网连接，但是如果你关心这些数字的“随机性”，那么这可能会很有用


范例

导入quantumrand
number=quantumrand.randint（0,9）
打印（数字）

输出：
4

文档中有许多不同的示例，包括掷骰子和列表选择器。
您需要标准库中的
random
python模块。
使用代码

from random import randint

num1= randint(0,9)

这将设置va
# 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]

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

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

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

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

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

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

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

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]

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]

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

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]

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  ]

from random import randint

num1= randint(0,9)

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

    

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