මට පහත ලැයිස්තුවක් ඇතැයි උපකල්පනය කරන්න:

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

මෙම ලැයිස්තුවෙන් අහඹු ලෙස අයිතමයක් ලබා ගැනීමට ඇති සරලම ක්‍රමය කුමක්ද?

භාවිත random.choice()

import random

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

සඳහා cryptographically සුරක්ෂිත අහඹු තෝරා ගැනීම් (අ wordlist සිට මුරවදනක් ජනනය සඳහා උදා:) භාවිතයsecrets.choice()

import secrets

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

secretsපයිතන් 3.6 හි අළුත් ය, පැරණි පයිතන් අනුවාද වල ඔබට random.SystemRandomපන්තිය භාවිතා කළ හැකිය :

import random

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

ඔබට අහඹු ලෙස ලැයිස්තුවකින් අයිතමයකට වඩා තෝරා ගැනීමට හෝ කට්ටලයකින් අයිතමයක් තෝරා ගැනීමට අවශ්‍ය නම්, ඒ random.sampleවෙනුවට භාවිතා කිරීමට මම නිර්දේශ කරමි .

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] 

ඔබ ලැයිස්තුවෙන් එක අයිතමයක් පමණක් අදින්නේ නම්, තේරීම අඩු විකාරයකි, නියැදිය භාවිතා කිරීම random.sample(some_list, 1)[0]වෙනුවට සින්ටැක්ස් ඇත random.choice(some_list).

අවාසනාවකට මෙන්, තේරීම ක්‍රියාත්මක වන්නේ අනුපිළිවෙලින් (ලැයිස්තු හෝ ටුපල් වැනි) එක් ප්‍රතිදානයක් සඳහා පමණි. random.choice(tuple(some_set))කට්ටලයකින් තනි අයිතමයක් ලබා ගැනීම සඳහා විකල්පයක් වුවද .

සංස්කරණය කරන්න: රහස් භාවිතා කිරීම

බොහෝ දෙනා පෙන්වා දී ඇති පරිදි, ඔබට වඩාත් ආරක්ෂිත ව්‍යාජ සාම්පල අවශ්‍ය නම්, ඔබ රහස් මොඩියුලය භාවිතා කළ යුතුය:

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]

සංස්කරණය කරන්න: පයිතොනික් වන්-ලයිනර්

බහුවිධ අයිතම තෝරා ගැනීම සඳහා ඔබට වඩාත් පයිතොනික් එක්-ලයිනර් අවශ්‍ය නම්, ඔබට ඉවත් කිරීම භාවිතා කළ හැකිය.

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

ඔබට දර්ශකයද අවශ්‍ය නම් භාවිතා කරන්න random.randrange

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

පයිතන් 3.6 වන විට ඔබට secretsමොඩියුලය භාවිතා කළ හැකියrandom ගුප්ත ලේඛනකරණය හෝ ආරක්ෂක භාවිතය සඳහා මොඩියුලයට .

ලැයිස්තුවකින් අහඹු අංගයක් මුද්‍රණය කිරීම සඳහා:

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

අහඹු දර්ශකයක් මුද්‍රණය කිරීම සඳහා:

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

වැඩි විස්තර සඳහා PEP 506 බලන්න .

ලැයිස්තුවෙන් අහඹු ලෙස ලබාගත් අයිතම හිස් වන තුරු ඉවත් කිරීම සඳහා ස්ක්‍රිප්ට් එකක් මා යෝජනා කරනවා:

එය පවත්වාගෙන setසහ අහඹු ලෙස (මුලද්රව්යයක් කඩුළු ඉවත් choiceලැයිස්තුව හිස් වන තුරු).

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

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

ලකුණු තුනක් වෙනස් පිළිතුරු තුනක් ලබා දෙයි:

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

පයිතන් 2 හි:

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

පයිතන් 3 හි:

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

numpy විසඳුමක්: numpy.random.choice

මෙම ප්‍රශ්නය සඳහා, එය පිළිගත් පිළිතුරට සමාන වේ ( import random; random.choice()), නමුත් මම එය එකතු කළේ ක්‍රමලේඛකයා numpyදැනටමත් ආනයනය කර ඇති නිසා (මා වැනි) සහ ඔබේ සත්‍ය භාවිත නඩුව සම්බන්ධයෙන් සැලකිලිමත් විය හැකි ක්‍රම දෙක අතර යම් යම් වෙනස්කම් ඇති බැවිනි.

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

ප්‍රජනන හැකියාව සඳහා, ඔබට කළ හැක්කේ:

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

අයිතම එකක් හෝ වැඩි ගණනක සාම්පල සඳහා , ලෙස ආපසු arrayලබා දී, sizeතර්කය සම්මත කරන්න :

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

ලැයිස්තුවකින් අයිතමයක් අහඹු ලෙස තෝරා ගන්නේ කෙසේද?

මට පහත ලැයිස්තුවක් ඇතැයි උපකල්පනය කරන්න:

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

මෙම ලැයිස්තුවෙන් අහඹු ලෙස අයිතමයක් ලබා ගැනීමට ඇති සරලම ක්‍රමය කුමක්ද?

ඔබට සැබවින්ම අහඹු ලෙස සමීප වීමට අවශ්‍ය නම් , මම secrets.choiceසම්මත පුස්තකාලයෙන් යෝජනා කරමි (නව පයිතන් 3.6.):

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

ඉහත සඳහන් මගේ කලින් නිර්දේශයට සමාන වේ SystemRandom, randomමොඩියුලයේ වස්තුවක් choiceක්‍රමවේදය සමඟ භාවිතා කිරීම - මීට පෙර පයිතන් 2 හි ඇත:

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

සහ දැන්:

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

ඔබට නිශ්චිත ව්‍යාජ තේරීමක් අවශ්‍ය නම්, choiceශ්‍රිතය භාවිතා කරන්න (එය ඇත්ත වශයෙන්ම Randomවස්තුවක් මත බැඳී ඇති ක්‍රමයකි ):

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

එය අහඹු ලෙස පෙනේ, නමුත් එය ඇත්ත වශයෙන්ම එසේ නොවේ, අප එය නැවත නැවත සමාන කළේ දැයි අපට දැක ගත හැකිය:

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

අදහස් දැක්වීමක්:

මෙය random.choice සැබවින්ම අහඹුද නැද්ද යන්න ගැන නොවේ. ඔබ බීජ සවි කළහොත් ඔබට ප්‍රජනන ප්‍රති results ල ලැබෙනු ඇත - බීජ සඳහා නිර්මාණය කර ඇත්තේ එයයි. ඔබට SystemRandom වෙත බීජයක් ද ලබා දිය හැකිය.sr = random.SystemRandom(42)

හොඳයි, ඔව් ඔබට එය "බීජ" තර්කයක් ඉදිරිපත් කළ හැකිය, නමුත් SystemRandomවස්තුව එය නොසලකා හරින බව ඔබට පෙනෙනු ඇත :

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

ඔබට දර්ශකය අවශ්‍ය නම් භාවිතා කරන්න:

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

random.choice එකම දේ කරයි :)

සසම්භාවී දර්ශකය අර්ථ දක්වන විචල්යයක් සහිත කේතය මෙයයි:

import random

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

විචල්‍යය නොමැතිව කේතය මෙයයි:

import random

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

එය කළ හැකි කෙටිම හා බුද්ධිමත් ආකාරයෙන් කේතය මෙයයි:

import random

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

(පයිතන් 2.7)

ඔබට එකම අයිතම නිෂ්පාදනය කිරීමට අවශ්‍ය නම් පහත කේතය පෙන්වයි. ඔබට නිස්සාරණය කිරීමට අවශ්‍ය සාම්පල කීයක් ද සඳහන් කළ හැකිය.
මෙම sampleක්‍රමය මගින් ජනගහනයේ මූලද්‍රව්‍ය අඩංගු නව ලැයිස්තුවක් ලබා දෙන අතර මුල් ජනගහනය නොවෙනස්ව පවතී. එහි ප්‍රති ing ලයක් ලෙස ලැයිස්තුව තේරීමේ අනුපිළිවෙලින් ඇති අතර එමඟින් සියලුම උප පෙති වලංගු අහඹු සාම්පල වේ.

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

අහඹු අයිතම තේරීම:

import random

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

new_list = random.sample(my_list, num_selections)

ලැයිස්තුවේ අනුපිළිවෙල ආරක්ෂා කිරීම සඳහා, ඔබට කළ හැක්කේ:

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

Https://stackoverflow.com/a/49682832/4383027 හි අනුපිටපත

අපට මෙය අහඹු ලෙස භාවිතා කළ හැකිය.

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)

ඔබට පුළුවන්:

from random import randint

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

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