Angenommen, ich habe die folgende Liste:

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

Was ist der einfachste Weg, um ein Element zufällig aus dieser Liste abzurufen?

Verwenden random.choice()

import random

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

Für kryptografisch sichere zufällige Auswahlmöglichkeiten (z. B. zum Generieren einer Passphrase aus einer Wortliste) verwendensecrets.choice()

import secrets

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

secretsist neu in Python 3.6, in älteren Versionen von Python können Sie die random.SystemRandomKlasse verwenden:

import random

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

Wenn Sie mehr als ein Element zufällig aus einer Liste auswählen oder ein Element aus einem Satz auswählen möchten, würde ich empfehlen, random.samplestattdessen zu verwenden.

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] 

Wenn Sie jedoch nur ein einzelnes Element aus einer Liste ziehen, ist die Auswahl weniger umständlich, da die Verwendung von sample die Syntax random.sample(some_list, 1)[0]anstelle von verwenden würde random.choice(some_list).

Leider funktioniert die Auswahl nur für eine einzelne Ausgabe von Sequenzen (wie Listen oder Tupeln). Dies random.choice(tuple(some_set))kann jedoch eine Option sein, um einen einzelnen Artikel aus einem Set zu erhalten.

BEARBEITEN: Verwenden von Geheimnissen

Wie viele bereits betont haben, sollten Sie das Modul "Geheimnisse" verwenden, wenn Sie sicherere Pseudozufallsstichproben benötigen:

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

Wenn Sie einen pythonischeren Einzeiler für die Auswahl mehrerer Elemente wünschen, können Sie das Auspacken verwenden.

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

Wenn Sie auch den Index benötigen, verwenden Sie random.randrange

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

Ab Python 3.6 können Sie das secretsModul verwenden, das dem randomModul für Kryptografie- oder Sicherheitszwecke vorzuziehen ist .

So drucken Sie ein zufälliges Element aus einer Liste:

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

So drucken Sie einen zufälligen Index:

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

Einzelheiten finden Sie in PEP 506 .

Ich schlage ein Skript vor, um zufällig ausgewählte Elemente von einer Liste zu entfernen, bis sie leer sind:

Pflegen Sie ein setund entfernen Sie zufällig aufgenommenes Element (mit choice), bis die Liste leer ist.

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

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

Drei Läufe geben drei verschiedene Antworten:

>>> 
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

In Python 2:

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

In Python 3:

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

numpy Lösung: numpy.random.choice

Für diese Frage funktioniert sie genauso wie die akzeptierte Antwort ( import random; random.choice()), aber ich habe sie hinzugefügt, da der Programmierer möglicherweise bereits importiert hat numpy(wie ich) und es auch einige Unterschiede zwischen den beiden Methoden gibt , die Ihren tatsächlichen Anwendungsfall betreffen können.

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

Für die Reproduzierbarkeit können Sie Folgendes tun:

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

Übergeben Sie für Beispiele eines oder mehrerer Elemente , die als zurückgegeben werden array, das folgende sizeArgument:

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

Wie wähle ich zufällig ein Element aus einer Liste aus?

Angenommen, ich habe die folgende Liste:

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

Was ist der einfachste Weg, um ein Element zufällig aus dieser Liste abzurufen?

Wenn Sie nahezu zufällig sein möchten , empfehle ich secrets.choiceaus der Standardbibliothek (Neu in Python 3.6.):

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

Das Obige entspricht meiner früheren Empfehlung, ein SystemRandomObjekt aus dem randomModul mit der choiceMethode zu verwenden - früher in Python 2 verfügbar:

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

Und nun:

>>> 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'

Wenn Sie eine deterministische Pseudozufallsauswahl wünschen, verwenden Sie die choiceFunktion (die eigentlich eine gebundene Methode für ein RandomObjekt ist):

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

Es scheint zufällig zu sein, aber es ist tatsächlich nicht so, was wir sehen können, wenn wir es wiederholt neu aussäen:

>>> 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')

Ein Kommentar:

Hier geht es nicht darum, ob random.choice wirklich zufällig ist oder nicht. Wenn Sie den Samen reparieren, erhalten Sie reproduzierbare Ergebnisse - und dafür ist der Samen ausgelegt. Sie können auch einen Startwert an SystemRandom übergeben.sr = random.SystemRandom(42)

Ja, Sie können ein "Seed" -Argument übergeben, aber Sie werden sehen, dass das SystemRandomObjekt es einfach ignoriert :

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

Wenn Sie den Index benötigen, verwenden Sie einfach:

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

random.choice macht das gleiche :)

Dies ist der Code mit einer Variablen, die den Zufallsindex definiert:

import random

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

Dies ist der Code ohne die Variable:

import random

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

Und dies ist der Code auf kürzeste und intelligenteste Weise:

import random

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

(Python 2.7)

Der folgende Code zeigt, ob Sie dieselben Artikel produzieren müssen. Sie können auch angeben, wie viele Samples Sie extrahieren möchten.
Die sampleMethode gibt eine neue Liste mit Elementen aus der Grundgesamtheit zurück, während die ursprüngliche Grundgesamtheit unverändert bleibt. Die resultierende Liste befindet sich in Auswahlreihenfolge, sodass alle Unterschnitte auch gültige Zufallsstichproben sind.

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']

Zufällige Artikelauswahl:

import random

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

new_list = random.sample(my_list, num_selections)

Um die Reihenfolge der Liste beizubehalten, können Sie Folgendes tun:

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

Duplikat von https://stackoverflow.com/a/49682832/4383027

Wir können dies auch mit Randint tun.

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)

Sie könnten einfach:

from random import randint

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

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