પાયથોનમાં યાદીને ચડતા અથવા ઉતરતા ક્રમમાં સૉર્ટ કરવાની બે રીતો છે.
sort()sorted()
જો તમે સ્ટ્રિંગ અથવા ટપલને સૉર્ટ કરવા માંગતા હો, તો sorted() નો ઉપયોગ કરો.
નીચેની માહિતી અહીં આપવામાં આવી છે.
- પ્રકાર સૂચિની એક પદ્ધતિ જે મૂળ સૂચિને સૉર્ટ કરે છે
sort() - નવી સૉર્ટ કરેલી સૂચિ બનાવો, બિલ્ટ-ઇન ફંક્શન: .
sorted() - શબ્દમાળાઓ અને ટ્યુપલ્સને કેવી રીતે સૉર્ટ કરવા
મૂળ સૂચિને સૉર્ટ કરવી, પ્રકાર સૂચિની પદ્ધતિ: sort()
sort() એ સૂચિ પ્રકારની પદ્ધતિ છે.
એક વિનાશક પ્રક્રિયા જેમાં મૂળ સૂચિ પોતે ફરીથી લખવામાં આવે છે.
org_list = [3, 1, 4, 5, 2]
org_list.sort()
print(org_list)
# [1, 2, 3, 4, 5]
નોંધ કરો કે sort() કંઈ નહીં આપે.
print(org_list.sort())
# None
ડિફોલ્ટ ચડતો ક્રમ છે. જો તમે ઉતરતા ક્રમમાં સૉર્ટ કરવા માંગતા હો, તો દલીલને વિપરીત સાચા પર સેટ કરો.
org_list.sort(reverse=True)
print(org_list)
# [5, 4, 3, 2, 1]
નવી સૉર્ટ કરેલી સૂચિ બનાવો, બિલ્ટ-ઇન ફંક્શન: sorted()
sorted() એ બિલ્ટ-ઇન ફંક્શન છે.
જ્યારે સૉર્ટ કરવાની સૂચિ દલીલ તરીકે ઉલ્લેખિત હોય ત્યારે સૉર્ટ કરેલી સૂચિ પરત કરે છે. આ એક બિન-વિનાશક પ્રક્રિયા છે જે મૂળ સૂચિને બદલતી નથી.
org_list = [3, 1, 4, 5, 2]
new_list = sorted(org_list)
print(org_list)
print(new_list)
# [3, 1, 4, 5, 2]
# [1, 2, 3, 4, 5]
sort() ની જેમ, ડિફોલ્ટ ચડતો ક્રમ છે. જો તમે ઉતરતા ક્રમમાં સૉર્ટ કરવા માંગતા હો, તો દલીલને વિપરીત સાચા પર સેટ કરો.
new_list_reverse = sorted(org_list, reverse=True)
print(org_list)
print(new_list_reverse)
# [3, 1, 4, 5, 2]
# [5, 4, 3, 2, 1]
શબ્દમાળાઓ અને ટ્યુપલ્સને કેવી રીતે સૉર્ટ કરવા
શબ્દમાળાઓ અને ટ્યુપલ્સ અપરિવર્તનશીલ હોવાથી, મૂળ ઑબ્જેક્ટને ફરીથી લખવા માટે કોઈ sort() પદ્ધતિ ઉપલબ્ધ નથી.
બીજી બાજુ, sorted() ફંક્શનની દલીલ, જે નવા ઓબ્જેક્ટ તરીકે સોર્ટ કરેલ યાદી જનરેટ કરે છે, તે સ્ટ્રીંગ અથવા ટપલ તેમજ યાદી હોઈ શકે છે. જો કે, sorted() યાદી પરત કરે છે, તેથી તેને સ્ટ્રીંગ અથવા ટપલમાં રૂપાંતરિત કરવાની જરૂર છે.
સૉર્ટિંગ શબ્દમાળાઓ
જ્યારે સ્ટ્રિંગને sorted() ફંક્શનની દલીલ તરીકે નિર્દિષ્ટ કરવામાં આવે છે, ત્યારે એક સૂચિ પરત કરવામાં આવે છે જેમાં સૉર્ટ કરેલ સ્ટ્રિંગના દરેક પાત્રને એક ઘટક તરીકે સંગ્રહિત કરવામાં આવે છે.
org_str = 'cebad'
new_str_list = sorted(org_str)
print(org_str)
print(new_str_list)
# cebad
# ['a', 'b', 'c', 'd', 'e']
શબ્દમાળાઓની સૂચિને એક સ્ટ્રિંગમાં જોડવા માટે, join() પદ્ધતિનો ઉપયોગ કરો.
new_str = ''.join(new_str_list)
print(new_str)
# abcde
જો તમે ઉતરતા ક્રમમાં સૉર્ટ કરવા માંગતા હો, તો દલીલને વિપરીત સાચા પર સેટ કરો.
new_str = ''.join(sorted(org_str))
print(new_str)
# abcde
new_str_reverse = ''.join(sorted(org_str, reverse=True))
print(new_str_reverse)
# edcba
સ્ટ્રિંગનું કદ અક્ષરના યુનિકોડ કોડ પોઇન્ટ (કેરેક્ટર કોડ) દ્વારા નક્કી કરવામાં આવે છે.
સૉર્ટિંગ ટ્યુપલ્સ
ટ્યુપલ્સ શબ્દમાળાઓ સમાન છે; sorted() ફંક્શનની દલીલ તરીકે ટ્યુપલનો ઉલ્લેખ કરવાથી તત્વોની સૉર્ટ કરેલી યાદી મળે છે.
org_tuple = (3, 1, 4, 5, 2)
new_tuple_list = sorted(org_tuple)
print(org_tuple)
print(new_tuple_list)
# (3, 1, 4, 5, 2)
# [1, 2, 3, 4, 5]
સૂચિને ટ્યુપલમાં કન્વર્ટ કરવા માટે, ટ્યુપલ() નો ઉપયોગ કરો.
new_tuple = tuple(new_tuple_list)
print(new_tuple)
# (1, 2, 3, 4, 5)
જો તમે ઉતરતા ક્રમમાં સૉર્ટ કરવા માંગતા હો, તો દલીલને વિપરીત સાચા પર સેટ કરો.
new_tuple = tuple(sorted(new_tuple_list))
print(new_tuple)
# (1, 2, 3, 4, 5)
new_tuple_reverse = tuple(sorted(new_tuple_list, reverse=True))
print(new_tuple_reverse)
# (5, 4, 3, 2, 1)
