Genera numeri interi casuali tra 0 e 9

Come posso generare numeri interi casuali tra 0 e 9 (inclusi) in Python?

Ad esempio, 0, 1, 2, 3, 4, 5, 6, 7, 8,9

Provare:

from random import randrange
print(randrange(10))

Ulteriori informazioni: http://docs.python.org/library/random.html#random.randrange

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

random.randint(a, b)

Restituisce un numero intero casuale N tale che a <= N <= b.

Documenti: https://docs.python.org/3.1/library/random.html#random.randint

Prova questo:

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)

from random import randint

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

Questo genera 10 interi pseudocasuali nell'intervallo da 0 a 9 inclusi.

Il secretsmodulo è nuovo in Python 3.6. Questo è meglio delrandom modulo per crittografia o usi di sicurezza.

Per stampare in modo casuale un numero intero compreso nell'intervallo 0-9:

from secrets import randbelow
print(randbelow(10))

Per i dettagli, vedere PEP 506 .

Scegli la dimensione dell'array (in questo esempio, ho scelto la dimensione da 20). E quindi, utilizzare quanto segue:

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

Puoi aspettarti di vedere un output del seguente modulo ( ogni volta che lo eseguirai verranno restituiti interi casuali diversi; quindi puoi aspettarti che gli interi nell'array di output differiscano dall'esempio riportato di seguito ).

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

Prova attraverso questo random.shuffle

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

Vorrei provare uno dei seguenti:

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

Velocità:

► np.random.randint è il più veloce , seguito da np.random.uniform e random.randrange . random.randint è il più lento .

► Sia np.random.randint che np.random.uniform sono molto più veloci (~ 8-12 volte più veloci) di 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)

Appunti:

1.> np.random.randint genera numeri interi casuali nell'intervallo semi-aperto [basso, alto).

2.> np.random.uniform genera numeri distribuiti uniformemente nell'intervallo semi-aperto [basso, alto).

3.> random.randrange (stop) genera un numero casuale dall'intervallo (start, stop, step).

4.> random.randint (a, b) restituisce un numero intero casuale N tale che a <= N <= b.

5.> astype (int) lancia l'array numpy nel tipo di dati int.

6.> Ho scelto size = (15,). Questo ti darà una matrice numpy di lunghezza = 15.

In caso di numeri continui randinto randrangesono probabilmente le scelte migliori, ma se si hanno diversi valori distinti in una sequenza (cioè a list) è possibile utilizzare anche choice:

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

choice funziona anche per un articolo da un campione non continuo:

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

Se ne hai bisogno "crittograficamente forte" c'è anche un secrets.choicein Python 3.6 e versioni successive:

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

Mentre molti messaggi dimostrano come ottenere un numero intero casuale, la domanda iniziale si chiede come generare intero casuale s (plurale):

Come posso generare numeri interi casuali tra 0 e 9 (inclusi) in Python?

Per chiarezza, qui dimostriamo come ottenere più numeri casuali casuali.

Dato

>>> import random


lo = 0
hi = 10
size = 5

Codice

Numero intero multiplo casuale

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

Esempio di numeri casuali

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

Dettagli

Alcuni post dimostrano come generare nativamente numeri interi casuali multipli . ¹ Ecco alcune opzioni che affrontano la domanda implicita:

• A : random.randomrestituisce un float casuale nell'intervallo[0.0, 1.0)
• B : random.randintrestituisce un numero intero casuale Ntale chea <= N <= b
• C : random.randrangealias arandint(a, b+1)
• D : random.shufflemescola una sequenza in atto
• E :random.choice restituisce un elemento casuale dalla sequenza non vuota
• F : random.choicesrestituisce le kselezioni da una popolazione (con sostituzione, Python 3.6+)
• G : random.samplerestituisce kselezioni uniche da una popolazione (senza sostituzione): ²

Vedi anche il discorso di R. Hettinger su Chunking e Aliasing usando esempi dal randommodulo.

Ecco un confronto di alcune funzioni casuali nella Libreria standard 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) |

Puoi anche convertire rapidamente una delle molte distribuzioni in Numpy in un campione di numeri interi casuali. ³

Esempi

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

_{¹ Vale a dire @ John Lawrence Aspden, @ST Mohammed, @SiddTheKid, @ user14372, @zangw, et al. ² @prashanth menziona questo modulo che mostra un numero intero. ³ Dimostrato da @Siddharth Satpathy}

se si desidera utilizzare numpy, utilizzare quanto segue:

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

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

Per ottenere un elenco di dieci campioni:

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

Generazione di numeri casuali tra 0 e 9.

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

Produzione:

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

random.sample è un altro che può essere utilizzato

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

Il modo migliore è utilizzare la funzione Random di importazione

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

o senza alcuna importazione di libreria:

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

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

qui popitems rimuove e restituisce un valore arbitrario dal dizionario n.

Questo è più un approccio matematico ma funziona il 100% delle volte:

Diciamo che vuoi usare la random.random()funzione per generare un numero tra ae b. A tale scopo, procedi come segue:

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

Certo, puoi generare più numeri.

Dalla pagina della documentazione per il modulo casuale :

Avvertenza: i generatori pseudo-casuali di questo modulo non devono essere utilizzati per motivi di sicurezza. Usa os.urandom () o SystemRandom se hai bisogno di un generatore di numeri pseudo-casuali sicuro crittograficamente.

random.SystemRandom , introdotto in Python 2.4, è considerato crittograficamente sicuro . È ancora disponibile in Python 3.7.1 che è attuale al momento della scrittura.

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

Invece di string.digits, rangepotrebbe essere usato per alcune delle altre risposte insieme forse con una comprensione. Mescola e abbina in base alle tue esigenze.

OpenTURNS consente non solo di simulare numeri interi casuali, ma anche di definire la distribuzione associata con la UserDefinedclasse definita.

Quanto segue simula 12 risultati della distribuzione.

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)

Questo stampa:

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

Le parentesi ci sono perché xè una Pointin 1 dimensione. Sarebbe più semplice generare i 12 risultati in una singola chiamata per getSample:

sample = distribution.getSample(12)

produrrebbe:

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

Maggiori dettagli su questo argomento sono disponibili qui: http://openturns.github.io/openturns/master/user_manual/_generated/openturns.UserDefined.html

Ho avuto più fortuna con questo per 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 aggiungere caratteri come "ABCD" e "abcd" o "^! ~ = -> <" per modificare il pool di caratteri da cui estrarre, modificare l'intervallo per modificare il numero di caratteri generati.