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

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

Essayer:

from random import randrange
print(randrange(10))

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

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

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 entiers pseudo-aléatoires compris entre 0 et 9 inclus.

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 .

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

Essayez ceci random.shuffle

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

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.

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

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. ¹ 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): ²

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

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

_{¹ À savoir @John Lawrence Aspden, @ST Mohammed, @SiddTheKid, @ user14372, @zangw, et al. ² @prashanth mentionne ce module affichant un entier. ³ Démontré par @Siddharth Satpathy}

si vous souhaitez utiliser numpy, utilisez ce qui suit:

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

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

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

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.

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.

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.

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

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.