Comment générer des nombres aléatoires en Python ?

Introduction

Le langage Python définit un ensemble de fonctions qui sont utilisées pour générer ou manipuler des nombres aléatoires par le biais de la bibliothèque random. Les fonctions du module random s'appuient sur une fonction générant des nombres pseudo-aléatoires, random(), qui génère un nombre flottant aléatoire compris entre 0,0 et 1,0. Ce type particulier de fonctions est utilisé dans de nombreux jeux, loteries, ou toute application nécessitant une génération de nombres aléatoires.

Dans ce tutoriel, vous découvrirez comment générer et travailler avec des nombres aléatoires en Python en utilisant le module random.

Objectif

Générer des nombres aléatoires en Python en utilisant la bibliothèque random.

Prérequis

Pour comprendre ce tutoriel, vous devez avoir des connaissances sur les sujets de programmation Python suivants :

• Entrée, sortie et importation Python
• Module Python random
• Les boucles Python

Le cours

Le module Python random

Python est capable de génèrer des nombres pseudo-aléatoires à l'aide du module random. Mais si vous vous rendez dans les docs Python pour la documentation de ce module, vous y verrez un avertissement :

“The pseudo-random generators of this module should not be used for security purposes.”

En français "Les générateurs pseudo-aléatoires de ce module ne doivent pas être utilisés à des fins de sécurité."

Apparemment, les nombres pseudo-aléatoires que le module random génère ne sont pas cryptographiquement fiables. Python utilise l'algorithme Mersenne Twister pour générer des nombres aléatoires. Mais cet algorithme est complètement déterministe, ce qui en fait un choix inadapté à des fins cryptographiques.

Passons maintenant aux diverses fonctions intégrées, sous le module random. Ces fonctions sont capables de générer des nombres pseudo-aléatoires dans différents scénarios.

Fonctions intégrées du Générateur de Nombres Aléatoires Python (Python Random Number Generator)

La liste ci-dessous contient une brève description des fonctions que nous allons aborder dans ce tutoriel pour la génération de nombres aléatoires.

Penchons-nous à présent sur chacune de ces fonctions.

1) La fonction randint()

Des valeurs entières aléatoires peuvent être générées avec la fonction randint().

Cette fonction prend deux arguments x et y, représentant respectivement le début et la fin de l'intervalle pour les valeurs entières générées. Les nombres entiers aléatoires sont générés dans cet intervalle et y compris les valeurs de début et de fin (x et y) de plage, plus précisément dans l'intervalle [x, y]. Les valeurs aléatoires sont tirées d'une distribution uniforme.

La fonction randint() génère donc un nombre entier i entre les limites spécifiées x et y tel que x <= i <= y.

L'exemple ci-dessous génère 10 valeurs entières aléatoires comprises entre 0 et 10.

# Programme pour générer 10 nombres aléatoire entre 0 et 10
import random

# génère quelques nombres entiers
for _ in range(10):
    value = random.randint(0, 10)
    print(value)

L'exécution de l'exemple ci-dessus génère et affiche 10 valeurs entières aléatoires.

Résultat

3
0
6
4
1
5
10
4
5
7

2) La fonction randrange()

Le module random offre une fonction qui peut générer des nombres aléatoires à partir d'une plage spécifiée et permettant également d'inclure des pas, appelée randrange().

Cette fonction prend 2 arguments start (début) et stop (fin) ainsi qu'un argument optionnel step pour le pas. Elle renvoie un entier aléatoire dans l'intervalle (start, stop, step). La valeur par défaut de step est 1.

L'exemple ci-dessous génère 5 nombres entièrs aléatoires compris entre 1 et 10 avec un pas de 2.

# Programme pour générer 5 nombres aléatoires entre 1 et 10 avec un pas de 2
import random

for _ in range(5):
    value = random.randrange(1, 10, 2)
    print(value)

Dans cet exemple, le résultat sera des entiers aléatoires parmi [1, 3, 5, 7, 9] car les valeurs de départ et d'arrêt sont respectivement 1 et 10 et la valeur du pas est 2.

Résultat

7
5
1
7
9

3) La fonction random()

Des nombres aléatoires à virgule flottante peuvent être générés à l'aide de la fonction random(). Les valeurs seront générées dans une plage comprise entre 0.0 et 1.0, plus précisément dans l'intervalle [0.0, 1.0].

Les valeurs sont tirées d'une distribution uniforme, ce qui signifie que chaque valeur a une chance égale d'être tirée.

La fonction random() renvoie donc un nombre aléatoire à virgule flottante compris entre 0.0 et 1.0 (0.0 et 1.0 exclus).

L'exemple ci-dessous génère 5 nombres aléatoires à virgule flottante entre 0.0 et 1.0.

# Programme pour générer 5 nombres aléatoires flottants entre 0.0 et 1.0
import random

for _ in range(5):
    value = random.random()
    print(value)

L'exécution de l'exemple ci-dessus génère et affiche chaque nombre aléatoire à virgule flottante.

Résultat

0.7403036818410228
0.8750486779205128
0.677831018227675
0.35139302480323065
0.2675178543344352

4) La fonction uniform()

La fonction uniform() est utilisée pour générer un nombre aléatoire à virgule flottante entre les limites spécifiées dans ses arguments. Elle prend deux arguments, la limite inférieure (incluse dans la génération) et la limite supérieure (non incluse dans la génération), et renvoie ensuite un nombre flottant compris entre la limite inférieure et la limite supérieure.

L'exemple ci-dessous génère 5 nombres aléatoires à virgule flottante entre 5 et 9.

# Programme pour générer 5 nombres aléatoires flottants entre 5 et 9
import random

for _ in range(5):
    value = random.uniform(5, 9)
    print(value)

L'exécution de l'exemple ci-dessus génère et affiche cinq nombres aléatoires à virgule flottante.

Résultat

8.679927265044514
7.970164807298936
8.784306455630547
5.8220683236941255
6.91579831275938

5) La fonction choice()

Les nombres aléatoires peuvent être utilisés pour choisir au hasard un élément d'une liste.

Par exemple, si une liste contient 10 éléments avec des index compris entre 0 et 9, vous pouvez générer un nombre entier aléatoire compris entre 0 et 9 et l'utiliser pour sélectionner aléatoirement un élément de la liste. La fonction choice() implémente ce comportement pour vous. Les sélections sont effectuées avec une probabilité uniforme.

Donc, si vous voulez choisir un élément aléatoire dans une séquence spécifique, vous pouvez utiliser la fonction choice(). Elle prend un argument : la séquence. Et elle renvoie un élément aléatoire de la séquence.

L'exemple ci-dessous choisit aléatoirement cinq éléments dans la liste donnée. Vous pouvez également générer votre propre liste d'éléments.

# Programme pour choisir aléatoirement 5 nombres dans une liste
import random

seq = (12, 33, 67, 55, 78, 90, 34, 67, 88, 41)

# génère une liste d'éléments de 0 à 19
#seq = [i for i in range(20)]

print("Contenu de la liste :", seq)

for _ in range(5):
    value = random.choice(seq)
    print(value)

L'exécution de l'exemple ci-dessus affiche cinq nombres choisis aléatoirement dans la liste donnée.

Résultat

Contenu de la liste : (12, 33, 67, 55, 78, 90, 34, 67, 88, 41)
12
88
55
90
78

6) La fonction sample()

Nous pouvons être intéressés par la répétition de la sélection aléatoire d'éléments d'une liste pour créer un sous-ensemble choisi au hasard.

Il est important de noter qu'une fois qu'un élément est sélectionné dans la liste et ajouté au sous-ensemble, il ne doit pas être ajouté à nouveau. On parle de sélection sans remplacement parce qu'une fois qu'un élément de la liste est sélectionné pour le sous-ensemble, il n'est pas ajouté à la liste originale (c'est-à-dire qu'il n'est pas disponible pour une nouvelle sélection).

Ce comportement est fourni par la fonction sample() qui sélectionne un échantillon aléatoire dans une liste sans remplacement. La fonction sample() prend comme arguments qui sont la liste et la taille k du sous-ensemble à sélectionner. Notez que les éléments ne sont pas réellement retirés de la liste originale, mais seulement sélectionnés dans une copie de la liste. Elle renvoie ensuite une liste de k éléments aléatoires issus de la liste.

L'exemple ci-dessous montre la sélection d'un sous-ensemble de cinq éléments dans une liste de 10 entiers. Vous pouvez également dans ce cas-ci générer votre propre liste d'éléments.

# Programme pour choisir aléatoirement une sous-liste 5 nombres dans une liste
import random

seq = (12, 33, 67, 55, 78, 90, 34, 67, 88, 41)

# génère une liste d'éléments de 0 à 19
#seq = [i for i in range(20)]

print("Contenu de la liste originale :", seq)
sub_seq = random.sample(seq, 5)
print("Contenu de la sous-liste :", sub_seq)

L'exécution de l'exemple ci-dessus affiche d'abord la liste originale, puis affiche une sous-liste de cinq nombres choisis aléatoirement dans la liste originale.

Résultat

Contenu de la liste originale : (12, 33, 67, 55, 78, 90, 34, 67, 88, 41)
Contenu de la sous-liste : [55, 33, 88, 34, 12]

7) La fonction shuffle()

Le caractère aléatoire peut être utilisé pour mélanger une liste d'éléments, comme pour mélanger un jeu de cartes.

La fonction shuffle() peut être utilisée pour mélanger une liste. Le mélange est effectué sur place, ce qui signifie que la liste fournie comme argument à la fonction shuffle() est mélangée au lieu qu'une copie mélangée de la liste soit faite et renvoyée.

Donc, la fonction shuffle() prend un argument qui est une liste. Elle mélange ensuite les éléments de la liste en place et renvoie None.

L'exemple ci-dessous illustre le mélange aléatoire d'une liste de nombres entiers.

# Programme pour mélanger aléatoirement les éléments d'une liste
import random

l = [10, 20, 30, 40, 50]

# génère une liste d'éléments de 0 à 5
#seq = [i for i in range(5)]

print("Contenu de la liste originale :", l)
random.shuffle(l)
print("Contenu de la liste après mélange :", l)

L'exécution de l'exemple ci-dessus affiche d'abord la liste originale des entiers, puis affiche la même liste après qu'elle ait été mélangée de façon aléatoire.

Résultat

Contenu de la liste originale : [10, 20, 30, 40, 50]
Contenu de la liste après mélange : [30, 10, 40, 50, 20]

8) La fonction seed()

Vous pouvez utiliser la fonction seed() lorsque vous devez générer la même séquence de nombres aléatoires plusieurs fois. Elle prend un argument : la valeur de la référence. Cette valeur initialise un générateur de nombres pseudo-aléatoires. Désormais, chaque fois que vous appellerez la fonction seed() avec cette valeur, elle produira exactement la même séquence de nombres aléatoires.

L'exemple ci-dessous illustre comment fonctionne la méthode seed().

import random

# seed = 3
random.seed(3)
for i in range(3):
    print(random.random(), end = ' ')
print('\n')

# seed = 7
random.seed(7)
for i in range(3):
    print(random.random(), end = ' ')
print('\n')

# encore seed = 3
random.seed(3)
for i in range(3):
    print(random.random(), end = ' ')
print('\n')

L'exécution de l'exemple ci-dessus affiche des nombres générés aléatoirement avec la fonction random() mais en faisant d'abord appel à la fonction seed() avec les valeurs 3, 7 et 3 à nouveau.

Résultat

0.23796462709189137 0.5442292252959519 0.36995516654807925 

0.32383276483316237 0.15084917392450192 0.6509344730398537 

0.23796462709189137 0.5442292252959519 0.36995516654807925

Remarquez que pour seed = 3, la même séquence est produite à chaque fois.

Conclusion

Dans ce tutoriel, vous avez découvert comment générer et travailler avec des nombres aléatoires en Python en utilisant le module random.

Nous avons examiné les fonctions les plus utilisées qui sont capables de générer des nombres pseudo-aléatoires en Python. Nous avons vu les fonctions qui peuvent être utilisées pour générer des nombres entiers. Nous avons également vu comment générer des nombres aléatoires à virgule flottante. Enfin, nous avons vu comment utiliser les fonctions intégrées pour sélectionner des éléments aléatoires dans une séquence. Vous pouvez créer divers petits projets en utilisant des nombres aléatoires. Vous pouvez créer des jeux, vous pouvez utiliser des nombres aléatoires tout en travaillant avec des statistiques en science des données et bien plus encore. Utilisez votre créativité et jouez avec les nombres !