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


1339

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

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


16
Jolis

Réponses:



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

random.randint(a, b)

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

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


1
Dans les nouvelles versions de Python, la limite supérieure semble être exclusive (c'est randint(0,9)-à- dire qu'elle ne renverra jamais 9). Cela n'est pas reflété dans la documentation en ligne, mais c'est dans l'aide intégrée.
Yly

134

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)

81
from random import randint

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

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


64

Le secretsmodule est nouveau dans Python 3.6. C'est mieux que le randommodule pour la cryptographie ou la sécurité.

Pour imprimer au hasard un entier dans la plage inclusive 0-9:

from secrets import randbelow
print(randbelow(10))

Pour plus de détails, voir PEP 506 .


3
Cela améliorerait la réponse et devrait être ajouté. Les réponses plus axées sur la sécurité doivent toujours être ajoutées si elles sont disponibles.
SudoKid

31

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

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

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

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

3
Il est également utile de savoir comment Numpy peut générer un tableau aléatoire de taille spécifiée, pas seulement un nombre aléatoire unique. (Docs: numpy.random.randint )
jkdev

28

Essayez ceci random.shuffle

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

Ce n'est pas une bonne réponse et devrait être supprimée.
Nicolas Gervais

22

J'essaierais l'une des options suivantes:

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]

La vitesse:

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

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

Remarques:

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

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

3.> random.randrange (stop) génère un nombre aléatoire à partir de la plage (start, stop, step).

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.


Comment ça %timeitmarche dans votre environnement?
Cadoiz

18

En cas de nombres continus randintou randrangesont probablement les meilleurs choix, mais si vous avez plusieurs valeurs distinctes dans une séquence (c'est-à-dire a 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 en avez besoin "cryptographiquement fort" il y a aussi un secrets.choiceen python 3.6 et plus récent:

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

Et si nous voulons plus de nombres de la séquence?
Gunjan naik

Si elles doivent être sans remplacement: random.sample. Avec le remplacement, vous pouvez utiliser une compréhension avec choice: par exemple pour une liste contenant 3 valeurs aléatoires avec remplacement:[choice(values) for _ in range(3)]
MSeifert

18

Alors que de nombreux articles montrent comment obtenir un entier aléatoire, la question d'origine demande comment générer un entier aléatoire s (pluriel):

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

Pour plus de clarté, nous montrons ici comment obtenir plusieurs entiers aléatoires.

Donné

>>> import random


lo = 0
hi = 10
size = 5

Code

Entiers aléatoires multiples

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

Exemple d'entiers aléatoires

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

Détails

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

  • A : random.randomrenvoie un flottant aléatoire dans la plage[0.0, 1.0)
  • B : random.randintretourne un entier aléatoire Ntel quea <= N <= b
  • C : random.randrangealias derandint(a, b+1)
  • D : random.shufflemélange une séquence en place
  • E : random.choiceretourne un élément aléatoire de la séquence non vide
  • F : random.choicesretourne les ksélections d'une population (avec remplacement, Python 3.6+)
  • G : random.sampleretourne kdes sélections uniques d'une population (sans remplacement): 2

Voir également l' exposé de R. Hettinger sur le découpage et l'alias en utilisant des exemples du randommodule.

Voici une comparaison de quelques fonctions aléatoires dans la bibliothèque standard et 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) |

Vous pouvez également convertir rapidement l'une des nombreuses distributions de Numpy en un échantillon d'entiers aléatoires. 3

Exemples

>>> 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 À savoir @John Lawrence Aspden, @ST Mohammed, @SiddTheKid, @ user14372, @zangw, et al. 2 @prashanth mentionne ce module affichant un entier. 3 Démontré par @Siddharth Satpathy


14

si vous souhaitez utiliser numpy, utilisez ce qui suit:

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

1
Vous pourriez dire quelque chose sur "numpy".
Simón

11
Ouais. Merci pour le lien. Mais je voulais dire que vous auriez pu améliorer votre réponse en fournissant des détails avant de citer simplement deux lignes de code; comme pour quelle raison quelqu'un préférerait-il l'utiliser plutôt que quelque chose de déjà intégré. Pas que vous y soyez obligé, de toute façon.
Simón

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

7

Génération d'entiers aléatoires entre 0 et 9.

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

Production:

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

6

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

La meilleure façon 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.


3

Il s'agit plus d'une approche mathématique mais cela fonctionne à 100% du temps:

Disons que vous souhaitez utiliser la random.random()fonction pour générer un nombre entre aet 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.


2

Depuis la page de documentation du module aléatoire :

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é comme cryptographiquement sécurisé . Il est toujours disponible dans Python 3.7.1 qui est à jour au moment de l'écriture.

>>> 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, rangepourrait être utilisé par certaines des autres réponses avec peut-être une compréhension. Mélangez et assortissez selon vos besoins.


0

OpenTURNS permet non seulement de simuler les entiers aléatoires mais également de définir la distribution associée à la UserDefinedclasse définie.

Ce qui suit simule 12 résultats de la distribution.

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)

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

Les crochets sont là parce que xc'est Pointen 1 dimension. Il serait plus facile de générer les 12 résultats en un seul appel à getSample:

sample = distribution.getSample(12)

produirait:

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

Plus de détails sur ce sujet sont ici: http://openturns.github.io/openturns/master/user_manual/_generated/openturns.UserDefined.html


-1

J'ai eu plus de chance avec cela pour Python 3.6

str_Key = ""                                                                                                
str_RandomKey = ""                                                                                          
for int_I in range(128):                                                                                    
      str_Key = random.choice('0123456789')
      str_RandomKey = str_RandomKey + str_Key 

Ajoutez simplement des caractères comme 'ABCD' et 'abcd' ou '^! ~ = -> <' pour modifier le pool de caractères à partir duquel vous souhaitez modifier, changez la plage pour modifier le nombre de caractères générés.

En utilisant notre site, vous reconnaissez avoir lu et compris notre politique liée aux cookies et notre politique de confidentialité.
Licensed under cc by-sa 3.0 with attribution required.