ਹੇਠਾਂ ਦਿੱਤੇ ਕੇਸਾਂ ਵਿੱਚੋਂ ਹਰੇਕ ਲਈ, ਪਾਈਥਨ ਵਿੱਚ ਇੱਕ ਸੂਚੀ (ਐਰੇ) ਵਿੱਚ ਡੁਪਲੀਕੇਟ ਤੱਤ (ਸਾਰੇ ਤੱਤ ਵਿਲੱਖਣ/ਵਿਲੱਖਣ ਹਨ) ਹਨ ਜਾਂ ਨਹੀਂ ਇਹ ਕਿਵੇਂ ਨਿਰਧਾਰਿਤ ਕਰਨਾ ਹੈ ਇਸਦਾ ਵਰਣਨ ਹੈ।
- ਇੱਕ ਸੂਚੀ ਲਈ ਜਿਸ ਵਿੱਚ ਤੱਤ ਵਿੱਚ ਕੋਈ ਸੂਚੀ ਨਹੀਂ ਹੈ
- ਤੱਤਾਂ ਦੀਆਂ ਸੂਚੀਆਂ ਵਾਲੀਆਂ ਸੂਚੀਆਂ ਲਈ (ਦੋ-ਅਯਾਮੀ ਐਰੇ, ਸੂਚੀਆਂ ਦੀਆਂ ਸੂਚੀਆਂ, ਆਦਿ)
ਸੂਚੀ ਵਿੱਚੋਂ ਡੁਪਲੀਕੇਟ ਤੱਤਾਂ ਨੂੰ ਕਿਵੇਂ ਹਟਾਉਣਾ ਜਾਂ ਐਕਸਟਰੈਕਟ ਕਰਨਾ ਹੈ ਇਸ ਬਾਰੇ ਹੇਠਾਂ ਦਿੱਤਾ ਲੇਖ ਦੇਖੋ।
ਨੋਟ ਕਰੋ ਕਿ ਸੂਚੀਆਂ ਵੱਖ-ਵੱਖ ਕਿਸਮਾਂ ਦੇ ਡੇਟਾ ਨੂੰ ਸਟੋਰ ਕਰ ਸਕਦੀਆਂ ਹਨ ਅਤੇ ਐਰੇ ਤੋਂ ਬਿਲਕੁਲ ਵੱਖਰੀਆਂ ਹਨ। ਜੇ ਤੁਸੀਂ ਉਹਨਾਂ ਪ੍ਰਕਿਰਿਆਵਾਂ ਵਿੱਚ ਐਰੇ ਨੂੰ ਸੰਭਾਲਣਾ ਚਾਹੁੰਦੇ ਹੋ ਜਿਹਨਾਂ ਲਈ ਮੈਮੋਰੀ ਆਕਾਰ ਅਤੇ ਮੈਮੋਰੀ ਪਤੇ ਜਾਂ ਵੱਡੇ ਡੇਟਾ ਦੀ ਸੰਖਿਆਤਮਕ ਪ੍ਰਕਿਰਿਆ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ, ਤਾਂ ਐਰੇ (ਸਟੈਂਡਰਡ ਲਾਇਬ੍ਰੇਰੀ) ਜਾਂ NumPy ਦੀ ਵਰਤੋਂ ਕਰੋ।
ਪਤਾ ਕਰੋ ਕਿ ਕੀ ਸੂਚੀ ਵਿੱਚ ਡੁਪਲੀਕੇਟ ਤੱਤ ਹਨ (ਜੇ ਤੱਤ ਦੀ ਕੋਈ ਸੂਚੀ ਨਹੀਂ ਹੈ)
ਜੇਕਰ ਐਲੀਮੈਂਟ ਕੋਲ ਅੱਪਡੇਟ ਕਰਨ ਯੋਗ ਵਸਤੂ ਨਹੀਂ ਹੈ ਜਿਵੇਂ ਕਿ ਸੂਚੀ, ਸੈੱਟ ਸੈੱਟ ਕਿਸਮ ਦੇ ਕੰਸਟਰਕਟਰ ਸੈੱਟ() ਦੀ ਵਰਤੋਂ ਕਰੋ।
ਸੈੱਟ ਕਿਸਮ ਇੱਕ ਡਾਟਾ ਕਿਸਮ ਹੈ ਜਿਸ ਵਿੱਚ ਕੋਈ ਡੁਪਲੀਕੇਟ ਤੱਤ ਨਹੀਂ ਹਨ। ਜਦੋਂ ਇੱਕ ਸੂਚੀ ਕੰਸਟਰਕਟਰ ਸੈੱਟ() ਨੂੰ ਪਾਸ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਤਾਂ ਡੁਪਲੀਕੇਟ ਮੁੱਲਾਂ ਨੂੰ ਅਣਡਿੱਠ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਅਤੇ ਐਲੀਮੈਂਟਸ ਦੇ ਤੌਰ ‘ਤੇ ਸਿਰਫ਼ ਵਿਲੱਖਣ ਮੁੱਲਾਂ ਦੇ ਨਾਲ ਸੈੱਟ ਦੀ ਕਿਸਮ ਦੀ ਵਸਤੂ ਵਾਪਸ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।
ਇਸ ਸੈੱਟ ਕਿਸਮ ਦੇ ਆਬਜੈਕਟ ਵਿੱਚ ਤੱਤਾਂ ਦੀ ਗਿਣਤੀ ਅਤੇ ਮੂਲ ਸੂਚੀ ਪ੍ਰਾਪਤ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਅਤੇ ਬਿਲਟ-ਇਨ ਫੰਕਸ਼ਨ len() ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਤੁਲਨਾ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।
- ਜੇਕਰ ਤੱਤਾਂ ਦੀ ਗਿਣਤੀ ਬਰਾਬਰ ਹੈ, ਤਾਂ ਅਸਲ ਸੂਚੀ ਵਿੱਚ ਕੋਈ ਡੁਪਲੀਕੇਟ ਤੱਤ ਨਹੀਂ ਹਨ
- ਡੁਪਲੀਕੇਟ ਤੱਤ ਅਸਲ ਸੂਚੀ ਵਿੱਚ ਸ਼ਾਮਲ ਕੀਤੇ ਜਾਂਦੇ ਹਨ ਜੇਕਰ ਤੱਤਾਂ ਦੀ ਗਿਣਤੀ ਵੱਖਰੀ ਹੈ
ਫੰਕਸ਼ਨ ਜੋ ਡੁਪਲੀਕੇਟ ਤੱਤ ਨਾ ਹੋਣ ‘ਤੇ ਗਲਤ ਵਾਪਸ ਕਰਦੇ ਹਨ ਅਤੇ ਜੇਕਰ ਡੁਪਲੀਕੇਟ ਤੱਤ ਹੋਣ ਤਾਂ ਸਹੀ ਹਨ:
def has_duplicates(seq):
return len(seq) != len(set(seq))
l = [0, 1, 2]
print(has_duplicates(l))
# False
l = [0, 1, 1, 2]
print(has_duplicates(l))
# True
ਉਦਾਹਰਨ ਇੱਕ ਸੂਚੀ ਹੈ, ਪਰ ਉਹੀ ਫੰਕਸ਼ਨ tuples ਨਾਲ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ.
ਪਰਿਵਰਤਨਸ਼ੀਲ (ਅਪਡੇਟ ਕਰਨ ਯੋਗ) ਵਸਤੂਆਂ ਜਿਵੇਂ ਕਿ ਸੂਚੀਆਂ ਕਿਸਮ ਸੈੱਟ ਦੇ ਤੱਤ ਨਹੀਂ ਹੋ ਸਕਦੀਆਂ। ਇਸਲਈ, ਐਲੀਮੈਂਟਸ (ਦੋ-ਅਯਾਮੀ ਐਰੇਜ਼, ਸੂਚੀਆਂ ਦੀਆਂ ਸੂਚੀਆਂ, ਆਦਿ) ਦੇ ਰੂਪ ਵਿੱਚ ਸੂਚੀਆਂ ਵਾਲੀਆਂ ਸੂਚੀਆਂ ਇੱਕ TypeError ਵਿੱਚ ਨਤੀਜਾ ਹੋਵੇਗਾ। ਵਿਰੋਧੀ ਉਪਾਅ ਹੇਠਾਂ ਦਿਖਾਇਆ ਗਿਆ ਹੈ।
l_2d = [[0, 1], [1, 1], [0, 1], [1, 0]]
# print(has_duplicates(l_2d))
# TypeError: unhashable type: 'list'
ਪਤਾ ਕਰੋ ਕਿ ਕੀ ਸੂਚੀ ਵਿੱਚ ਡੁਪਲੀਕੇਟ ਤੱਤ ਹਨ (ਜੇ ਤੱਤ ਦੀ ਇੱਕ ਸੂਚੀ ਹੈ)
ਤੱਤਾਂ ਦੀ ਸੂਚੀ (ਜਿਵੇਂ ਕਿ ਸੂਚੀਆਂ ਦੀ ਸੂਚੀ) ਵਾਲੀ ਸੂਚੀ ਦੇ ਮਾਮਲੇ ਵਿੱਚ, ਹੇਠਾਂ ਦਿੱਤੇ ਫੰਕਸ਼ਨਾਂ ਦੀ ਵਰਤੋਂ ਇਹ ਨਿਰਧਾਰਤ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ ਕਿ ਕੀ ਡੁਪਲੀਕੇਟ ਤੱਤ ਹਨ।
def has_duplicates2(seq):
seen = []
unique_list = [x for x in seq if x not in seen and not seen.append(x)]
return len(seq) != len(unique_list)
l_2d = [[0, 0], [0, 1], [1, 1], [1, 0]]
print(has_duplicates2(l_2d))
# False
l_2d = [[0, 0], [0, 1], [1, 1], [1, 1]]
print(has_duplicates2(l_2d))
# True
ਸੈੱਟ() ਦੀ ਬਜਾਏ, ਸੂਚੀ ਸਮਝ ਸੰਕੇਤ ਇੱਕ ਸੂਚੀ ਤਿਆਰ ਕਰਦੀ ਹੈ ਜਿਸ ਦੇ ਤੱਤ ਸਿਰਫ਼ ਵਿਲੱਖਣ ਮੁੱਲ ਹਨ, ਅਤੇ ਤੱਤਾਂ ਦੀ ਗਿਣਤੀ ਦੀ ਤੁਲਨਾ ਕੀਤੀ ਜਾਂਦੀ ਹੈ। ਵੇਰਵਿਆਂ ਲਈ ਅਗਲਾ ਲੇਖ ਦੇਖੋ।
ਇਹ ਫੰਕਸ਼ਨ ਉਹਨਾਂ ਸੂਚੀਆਂ ਲਈ ਵੀ ਵੈਧ ਹੈ ਜਿਹਨਾਂ ਵਿੱਚ ਤੱਤਾਂ ਦੀ ਸੂਚੀ ਨਹੀਂ ਹੈ।
l = [0, 1, 2]
print(has_duplicates2(l))
# False
l = [0, 1, 1, 2]
print(has_duplicates2(l))
# True
ਹੁਣ ਤੱਕ ਦੀ ਉਦਾਹਰਨ ਇਸ ਗੱਲ ਦਾ ਨਿਰਧਾਰਨ ਹੈ ਕਿ ਕੀ ਤੱਤਾਂ ਦੀ ਸੂਚੀ ਡੁਪਲੀਕੇਟ ਹੈ (ਇਸ ਵਿੱਚ ਇੱਕੋ ਸੂਚੀ ਸ਼ਾਮਲ ਹੈ)।
ਕੀ ਹਰੇਕ ਸੂਚੀ ਓਵਰਲੈਪ ਦੇ ਤੱਤ ਮੂਲ ਸੂਚੀ ਨੂੰ ਇੱਕ ਅਯਾਮ ਵਿੱਚ ਸਮਤਲ ਕਰਨ ਤੋਂ ਬਾਅਦ ਨਿਰਧਾਰਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ।
l_2d = [[0, 1], [2, 3]]
print(sum(l_2d, []))
# [0, 1, 2, 3]
print(has_duplicates(sum(l_2d, [])))
# False
l_2d = [[0, 1], [2, 0]]
print(has_duplicates(sum(l_2d, [])))
# True
ਇੱਥੇ, sum() ਦੀ ਵਰਤੋਂ ਸੂਚੀ ਨੂੰ ਸਮਤਲ ਕਰਨ ਲਈ ਕੀਤੀ ਜਾਂਦੀ ਹੈ, ਪਰ itertools.chain.from_iterable() ਦੀ ਵਰਤੋਂ ਵੀ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਜਦੋਂ ਤਿੰਨ ਜਾਂ ਵੱਧ ਮਾਪਾਂ ਦੀ ਸੂਚੀ ਨੂੰ ਸਮਤਲ ਕਰਦੇ ਹੋ, ਤਾਂ ਇੱਕ ਨਵੇਂ ਫੰਕਸ਼ਨ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰਨਾ ਜ਼ਰੂਰੀ ਹੁੰਦਾ ਹੈ।
