Name: Tremplin Numérique
Price range: $$$

Vous souhaitez ajouter un peu d'imprévisibilité à votre code Python ? Le module aléatoire est le moyen le plus rapide de le faire. De la génération de nombres et du mélange de listes à la simulation du caractère aléatoire du monde réel, c'est l'un de ces modules petits mais utiles que tout programmeur Python devrait connaître. Allons-y !

Sommaire

Importer le module aléatoire

Le module random fait partie de la bibliothèque standard de Python, vous n'avez donc rien à installer. Ajoutez simplement une simple ligne en haut de votre script.

import random

C'est ça! Vous pouvez désormais accéder à toutes les fonctions de génération de nombres aléatoires proposées par Python.

Parfois, j'aime utiliser le à partir d'une importation aléatoire syntaxe quand je sais que j'utiliserai des fonctions spécifiques à plusieurs reprises. De cette façon, je peux taper moins pendant le codage.

from random import randint, choice, shuffle

Maintenant, je peux utiliser directement randint() et Choice() sans les préfixer avec random. C'est une petite commodité qui rend votre code plus propre lorsque vous n'utilisez que quelques fonctions du module.

Générer des nombres ou des plages aléatoires

À la base, le module aléatoire consiste à générer des nombres aléatoires. C'est comme avoir un dé numérique capable de lancer des nombres dans n'importe quelle plage que vous pouvez imaginer. Par exemple, si vous souhaitez générer des nombres entiers, vous devrez utiliser la fonction randint() ou randrange() du module random.

Le premier, random.randint(), est parfait lorsque vous avez besoin d'un entier entre deux points, les deux points finaux étant inclus. Par exemple:

import random
dice_roll = random.randint(1, 6)
print(f"You rolled a {dice_roll}!")

Cela vous donnera un lancer de dés classique, avec des résultats possibles de 1 à 6 inclus.

Mais que se passe-t-il si vous avez besoin de plus de contrôle, comme générer uniquement des nombres impairs entre 1 et 10 ? C'est là qu'intervient la deuxième fonction, random.randrange(). Elle fonctionne exactement comme la fonction range() intégrée mais renvoie une valeur aléatoire. Par exemple:

import random
random_odd = random.randrange(1, 11, 2)
print(f"Random odd number: {random_odd}")

Ce code sélectionne aléatoirement un nombre impair entre 1 et 10.

Désormais, pour les nombres décimaux compris entre deux valeurs, vous disposez de deux excellentes options. Le premier est random.random(), qui vous donne un flottant compris entre 0,0 et 1,0 (mais n'atteignant jamais vraiment 1,0).

import random
chance = random.random()
print(f"The chance of success is: {chance:.2f}")

Ceci imprime un nombre aléatoire à virgule flottante entre 0 et 1, simulant des probabilités ou des pourcentages.

Si vous avez besoin d'un flottant dans une plage spécifique, utilisez la fonction random.uniform().

import random
temperature = random.uniform(-10.0, 50.0)
print(f"Simulated temperature: {temperature:.2f}°C")

Cela pourrait produire quelque chose comme « Température simulée : 23,45°C », parfait pour les simulations météorologiques ou la modélisation scientifique.

Choisir des éléments aléatoires uniques ou multiples

Si vous travaillez avec une liste d'éléments, tels que des noms ou des options, vous devrez peut-être en choisir un ou plusieurs. Pour sélectionner un seul élément dans une liste, utilisez la fonction random.choice(seq).

Par exemple, créons un script Python qui sélectionne une couleur dans une liste :

import random
colors = ('red', 'green', 'blue', 'yellow')
print(random.choice(colors))

Cela fonctionne avec n'importe quelle séquence telle que des listes, des chaînes, des tuples et même des objets de plage. Mais que se passe-t-il si vous avez besoin de plus d’un article ? Pour choisir plusieurs éléments, vous disposez de deux outils principaux : random.choices(seq, k=n) et random.sample(seq, k=n). La fonction random.choices() sélectionne plusieurs éléments dans une liste avec des doublons possibles. Par exemple:

import random
colors = ('red', 'green', 'blue', 'yellow')
print(random.choices(colors, k=3))

Cela pourrait produire quelque chose comme (« rouge », « rouge », « bleu »), où le rouge apparaît deux fois. Cependant, si vous souhaitez des éléments uniques sans doublons, utilisez plutôt random.sample() :

print(random.sample(colors, k=3))

Ici, vous obtiendrez trois couleurs distinctes. Assurez-vous également que le nombre que vous demandez (k) ne peut pas être plus grand que la liste elle-même.

Mélanger une liste sur place

Parfois, vous ne souhaitez pas sélectionner des éléments dans une liste, vous souhaitez simplement mélanger la liste entière. Vous pouvez le faire avec la fonction random.shuffle(). Une chose importante à retenir est que random.shuffle() modifie la liste en place. Cela signifie qu'il ne renvoie pas une nouvelle liste mélangée ; au lieu de cela, cela change directement celui d'origine.

import random
playlist = ('Song A', 'Song B', 'Song C', 'Song D', 'Song E')
random.shuffle(playlist)
print(f"Shuffled playlist: {playlist}")

Ce code modifie votre liste d'origine et n'en renvoie pas de nouvelle. C'est pourquoi nous transmettons la liste originale à la fonction d'impression. Si vous essayez d'attribuer la valeur de retour de random.shuffle() à une variable, elle renverra Aucun.

Pour conserver votre liste d'origine inchangée, faites d'abord une copie :

import random
playlist = ('Song A', 'Song B', 'Song C', 'Song D', 'Song E')
copy_playlist = playlist.copy()
print(random.shuffle(copy_playlist))
print('Original List: ', playlist)

Ici, nous faisons une copie de la liste de lecture originale, de sorte que la lecture aléatoire n'affecte que la copie, laissant la liste originale intacte.

Si votre liste est immuable, comme un tuple, vous ne pouvez pas la mélanger directement. Cependant, vous pouvez utiliser la fonction sample() de manière créative pour obtenir le même effet.

import random
original_tuple = (1, 2, 3, 4, 5)
shuffled_list = random.sample(original_tuple, len(original_tuple))
print(f"Shuffled as list: {shuffled_list}")

Ce code sélectionne tous les éléments du tuple dans un ordre aléatoire et les renvoie sous la forme d'une nouvelle liste mélangée.

Générer des mots de passe ou des chaînes aléatoires

Vous pouvez combiner le module aléatoire avec le module de chaîne intégré de Python pour créer des mots de passe aléatoires forts. L'idée est de créer un pool de caractères tels que des lettres, des chiffres et des symboles, puis d'utiliser random.choices() pour sélectionner des caractères un certain nombre de fois.

Voici une fonction simple de générateur de mot de passe :

        import string
import randomdef gen_password(length=12):
   characters = string.ascii_letters + string.digits + string.punctuation
   password = ''.join(random.choices(characters, k=length))
   return password
print(f"Your new password: {gen_password()}")

Ici,

string.ascii_letters vous donne toutes les lettres majuscules et minuscules.
chaîne.chiffres fournit les nombres de 0 à 9.
chaîne.ponctuation ajoute des caractères spéciaux.

Nous regroupons tous ces éléments dans un plus grand pool de caractères et utilisons random.choices() pour en sélectionner autant que nécessaire. Pour les cas plus simples, comme la génération de codes de vérification ou de codes PIN, vous pouvez limiter la sélection aux chiffres uniquement.

        def generate_pin(length=6):
   digits = string.digits
   return ''.join(random.choices(digits, k=length))
print(f"Your verification PIN: {generate_pin()}")

Ce code génère un code PIN numérique aléatoire à six chiffres, idéal pour les systèmes d'authentification simples ou les données de test.

Travailler avec le hasard pondéré

Parfois, vous ne voulez pas que chaque choix aléatoire ait la même chance de se produire. Par exemple, dans certains programmes, certains résultats devraient se produire plus souvent que d’autres. C'est là qu'intervient le hasard pondéré.

La fonction random.choices() de Python vous permet d'attribuer différentes probabilités à chaque option à l'aide du paramètre pondérations, vous permettant de rendre certains résultats plus probables que d'autres.

Voici un exemple où certains prix d'un jeu sont plus rares que d'autres :

import random
prizes = ('gold', 'silver', 'bronze')
weights = (0.6, 0.3, 0.1) # Relative chances
winner = random.choices(prizes, weights=weights, k=1)(0)
print(winner)

Dans cet exemple, l'or a la plus grande chance (60 %) d'être sélectionné, l'argent est moins probable (30 %) et le bronze est rare (10 %). Cette approche permet de faire apparaître les objets courants plus souvent tout en gardant les objets rares spéciaux.

Vous pouvez également utiliser des pondérations cumulées, qui représentent les totaux cumulés des probabilités. Cela peut être plus efficace pour les grands ensembles de données.

import random
loot_value = ('common', 'uncommon', 'rare', 'legendary')
cumulative_weights = (70, 90, 99, 100) # Cumulative of (70, 20, 9, 1)random_loot = random.choices(loot_value, cum_weights=cumulative_weights, k=1)(0)
print(f"You found a {random_loot} item!")

Le résultat est la même distribution de probabilité qu'auparavant, mais les poids cumulés sont traités plus rapidement, en particulier avec de longues listes. La principale différence entre les poids normaux et les poids cumulés réside dans le fait que les poids normaux représentent les probabilités individuelles pour chaque élément, tandis que les poids cumulés représentent la probabilité totale cumulée jusqu'à chaque élément.

Définition de graines aléatoires pour des résultats reproductibles

Le module aléatoire offre de l'imprévisibilité lorsque vous en avez besoin, mais il permet également la reproductibilité. Même si cela peut paraître étrange, c'est crucial pour les tests, le débogage et les simulations scientifiques.

Les ordinateurs ne génèrent pas de véritable hasard ; ils produisent des nombres pseudo-aléatoires basés sur une formule mathématique qui commence par une valeur appelée graine. Si vous utilisez la même graine, vous obtiendrez toujours la même séquence de nombres aléatoires.

Définissons la graine avec random.seed() en utilisant ce script :

import random
# Set a specific seed
random.seed(42)
print(random.randint(1, 100)) # Always prints 82
print(random.randint(1, 100)) # Always prints 15

Exécutez à nouveau le script avec la même graine et vous obtiendrez les mêmes résultats.

Cette prévisibilité est extrêmement utile pour tester et déterminer les bogues imprévisibles. De plus, lorsqu'aucune valeur de départ n'est définie, Python utilise l'entropie générée par le système (comme l'heure actuelle) pour produire des résultats différents à chaque exécution.

Générer des dates et des heures aléatoires

Le module random ne génère pas directement de dates ou d'heures, mais lorsque vous le combinez avec le module datetime de Python, il devient un outil précieux pour créer des données de test réalistes.

L'idée est simple : définir une date de début et de fin, calculer l'intervalle de temps entre elles, puis choisir un point aléatoire dans cette plage.

from datetime import date, timedelta
import randomstart_date = date(2023, 1, 1)
end_date = date(2023, 12, 31)
time_between = end_date - start_date
days_between = time_between.days
random_days = random.randrange(days_between)
random_date = start_date + timedelta(days=random_days)
print(f"Here's a random date in 2023: {random_date}")

Ce script calcule le nombre total de jours entre les deux dates, sélectionne un nombre aléatoire de jours dans cette plage et l'ajoute à la date de début. De plus, si vous avez besoin d’horodatages aléatoires (avec heures, minutes et secondes), vous pouvez également travailler avec des secondes au lieu de jours.

from datetime import datetime, timedelta
import randomstart = datetime(2023, 1, 1)
end = datetime(2023, 12, 31)
delta = end - start
random_seconds = random.randint(0, int(delta.total_seconds()))
random_timestamp = start + timedelta(seconds=random_seconds)
print(f"Random timestamp: {random_timestamp}")

Vous pouvez également pousser cette idée plus loin et créer un simple générateur de données. C’est parfait pour créer des ensembles de données fictifs qui semblent authentiques. Qu'il s'agisse de générer des heures de connexion aléatoires, des données météorologiques ou des historiques d'événements, la combinaison de l'aléatoire et de la date/heure ajoute une couche d'imprévisibilité réaliste et sensible au temps à vos projets.

Python comprend une collection impressionnante de bibliothèques et de modules qui simplifient de nombreuses tâches du monde réel. Que vous automatisiez la gestion de fichiers ou analysiez de grands ensembles de données, il existe un module conçu pour rendre votre travail plus facile et plus rapide.