ਪਾਈਥਨ ਵਿੱਚ ਕਿਸਮ ਸੂਚੀ ਦੀ ਇੱਕ ਸੂਚੀ (ਐਰੇ) ਵਿੱਚੋਂ ਇੱਕ ਤੱਤ ਨੂੰ ਹਟਾਉਣ ਲਈ, ਸੂਚੀ ਵਿਧੀਆਂ clear(), pop() ਅਤੇ remove() ਦੀ ਵਰਤੋਂ ਕਰੋ। ਤੁਸੀਂ ਸੂਚਕਾਂਕ ਜਾਂ ਟੁਕੜੇ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਸੂਚੀ ਦੀ ਸਥਿਤੀ ਅਤੇ ਰੇਂਜ ਵੀ ਨਿਰਧਾਰਤ ਕਰ ਸਕਦੇ ਹੋ ਅਤੇ ਫਿਰ ਡੇਲ ਸਟੇਟਮੈਂਟ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਇਸਨੂੰ ਮਿਟਾ ਸਕਦੇ ਹੋ।
ਹੇਠਾਂ ਦਿੱਤੀ ਜਾਣਕਾਰੀ ਇੱਥੇ ਦਿੱਤੀ ਗਈ ਹੈ।
- ਸਾਰੇ ਤੱਤ ਹਟਾਓ:
clear() - ਨਿਰਧਾਰਤ ਸਥਿਤੀ ‘ਤੇ ਇੱਕ ਤੱਤ ਨੂੰ ਮਿਟਾਓ ਅਤੇ ਇਸਦਾ ਮੁੱਲ ਪ੍ਰਾਪਤ ਕਰੋ।:
pop() - ਨਿਰਧਾਰਤ ਮੁੱਲ ਵਾਲੇ ਤੱਤਾਂ ਦੀ ਖੋਜ ਕਰਦਾ ਹੈ ਅਤੇ ਪਹਿਲੇ ਤੱਤ ਨੂੰ ਹਟਾ ਦਿੰਦਾ ਹੈ।:
remove() - ਸੂਚਕਾਂਕ ਦੇ ਟੁਕੜੇ ਵਿੱਚ ਸਥਿਤੀ ਅਤੇ ਰੇਂਜ ਨੂੰ ਨਿਸ਼ਚਿਤ ਕਰਕੇ ਮਿਟਾਇਆ ਜਾ ਰਿਹਾ ਹੈ:
del - ਬੈਚ ਕਈ ਤੱਤਾਂ ਨੂੰ ਮਿਟਾਓ ਜੋ ਮਾਪਦੰਡਾਂ ਨੂੰ ਪੂਰਾ ਕਰਦੇ ਹਨ।:ਸੂਚੀ ਸ਼ਾਮਲ ਕਰਨ ਦਾ ਸੰਕੇਤ
ਨੋਟ ਕਰੋ ਕਿ ਸੂਚੀਆਂ ਵੱਖ-ਵੱਖ ਕਿਸਮਾਂ ਦੇ ਡੇਟਾ ਨੂੰ ਸਟੋਰ ਕਰ ਸਕਦੀਆਂ ਹਨ, ਅਤੇ ਐਰੇ ਤੋਂ ਬਿਲਕੁਲ ਵੱਖਰੀਆਂ ਹਨ। ਐਰੇ (ਸਟੈਂਡਰਡ ਲਾਇਬ੍ਰੇਰੀ) ਜਾਂ NumPy ਦੀ ਵਰਤੋਂ ਕਰੋ ਜਦੋਂ ਤੁਸੀਂ ਉਹਨਾਂ ਪ੍ਰਕਿਰਿਆਵਾਂ ਲਈ ਐਰੇ ਨੂੰ ਸੰਭਾਲਣਾ ਚਾਹੁੰਦੇ ਹੋ ਜਿਹਨਾਂ ਲਈ ਮੈਮੋਰੀ ਆਕਾਰ ਜਾਂ ਮੈਮੋਰੀ ਐਡਰੈੱਸ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ, ਜਾਂ ਵੱਡੇ ਪੈਮਾਨੇ ਦੇ ਡੇਟਾ ਦੀ ਸੰਖਿਆਤਮਕ ਗਣਨਾ ਲਈ।
- ਸਾਰੇ ਤੱਤ ਹਟਾਓ:clear()
- ਨਿਰਧਾਰਤ ਸਥਿਤੀ ‘ਤੇ ਇੱਕ ਤੱਤ ਨੂੰ ਮਿਟਾਓ ਅਤੇ ਇਸਦਾ ਮੁੱਲ ਪ੍ਰਾਪਤ ਕਰੋ।:pop()
- ਨਿਰਧਾਰਤ ਮੁੱਲ ਵਾਲੇ ਤੱਤਾਂ ਦੀ ਖੋਜ ਕਰਦਾ ਹੈ ਅਤੇ ਪਹਿਲੇ ਤੱਤ ਨੂੰ ਹਟਾ ਦਿੰਦਾ ਹੈ।:remove()
- ਸੂਚਕਾਂਕ ਦੇ ਟੁਕੜੇ ਵਿੱਚ ਸਥਿਤੀ ਅਤੇ ਰੇਂਜ ਨੂੰ ਨਿਸ਼ਚਿਤ ਕਰਕੇ ਮਿਟਾਇਆ ਜਾ ਰਿਹਾ ਹੈ:del
- ਬੈਚ ਕਈ ਤੱਤਾਂ ਨੂੰ ਮਿਟਾਓ ਜੋ ਮਾਪਦੰਡਾਂ ਨੂੰ ਪੂਰਾ ਕਰਦੇ ਹਨ।:ਸੂਚੀ ਸ਼ਾਮਲ ਕਰਨ ਦਾ ਸੰਕੇਤ
ਸਾਰੇ ਤੱਤ ਹਟਾਓ:clear()
ਸੂਚੀ ਵਿਧੀ clear(), ਵਿੱਚ ਸਾਰੇ ਤੱਤ ਹਟਾ ਦਿੱਤੇ ਜਾਂਦੇ ਹਨ, ਨਤੀਜੇ ਵਜੋਂ ਇੱਕ ਖਾਲੀ ਸੂਚੀ ਹੁੰਦੀ ਹੈ।
l = list(range(10))
print(l)
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
l.clear()
print(l)
# []
ਨਿਰਧਾਰਤ ਸਥਿਤੀ ‘ਤੇ ਇੱਕ ਤੱਤ ਨੂੰ ਮਿਟਾਓ ਅਤੇ ਇਸਦਾ ਮੁੱਲ ਪ੍ਰਾਪਤ ਕਰੋ।:pop()
ਇੱਕ ਸੂਚੀ ਦੀ ਵਿਧੀ ਪੌਪ() ਨੂੰ ਇੱਕ ਵਿਸ਼ੇਸ਼ ਸਥਿਤੀ ‘ਤੇ ਇੱਕ ਤੱਤ ਨੂੰ ਮਿਟਾਉਣ ਅਤੇ ਉਸ ਤੱਤ ਦਾ ਮੁੱਲ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ।
ਪਹਿਲਾ (ਸ਼ੁਰੂਆਤੀ) ਨੰਬਰ 0 ਹੈ।
l = list(range(10))
print(l)
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print(l.pop(0))
# 0
print(l)
# [1, 2, 3, 4, 5, 6, 7, 8, 9]
print(l.pop(3))
# 4
print(l)
# [1, 2, 3, 5, 6, 7, 8, 9]
ਅੰਤ (ਆਖਰੀ) ਤੋਂ ਸਥਿਤੀ ਨੂੰ ਨਿਸ਼ਚਿਤ ਕਰਨ ਲਈ ਇੱਕ ਨਕਾਰਾਤਮਕ ਮੁੱਲ ਵੀ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ। ਅੰਤ (ਅੰਤ) -1 ਹੈ।
print(l.pop(-2))
# 8
print(l)
# [1, 2, 3, 5, 6, 7, 9]
ਜੇਕਰ ਆਰਗੂਮੈਂਟ ਨੂੰ ਛੱਡ ਦਿੱਤਾ ਗਿਆ ਹੈ ਅਤੇ ਕੋਈ ਸਥਿਤੀ ਨਿਰਧਾਰਤ ਨਹੀਂ ਕੀਤੀ ਗਈ ਹੈ, ਤਾਂ ਅੰਤ (ਆਖਰੀ) ‘ਤੇ ਤੱਤ ਮਿਟਾ ਦਿੱਤਾ ਜਾਵੇਗਾ।
print(l.pop())
# 9
print(l)
# [1, 2, 3, 5, 6, 7]
ਇੱਕ ਗੈਰ-ਮੌਜੂਦ ਸਥਿਤੀ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰਨ ਦੇ ਨਤੀਜੇ ਵਜੋਂ ਇੱਕ ਗਲਤੀ ਹੋਵੇਗੀ।
# print(l.pop(100))
# IndexError: pop index out of range
ਨੋਟ ਕਰੋ ਕਿ ਪੌਪ(0), ਜੋ ਪਹਿਲੇ ਤੱਤ ਨੂੰ ਹਟਾਉਂਦਾ ਹੈ, ਲਈ ਹੇਠਾਂ ਦਿੱਤੀ ਲਾਗਤ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ ਅਤੇ ਇਹ ਇੱਕ ਕੁਸ਼ਲ ਕਾਰਵਾਈ ਨਹੀਂ ਹੈ। ਸੂਚੀਆਂ ‘ਤੇ ਵੱਖ-ਵੱਖ ਕਾਰਵਾਈਆਂ ਦੀ ਗਣਨਾਤਮਕ ਗੁੰਝਲਤਾ ਲਈ ਅਧਿਕਾਰਤ ਵਿਕੀ ‘ਤੇ ਹੇਠਾਂ ਦਿੱਤੇ ਪੰਨੇ ਨੂੰ ਦੇਖੋ।O(n)
O(1)ਡੀਕ ਕਿਸਮ ਮਿਆਰੀ ਲਾਇਬ੍ਰੇਰੀ ਸੰਗ੍ਰਹਿ ਮੋਡੀਊਲ ਵਿੱਚ ਇੱਕ ਕਿਸਮ ਦੇ ਰੂਪ ਵਿੱਚ ਪ੍ਰਦਾਨ ਕੀਤੀ ਗਈ ਹੈ ਜੋ ਇਸ ਕੀਮਤ ‘ਤੇ ਤੱਤ ਨੂੰ ਸਿਖਰ ‘ਤੇ ਮਿਟਾ ਦਿੰਦੀ ਹੈ। ਉਦਾਹਰਨ ਲਈ, ਜੇਕਰ ਤੁਸੀਂ ਡੇਟਾ ਨੂੰ ਇੱਕ ਕਤਾਰ (FIFO) ਦੇ ਰੂਪ ਵਿੱਚ ਮੰਨਣਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਇਹ deque ਦੀ ਵਰਤੋਂ ਕਰਨਾ ਵਧੇਰੇ ਕੁਸ਼ਲ ਹੈ।
ਨਿਰਧਾਰਤ ਮੁੱਲ ਵਾਲੇ ਤੱਤਾਂ ਦੀ ਖੋਜ ਕਰਦਾ ਹੈ ਅਤੇ ਪਹਿਲੇ ਤੱਤ ਨੂੰ ਹਟਾ ਦਿੰਦਾ ਹੈ।:remove()
ਸੂਚੀ ਵਿਧੀ remove() ਦੀ ਵਰਤੋਂ ਉਸੇ ਮੁੱਲ ਵਾਲੇ ਤੱਤਾਂ ਦੀ ਖੋਜ ਕਰਨ ਅਤੇ ਪਹਿਲੇ ਤੱਤ ਨੂੰ ਹਟਾਉਣ ਲਈ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ।
l = ['Alice', 'Bob', 'Charlie', 'Bob', 'Dave']
print(l)
# ['Alice', 'Bob', 'Charlie', 'Bob', 'Dave']
l.remove('Alice')
print(l)
# ['Bob', 'Charlie', 'Bob', 'Dave']
ਜੇਕਰ ਸੂਚੀ ਵਿੱਚ ਇੱਕ ਤੋਂ ਵੱਧ ਤੱਤ ਹਨ ਜੋ ਦਿੱਤੇ ਗਏ ਮੁੱਲ ਨਾਲ ਮੇਲ ਖਾਂਦੇ ਹਨ, ਤਾਂ ਸਿਰਫ਼ ਪਹਿਲੇ ਨੂੰ ਹੀ ਹਟਾਇਆ ਜਾਵੇਗਾ।
l.remove('Bob')
print(l)
# ['Charlie', 'Bob', 'Dave']
ਜੇਕਰ ਕੋਈ ਗੈਰ-ਮੌਜੂਦ ਮੁੱਲ ਦਿੱਤਾ ਗਿਆ ਹੈ, ਤਾਂ ਇੱਕ ਤਰੁੱਟੀ ਵਾਪਰਦੀ ਹੈ।
# l.remove('xxx')
# ValueError: list.remove(x): x not in list
ਸੂਚਕਾਂਕ ਦੇ ਟੁਕੜੇ ਵਿੱਚ ਸਥਿਤੀ ਅਤੇ ਰੇਂਜ ਨੂੰ ਨਿਸ਼ਚਿਤ ਕਰਕੇ ਮਿਟਾਇਆ ਜਾ ਰਿਹਾ ਹੈ:del
ਤੁਸੀਂ ਸੂਚੀ ਵਿੱਚੋਂ ਤੱਤਾਂ ਨੂੰ ਹਟਾਉਣ ਲਈ ਡੈਲ ਸਟੇਟਮੈਂਟ ਦੀ ਵਰਤੋਂ ਵੀ ਕਰ ਸਕਦੇ ਹੋ।
ਇਸ ਦੇ ਸੂਚਕਾਂਕ ਦੁਆਰਾ ਮਿਟਾਏ ਜਾਣ ਵਾਲੇ ਤੱਤ ਨੂੰ ਨਿਸ਼ਚਿਤ ਕਰੋ। ਪਹਿਲਾ (ਸ਼ੁਰੂਆਤੀ) ਸੂਚਕਾਂਕ 0 ਹੈ, ਅਤੇ ਆਖਰੀ (ਅੰਤਿਮ) ਸੂਚਕਾਂਕ -1 ਹੈ।
l = list(range(10))
print(l)
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
del l[0]
print(l)
# [1, 2, 3, 4, 5, 6, 7, 8, 9]
del l[-1]
print(l)
# [1, 2, 3, 4, 5, 6, 7, 8]
del l[6]
print(l)
# [1, 2, 3, 4, 5, 6, 8]
ਜੇਕਰ ਤੁਸੀਂ ਟੁਕੜਿਆਂ ਨਾਲ ਇੱਕ ਰੇਂਜ ਨਿਸ਼ਚਿਤ ਕਰਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਇੱਕ ਵਾਰ ਵਿੱਚ ਕਈ ਤੱਤਾਂ ਨੂੰ ਮਿਟਾ ਸਕਦੇ ਹੋ।
l = list(range(10))
print(l)
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
del l[2:5]
print(l)
# [0, 1, 5, 6, 7, 8, 9]
l = list(range(10))
del l[:3]
print(l)
# [3, 4, 5, 6, 7, 8, 9]
l = list(range(10))
del l[4:]
print(l)
# [0, 1, 2, 3]
l = list(range(10))
del l[-3:]
print(l)
# [0, 1, 2, 3, 4, 5, 6]
ਪੂਰੀ ਰੇਂਜ ਨੂੰ ਨਿਰਧਾਰਤ ਕਰਨਾ ਅਤੇ ਸਾਰੇ ਤੱਤਾਂ ਨੂੰ ਮਿਟਾਉਣਾ ਵੀ ਸੰਭਵ ਹੈ।
l = list(range(10))
del l[:]
print(l)
# []
[start:stop:step]ਜੇ ਤੁਸੀਂ ਇਸ ਤਰੀਕੇ ਨਾਲ ਸਲਾਈਸ ਵਿੱਚ ਰੇਂਜ ਨੂੰ ਨਿਸ਼ਚਿਤ ਕਰਦੇ ਹੋ ਅਤੇ ਵਾਧੇ ਵਾਲੇ ਪੜਾਅ ਨੂੰ ਨਿਸ਼ਚਿਤ ਕਰਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਇੱਕ ਵਾਰ ਵਿੱਚ ਕਈ ਜੰਪਿੰਗ ਤੱਤਾਂ ਨੂੰ ਮਿਟਾ ਸਕਦੇ ਹੋ।
l = list(range(10))
del l[2:8:2]
print(l)
# [0, 1, 3, 5, 7, 8, 9]
l = list(range(10))
del l[::3]
print(l)
# [1, 2, 4, 5, 7, 8]
ਕੱਟਣ ਬਾਰੇ ਹੋਰ ਜਾਣਕਾਰੀ ਲਈ, ਹੇਠਾਂ ਦਿੱਤਾ ਲੇਖ ਦੇਖੋ।
ਬੈਚ ਕਈ ਤੱਤਾਂ ਨੂੰ ਮਿਟਾਓ ਜੋ ਮਾਪਦੰਡਾਂ ਨੂੰ ਪੂਰਾ ਕਰਦੇ ਹਨ।:ਸੂਚੀ ਸ਼ਾਮਲ ਕਰਨ ਦਾ ਸੰਕੇਤ
ਸ਼ਰਤਾਂ ਨੂੰ ਸੰਤੁਸ਼ਟ ਕਰਨ ਵਾਲੇ ਤੱਤਾਂ ਨੂੰ ਹਟਾਉਣ ਦੀ ਪ੍ਰਕਿਰਿਆ ਉਹਨਾਂ ਤੱਤਾਂ ਨੂੰ ਛੱਡਣ (ਐਕਸਟਰੈਕਟ ਕਰਨ) ਦੀ ਪ੍ਰਕਿਰਿਆ ਦੇ ਬਰਾਬਰ ਹੈ ਜੋ ਸ਼ਰਤਾਂ ਨੂੰ ਸੰਤੁਸ਼ਟ ਨਹੀਂ ਕਰਦੇ ਹਨ। ਇਸ ਕਿਸਮ ਦੀ ਪ੍ਰੋਸੈਸਿੰਗ ਲਈ ਸੂਚੀ ਸਮਝ ਸੰਕੇਤ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।
- ਸੰਬੰਧਿਤ ਲੇਖ:ਪਾਈਥਨ ਸੂਚੀ ਸਮਝ ਸੰਕੇਤ ਦੀ ਵਰਤੋਂ ਕਰਨਾ
ਔਡ ਜਾਂ ਈਵਨ ਐਲੀਮੈਂਟਸ ਨੂੰ ਹਟਾਉਣ ਦਾ ਇੱਕ ਉਦਾਹਰਨ ਹੇਠਾਂ ਦਿਖਾਇਆ ਗਿਆ ਹੈ।%ਇਹ ਬਾਕੀ ਆਪਰੇਟਰ ਹੈ।i % 2
ਇਹ 2 ਨਾਲ ਭਾਗ ਕੀਤਾ ਗਿਆ i ਦਾ ਬਾਕੀ ਬਚਿਆ ਹਿੱਸਾ ਹੈ।
ਸੂਚੀ ਸਮਝ ਸੰਕੇਤ ਵਿੱਚ, ਇੱਕ ਨਵੀਂ ਸੂਚੀ ਬਣਾਈ ਜਾਂਦੀ ਹੈ। ਹੁਣ ਤੱਕ ਪੇਸ਼ ਕੀਤੇ ਗਏ ਸੂਚੀ ਕਿਸਮ ਦੇ ਤਰੀਕਿਆਂ ਦੇ ਉਲਟ, ਅਸਲ ਸੂਚੀ ਵਿੱਚ ਕੋਈ ਬਦਲਾਅ ਨਹੀਂ ਹੈ।
l = list(range(10))
print(l)
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
print([i for i in l if i % 2 == 0])
# [0, 2, 4, 6, 8]
print([i for i in l if i % 2 != 0])
# [1, 3, 5, 7, 9]
print(l)
# [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
ਹੋਰ ਉਦਾਹਰਣਾਂ। ਸ਼ਰਤੀਆ ਸਮੀਕਰਨ ਦੇ ਆਧਾਰ ‘ਤੇ ਕਈ ਤਰ੍ਹਾਂ ਦੀ ਪ੍ਰੋਸੈਸਿੰਗ ਸੰਭਵ ਹੈ।
l = ['Alice', 'Bob', 'Charlie', 'Bob', 'David']
print(l)
# ['Alice', 'Bob', 'Charlie', 'Bob', 'David']
print([s for s in l if s != 'Bob'])
# ['Alice', 'Charlie', 'David']
print([s for s in l if s.endswith('e')])
# ['Alice', 'Charlie']
ਜੇਕਰ ਤੁਸੀਂ ਡੁਪਲੀਕੇਟ ਐਲੀਮੈਂਟਸ ਨੂੰ ਹਟਾਉਣਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਸੈੱਟ ਸੈੱਟ ਕਿਸਮ ਦੀ ਵਰਤੋਂ ਕਰੋ।
print(list(set(l)))
# ['David', 'Alice', 'Charlie', 'Bob']
