పైథాన్‌లో జాబితాను ఆరోహణ లేదా అవరోహణ క్రమంలో క్రమబద్ధీకరించడానికి రెండు మార్గాలు ఉన్నాయి.
sort()sorted()
మీరు స్ట్రింగ్ లేదా టుపుల్‌ను క్రమబద్ధీకరించాలనుకుంటే, క్రమబద్ధీకరించబడిన()ని ఉపయోగించండి.
కింది సమాచారం ఇక్కడ అందించబడింది.
- అసలైన జాబితాను క్రమబద్ధీకరించే రకం జాబితా పద్ధతి
sort() - కొత్త క్రమబద్ధీకరించబడిన జాబితాను రూపొందించండి, అంతర్నిర్మిత ఫంక్షన్: .
sorted() - తీగలను మరియు టుపుల్‌లను ఎలా క్రమబద్ధీకరించాలి
అసలైన జాబితాను క్రమబద్ధీకరించడం, రకం జాబితా యొక్క పద్ధతి: sort()
sort() అనేది జాబితా రకం పద్ధతి.
అసలు జాబితానే తిరిగి వ్రాయబడే విధ్వంసక ప్రక్రియ.
org_list = [3, 1, 4, 5, 2]
org_list.sort()
print(org_list)
# [1, 2, 3, 4, 5]
క్రమబద్ధీకరించు() ఏదీ కాదు అని తిరిగి ఇస్తుంది.
print(org_list.sort())
# None
డిఫాల్ట్ ఆరోహణ క్రమం. మీరు అవరోహణ క్రమంలో క్రమబద్ధీకరించాలనుకుంటే, ఆర్గ్యుమెంట్ రివర్స్‌కి సెట్ చేయండి.
org_list.sort(reverse=True)
print(org_list)
# [5, 4, 3, 2, 1]
కొత్త క్రమబద్ధీకరించబడిన జాబితాను రూపొందించండి, అంతర్నిర్మిత ఫంక్షన్: క్రమబద్ధీకరించబడింది()
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]
తీగలను మరియు టుపుల్‌లను ఎలా క్రమబద్ధీకరించాలి
తీగలు మరియు టుపుల్స్ మారనివి కాబట్టి, అసలు వస్తువును తిరిగి వ్రాయడానికి ఏ విధమైన () పద్ధతి అందుబాటులో లేదు.
మరోవైపు, క్రమబద్ధీకరించబడిన () ఫంక్షన్ యొక్క ఆర్గ్యుమెంట్, క్రమబద్ధీకరించబడిన జాబితాను కొత్త వస్తువుగా ఉత్పత్తి చేస్తుంది, ఇది స్ట్రింగ్ లేదా టుపుల్ అలాగే జాబితా కావచ్చు. అయినప్పటికీ, క్రమబద్ధీకరించబడిన() జాబితాను అందిస్తుంది కాబట్టి, దానిని స్ట్రింగ్ లేదా టుపుల్‌గా మార్చాలి.
తీగలను క్రమబద్ధీకరించడం
క్రమబద్ధీకరించబడిన() ఫంక్షన్ యొక్క ఆర్గ్యుమెంట్‌గా స్ట్రింగ్ పేర్కొనబడినప్పుడు, క్రమబద్ధీకరించబడిన స్ట్రింగ్‌లోని ప్రతి అక్షరం మూలకం వలె నిల్వ చేయబడిన జాబితా అందించబడుతుంది.
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
అక్షరం యొక్క యూనికోడ్ కోడ్ పాయింట్ (క్యారెక్టర్ కోడ్) ద్వారా స్ట్రింగ్ పరిమాణం నిర్ణయించబడుతుంది.
టూపుల్స్ సార్టింగ్
టుపుల్స్ స్ట్రింగ్స్ లాగానే ఉంటాయి; క్రమబద్ధీకరించబడిన() ఫంక్షన్ యొక్క ఆర్గ్యుమెంట్‌గా tupleని పేర్కొనడం మూలకాల యొక్క క్రమబద్ధీకరించబడిన జాబితాను అందిస్తుంది.
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)
