web-dev-qa-db-fra.com

Générer des entiers aléatoires entre 0 et 9

Comment générer des entiers aléatoires compris entre 0 et 9 (inclus) en Python?

Par exemple, 0, 1, 2, 3, 4, 5, 6, 7, , 8, 9

1176
aneuryzm

Essayer:

from random import randrange
print(randrange(10))

Plus d'infos: http://docs.python.org/library/random.html#random.randrange

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

random.randint(a, b)

Retourne un entier aléatoire N tel que a <= N <= b.

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

349
JMSamudio

Essaye ça:

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)
108
Andrew Hare
from random import randint

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

Cela génère 10 nombres entiers pseudo-aléatoires compris entre 0 et 9 inclus.

66
user14372

Le module secrets est nouveau dans Python 3.6. C'est mieux que le module random pour les utilisations en cryptographie ou en sécurité.

Pour imprimer de manière aléatoire un entier compris entre 0 et 9:

from secrets import randbelow
print(randbelow(10))

Pour plus de détails, voir PEP 506 .

49
Chris_Rands

Essayez ceci à travers random.shuffle

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

Choisissez la taille du tableau (dans cet exemple, j'ai choisi la taille 20). Et ensuite, utilisez ce qui suit:

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

Vous pouvez vous attendre à voir une sortie sous la forme suivante (différents nombres entiers aléatoires seront renvoyés à chaque fois que vous l'exécuterez; par conséquent, vous pouvez vous attendre à ce que les entiers du tableau en sortie diffèrent de l'exemple ci-dessous).

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

En cas de nombres continus randint ou randrange sont probablement les meilleurs choix, mais Si vous avez plusieurs valeurs distinctes dans une séquence (par exemple, une list), vous pouvez également utiliser choice :

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

choice fonctionne également pour un élément d'un échantillon non continu:

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

Si vous avez besoin de "forte cryptographie", il y a aussi un secrets.choice dans python 3.6 et plus récent:

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

si vous voulez utiliser numpy, utilisez ce qui suit:

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

Je voudrais essayer l'un des éléments suivants:

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]

Vitesse:

np.random.randint est le plus rapide , suivi de np.random.uniform et random.randrange . random.randint est le plus lent .

► Les deux np.random.randint et np.random.uniform sont beaucoup plus rapides (~ 8 - 12 fois plus rapide) que random.randrange et 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)

Notes:

1.> np.random.randint génère des entiers aléatoires sur l'intervalle de demi-ouverture [bas, haut).

2.> np.random.uniform génère des nombres uniformément répartis sur l'intervalle de demi-ouverture [bas, haut).

3.> random.randrange (stop) génère un nombre aléatoire à partir de la plage (début, fin, étape).

4.> random.randint (a, b) renvoie un entier aléatoire N tel que a <= N <= b.

5.> astype (int) convertit le tableau numpy en type de données int.

6.> J'ai choisi la taille = (15,). Cela vous donnera un tableau numpy de longueur = 15.

10
Siddharth Satpathy

La question initiale implique de générer plusieurs nombres entiers aléatoires.

Comment puis-je générer des entiers compris entre 0 et 9 (inclus) en Python?

Cependant, beaucoup de réponses montrent seulement comment obtenir un nombre aléatoire, par ex. _random.randint_ et _random.choice_.

Entiers aléatoires multiples

Pour plus de clarté, vous pouvez toujours générer plusieurs nombres aléatoires à l'aide de ces techniques en itérant simplement N fois:

_import random


N = 5

[random.randint(0, 9) for _ in range(N)]
# [9, 7, 0, 7, 3]

[random.choice(range(10)) for _ in range(N)]
# [8, 3, 6, 8, 7]
_

Échantillon de nombres entiers aléatoires

Certaines publications montrent comment générer nativement plusieurs nombres entiers aléatoires.1 Voici quelques options qui répondent à la question implicite:

random.sample renvoie k sélections uniques dans une population (sans remplacement):2

_random.sample(range(10), k=N)
# [4, 5, 1, 2, 3]
_

Dans Python 3.6, random.choices renvoie k sélections à partir d'une population (avec remplacement):

_random.choices(range(10), k=N)
# [3, 2, 0, 8, 2]
_

Voir aussi cet article lié en utilisant _numpy.random.choice_.

1À savoir @ John Lawrence Aspden, @S T Mohammed, @SiddTheKid, @ user14372, @zangw, et al.

2@prashanth mentionne ce module montrant un entier.

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

Pour obtenir une liste de dix échantillons:

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

Générer des entiers aléatoires entre 0 et 9.

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

Sortie:

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

random.sample est un autre qui peut être utilisé

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

Le meilleur moyen est d'utiliser la fonction d'importation aléatoire

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

ou sans aucune importation de bibliothèque:

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

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

ici, le popitems supprime et renvoie une valeur arbitraire du dictionnaire n.

6
S T Mohammed

Essaye ça,

import numpy as np

X = np.random.randint(0, 99, size=1000) # 1k random integer
4
Rakesh Chaudhari

C'est plus une approche mathématique mais cela fonctionne 100% du temps:

Supposons que vous souhaitiez utiliser la fonction random.random() pour générer un nombre compris entre a et b. Pour ce faire, procédez comme suit:

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

Bien sûr, vous pouvez générer plus de nombres.

3
Orestis Zekai

Pour l'exemple que vous avez donné (un entier aléatoire compris entre 0 et 9), la solution la plus propre est:

from random import randrange

randrange(10)
3
Utku

J'ai utilisé variable pour contrôler la plage

from random import randint 
numberStartRange = 1
numberEndRange = 9
randomNumber = randint(numberStartRange, numberEndRange)
print(randomNumber)

J'ai utilisé la fonction d'impression pour voir les résultats. Vous pouvez commenter si vous n'en avez pas besoin.

2
Amir Md Amiruzzaman

Depuis la page de documentation du module random :

Avertissement: Les générateurs pseudo-aléatoires de ce module ne doivent pas être utilisés à des fins de sécurité. Utilisez os.urandom () ou SystemRandom si vous avez besoin d’un générateur de nombres pseudo aléatoires cryptographiquement sécurisé.

random.SystemRandom , qui a été introduit dans Python 2.4, est considéré cryptographiquement sécurisé . Il est toujours disponible dans Python 3.7.1, qui est à jour au moment de la rédaction.

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

Au lieu de string.digits, range pourrait être utilisé avec certaines des autres réponses avec peut-être une compréhension. Mélangez et assortissez selon vos besoins.

1
rriehle