ਪਾਈਥਨ ਵਿੱਚ ਇੱਕ ਸੂਚੀ ਨੂੰ ਚੜ੍ਹਦੇ ਜਾਂ ਘਟਦੇ ਕ੍ਰਮ ਵਿੱਚ ਕ੍ਰਮਬੱਧ ਕਰਨ ਦੇ ਦੋ ਤਰੀਕੇ ਹਨ।
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() 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]
ਤਾਰਾਂ ਅਤੇ ਟੂਪਲਾਂ ਨੂੰ ਕਿਵੇਂ ਕ੍ਰਮਬੱਧ ਕਰਨਾ ਹੈ
ਕਿਉਂਕਿ ਸਤਰ ਅਤੇ ਟੂਪਲ ਅਟੱਲ ਹਨ, ਅਸਲ ਵਸਤੂ ਨੂੰ ਮੁੜ ਲਿਖਣ ਲਈ ਕੋਈ ਵੀ sort() ਵਿਧੀ ਉਪਲਬਧ ਨਹੀਂ ਹੈ।
ਦੂਜੇ ਪਾਸੇ, sorted() ਫੰਕਸ਼ਨ ਦਾ ਆਰਗੂਮੈਂਟ, ਜੋ ਇੱਕ ਨਵੀਂ ਆਬਜੈਕਟ ਦੇ ਰੂਪ ਵਿੱਚ ਇੱਕ ਲੜੀਬੱਧ ਸੂਚੀ ਤਿਆਰ ਕਰਦਾ ਹੈ, ਇੱਕ ਸਟ੍ਰਿੰਗ ਜਾਂ ਟੂਪਲ ਦੇ ਨਾਲ-ਨਾਲ ਇੱਕ ਸੂਚੀ ਵੀ ਹੋ ਸਕਦਾ ਹੈ। ਹਾਲਾਂਕਿ, ਕਿਉਂਕਿ sorted() ਇੱਕ ਸੂਚੀ ਵਾਪਸ ਕਰਦਾ ਹੈ, ਇਸ ਨੂੰ ਇੱਕ ਸਤਰ ਜਾਂ tuple ਵਿੱਚ ਤਬਦੀਲ ਕਰਨ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ।
ਤਾਰਾਂ ਨੂੰ ਛਾਂਟਣਾ
ਜਦੋਂ ਇੱਕ ਸਤਰ ਨੂੰ 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() ਫੰਕਸ਼ਨ ਦੇ ਆਰਗੂਮੈਂਟ ਦੇ ਰੂਪ ਵਿੱਚ ਇੱਕ 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 ਵਿੱਚ ਬਦਲਣ ਲਈ, 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)