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
Essayer:
from random import randrange
print(randrange(10))
Plus d'infos: http://docs.python.org/library/random.html#random.randrange
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
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)
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.
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]
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]])
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
_si vous voulez utiliser numpy, utilisez ce qui suit:
import numpy as np
print(np.random.randint(0,10))
Je voudrais essayer l'un des éléments suivants:
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]
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.
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.
>>> 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]
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]
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
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.
Essaye ça,
import numpy as np
X = np.random.randint(0, 99, size=1000) # 1k random integer
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.
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)
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.
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.