Python හි ලැයිස්තුවක් ආරෝහණ හෝ අවරෝහණ අනුපිළිවෙලින් වර්ග කිරීමට ක්‍රම දෙකක් තිබේ.
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() Return කරන්නේ None බව සලකන්න.
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]
නූල් සහ ටියුපල් වර්ග කරන්නේ කෙසේද
නූල් සහ ටියුපල් වෙනස් කළ නොහැකි බැවින්, මුල් වස්තුව නැවත ලිවීමට වර්ග() ක්‍රමයක් නොමැත.
අනෙක් අතට, නව වස්තුවක් ලෙස වර්ග කළ ලැයිස්තුවක් උත්පාදනය කරන sorted() ශ්‍රිතයේ තර්කය, string හෝ tuple මෙන්ම ලැයිස්තුවක් විය හැක. කෙසේ වෙතත්, sorted() ලැයිස්තුවක් ලබා දෙන බැවින්, එය තන්තුවක් හෝ tuple එකක් බවට පරිවර්තනය කිරීම අවශ්‍ය වේ.
නූල් වර්ග කිරීම
අනුපිළිවෙල () ශ්‍රිතයේ තර්කය ලෙස තන්තුවක් සඳහන් කළ විට, අනුපිළිවෙළට සකසන ලද තන්තුවේ සෑම අක්ෂරයක්ම මූලද්‍රව්‍යයක් ලෙස ගබඩා කර ඇති ලැයිස්තුවක් ආපසු එවනු ලැබේ.
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
තන්තුවක ප්‍රමාණය තීරණය වන්නේ අක්ෂරයේ යුනිකෝඩ් කේත ලක්ෂ්‍යය (අක්ෂර කේතය) මගිනි.
ටියුපල් වර්ග කිරීම
Tuples නූල් හා සමාන වේ; අනුපිළිවෙලට () ශ්‍රිතයේ තර්කය ලෙස ටුපල් එකක් සඳහන් කිරීමෙන් අනුපිළිවෙළට සැකසූ මූලද්‍රව්‍ය ලැයිස්තුවක් ලබා දේ.
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]
ලැයිස්තුවක් ටුපල් එකක් බවට පරිවර්තනය කිරීමට, tuple() භාවිතා කරන්න.
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)
