మీరు పైథాన్‌లో జాబితా (శ్రేణి) యొక్క మూలకాలను షఫుల్ చేయాలనుకుంటే (యాదృచ్ఛికంగా క్రమబద్ధీకరించాలి), ప్రామాణిక లైబ్రరీ యొక్క యాదృచ్ఛిక మాడ్యూల్‌ని ఉపయోగించండి.
రెండు విధులు ఉన్నాయి: షఫుల్(), ఇది అసలైన జాబితాను యాదృచ్ఛికంగా క్రమబద్ధీకరిస్తుంది మరియు కొత్త యాదృచ్ఛికంగా క్రమబద్ధీకరించబడిన జాబితాను అందించే నమూనా(). నమూనా() స్ట్రింగ్స్ మరియు టుపుల్స్ కోసం ఉపయోగించవచ్చు.
- అసలు జాబితాను షఫుల్ చేయండి:
random.shuffle() - కొత్త, షఫుల్ చేసిన జాబితాను రూపొందించండి.:
random.sample() - స్ట్రింగ్స్ మరియు టుపుల్స్ షఫుల్ చేయండి
- యాదృచ్ఛిక సంఖ్య విత్తనాన్ని పరిష్కరించండి
మీరు యాదృచ్ఛికంగా కాకుండా ఆరోహణ లేదా అవరోహణ క్రమంలో లేదా రివర్స్ ఆర్డర్‌లో క్రమబద్ధీకరించాలనుకుంటే, క్రింది కథనాన్ని చూడండి.
- సంబంధిత కథనాలు:పైథాన్‌లో జాబితాను క్రమబద్ధీకరించడం: క్రమబద్ధీకరించబడిన మరియు క్రమబద్ధీకరించబడిన మధ్య వ్యత్యాసం
అసలు జాబితాను షఫుల్ చేయండి:random.shuffle()
యాదృచ్ఛిక మాడ్యూల్‌లోని ఫంక్షన్ షఫుల్() అసలు జాబితాను యాదృచ్ఛికంగా క్రమబద్ధీకరించగలదు.
import random
l = list(range(5))
print(l)
# [0, 1, 2, 3, 4]
random.shuffle(l)
print(l)
# [1, 0, 4, 3, 2]
కొత్త, షఫుల్ చేసిన జాబితాను రూపొందించండి.:random.sample()
యాదృచ్ఛిక మాడ్యూల్‌లోని ఫంక్షన్ నమూనా() అసలు జాబితాను మార్చకుండా, యాదృచ్ఛికంగా క్రమబద్ధీకరించబడిన కొత్త జాబితాను సృష్టించడానికి ఉపయోగించబడుతుంది.
నమూనా() అనేది జాబితా నుండి ఒక మూలకాన్ని యాదృచ్ఛికంగా ఎంచుకుని, తిరిగి పొందే ఫంక్షన్. మొదటి వాదన ఒక జాబితా, మరియు రెండవ ఆర్గ్యుమెంట్ తిరిగి పొందవలసిన మూలకాల సంఖ్య. వివరాల కోసం క్రింది కథనాన్ని చూడండి.
- సంబంధిత కథనాలు:పైథాన్‌లోని జాబితా నుండి యాదృచ్ఛికంగా ఎలిమెంట్‌లను ఎంచుకోండి:
choice(),sample(),choices()
నమూనా() ద్వారా ఎంచుకోవలసిన మూలకాల సంఖ్య జాబితాలోని మొత్తం మూలకాల సంఖ్య అయితే, మేము యాదృచ్ఛికంగా క్రమబద్ధీకరించబడిన అన్ని మూలకాలతో కొత్త జాబితాను పొందుతాము. జాబితాలోని మొత్తం మూలకాల సంఖ్య len() ద్వారా పొందబడుతుంది.
అసలు వస్తువు మార్చబడదు.
l = list(range(5))
print(l)
# [0, 1, 2, 3, 4]
lr = random.sample(l, len(l))
print(lr)
# [0, 3, 1, 4, 2]
print(l)
# [0, 1, 2, 3, 4]
స్ట్రింగ్స్ మరియు టుపుల్స్ షఫుల్ చేయండి
స్ట్రింగ్స్ మరియు టుపుల్స్ మారకుండా ఉంటాయి, కాబట్టి మీరు అసలైన వస్తువును మార్చడానికి random.shuffle()ని ఉపయోగిస్తే, మీరు ఈ క్రింది దోషాన్ని పొందుతారు.TypeError
s = 'abcde'
# random.shuffle(s)
# TypeError: 'str' object does not support item assignment
t = tuple(range(5))
print(t)
# (0, 1, 2, 3, 4)
# random.shuffle(t)
# TypeError: 'tuple' object does not support item assignment
మీరు స్ట్రింగ్ లేదా టుపుల్‌ని షఫుల్ చేయాలనుకుంటే, కొత్త వస్తువును సృష్టించే random.sample()ని ఉపయోగించండి.
స్ట్రింగ్ లేదా టుపుల్ ఆర్గ్యుమెంట్‌గా పేర్కొనబడినప్పటికీ, random.sample() జాబితాను అందిస్తుంది, కాబట్టి దానిని స్ట్రింగ్ లేదా టుపుల్‌కి తిరిగి ప్రాసెస్ చేయడం అవసరం.
స్ట్రింగ్ విషయంలో, ఇది ఒక్కొక్కటిగా అక్షరాల జాబితాగా ఉంటుంది. వాటిని మళ్లీ ఒకే స్ట్రింగ్‌లో కలపడానికి, join() పద్ధతిని ఉపయోగించండి.
sr = ''.join(random.sample(s, len(s)))
print(sr)
# bedca
Tuples కోసం, tuple()ని ఉపయోగించండి, ఇది జాబితా నుండి tupleని సృష్టిస్తుంది.
tr = tuple(random.sample(t, len(l)))
print(tr)
# (0, 1, 2, 4, 3)
యాదృచ్ఛిక సంఖ్య విత్తనాన్ని పరిష్కరించండి
యాదృచ్ఛిక మాడ్యూల్ యొక్క ఫంక్షన్ సీడ్()కి ఏకపక్ష పూర్ణాంకం ఇవ్వడం ద్వారా, యాదృచ్ఛిక సంఖ్య విత్తనాన్ని స్థిరపరచవచ్చు మరియు యాదృచ్ఛిక సంఖ్య జనరేటర్‌ను ప్రారంభించవచ్చు.
అదే విత్తనంతో ప్రారంభించిన తర్వాత, ఇది ఎల్లప్పుడూ అదే విధంగా క్రమాన్ని మార్చబడుతుంది.
l = list(range(5))
random.seed(0)
random.shuffle(l)
print(l)
# [2, 1, 0, 4, 3]
l = list(range(5))
random.seed(0)
random.shuffle(l)
print(l)
# [2, 1, 0, 4, 3]
