random

Par Christophe Hirschi 1

Introduction

random est un module Python regroupant plusieurs fonctions permettant de travailler avec des valeurs aléatoires.

La distribution des nombres aléatoires est réalisée par le générateur de nombres pseudo-aléatoires Mersenne Twister, l’un des générateurs les plus testés et utilisés dans le monde informatique.

Module random

Le module comprend plusieurs fonctions travaillant chacune avec un type défini de variables. Ces fonctions peuvent être séparées en trois groupes :

• Celles qui travaillent avec des nombres entiers

• Celles qui travaillent avec des nombres réels

• Celles qui travaillent avec des séquences (par exemple des listes).

Les fonctions de nombres entiers telles que random.randint() et random.randrange() permettent de sélectionner arbitrairement une valeur entière dans un intervalle donné.

Les fonctions de nombres réels, en plus de sélectionner des valeurs dans un intervalle (avec les fonctions random.random() et random.uniform() par exemple), permettent aussi de réaliser des distributions gaussienne, exponentielles et logarithmiques.

Les fonctions de séquences permettent de manipuler des éléments dans une liste donnée. Elles peuvent sélectionner un élément de la liste aléatoirement (random.choice()), altérer l’ordre des éléments dans la liste elle-même (random.shuffle()) ou encore retourner un nombre d’éléments aléatoires d’une liste (random.sample()).

Avertissement

Il est préférable d’éviter l’utilisation de random pour des applications liées à la cryptographie ou la sécurité en général (génération de mots de passe, authentification de compte, etc.) et de préférer le module secrets à la place.

Seeding

Comme spécifiés dans l’introduction, les nombres générés par random sont de nature pseudo-aléatoire, c’est-à-dire qu’une graine, seed en anglais, génère la suite de nombres. Dans le cas de random, la période des graines est suffisamment élevée pour éviter de tomber sur les mêmes numéros lors d’un usage commun. Cependant, il peut être utile dans certains cas de répéter la même suite aléatoire de nombres. Pour cela, il est possible d’indiquer à random la graine que l’on souhaite utiliser avec la fonction random.seed() qui reçoit un nombre en argument, la graine.

"""Exemple de seeding avec random."""

import random

# Attribution d'une graine.
random.seed(1)

# Retour de valeurs.
print(random.random())  # N°1
print(random.random())  # N°2
print(random.random())  # N°3

Résultats :

$ python random_seeding.py
0.13436424411240122
0.8474337369372327
0.763774618976614

$ python random_seeding.py
0.13436424411240122
0.8474337369372327
0.763774618976614

Exemples

Avant toutes choses, il convient d’importer le module au projet :

>>> import random

Nombres réels

random.random() est la fonction la plus basique du module. Elle retourne un nombre à virgule dans l’intervalle compris entre 0 et 1 non-compris \([0; 1[\) :

>>> random.random()
0.6982933392406706

random.uniform() permet de spécifier un intervalle. La fonction accepte deux nombres comme arguments, a et b. Elle retourne un nombre à virgule dans l’intervalle compris entre a et b non-compris \([a; b[\) :

>>> random.uniform(4.5, 7.5)
5.292029100094782

Nombres entiers

Si l’on souhaite travailler avec des nombres entiers, il faut utiliser les fonctions suivantes :

random.randint() accepte deux nombre comme arguments, a et b, et retourne un nombre entier de l’intervalle compris entre a et b \([a;b]\) :

>>> random.randint(2, 9)
8

Note

C’est la seule fonction qui prend en compte la valeur limite supérieur de l’intervalle dans son exécution.

random.randrange() accepte un nombre comme argument, a. Cette fonction retourne un nombre entier compris entre 0 et a non-compris \([0; a[\) :

>>> random.randrange(15)
8

Elle accepte aussi deux nombres comme arguments, a et b. Il est ainsi possible de spécifier le commencement de l’intervalle, ce qui correspond à l’intervalle \([a; b[\) :

>>> random.randrange(10, 12)
10

Il est possible d’ajouter un nombre en troisième argument pour indiquer un pas dans l’intervalle :

>>> random.randrange(4, 8, 2) # Retourne un nombre paire.
6

Séquences

Il est possible d’utiliser certaines fonctions du module sur des listes d’éléments :

random.choice() accepte une séquence comme argument, seq. Elle retourne un élément de la séquence seq à condition que celle-ci ne soit pas vide :

>>> random.choice(['dede', 'toto', 'lulu'])
'lulu'

>>> random.choice([4, 7, 11, 18])
18

random.shuffle() accepte une séquence en argument, seq, et permet de mélanger les éléments de la séquence seq :

>>> names = ['dede', 'toto', 'lulu']
>>> random.shuffle(names)
>>> names
['lulu', 'toto', 'dede']

>>> numbers = [4, 7, 11, 18]
>>> random.shuffle(numbers)
>>> numbers
[4, 11, 18, 7]

random.sample() prend en compte une séquence seq comme premier argument et un nombre k en second argument. Elle permet de retourner une liste de k éléments de la séquence seq aléatoirement :

>>> random.sample(['dede', 'toto', 'lulu', 'momo', 'bibi'], 3)
['momo', 'dede', 'bibi']

>>> random.sample([10, 20, 30, 40, 50, 60], 4)
[10, 30, 60, 50]

Exemple concret

L’exemple ci-dessous utilise la fonction random.shuffle() pour mélanger un jeu de 52 cartes.

Dans un premier temps, les cartes sont créées et ajoutées une à une dans une liste de cartes appelée jeu. Cette liste est ensuite mélangée, puis les 5 premières cartes du jeu mélangé sont attribuées au joueur.

"""Exemple d'attribution de cartes."""

import random

# Préparation des cartes.
valeurs = [
    "Deux", "Trois", "Quatre", "Cinq", "Six", "Sept", "Huit", "Neuf", "Dix",
    "Valet", "Dame", "Roi", "As"
]
enseignes = ["Cœur", "Pique", "Carreau", "Trèfle"]

# Préparation du jeu de cartes (52 cartes).
jeu_de_cartes = [f"{v} de {e}" for v in valeurs for e in enseignes]

# Mélange du jeu de cartes.
random.shuffle(jeu_de_cartes)

# Création de la main du joueur (5 cartes).
main = jeu_de_cartes[:5]

# Affichage de la main du joueur.
print("Main du joueur :")
for carte in main:
    print("- " + carte)

Résultats :

$ python cards_shuffling.py
Main du joueur :
- Valet de Pique
- Dix de Trèfle
- Dix de Carreau
- Roi de Carreau
- Trois de Coeur

$ python cards_shuffling.py
Main du joueur :
- Dame de Coeur
- Six de Coeur
- As de Carreau
- Deux de Trèfle
- Sept de Carreau

Conclusion

random permet bien plus d’utilisations que la simple attribution d’une valeur dans un intervalle donné. Toutes ses fonctionnalités n’ont pu être traitées ici (car certaines sont exotiques et/ou très spécifiques) et si vous êtes désireux d’en connaitre encore un peu plus sur son sujet, visitez la documentation officielle Python3 de random.

1

<christophe.hirschi@he-arc.ch>