Respostas:
Tentar:
from random import randrange
print(randrange(10))
Mais informações: http://docs.python.org/library/random.html#random.randrange
secrets
módulo para obter melhores números aleatórios. Referência: docs.python.org/3/library/random.html
import random
print(random.randint(0,9))
random.randint(a, b)
Retorne um número inteiro aleatório N tal que a <= N <= b.
Documentos: https://docs.python.org/3.1/library/random.html#random.randint
randint(0,9)
, nunca retornará 9). Isso não se reflete na documentação online, mas está na ajuda interna.
Tente o seguinte:
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)
O secrets
módulo é novo no Python 3.6. Isso é melhor que o random
módulo para criptografia ou segurança.
Para imprimir aleatoriamente um número inteiro no intervalo inclusivo de 0 a 9:
from secrets import randbelow
print(randbelow(10))
Para detalhes, consulte PEP 506 .
Escolha o tamanho da matriz (neste exemplo, eu escolhi o tamanho para 20). E então, use o seguinte:
import numpy as np
np.random.randint(10, size=(1, 20))
Você pode esperar ver uma saída do seguinte formato ( números inteiros aleatórios diferentes serão retornados toda vez que você a executar; portanto, você pode esperar que os números inteiros na matriz de saída sejam diferentes do exemplo dado abaixo ).
array([[1, 6, 1, 2, 8, 6, 3, 3, 2, 5, 6, 5, 0, 9, 5, 6, 4, 5, 9, 3]])
Tente isso através random.shuffle
>>> import random
>>> nums = range(10)
>>> random.shuffle(nums)
>>> nums
[6, 3, 5, 4, 0, 1, 2, 9, 8, 7]
Eu tentaria um dos seguintes:
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])
3.> random.randrange
from random import randrange
X3 = [randrange(10) for i in range(15)]
print (X3)
>>> [2, 1, 4, 1, 2, 8, 8, 6, 4, 1, 0, 5, 8, 3, 5]
4.> random.randint
from random import randint
X4 = [randint(0, 9) for i in range(0, 15)]
print (X4)
>>> [6, 2, 6, 9, 5, 3, 2, 3, 3, 4, 4, 7, 4, 9, 6]
Rapidez:
► np.random.randint é o mais rápido , seguido por np.random.uniform e random.randrange . random.randint é o mais lento .
► O np.random.randint e o np.random.uniform são muito mais rápidos (~ 8 a 12 vezes mais rápidos) do que random.randrange e 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 [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)
Notas:
1.> np.random.randint gera números inteiros aleatórios no intervalo semiaberto [baixo, alto).
2.> np.random.uniform gera números uniformemente distribuídos no intervalo semiaberto [baixo, alto).
3.> random.randrange (stop) gera um número aleatório a partir do intervalo (start, stop, step).
4.> random.randint (a, b) retorna um número inteiro aleatório N tal que a <= N <= b.
5.> astype (int) lança a matriz numpy no tipo de dados int.
6.> Eu escolhi size = (15,). Isso fornecerá uma matriz numpy de comprimento = 15.
%timeit
funciona no seu ambiente?
No caso de números contínuos randint
ou randrange
provavelmente as melhores opções, mas se você tiver vários valores distintos em uma sequência (ou seja, a list
), também poderá usar choice
:
>>> import random
>>> values = list(range(10))
>>> random.choice(values)
5
choice
também funciona para um item de uma amostra não contínua:
>>> values = [1, 2, 3, 5, 7, 10]
>>> random.choice(values)
7
Se você precisar "criptograficamente forte", também existe um secrets.choice
no python 3.6 e mais recente:
>>> import secrets
>>> values = list(range(10))
>>> secrets.choice(values)
2
random.sample
. Com a substituição, você pode usar uma compreensão com choice
: por exemplo, uma lista contendo 3 valores aleatórios com substituição:[choice(values) for _ in range(3)]
Enquanto muitas postagens demonstram como obter um número inteiro aleatório, a pergunta original pergunta como gerar um número inteiro aleatório s (plural):
Como posso gerar números inteiros aleatórios entre 0 e 9 (inclusive) em Python?
Para maior clareza, aqui demonstramos como obter vários números aleatórios.
Dado
>>> import random
lo = 0
hi = 10
size = 5
Código
Múltiplos Inteiros Aleatórios
# 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]
Amostra de Inteiros Aleatórios
# 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]
Detalhes
Algumas postagens demonstram como gerar nativamente vários números aleatórios. 1 Aqui estão algumas opções que abordam a questão implícita:
random.random
retorna um flutuador aleatório no intervalo[0.0, 1.0)
random.randint
retorna um número inteiro aleatório N
tal quea <= N <= b
random.randrange
alias pararandint(a, b+1)
random.shuffle
embaralha uma sequência no lugarrandom.choice
retorna um elemento aleatório da sequência não vaziarandom.choices
retorna k
seleções de uma população (com substituição, Python 3.6+)random.sample
retorna k
seleções únicas de uma população (sem substituição): 2Veja também a palestra de R. Hettinger sobre Chunking e Aliasing usando exemplos do random
módulo.
Aqui está uma comparação de algumas funções aleatórias na Biblioteca Padrão e 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) |
Você também pode converter rapidamente uma das muitas distribuições no Numpy em uma amostra de números inteiros aleatórios. 3
Exemplos
>>> 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 Ou seja, John Lawrence Aspden, @ST Mohammed, @SiddTheKid, @ user14372, @zangw, et al. 2 @prashanth menciona este módulo mostrando um número inteiro. 3 Demonstrado por @Siddharth Satpathy
se você deseja usar numpy, use o seguinte:
import numpy as np
print(np.random.randint(0,10))
>>> import random
>>> random.randrange(10)
3
>>> random.randrange(10)
1
Para obter uma lista de dez amostras:
>>> [random.randrange(10) for x in range(10)]
[9, 0, 4, 0, 5, 7, 4, 3, 6, 8]
Gerando números inteiros aleatórios entre 0 e 9.
import numpy
X = numpy.random.randint(0, 10, size=10)
print(X)
Resultado:
[4 8 0 4 9 6 9 9 0 7]
A melhor maneira é usar a função Aleatória de importação
import random
print(random.sample(range(10), 10))
ou sem nenhuma importação de biblioteca:
n={}
for i in range(10):
n[i]=i
for p in range(10):
print(n.popitem()[1])
aqui o popitems remove e retorna um valor arbitrário do dicionário n
.
Essa é mais uma abordagem matemática, mas funciona 100% do tempo:
Digamos que você queira usar a random.random()
função para gerar um número entre a
e b
. Para conseguir isso, basta fazer o seguinte:
num = (b-a)*random.random() + a;
Claro, você pode gerar mais números.
Na página de documentação do módulo aleatório :
Aviso: Os geradores pseudo-aleatórios deste módulo não devem ser usados para fins de segurança. Use os.urandom () ou SystemRandom se precisar de um gerador de números pseudo-aleatórios criptograficamente seguro.
random.SystemRandom , que foi introduzido no Python 2.4, é considerado criptograficamente seguro . Ele ainda está disponível no Python 3.7.1, que é atual no momento da escrita.
>>> 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'
Em vez de string.digits
, range
poderia ser usado por algumas das outras respostas, talvez junto com uma compreensão. Misture e combine de acordo com suas necessidades.
O OpenTURNS permite não apenas simular números inteiros aleatórios, mas também definir a distribuição associada à UserDefined
classe definida.
A seguir, são simulados 12 resultados da distribuição.
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)
Isso imprime:
0 [8]
1 [7]
2 [4]
3 [7]
4 [3]
5 [3]
6 [2]
7 [9]
8 [0]
9 [5]
10 [9]
11 [6]
Os colchetes estão lá porque x
existe Point
em uma dimensão. Seria mais fácil gerar os 12 resultados em uma única chamada para getSample
:
sample = distribution.getSample(12)
produziria:
>>> 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 ]
Mais detalhes sobre este tópico estão aqui: http://openturns.github.io/openturns/master/user_manual/_generated/openturns.UserDefined.html
Eu tive melhor sorte com isso para Python 3.6
str_Key = ""
str_RandomKey = ""
for int_I in range(128):
str_Key = random.choice('0123456789')
str_RandomKey = str_RandomKey + str_Key
Basta adicionar caracteres como 'ABCD' e 'abcd' ou '^! ~ = -> <' para alterar o conjunto de caracteres para retirar, altere o intervalo para alterar o número de caracteres gerados.