Python માં સૂચિમાંથી ઘટકોને રેન્ડમલી પસંદ કરવા માટે પસંદગી, નમૂના અને પસંદગીઓ.

પાયથોન સ્ટાન્ડર્ડ લાઇબ્રેરીના રેન્ડમ મોડ્યુલમાં ફંક્શન ચોઈસ(), સેમ્પલ(), અને ચોઈસ() નો ઉપયોગ યાદી, ટ્યુપલ, સ્ટ્રીંગ અથવા અન્ય સિક્વન્સ ઓબ્જેક્ટ (રેન્ડમ સેમ્પલિંગ)માંથી તત્વોને રેન્ડમલી પસંદ કરવા અને પુનઃપ્રાપ્ત કરવા માટે થઈ શકે છે.

choice() એક એલિમેન્ટ મેળવે છે, સેમ્પલ() અને choices() ને બહુવિધ તત્વોની યાદી મળે છે. સેમ્પલ() કોઈ ડુપ્લિકેટ્સ સાથે નોન-રિકવરેબલ એક્સટ્રેક્શન છે, ચોઈસ() ડુપ્લિકેટ્સ સાથે રીકવરેબલ એક્સટ્રેક્શન છે.

• random — Generate pseudo-random numbers — Python 3.10.2 Documentation

નીચેની માહિતી અહીં આપવામાં આવી છે.

• રેન્ડમ પર એક ઘટક પસંદ કરો.:random.choice()
• રેન્ડમલી બહુવિધ તત્વો પસંદ કરો (કોઈ ડુપ્લિકેટ નથી):random.sample()
• રેન્ડમલી બહુવિધ તત્વો પસંદ કરો (ડુપ્લિકેટ્સ સાથે):random.choices()
• રેન્ડમ નંબરના બીજને ઠીક કરો

રેન્ડમ પર એક ઘટક પસંદ કરો.:random.choice()

રેન્ડમ મોડ્યુલના ફંક્શન પસંદ() સાથે, સૂચિમાંથી એક ઘટક રેન્ડમલી પસંદ કરવામાં આવે છે અને તેને પુનઃપ્રાપ્ત કરી શકાય છે.

• random.choice() — Generate pseudo-random numbers — Python 3.10.2 Documentation

import random

l = [0, 1, 2, 3, 4]

print(random.choice(l))
# 1

આ જ ટ્યુપલ્સ અને શબ્દમાળાઓ પર લાગુ પડે છે. શબ્દમાળાઓના કિસ્સામાં, એક અક્ષર પસંદ થયેલ છે.

print(random.choice(('xxx', 'yyy', 'zzz')))
# yyy

print(random.choice('abcde'))
# b

જો કોઈ ખાલી સૂચિ, ટ્યુપલ અથવા સ્ટ્રિંગ દલીલ તરીકે ઉલ્લેખિત હોય તો ભૂલ.

# print(random.choice([]))
# IndexError: Cannot choose from an empty sequence

રેન્ડમલી બહુવિધ તત્વો પસંદ કરો (કોઈ ડુપ્લિકેટ નથી):random.sample()

રેન્ડમ મોડ્યુલના ફંક્શન સેમ્પલ() સાથે, તમે સૂચિમાંથી રેન્ડમ પર બહુવિધ તત્વો મેળવી શકો છો. તત્વોનું કોઈ ડુપ્લિકેશન નથી (બિન-પુનઃપ્રાપ્ત નિષ્કર્ષણ).

પ્રથમ દલીલ એ સૂચિ છે, અને બીજી દલીલ એ પુનઃપ્રાપ્ત કરવાના ઘટકોની સંખ્યા છે. યાદી પરત કરવામાં આવે છે.

• random.sample() — Generate pseudo-random numbers — Python 3.10.2 Documentation

import random

l = [0, 1, 2, 3, 4]

print(random.sample(l, 3))
# [2, 4, 0]

print(type(random.sample(l, 3)))
# <class 'list'>

જો બીજી દલીલ 1 પર સેટ છે, તો એક તત્વ સાથેની સૂચિ પણ પરત કરવામાં આવે છે; જો તે 0 પર સેટ કરેલ હોય, તો યાદી ખાલી છે. જો બીજી દલીલ 1 હોય, તો એક તત્વ સાથેની સૂચિ પરત કરવામાં આવે છે; જો તે 0 હોય, તો ખાલી યાદી પરત કરવામાં આવે છે; જો પ્રથમ દલીલ યાદીમાં ઘટકોની સંખ્યા કરતાં વધુ હોય, તો ભૂલ થાય છે.

print(random.sample(l, 1))
# [3]

print(random.sample(l, 0))
# []

# print(random.sample(l, 10))
# ValueError: Sample larger than population or is negative

જો પ્રથમ દલીલ ટ્યુપલ અથવા સ્ટ્રિંગ હોય, તો જે પરત કરવામાં આવે છે તે હજુ પણ સૂચિ છે.

print(random.sample(('xxx', 'yyy', 'zzz'), 2))
# ['xxx', 'yyy']

print(random.sample('abcde', 2))
# ['b', 'e']

જો તમે ટ્યુપલ અથવા સ્ટ્રિંગ પર પાછા ફરવા માંગતા હો, તો ટ્યુપલ(),જોઇન() નો ઉપયોગ કરો.

print(tuple(random.sample(('xxx', 'yyy', 'zzz'), 2)))
# ('xxx', 'yyy')

print(''.join(random.sample('abcde', 2)))
# dc

નોંધ કરો કે મૂલ્યનું મૂલ્યાંકન કરવામાં આવતું નથી, તેથી જો મૂળ સૂચિ અથવા ટ્યૂપલમાં સમાન મૂલ્ય ધરાવતા ઘટકો હોય, તો તે જ મૂલ્ય પસંદ કરવામાં આવશે તેવી શક્યતા છે.

l_dup = [0, 0, 0, 1, 1, 1, 2, 2, 2, 3, 3, 3]

print(random.sample(l_dup, 3))
# [3, 1, 1]

જો તમે ડુપ્લિકેટ મૂલ્યોને ટાળવા માંગતા હો, તો તમે તેને સેટ (સેટ પ્રકાર) માં રૂપાંતરિત કરવા માટે સેટ() નો ઉપયોગ કરી શકો છો અને ફક્ત અનન્ય ઘટકોને બહાર કાઢી શકો છો, અને પછી નમૂના() નો ઉપયોગ કરી શકો છો.

print(set(l_dup))
# {0, 1, 2, 3}

print(random.sample(set(l_dup), 3))
# [1, 3, 2]

રેન્ડમલી બહુવિધ તત્વો પસંદ કરો (ડુપ્લિકેટ્સ સાથે):random.choices()

રેન્ડમ મોડ્યુલની ફંક્શન પસંદગીઓ() તમને સૂચિમાંથી રેન્ડમ પર બહુવિધ ઘટકોને પુનઃપ્રાપ્ત કરવાની મંજૂરી આપે છે, અને નમૂના()થી વિપરીત, તે ડુપ્લિકેટ ઘટકોને પસંદ કરવાની મંજૂરી આપે છે.

choices() એ Python 3.6 માં ઉમેરાયેલ કાર્ય છે. તે પહેલાનાં વર્ઝનમાં ઉપલબ્ધ નથી.

• random.choices() — Generate pseudo-random numbers — Python 3.10.2 Documentation

દલીલ k પુનઃપ્રાપ્ત કરવાના ઘટકોની સંખ્યાનો ઉલ્લેખ કરે છે. ડુપ્લિકેશનની મંજૂરી છે, તેથી પુનઃપ્રાપ્ત કરવાના ઘટકોની સંખ્યા મૂળ સૂચિમાંના ઘટકોની સંખ્યા કરતાં મોટી હોઈ શકે છે.

k એ કીવર્ડ-ઓન્લી દલીલ હોવાથી, કીવર્ડનો ઉલ્લેખ કરવો જરૂરી છે, જેમ કે k=3.

import random

l = [0, 1, 2, 3, 4]

print(random.choices(l, k=3))
# [2, 1, 0]

print(random.choices(l, k=10))
# [3, 4, 1, 4, 4, 2, 0, 4, 2, 0]

k ની મૂળભૂત કિંમત 1 છે; જો તે અવગણવામાં આવે તો, 1 ઘટક સાથેની સૂચિ પરત કરવામાં આવે છે.

print(random.choices(l))
# [1]

દરેક તત્વ પસંદ કરવામાં આવશે તે વજન (સંભાવના)નો ઉલ્લેખ કરવા માટે દલીલના વજનનો ઉપયોગ કરી શકાય છે, અને સૂચિમાંના ઘટકોનો પ્રકાર પૂર્ણાંક અથવા ફ્લોટ હોઈ શકે છે.

print(random.choices(l, k=3, weights=[1, 1, 1, 10, 1]))
# [0, 2, 3]

print(random.choices(l, k=3, weights=[1, 1, 0, 0, 0]))
# [0, 1, 1]

દલીલ cum_weights ને સંચિત વજન તરીકે પણ સ્પષ્ટ કરી શકાય છે. નીચેના નમૂના કોડમાં કમ_વજન ઉપરના પ્રથમ વજનની સમકક્ષ છે.

print(random.choices(l, k=3, cum_weights=[1, 2, 3, 13, 14]))
# [3, 2, 3]

દલીલો વજન અને કમ_વજન બંને માટે ડિફોલ્ટ કંઈ નથી, જેનો અર્થ છે કે દરેક ઘટક સમાન સંભાવના સાથે પસંદ થયેલ છે.

જો દલીલના વજન અથવા કમ_વેટ્સની લંબાઈ (તત્વોની સંખ્યા) મૂળ સૂચિથી અલગ હોય, તો ભૂલ થાય છે.

# print(random.choices(l, k=3, weights=[1, 1, 1, 10, 1, 1, 1]))
# ValueError: The number of weights does not match the population_

તે જ સમયે વજન અને કમ_વેટ્સનો ઉલ્લેખ કરવામાં પણ ભૂલ છે.

# print(random.choices(l, k=3, weights=[1, 1, 1, 10, 1], cum_weights=[1, 2, 3, 13, 14]))
# TypeError: Cannot specify both weights and cumulative weights

અમે અત્યાર સુધી નમૂના કોડમાં ઉદાહરણ તરીકે પ્રથમ દલીલ તરીકે સૂચિનો ઉલ્લેખ કર્યો છે, પરંતુ તે જ ટ્યુપલ્સ અને સ્ટ્રિંગ્સ પર લાગુ થાય છે.

રેન્ડમ નંબરના બીજને ઠીક કરો

રેન્ડમ મોડ્યુલના ફંક્શન સીડ() ને મનસ્વી પૂર્ણાંક આપીને, રેન્ડમ નંબર સીડને નિશ્ચિત કરી શકાય છે અને રેન્ડમ નંબર જનરેટરને પ્રારંભ કરી શકાય છે.

સમાન બીજ સાથે પ્રારંભ કર્યા પછી, તત્વો હંમેશા એ જ રીતે પસંદ કરવામાં આવે છે.

random.seed(0)
print(random.choice(l))
# 3

random.seed(0)
print(random.choice(l))
# 3