ਜੇਕਰ ਤੁਸੀਂ ਪਾਈਥਨ ਵਿੱਚ ਸਭ ਤੋਂ ਵੱਡੇ ਜਾਂ ਸਭ ਤੋਂ ਛੋਟੇ ਮੁੱਲ ਤੋਂ ਕ੍ਰਮ ਵਿੱਚ ਸੂਚੀ (ਐਰੇ) ਦੇ n ਤੱਤ ਪ੍ਰਾਪਤ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਅਤੇ n=1, ਤੁਸੀਂ ਹੇਠਾਂ ਦਿੱਤੇ ਬਿਲਟ-ਇਨ ਫੰਕਸ਼ਨ ਦੀ ਵਰਤੋਂ ਕਰ ਸਕਦੇ ਹੋ।
max()min()
ਜੇਕਰ n>1, ਸੂਚੀ ਨੂੰ ਕ੍ਰਮਬੱਧ ਕਰਨ ਜਾਂ ਸਟੈਂਡਰਡ ਲਾਇਬ੍ਰੇਰੀ ਦੇ heapq ਮੋਡੀਊਲ ਦੀ ਵਰਤੋਂ ਕਰਨ ਦੇ ਦੋ ਤਰੀਕੇ ਹਨ।
- ਵੱਧ ਤੋਂ ਵੱਧ ਅਤੇ ਘੱਟੋ-ਘੱਟ ਮੁੱਲ ਪ੍ਰਾਪਤ ਕਰੋ:
max(),min() - ਵੱਧ ਤੋਂ ਵੱਧ ਅਤੇ ਨਿਊਨਤਮ ਮੁੱਲ ਦੇ ਕ੍ਰਮ ਵਿੱਚ n ਤੱਤ ਪ੍ਰਾਪਤ ਕਰੋ:ਲੜੀਬੱਧ
- ਵੱਧ ਤੋਂ ਵੱਧ ਅਤੇ ਨਿਊਨਤਮ ਮੁੱਲ ਦੇ ਕ੍ਰਮ ਵਿੱਚ n ਤੱਤ ਪ੍ਰਾਪਤ ਕਰੋ:
heapqਮੋਡੀਊਲ
ਜੇਕਰ ਮੁੜ ਪ੍ਰਾਪਤ ਕੀਤੇ ਜਾਣ ਵਾਲੇ ਤੱਤਾਂ ਦੀ ਸੰਖਿਆ ਵੱਡੀ ਹੈ, ਤਾਂ ਉਹਨਾਂ ਨੂੰ ਪਹਿਲਾਂ sorted() ਜਾਂ sort() ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਛਾਂਟਣਾ ਵਧੇਰੇ ਕੁਸ਼ਲ ਹੈ, ਅਤੇ ਜੇਕਰ ਸੰਖਿਆ ਛੋਟੀ ਹੈ, heapq ਮੋਡੀਊਲ ਦੇ nargest() ਅਤੇ nsmallest() ਵਧੇਰੇ ਕੁਸ਼ਲ ਹਨ।
ਅਧਿਕਤਮ ਅਤੇ ਨਿਊਨਤਮ ਮੁੱਲਾਂ ਦੇ ਸੂਚਕਾਂਕ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ, max(), min() ਅਤੇ index() ਦੀ ਵਰਤੋਂ ਕਰੋ।
ਵੱਧ ਤੋਂ ਵੱਧ ਅਤੇ ਘੱਟੋ-ਘੱਟ ਮੁੱਲ ਪ੍ਰਾਪਤ ਕਰੋ: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 ਮੋਡੀਊਲ ਵਧੇਰੇ ਕੁਸ਼ਲ ਹਨ।
