Supposons que j'ai la liste suivante:

foo = ['a', 'b', 'c', 'd', 'e']

Quelle est la manière la plus simple de récupérer un élément au hasard dans cette liste?

Utilisation random.choice()

import random

foo = ['a', 'b', 'c', 'd', 'e']
print(random.choice(foo))

Pour des choix aléatoires cryptographiquement sécurisés (par exemple pour générer une phrase secrète à partir d'une liste de mots), utilisezsecrets.choice()

import secrets

foo = ['battery', 'correct', 'horse', 'staple']
print(secrets.choice(foo))

secretsest nouveau dans Python 3.6, sur les anciennes versions de Python, vous pouvez utiliser la random.SystemRandomclasse:

import random

secure_random = random.SystemRandom()
print(secure_random.choice(foo))

Si vous souhaitez sélectionner au hasard plusieurs éléments dans une liste, ou sélectionner un élément dans un ensemble, je vous recommande d'utiliser à la random.sampleplace.

import random
group_of_items = {1, 2, 3, 4}               # a sequence or set will work here.
num_to_select = 2                           # set the number to select here.
list_of_random_items = random.sample(group_of_items, num_to_select)
first_random_item = list_of_random_items[0]
second_random_item = list_of_random_items[1] 

Si vous ne retirez qu'un seul élément d'une liste, le choix est moins maladroit, car l'utilisation de sample aurait la syntaxe à la random.sample(some_list, 1)[0]place de random.choice(some_list).

Malheureusement, le choix ne fonctionne que pour une seule sortie de séquences (telles que des listes ou des tuples). Bien que cela random.choice(tuple(some_set))puisse être une option pour obtenir un seul élément d'un ensemble.

EDIT: Utilisation des secrets

Comme beaucoup l'ont souligné, si vous avez besoin d'échantillons pseudo-aléatoires plus sécurisés, vous devez utiliser le module secrets:

import secrets                              # imports secure module.
secure_random = secrets.SystemRandom()      # creates a secure random object.
group_of_items = {1, 2, 3, 4}               # a sequence or set will work here.
num_to_select = 2                           # set the number to select here.
list_of_random_items = secure_random.sample(group_of_items, num_to_select)
first_random_item = list_of_random_items[0]
second_random_item = list_of_random_items[1]

EDIT: Pythonic One-Liner

Si vous voulez une doublure plus pythonique pour sélectionner plusieurs articles, vous pouvez utiliser le déballage.

import random
first_random_item, second_random_item = random.sample(group_of_items, 2)

Si vous avez également besoin de l'index, utilisez random.randrange

from random import randrange
random_index = randrange(len(foo))
print(foo[random_index])

Depuis Python 3.6, vous pouvez utiliser le secretsmodule, qui est préférable au randommodule pour des utilisations de cryptographie ou de sécurité.

Pour imprimer un élément aléatoire à partir d'une liste:

import secrets
foo = ['a', 'b', 'c', 'd', 'e']
print(secrets.choice(foo))

Pour imprimer un index aléatoire:

print(secrets.randbelow(len(foo)))

Pour plus de détails, voir PEP 506 .

Je propose un script pour supprimer les éléments ramassés au hasard d'une liste jusqu'à ce qu'elle soit vide:

Maintenez un setélément et supprimez-le au hasard (avec choice) jusqu'à ce que la liste soit vide.

s=set(range(1,6))
import random

while len(s)>0:
  s.remove(random.choice(list(s)))
  print(s)

Trois pistes donnent trois réponses différentes:

>>> 
set([1, 3, 4, 5])
set([3, 4, 5])
set([3, 4])
set([4])
set([])
>>> 
set([1, 2, 3, 5])
set([2, 3, 5])
set([2, 3])
set([2])
set([])

>>> 
set([1, 2, 3, 5])
set([1, 2, 3])
set([1, 2])
set([1])
set([])

foo = ['a', 'b', 'c', 'd', 'e']
number_of_samples = 1

En python 2:

random_items = random.sample(population=foo, k=number_of_samples)

En python 3:

random_items = random.choices(population=foo, k=number_of_samples)

numpy Solution: numpy.random.choice

Pour cette question, cela fonctionne de la même manière que la réponse acceptée ( import random; random.choice()), mais je l'ai ajoutée parce que le programmeur a peut-être numpydéjà importé (comme moi) et il existe également des différences entre les deux méthodes qui peuvent concerner votre cas d'utilisation réel.

import numpy as np    
np.random.choice(foo) # randomly selects a single item

Pour la reproductibilité, vous pouvez faire:

np.random.seed(123)
np.random.choice(foo) # first call will always return 'c'

Pour les échantillons d' un ou plusieurs éléments , renvoyés sous forme de array, passez l' sizeargument:

np.random.choice(foo, 5)          # sample with replacement (default)
np.random.choice(foo, 5, False)   # sample without replacement

Comment sélectionner au hasard un élément dans une liste?

Supposons que j'ai la liste suivante:

foo = ['a', 'b', 'c', 'd', 'e']  

Quelle est la manière la plus simple de récupérer un élément au hasard dans cette liste?

Si vous voulez près de vraiment aléatoire , alors je suggère secrets.choicede la bibliothèque standard (Nouveau dans Python 3.6.):

>>> from secrets import choice         # Python 3 only
>>> choice(list('abcde'))
'c'

Ce qui précède est équivalent à mon ancienne recommandation, en utilisant un SystemRandomobjet du randommodule avec la choiceméthode - disponible plus tôt dans Python 2:

>>> import random                      # Python 2 compatible
>>> sr = random.SystemRandom()
>>> foo = list('abcde')
>>> foo
['a', 'b', 'c', 'd', 'e']

Et maintenant:

>>> sr.choice(foo)
'd'
>>> sr.choice(foo)
'e'
>>> sr.choice(foo)
'a'
>>> sr.choice(foo)
'b'
>>> sr.choice(foo)
'a'
>>> sr.choice(foo)
'c'
>>> sr.choice(foo)
'c'

Si vous voulez une sélection pseudo-aléatoire déterministe, utilisez la choicefonction (qui est en fait une méthode liée sur un Randomobjet):

>>> random.choice
<bound method Random.choice of <random.Random object at 0x800c1034>>

Cela semble aléatoire, mais ce n'est pas le cas, ce que nous pouvons voir si nous le réensemencons à plusieurs reprises:

>>> random.seed(42); random.choice(foo), random.choice(foo), random.choice(foo)
('d', 'a', 'b')
>>> random.seed(42); random.choice(foo), random.choice(foo), random.choice(foo)
('d', 'a', 'b')
>>> random.seed(42); random.choice(foo), random.choice(foo), random.choice(foo)
('d', 'a', 'b')
>>> random.seed(42); random.choice(foo), random.choice(foo), random.choice(foo)
('d', 'a', 'b')
>>> random.seed(42); random.choice(foo), random.choice(foo), random.choice(foo)
('d', 'a', 'b')

Un commentaire:

Il ne s'agit pas de savoir si random.choice est vraiment aléatoire ou non. Si vous réparez la graine, vous obtiendrez des résultats reproductibles - et c'est pour cela que la graine est conçue. Vous pouvez également transmettre une graine à SystemRandom.sr = random.SystemRandom(42)

Eh bien, oui, vous pouvez lui passer un argument "seed", mais vous verrez que l' SystemRandomobjet l'ignore simplement :

def seed(self, *args, **kwds):
    "Stub method.  Not used for a system random number generator."
    return None

si vous avez besoin de l'index, utilisez simplement:

import random
foo = ['a', 'b', 'c', 'd', 'e']
print int(random.random() * len(foo))
print foo[int(random.random() * len(foo))]

random.choice fait de même :)

Voici le code avec une variable qui définit l'index aléatoire:

import random

foo = ['a', 'b', 'c', 'd', 'e']
randomindex = random.randint(0,len(foo)-1) 
print (foo[randomindex])
## print (randomindex)

Voici le code sans la variable:

import random

foo = ['a', 'b', 'c', 'd', 'e']
print (foo[random.randint(0,len(foo)-1)])

Et voici le code de la manière la plus courte et la plus intelligente pour le faire:

import random

foo = ['a', 'b', 'c', 'd', 'e']
print(random.choice(foo))

(python 2.7)

Le code suivant montre si vous devez produire les mêmes éléments. Vous pouvez également spécifier le nombre d'échantillons que vous souhaitez extraire.
La sampleméthode renvoie une nouvelle liste contenant des éléments de la population tout en laissant la population d'origine inchangée. La liste résultante est dans l'ordre de sélection afin que toutes les sous-tranches soient également des échantillons aléatoires valides.

import random as random
random.seed(0)  # don't use seed function, if you want different results in each run
print(random.sample(foo,3))  # 3 is the number of sample you want to retrieve

Output:['d', 'e', 'a']

Sélection aléatoire d'éléments:

import random

my_list = [1, 2, 3, 4, 5]
num_selections = 2

new_list = random.sample(my_list, num_selections)

Pour conserver l'ordre de la liste, vous pouvez faire:

randIndex = random.sample(range(len(my_list)), n_selections)
randIndex.sort()
new_list = [my_list[i] for i in randIndex]

Duplicata de https://stackoverflow.com/a/49682832/4383027

Nous pouvons également le faire en utilisant randint.

from random import randint
l= ['a','b','c']

def get_rand_element(l):
    if l:
        return l[randint(0,len(l)-1)]
    else:
        return None

get_rand_element(l)

Vous pourriez simplement:

from random import randint

foo = ["a", "b", "c", "d", "e"]

print(foo[randint(0,4)])