જો તમે Python અને n=1 માં સૌથી મોટી અથવા સૌથી નાની કિંમતમાંથી ક્રમમાં યાદી (એરે) ના n તત્વો મેળવવા માંગતા હો, તો તમે નીચેના બિલ્ટ-ઇન ફંક્શનનો ઉપયોગ કરી શકો છો.
max()min()
જો n>1 હોય, તો સૂચિને સૉર્ટ કરવાની અથવા પ્રમાણભૂત લાઇબ્રેરીના heapq મોડ્યુલનો ઉપયોગ કરવાની બે રીત છે.
- મહત્તમ અને લઘુત્તમ મૂલ્યો મેળવો:
max(),min() - મહત્તમ અને ન્યૂનતમ મૂલ્યના ક્રમમાં n તત્વો મેળવો:સૉર્ટ કરો
- મહત્તમ અને ન્યૂનતમ મૂલ્યના ક્રમમાં n તત્વો મેળવો:
heapqમોડ્યુલ
જો પુનઃપ્રાપ્ત કરવાના ઘટકોની સંખ્યા મોટી હોય, તો તેને પ્રથમ સોર્ટેડ() અથવા સોર્ટ() નો ઉપયોગ કરીને સૉર્ટ કરવું વધુ કાર્યક્ષમ છે, અને જો સંખ્યા નાની હોય, તો heapq મોડ્યુલના nargest() અને nsmallest() વધુ કાર્યક્ષમ છે.
મહત્તમ અને લઘુત્તમ મૂલ્યોના અનુક્રમણિકાઓ મેળવવા માટે, મહત્તમ(), મિનિટ() અને અનુક્રમણિકા() નો ઉપયોગ કરો.
મહત્તમ અને લઘુત્તમ મૂલ્યો મેળવો:max(),min()
સૂચિના મહત્તમ અને લઘુત્તમ ઘટકો મેળવવા માટે, બિલ્ટ-ઇન ફંક્શન્સ max() અને min() નો ઉપયોગ કરો.
l = [3, 6, 7, -1, 23, -10, 18]
print(max(l))
# 23
print(min(l))
# -10
મહત્તમ અને ન્યૂનતમ મૂલ્યના ક્રમમાં n તત્વો મેળવો: સૉર્ટ કરો
જો તમે સૂચિના n તત્વોને સૌથી મોટા અથવા નાના મૂલ્યમાંથી ક્રમમાં મેળવવા માંગતા હો, તો પ્રથમ પદ્ધતિ એ સૂચિને સૉર્ટ (સૉર્ટ) કરવાની છે.
સૂચિને સૉર્ટ કરવા માટે, બિલ્ટ-ઇન ફંક્શન sorted() અથવા સૂચિની sort() પદ્ધતિનો ઉપયોગ કરો. 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]
જો તમને મૂળ સૂચિનો ક્રમ બદલવામાં કોઈ વાંધો નથી, તો તમે sort() પદ્ધતિનો ઉપયોગ કરી શકો છો.
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]
જેમ મેં શરૂઆતમાં લખ્યું હતું તેમ, જો પુનઃપ્રાપ્ત કરવાના ઘટકોની સંખ્યા મોટી હોય, તો તેને પ્રથમ sorted() અથવા sort(), અને જો સંખ્યા નાની હોય, nargest() અને nsmallest() હોય તો તે વધુ કાર્યક્ષમ છે. heapq મોડ્યુલ વધુ કાર્યક્ષમ છે.
