పైథాన్ స్టాండర్డ్ లైబ్రరీ యొక్క యాదృచ్ఛిక మాడ్యూల్‌లోని ఫంక్షన్‌ల ఎంపిక(), నమూనా(), మరియు ఎంపికలు()ని యాదృచ్ఛికంగా జాబితా, టుపుల్, స్ట్రింగ్ లేదా ఇతర సీక్వెన్స్ ఆబ్జెక్ట్ (యాదృచ్ఛిక నమూనా) నుండి ఎలిమెంట్‌లను ఎంచుకోవడానికి మరియు తిరిగి పొందేందుకు ఉపయోగించవచ్చు.
ఎంపిక() ఒకే మూలకాన్ని పొందుతుంది, నమూనా() మరియు ఎంపికలు() బహుళ మూలకాల జాబితాను పొందుతాయి. నమూనా() అనేది డూప్లికేట్‌లు లేకుండా తిరిగి పొందలేని వెలికితీత, ఎంపికలు() అనేది డూప్లికేట్‌లతో తిరిగి పొందగలిగే వెలికితీత.
కింది సమాచారం ఇక్కడ అందించబడింది.
- యాదృచ్ఛికంగా ఒక మూలకాన్ని ఎంచుకోండి.:
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']
మీరు టుపుల్ లేదా స్ట్రింగ్‌కి తిరిగి వెళ్లాలనుకుంటే, టుపుల్(),జాయిన్()ని ఉపయోగించండి.
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()
యాదృచ్ఛిక మాడ్యూల్ యొక్క ఫంక్షన్ ఎంపికలు() జాబితా నుండి యాదృచ్ఛికంగా బహుళ మూలకాలను తిరిగి పొందడానికి మిమ్మల్ని అనుమతిస్తుంది మరియు నమూనా() వలె కాకుండా, ఇది నకిలీ మూలకాలను ఎంచుకోవడానికి అనుమతిస్తుంది.
ఎంపికలు() అనేది పైథాన్ 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]
ప్రతి మూలకం ఎంపిక చేయబడే బరువు (సంభావ్యత)ని పేర్కొనడానికి ఆర్గ్యుమెంట్ బరువులు ఉపయోగించబడతాయి మరియు జాబితాలోని మూలకాల రకం పూర్ణాంకం లేదా ఫ్లోట్ కావచ్చు.
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]
ఆర్గ్యుమెంట్‌ల బరువులు మరియు కమ్_వెయిట్‌లు రెండింటికీ డిఫాల్ట్ ఏదీ కాదు, అంటే ప్రతి మూలకం ఒకే సంభావ్యతతో ఎంచుకోబడింది.
ఆర్గ్యుమెంట్ బరువులు లేదా 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_
బరువులు మరియు కమ్_వెయిట్‌లను ఒకే సమయంలో పేర్కొనడం కూడా లోపం.
# 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
