Python >> Tutoriel Python >  >> Python

Créer une liste de nombres aléatoires - La manière la plus pythonique

Voulez-vous initialiser une liste avec des nombres aléatoires ? Dans cet article, je vais vous montrer quatre manières différentes d'y parvenir, ainsi qu'une courte discussion sur "la manière la plus pythonique" .

Problème :Soit un entier n . Créer une liste de n éléments dans un certain intervalle (exemple intervalle :[0, 20] ).

# n = 5 --> [2, 3, 1, 4, 3]
# n = 3 --> [10, 12, 1]
# n = 10 --> [8, 2, 18, 10, 4, 19, 5, 9, 8, 1]

Solution  :Voici un bref aperçu de la façon dont vous pouvez créer une liste de nombres aléatoires :

  • Méthode 1 :[random.random() for _ in range(10)] pour créer une liste de flottants aléatoires.
  • Méthode 2 :[random.randint(0, 999) for _ in range(10)] pour créer une liste d'entiers aléatoires.
  • Méthode 3 :randlist = []; for _ in range(10): randlist.append(random.randint(0, 99)) pour créer une liste d'entiers aléatoires.
  • Méthode 4 :randlist = random.sample(range(20), 10) pour créer une liste d'entiers aléatoires.

Vous pouvez les essayer vous-même dans notre shell de code interactif :

Exercice :Modifiez l'intervalle de chaque méthode sur [0, ] et exécutez le code.

Méthode 1 :Compréhension de la liste dans une liste flottante aléatoire [0, 1]

La compréhension de liste est une manière compacte de créer des listes. La formule simple est [expression + context] .

  • Expression :Que faire de chaque élément de la liste ?
  • Contexte :Quels éléments sélectionner ? Le contexte consiste en un nombre arbitraire de for et if déclarations.
# Method 1: List Comprehension Random Float List [0, 1]
import random
randlist = [random.random() for _ in range(10)]

Dans mon shell Python, le résultat est le suivant :

print(randlist)
# [0.06472744987876633, 0.011889634172418173, 0.70189711954834, 0.030063483145627568, 0.22255082691969674, 0.26704646386061337, 0.3242939534531408, 0.1781476583083168, 0.5367990394305883, 0.7621210982784024]

Dans le code, vous importez d'abord le module random.

Ensuite, vous créez une liste de flottants aléatoires en appelant à plusieurs reprises random.random() qui génère un nombre flottant aléatoire entre 0 et 1 à chaque fois qu'il est appelé.

Vous l'appelez dix fois comme défini dans la partie contexte for _ in range(10) . Notez que le trait de soulignement sert de variable "jetable" car vous n'en avez pas réellement besoin pour créer la liste.

Notez également que l'instruction de compréhension de liste évalue l'expression plusieurs fois, et pas une seule fois au début. C'est pourquoi tous les chiffres de la liste sont différents.

Vous pouvez facilement étendre la création de flottants dans un intervalle plus grand en multipliant le flottant créé aléatoirement par une constante :[random.random() * 999 for _ in range(10)] créerait une liste de flottants aléatoires dans l'intervalle [0, 999] .

Si vous avez du mal à comprendre la liste, regardez ma vidéo explicative :

L'utilisation de la compréhension de liste pour générer une liste de nombres aléatoires est lisible, concise et efficace. S'il n'y avait pas la quatrième méthode, je considérerais que c'est le moyen le plus Pythonique de créer une liste de flottants aléatoires.

Méthode 2 :Compréhension de la liste d'entiers aléatoires [0 999]

Juste pour être complet, voici la déclaration de compréhension de liste qui crée une liste d'entiers aléatoires dans l'intervalle [0, 999] :

# Method 2: List Comprehension Random Int List [0, 999]
import random
randlist = [random.randint(0, 999) for _ in range(10)]

Dans mon shell Python, le résultat est le suivant :

print(randlist)
# [298, 218, 58, 260, 485, 192, 588, 615, 42, 499]

Vous utilisez le random.randint(0, 999) fonction pour créer une valeur entière aléatoire entre la valeur de début 0 et la valeur de fin 999, de sorte que tous les entiers créés soient dans l'intervalle [0, 999].

C'est un moyen très Pythonique et lisible de créer une liste d'entiers aléatoires. Vous pouvez arrêter de lire tout de suite et l'utiliser dans votre propre code.

Méthode 3 : Liste d'entiers aléatoires de boucle for [0, 99]

Une alternative souvent utilisée par les codeurs non-Python consiste à utiliser une simple boucle for qui fait la même chose que la compréhension de liste (mais qui demande plus d'espace) :

# Method 3: For Loop Random Int List [0, 99]
import random
randlist = []
for _ in range(10):
    randlist.append(random.randint(0, 99))

Dans mon shell Python, le résultat est le suivant :

print(randlist)
# [19, 35, 0, 13, 36, 15, 13, 65, 41, 99]

Encore une fois, vous utilisez la variable de soulignement jetable car le nombre aléatoire n'est pas une fonction d'une variable de boucle. Tous les deux appels au random.randint() fonction sont indépendantes.

Je considérerais cela comme le moins Manière pythonique de résoudre ce problème.

Méthode 4 :random.sample()

Enfin, nous arrivons à la manière la plus Pythonique de résoudre ce problème :se tenir sur les épaules de géants et utiliser les fonctionnalités intégrées existantes. Le random.sample() la méthode prend un "univers" à partir duquel les nombres aléatoires sont tirés et une taille de liste n —et dessine n nombres aléatoires de votre univers.

# Method 4: random.sample()
import random
# Generate 10 random numbers between 0 and 20 (included)
randlist = random.sample(range(20), 10)

Dans mon shell Python, le résultat est le suivant :

print(randlist)
# [1, 3, 0, 14, 7, 9, 13, 4, 12, 8]

Vous utilisez l'univers range(20) des 20 premiers nombres entiers 0, …, 19 et tirez 10 éléments aléatoires de l'univers. Notez que par défaut, aucun doublon n'est autorisé. Si l'univers est plus petit que la taille de la liste n, une erreur est générée :

ValueError: Sample larger than population or is negative

Discussion

Dans ce didacticiel, vous avez appris quatre méthodes pour résoudre le problème de la création d'une liste de nombres aléatoires. Objectivement, la manière la plus Pythonique d'y parvenir est la quatrième méthode :utilisez le random.sample() fonctionner tel qu'il est implémenté pour faire exactement cela.

Mais subjectivement, j'utiliserais la première ou la deuxième méthode basée sur la compréhension de liste pour créer une liste de flottants ou d'entiers aléatoires.

Pourquoi? Parce que je suis paresseux et que je connais le random.random() et random.randint() fonctions est déjà suffisant pour résoudre efficacement le problème. En pratique, je ne veux pas perdre trop d'énergie à essayer de mémoriser des fonctions de code qui n'améliorent ni la lisibilité, ni l'efficacité de mon code.