Python සම්මත පුස්තකාලයේ අහඹු මොඩියුලයේ ඇති ශ්‍රිත තේරීම(), නියැදිය(), සහ තේරීම්() ලැයිස්තුවක්, tuple, string හෝ වෙනත් අනුක්‍රමික වස්තුවකින් (සසම්භාවී නියැදීම) මූලද්රව්ය අහඹු ලෙස තෝරා ගැනීමට සහ ලබා ගැනීමට භාවිතා කළ හැක.
තේරීම() තනි මූලද්රව්යයක් ලබා ගනී, නියැදිය() සහ තේරීම්() බහු මූලද්රව්ය ලැයිස්තුවක් ලබා ගනී. නියැදිය () යනු අනුපිටපත් නොමැතිව ප්‍රතිසාධනය කළ නොහැකි නිස්සාරණයකි, තේරීම්() යනු අනුපිටපත් සමඟ ප්‍රතිසාධනය කළ හැකි නිස්සාරණයයි.
පහත තොරතුරු මෙහි දක්වා ඇත.
- අහඹු ලෙස එක් මූලද්රව්යයක් තෝරන්න.:
random.choice() - අහඹු ලෙස බහු මූලද්රව්ය තෝරන්න (අනුපිටපත් නැත):
random.sample() - අහඹු ලෙස බහු මූලද්රව්ය තෝරන්න (අනුපිටපත් සහිත):
random.choices() - අහඹු අංක බීජය සවි කරන්න
අහඹු ලෙස එක් මූලද්රව්යයක් තෝරන්න.:random.choice()
සසම්භාවී මොඩියුලයේ ශ්‍රිතය තෝරන්න() සමඟින්, ලැයිස්තුවෙන් අහඹු ලෙස එක් මූලද්රව්යයක් තෝරාගෙන නැවත ලබාගත හැක.
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()
අහඹු මොඩියුලයේ ශ්‍රිත නියැදිය() සමඟින්, ඔබට ලැයිස්තුවකින් අහඹු ලෙස බහු මූලද්රව්ය ලබා ගත හැක. මූලද්‍රව්‍යවල අනුපිටපතක් නොමැත (ප්‍රතිසාධනය කළ නොහැකි නිස්සාරණය).
පළමු තර්කය ලැයිස්තුවක් වන අතර, දෙවන තර්කය නැවත ලබා ගත යුතු මූලද්රව්ය සංඛ්යාව වේ. ලැයිස්තුව ආපසු ලබා දී ඇත.
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']
ඔබට tuple හෝ string වෙත ආපසු යාමට අවශ්‍ය නම්, tuple(),join() භාවිතා කරන්න.
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]
ඔබට අනුපිටපත් අගයන් වළක්වා ගැනීමට අවශ්‍ය නම්, ඔබට එය කට්ටලයක් (සැකසුම් වර්ගය) බවට පරිවර්තනය කිරීමට set() භාවිතා කර අනන්‍ය මූලද්රව්ය පමණක් උකහා ගත හැක, ඉන්පසු නියැදිය() භාවිතා කරන්න.
print(set(l_dup))
# {0, 1, 2, 3}
print(random.sample(set(l_dup), 3))
# [1, 3, 2]
අහඹු ලෙස බහු මූලද්රව්ය තෝරන්න (අනුපිටපත් සහිත):random.choices()
සසම්භාවී මොඩියුලයේ ශ්‍රිත තේරීම්() මඟින් ඔබට ලැයිස්තුවකින් අහඹු ලෙස බහුවිධ මූලද්රව්ය ලබා ගැනීමට ඉඩ සලසයි, සහ නියැදි() මෙන් නොව, අනුපිටපත් මූලද්රව්ය තෝරා ගැනීමට එය ඉඩ දෙයි.
තේරීම්() යනු පයිතන් 3.6 හි එකතු කරන ලද ශ්‍රිතයකි. එය පෙර අනුවාද වල නොමැත.
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]
එක් එක් මූලද්රව්ය තෝරා ගන්නා බර (සම්භාවිතාව) සඳහන් කිරීමට තර්ක බර භාවිතා කළ හැකි අතර, ලැයිස්තුවේ ඇති මූලද්‍රව්‍යවල වර්ගය int හෝ float විය හැක.
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 සමුච්චිත බරක් ලෙස ද දැක්විය හැක. පහත නියැදි කේතයේ cum_weights ඉහත පළමු බරට සමාන වේ.
print(random.choices(l, k=3, cum_weights=[1, 2, 3, 13, 14]))
# [3, 2, 3]
විස්තාරක බර සහ cum_weights දෙකෙහිම පෙරනිමිය කිසිවක් නොවේ, එයින් අදහස් වන්නේ එක් එක් මූලද්රව්ය එකම සම්භාවිතාවකින් තෝරාගෙන ඇති බවයි.
තර්ක බර හෝ cum_weights වල දිග (මූලද්රව්ය ගණන) මුල් ලැයිස්තුවට වඩා වෙනස් නම්, දෝෂයක් ඇතිවේ.
# print(random.choices(l, k=3, weights=[1, 1, 1, 10, 1, 1, 1]))
# ValueError: The number of weights does not match the population_
බර සහ cum_weights එකවර සඳහන් කිරීම ද දෝෂයකි.
# 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
