Parfois, vous avez besoin d'un nombre ou d'un élément aléatoire. Comment Python peut-il aider ?
La vérité est que le hasard est tout autour de nous. Pensez à la loterie, à un lancer de dés ou au caractère aléatoire (extrême) du fonctionnement du Père Noël secret de votre bureau.
Dans cet article, nous discuterons du pseudo-aléatoire, en quoi il est différent du vrai hasard et comment il peut être appliqué en Python pour générer des nombres aléatoires. Nous aborderons également des sujets plus avancés, comme le codage reproductible avec des nombres aléatoires et l'utilisation de choice() et choix() fonctions pour renvoyer des éléments de chaîne aléatoires à partir d'une liste. Enfin, nous vous montrerons comment randomiser l'ordre des listes.
Que sont les nombres pseudo-aléatoires ?
Un générateur de nombres pseudo-aléatoires génère du « hasard » à l'aide d'un algorithme mathématique. Cela signifie qu'un choix aléatoire est produit avec un programme informatique. Pour les humains, cela a un effet aléatoire :le résultat apparaît complètement arbitraire. Un générateur pseudo-aléatoire est presque aussi bon qu'un vrai générateur aléatoire (qui utilise un moyen physique imprévisible pour générer des nombres aléatoires).
Pour les besoins de cet article, lorsque nous parlons du caractère aléatoire produit par Python, nous parlons en fait de pseudo-aléatoire. Il est important de mentionner que nous n'utiliserons pas un véritable générateur aléatoire, mais le pseudo-aléatoire est suffisant pour la plupart des besoins actuels du monde des affaires.
Générer des nombres pseudo-aléatoires avec le module random de Python
L'un des modules les plus connus de Python pour générer des choix aléatoires est random . Regardons les fonctions les plus célèbres de cette bibliothèque.
Choisir un entier aléatoire
Imaginez que vous travaillez dans la vente et que vous avez 10 clients. Vous souhaitez choisir au hasard l'un de ces clients pour une offre spéciale. Vous pouvez faire un choix aléatoire en Python en utilisant le randint() fonction.
Nous avons créé un exemple ? — ? 10 clients sont stockés dans une trame de données Pandas. Chaque client a un identifiant et un nom. Les numéros d'identification vont de 0 à 10 et identifient de manière unique chaque client.
import pandas as pd clients = pd.DataFrame() clients['client_id'] = [0,1,2,3,4,5,6,7,8,9] clients['client_name'] = ["Mobili Ltd.","Tymy Ltd.", "Lukas Ltd.","Brod Ltd.", "Missyda Ltd.", "Abiti Ltd.", "Bomy Ltd." , "Citiwi Ltd.", "Dolphy Ltd.", "Doper Ltd."]
Maintenant une question se pose :Comment pouvons-nous utiliser randint() choisir un client dans la base de données ? Facilement :
import random random_number = random.randint(0,9) clients.loc[clients['client_id'] == random_number]
Dans le code ci-dessus, randint() est appelée avec deux arguments :le numéro de départ (qui dans ce cas est 0) et le numéro de fin (qui est 9). En appelant randint() avec les arguments 0 et 9, nous disons à Python de renvoyer un nombre entier aléatoire parmi 0,1,2,3,4,5,6,7,8, 9. Appel clients.loc[clients[' client_id']==random_number] renvoie l'ID client sélectionné au hasard et le nom associé :
Essayez de répéter ce processus plusieurs fois. Vous n'obtiendrez pas toujours le même client car l'ID est choisi au hasard par le random module.
Mais que se passe-t-il si vous voulez rendre votre code reproductible ? Peut-être que votre patron veut savoir comment Bomy Ltd. a été sélectionné. Et peut-être qu'il veut exécuter le code et obtenir à nouveau les mêmes résultats. Ceci est possible car le aléatoire module génère des nombres pseudo-aléatoires, pas de vrais nombres aléatoires. Les nombres générés aléatoirement en Python peuvent être déterminés. (Il y a une formule mathématique derrière le choix). Nous pouvons utiliser la seed() fonction si nous voulons obtenir des résultats reproductibles.
Codage reproductible avec la fonction seed()
Crédit image :"Scratch" de "Pied Higher and Deeper" par Jorge Cham www.phdcomics.com.
La graine() La fonction est utilisée pour enregistrer l'état du random() fonction, lui permettant de générer le ou les mêmes nombres aléatoires lors de plusieurs exécutions du code sur la même machine ou sur des machines différentes pour une valeur de départ spécifique. Passer la même graine à random() puis appeler cette fonction vous donnera toujours le même ensemble de nombres.
Si nous mettons random.seed(0) au début du code dans l'exemple ci-dessus, en appelant randint(0,9) obtiendra toujours le même résultat :
import random random.seed(0) random.randint(0,9)
Utiliser graine() rend votre code reproductible; chaque exécution produira le même résultat.
Le générateur de nombre flottant aléatoire
Une autre fonction utile, random() , peut être utilisé pour un générateur de nombres flottants aléatoires.
De nombreux algorithmes célèbres utilisent aujourd'hui un générateur de nombres flottants pseudo-aléatoires dans l'une de leurs étapes. Par exemple, dans les réseaux de neurones, les poids sont initialisés avec de petits nombres aléatoires. L'idée est de trouver un ensemble parfait de poids, qu'une fonction de mappage spécifique utilisera pour faire une bonne prédiction pour la variable de sortie. Le processus de recherche de ces poids est appelé « apprentissage »; de nombreuses itérations de combinaisons de poids sont essayées et la meilleure combinaison (c'est-à-dire l'ensemble de poids qui donnera les prédictions les plus précises) est choisie à l'aide d'un type d'algorithme appelé « descente de gradient stochastique ».
La première étape du processus ci-dessus consiste à utiliser des nombres flottants générés de manière aléatoire. Ils peuvent être choisis à l'aide du random() fonction. Donc, si vous êtes dans une situation où vous devez générer un petit nombre (entre 0 et 1), vous pouvez appeler random() :
import random random.random()
Cela produira un nombre aléatoire - dans notre cas, 0,5417604303861212.
Le nombre aléatoire renvoyé est toujours compris entre 0 et 1. Si vous souhaitez obtenir un nombre d'un autre intervalle, vous pouvez simplement multiplier votre résultat. Le code ci-dessous générera toujours un nombre aléatoire entre 0 et 10 :
import random random.random() * 10
Il existe une autre option si vous souhaitez choisir un nombre aléatoire dans un intervalle spécifique. C'est l'uniforme() fonction, qui prend deux arguments :low (la limite la plus basse de l'intervalle) et haut (la limite la plus élevée de l'intervalle).
Si vous voulez choisir un nombre aléatoire entre 0 et 10, voici comment vous pouvez le faire avec uniform() :
import random radom.uniform(0,10)
Maintenant que nous vous avons montré random() et uniforme() , c'est à vous de décider quelle fonction utiliser. L'un ou l'autre peut être utilisé pour obtenir un nombre aléatoire dans une plage.
Mais qu'en est-il lorsque vous souhaitez choisir au hasard un élément dans un tuple ou une liste prédéfinie ? Il existe également une fonction pour cela - elle s'appelle choice() . Cette fonction est utilisée lorsque vous souhaitez sélectionner au hasard un élément dans une liste donnée. Voyons comment cela fonctionne.
Utilisation de choice() pour renvoyer un élément aléatoire d'une liste
Précédemment, nous avons donné l'exemple d'un vendeur qui doit choisir un de ses clients dans une liste. Chaque client était représenté par un entier de 0 à 10. Au lieu d'utiliser randint() pour sélectionner un entier aléatoire, notre vendeur pourrait simplement utiliser le choice() fonction, comme ceci :
import random
import pandas as pd
clients = pd.DataFrame()
clients['client_id'] = [0,1,2,3,4,5,6,7,8,9]
clients['client_name'] = ["Mobili Ltd.","Tymy Ltd.", "Lukas Ltd.","Brod Ltd.",
"Missyda Ltd.", "Abiti Ltd.", "Bomy Ltd." , "Citiwi Ltd.", "Dolphy Ltd.", "Doper Ltd."]
clients.loc[clients['client_id'] == random.choice(clients['client_id'])]
Dans le code ci-dessus, random.choice(clients['client_id']) choisit un nombre dans la liste [0,1,2,3,4,5,6,7,8,9] . La ligne clients.loc[clients['client_id'] ==random.choice(clients['client_id'])] récupère le nom et l'ID du client qui a été choisi au hasard avec random.choice(['clients_id']) . C'est une façon très élégante de récupérer un objet aléatoire.
Il est également important de mentionner que choice() fonctionne également avec une liste de chaînes. Notre vendeur pourrait également exécuter au hasard.choix (clients['client_name']) et un nom aléatoire serait directement renvoyé dans la sortie. Au lieu d'un choix d'entier aléatoire, choice() ferait un choix de chaîne aléatoire.
Parfois, vous voudrez peut-être choisir plusieurs éléments dans une liste. Cela peut être fait avec les choices() fonction (notez le 's'). Nous pouvons choisir au hasard deux clients dans la liste en utilisant random.choices(clients['client_name'],k=2) . L'argument k est utilisé pour définir le nombre d'éléments que nous voulons sélectionner au hasard.
Le code ci-dessus renverra deux noms choisis au hasard - gardez simplement à l'esprit que si vous voulez rendre votre code reproductible, vous devez utiliser le seed() fonction. (Sinon, vous obtiendrez toujours des noms différents.)
import random
import pandas as pd
clients = pd.DataFrame()
clients['client_id'] = [0,1,2,3,4,5,6,7,8,9]
clients['client_name'] = ["Mobili Ltd.","Tymy Ltd.", "Lukas Ltd.","Brod Ltd.",
"Missyda Ltd.", "Abiti Ltd.", "Bomy Ltd." , "Citiwi Ltd.", "Dolphy Ltd.", "Doper Ltd."]
random.choices(clients['client_name'],k=2)
Réorganiser aléatoirement une liste avec shuffle()
La dernière fonction que nous allons mentionner est shuffle() . Vous utilisez cette fonction lorsque vous devez renvoyer tous les éléments de la liste mais dans un ordre différent. Peut-être que notre vendeur veut mélanger sa liste de clients et utiliser la liste réorganisée pour faire des appels commerciaux. La liste des client_ids ressemble à ceci :[0,1,2,3,4,5,6,7,8,9] . Il peut être réorganisé avec random.shuffle(client_id) . Après avoir exécuté cette ligne de code, la variable client_id ressemblerait à quelque chose comme [0, 4, 3, 2, 8, 9, 1, 6, 7, 5] . Nous avons mélangé la liste au hasard. Maintenant, notre vendeur peut passer des appels par cette commande aléatoire.
Bien sûr, nous pouvons également réorganiser une liste de chaînes avec shuffle() . Si nous avons des noms stockés dans une liste, comme ceci :
nom_client(['Mobili Ltd.', 'Tymy Ltd.', 'Lukas Ltd.', 'Brod Ltd.', 'Missyda Ltd.', 'Abiti Ltd.', 'Bomy Ltd.', 'Citiwi Ltd.', 'Dolphy Ltd.', 'Doper Ltd.'])
Nous pouvons réorganiser cette liste en exécutant random.shuffle(client_name) . Il renvoie une liste mélangée.
import random client_name= ["Mobili Ltd.","Tymy Ltd.", "Lukas Ltd.","Brod Ltd.", "Missyda Ltd.", "Abiti Ltd.", "Bomy Ltd." , "Citiwi Ltd.", "Dolphy Ltd.", "Doper Ltd."] random.shuffle(client_name) client_name
Après avoir appelé random.shuffle() , la liste a été réorganisée. Cela ressemblerait à ceci :
['Abiti Ltd.', 'Citiwi Ltd.', 'Dolphy Ltd.', 'Tymy Ltd.', 'Doper Ltd.', 'Missyda Ltd.', 'Mobili Ltd.', 'Lukas Ltd. ', 'Brod Ltd.', 'Bomy Ltd.']
Les nombres aléatoires en Python sont plus simples que vous ne le pensez
L'un des modules Python les plus populaires facilite la génération de nombres pseudo-aléatoires. Certaines des fonctions les plus fréquemment utilisées du module random incluent celles qui gèrent un choix d'entier aléatoire (randint() ), un nombre flottant aléatoire (random() , uniforme() ), un choix d'élément de liste aléatoire (choice() , choix() ) et réorganisation aléatoire des listes (shuffle() ). Cet article vous a montré comment utiliser ces fonctions et comment implémenter le caractère aléatoire dans votre code. Rappelez-vous, lorsque vous utilisez seed() , ces résultats pseudo-aléatoires peuvent être reproduits dans votre code - un moyen très pratique de faire fonctionner des nombres aléatoires en Python !
