మీరు పైథాన్‌లోని అతిపెద్ద లేదా అతిచిన్న విలువ మరియు n=1 నుండి జాబితా (శ్రేణి) యొక్క n మూలకాలను పొందాలనుకుంటే, మీరు క్రింది అంతర్నిర్మిత ఫంక్షన్‌ని ఉపయోగించవచ్చు.
max()min()
n>1 అయితే, జాబితాను క్రమబద్ధీకరించడానికి లేదా ప్రామాణిక లైబ్రరీ యొక్క heapq మాడ్యూల్‌ని ఉపయోగించడానికి రెండు మార్గాలు ఉన్నాయి.
- గరిష్ట మరియు కనిష్ట విలువలను పొందండి:
max(),min() - గరిష్ట మరియు కనిష్ట విలువల క్రమంలో n మూలకాలను పొందండి:క్రమబద్ధీకరించు
- గరిష్ట మరియు కనిష్ట విలువల క్రమంలో n మూలకాలను పొందండి:
heapqమాడ్యూల్
తిరిగి పొందవలసిన మూలకాల సంఖ్య పెద్దగా ఉంటే, క్రమబద్ధీకరించబడిన() లేదా sort()ని ఉపయోగించి మొదట వాటిని క్రమబద్ధీకరించడం మరింత ప్రభావవంతంగా ఉంటుంది మరియు సంఖ్య తక్కువగా ఉంటే, heapq మాడ్యూల్ యొక్క nargest() మరియు nsmallest() మరింత సమర్థవంతంగా పనిచేస్తాయి.
గరిష్ట మరియు కనిష్ట విలువల సూచికలను పొందడానికి, max(), min() మరియు index() ఉపయోగించండి.
గరిష్ట మరియు కనిష్ట విలువలను పొందండి:max(),min()
జాబితా యొక్క గరిష్ట మరియు కనిష్ట అంశాలను పొందడానికి, అంతర్నిర్మిత విధులు max() మరియు min() ఉపయోగించండి.
l = [3, 6, 7, -1, 23, -10, 18]
print(max(l))
# 23
print(min(l))
# -10
గరిష్ట మరియు కనిష్ట విలువల క్రమంలో n మూలకాలను పొందండి: క్రమబద్ధీకరించండి
మీరు జాబితా యొక్క n మూలకాలను అతిపెద్ద లేదా అతి చిన్న విలువ నుండి క్రమంలో పొందాలనుకుంటే, జాబితాను క్రమబద్ధీకరించడం (క్రమబద్ధీకరించడం) మొదటి పద్ధతి.
జాబితాను క్రమబద్ధీకరించడానికి, అంతర్నిర్మిత ఫంక్షన్ క్రమబద్ధీకరించబడిన() లేదా జాబితా యొక్క క్రమబద్ధీకరణ() పద్ధతిని ఉపయోగించండి. sorted() ఒక కొత్త క్రమబద్ధీకరించబడిన జాబితాను అందిస్తుంది, అయితే sort() అసలు జాబితాను మళ్లీ ఆర్డర్ చేస్తుంది.
ఆర్గ్యుమెంట్ రివర్స్‌తో ఆరోహణ/అవరోహణ క్రమాన్ని మార్చడం ద్వారా మరియు ఎగువ నుండి ఎన్ని స్లైస్‌లను ఎంచుకోవడం ద్వారా, మీరు జాబితాలోని అతిపెద్ద/చిన్న విలువ నుండి క్రమంలో n మూలకాలను పొందవచ్చు.
- సంబంధిత కథనాలు:పైథాన్‌లో జాబితాను క్రమబద్ధీకరించడం: క్రమబద్ధీకరించబడిన మరియు క్రమబద్ధీకరించబడిన మధ్య వ్యత్యాసం
ld = sorted(l, reverse=True)
print(ld)
# [23, 18, 7, 6, 3, -1, -10]
print(ld[:3])
# [23, 18, 7]
la = sorted(l)
print(la)
# [-10, -1, 3, 6, 7, 18, 23]
print(la[:3])
# [-10, -1, 3]
మీరు వాటన్నింటినీ ఒకే వరుసలో వ్రాయవచ్చు.
print(sorted(l, reverse=True)[:3])
# [23, 18, 7]
print(sorted(l)[:3])
# [-10, -1, 3]
అసలు జాబితా క్రమాన్ని మార్చడం మీకు అభ్యంతరం లేకపోతే, మీరు క్రమబద్ధీకరణ() పద్ధతిని ఉపయోగించవచ్చు.
print(l)
# [3, 6, 7, -1, 23, -10, 18]
l.sort(reverse=True)
print(l[:3])
# [23, 18, 7]
print(l)
# [23, 18, 7, 6, 3, -1, -10]
l.sort()
print(l[:3])
# [-10, -1, 3]
print(l)
# [-10, -1, 3, 6, 7, 18, 23]
గరిష్ట మరియు కనిష్ట విలువల క్రమంలో n మూలకాలను పొందండి:heapqమాడ్యూల్
మీరు జాబితా యొక్క n మూలకాలను అతిపెద్ద లేదా అతి చిన్న విలువ నుండి క్రమంలో పొందాలనుకుంటే, మీరు heapq మాడ్యూల్‌ని ఉపయోగించవచ్చు.
heapq మాడ్యూల్‌లో కింది ఫంక్షన్‌ని ఉపయోగించండి. ఈ సందర్భంలో, అసలు జాబితా మార్చబడదు.
nlargest()nsmallest()
మొదటి ఆర్గ్యుమెంట్ తిరిగి పొందవలసిన మూలకాల సంఖ్య, మరియు రెండవ ఆర్గ్యుమెంట్ లక్ష్యం చేయదగినది (జాబితా మొదలైనవి).
import heapq
l = [3, 6, 7, -1, 23, -10, 18]
print(heapq.nlargest(3, l))
# [23, 18, 7]
print(heapq.nsmallest(3, l))
# [-10, -1, 3]
print(l)
# [3, 6, 7, -1, 23, -10, 18]
నేను ప్రారంభంలో వ్రాసినట్లుగా, తిరిగి పొందవలసిన మూలకాల సంఖ్య పెద్దగా ఉంటే, వాటిని ముందుగా క్రమబద్ధీకరించిన() లేదా క్రమబద్ధీకరణ()తో క్రమబద్ధీకరించడం మరింత ప్రభావవంతంగా ఉంటుంది మరియు సంఖ్య చిన్నది అయితే, అతి తక్కువ() మరియు nsmallest() heapq మాడ్యూల్ మరింత ప్రభావవంతంగా ఉంటుంది.
