Générer des nombres aléatoires avec une distribution uniforme en python

Cet article met en évidence la distribution uniforme et la façon dont nous générons des nombres aléatoires à l'aide d'une distribution uniforme à Python. La distribution uniforme est le concept de statistiques utilisées pour la distribution continue de probabilité pour un modèle simple dans des situations où les résultats de probabilité sont également susceptibles d'être une valeur dans la plage donnée par l'utilisateur. Python gère cela facilement à l'aide du module de bibliothèque Numpy «aléatoire». Ici, nous démontrerons tout ce qui concerne les nombres de génération à l'aide d'exemples et de codes de référence appropriés.

Nombres aléatoires avec distribution uniforme

Une séquence de nombres avec une distribution uniforme est celle dans laquelle chaque nombre a une chance égale d'être sélectionné. Ces nombres sont fréquemment utilisés dans les simulations, la modélisation statistique et d'autres applications où une distribution uniforme des nombres est requise. Utilisez le hasard.Fonction uniforme () du package aléatoire Python pour obtenir des nombres aléatoires avec une distribution uniforme. La fonction accepte deux paramètres, A et B qui définissent la plage de la distribution et renvoie un numéro de point flottant aléatoire.

Importer un module aléatoire

Dans Python, nous avons utilisé le module «aléatoire» de la bibliothèque Numpy. Pour produire des nombres aléatoires à partir d'une distribution uniforme, utilisez ce module. Maintenant, nous allons discuter de la procédure de génération de nombres aléatoires. Tout d'abord, ouvrez un outil Python comme PyCharm, Spyder ou Jupiter Notebook et créez un projet où nous pouvons importer des bibliothèques Python et effectuer une distribution uniforme. Le code d'importation du module aléatoire est donné ci-dessous.

Importer au hasard

Vous pouvez également écrire ceci comme:

Importer aléatoire comme RDM
ou
importer aléatoire comme Rd

Ou quelle que soit la forme courte que vous voulez donner.

Le Mersenne Twister sert de générateur principal du module «aléatoire». Il génère des flotteurs de précision avec 53 bits.

Syntaxe du module aléatoire

Après avoir importé le module «aléatoire» avec succès dans une application Python, nous discuterons de la syntaxe du module aléatoire pour trouver une distribution uniforme. La syntaxe de ce module est:

NP. aléatoire. uniforme (a, b, taille = aucun)

Pour générer des nombres aléatoires, le hasard.La méthode uniforme () est utilisée. N'oubliez pas que les nombres aléatoires sont générés à partir de la distribution uniforme. En faisant référence à la bibliothèque Numpy, nous utilisons l'alias «NP» pour la bibliothèque Numpy. Cette méthode prend trois paramètres comme a, b et taille.

L'argument «A» affiche un intervalle faible, l'argument «B» affiche un intervalle élevé et l'argument «taille» affiche des nombres aléatoires en fonction de la taille spécifiée.

Exemple 1:
Ici, nous prendrons un exemple simple et linéaire dans lequel nous ne prendrons que la limite inférieure et la limite supérieure. Le code de référence est fourni.

Importer Numpy
Importer au hasard
random_number = numpy.aléatoire.uniforme (1.2, 4.3)
Uniform_Distrib = print ("Le nombre aléatoire de la distribution uniforme est:", random_number)

Dans cet exemple, nous importons une bibliothèque Numpy, puis importons un module aléatoire à travers lequel nous pouvons générer des nombres aléatoires. Ces deux bibliothèques (Numpy et Random) sont très cruciales pour exécuter les exemples de codes mentionnés dans cet article.

Après cela, nous avons appelé une méthode uniforme. Cette fonction est principalement définie dans le module aléatoire. Ici, nous avons pris une plage entre «1.2 ”'et« 4.Valeurs de 3 ”et généré un nombre aléatoire entre ces gammes. La méthode uniforme renvoie une valeur et nous avons stocké cette valeur dans la variable 'random_number'. Après cela, nous voulions afficher cette variable 'random_number' à la console. Donc, nous avons passé cette variable dans une déclaration d'impression. Enfin, nous avons attribué une valeur d'instruction d'impression à la variable 'Uniform_distrib'.

En exécutant le code, le résultat est affiché sur la console. Le résultat du formulaire textuel est donné ci-dessous:

Le nombre aléatoire d'une distribution uniforme est: 2.0215816312995187

Ici, nous ne pouvons donner aucune valeur de taille. C'est pourquoi une seule valeur flottante est indiquée sur la console.

Exemple n ° 2:
Ici, nous discuterons à nouveau de générer des nombres aléatoires. Nous expliquerons cela avec la taille des nombres. Le code de référence lié à cet exemple est mentionné ci-dessous:

Importer Numpy comme NP
Importer au hasard
rand_num = np.aléatoire.uniforme (bas = 3.2, haut = 6.5, taille = 3.3)
Unidistrirandnum = print ("Les nombres aléatoires sont:", rand_num)

Nous avons importé la bibliothèque Numpy et l'avons aliasée comme «NP» dans ce cas. Le module aléatoire fait partie de Numpy, donc l'importation Numpy est très importante. Après l'importation, nous avons appelé la «méthode uniforme», dans laquelle nous avons passé trois arguments comme la limite supérieure, la borne inférieure et la taille de cette distribution uniforme. La borne basse dans ce cas est 3.2, la limite élevée est 6.5, et la taille est 3.3 '. Les méthodes uniformes renvoient une valeur et nous avons stocké cette valeur dans la variable «rand_num». Après cela, nous avons passé ce «rand_num» dans une déclaration d'impression pour afficher le résultat sur la console. Donc, de cette façon, nous trouvons des nombres aléatoires à partir d'une distribution uniforme.

La sortie de l'exemple 2 est indiquée ici.

Les nombres aléatoires sont: [6.16573794 5.34926847 3.38366092]

Ici, nous voyons que trois nombres aléatoires sont générés à partir de notre gamme donnée. Ces trois nombres aléatoires sont '6.16573794 ',' 5.34926847 'et' 3.38366092 '. Donc, de cette façon, nous avons généré des nombres aléatoires.

Exemple # 3:
Dans le dernier exemple de cet article, le module aléatoire est à nouveau mis en évidence. Voir le code ci-dessous. Ici, nous importons d'abord une bibliothèque Numpy, puis importons un module aléatoire dans ces fichiers Python. Après cela, nous prendrons des gammes et entre ces gammes, nous générerons des nombres aléatoires. Dans la ligne 3, nous appellerons un module aléatoire avec la méthode uniforme dans laquelle nous passerons 3 paramètres comme la limite inférieure, la limite supérieure et la taille des nombres aléatoires entre ces plages. La valeur liée inférieure sera «-3.2 », la valeur limite supérieure sera« 2.5 »et la taille des valeurs sera« 5 ». Les fonctions uniformes renvoient une valeur et nous stockons cette valeur dans la variable «RNUM». Maintenant, nous allons pousser cette variable à l'instruction d'impression pour afficher le résultat de la méthode uniforme sur la console. Ainsi, de cette manière, nous générons avec succès des nombres aléatoires qui proviennent d'une distribution uniforme.

Importer Numpy comme NP
Importer au hasard
rnum = np.aléatoire.uniforme (bas = -3.2, haut = 2.5, taille = 5)
Unidri = Print ("Générer des nombres aléatoires à partir de la distribution uniforme:", RNUM)

La sortie de l'exemple 3 est donnée ci-dessous:

Générer des nombres aléatoires à partir de la distribution uniforme: [2.08222359 0.75018807 2.03184071 1.88274545 1.14929147].

Conclusion

Dans cet article, nous avons découvert que nous pouvons facilement générer des nombres aléatoires à partir de la distribution uniforme en utilisant le module aléatoire de la bibliothèque Numpy. Dans vos applications Python, vous pouvez également utiliser aléatoire. Exemple de méthode uniforme () pour pratiquer le processus de génération d'un nombre aléatoire à partir de la distribution uniforme. Comme le montre cet article, les nombres aléatoires sont générés à partir d'une distribution uniforme, ce qui signifie que toutes les valeurs de la plage ont une chance égale d'être générée. Ce concept est très utile dans des applications Python comme les jeux ou où des gammes de valeurs aléatoires sont nécessaires.