ਇਹ ਭਾਗ ਦੱਸਦਾ ਹੈ ਕਿ ਸੂਚੀ (ਐਰੇ) ਤੋਂ ਡੁਪਲੀਕੇਟ ਐਲੀਮੈਂਟਸ ਨੂੰ ਹਟਾ ਕੇ ਜਾਂ ਐਕਸਟਰੈਕਟ ਕਰਕੇ ਪਾਈਥਨ ਵਿੱਚ ਇੱਕ ਨਵੀਂ ਸੂਚੀ ਕਿਵੇਂ ਤਿਆਰ ਕਰਨੀ ਹੈ।
ਹੇਠਾਂ ਦਿੱਤੇ ਵੇਰਵਿਆਂ ਦਾ ਇੱਥੇ ਵਰਣਨ ਕੀਤਾ ਗਿਆ ਹੈ।
- ਡੁਪਲੀਕੇਟ ਤੱਤ ਹਟਾਓ ਅਤੇ ਨਵੀਂ ਸੂਚੀ ਬਣਾਓ
- ਅਸਲੀ ਸੂਚੀ ਦੇ ਕ੍ਰਮ ਨੂੰ ਸੁਰੱਖਿਅਤ ਨਾ ਕਰੋ:
set() - ਮੂਲ ਸੂਚੀਕਰਨ ਦੇ ਕ੍ਰਮ ਨੂੰ ਸੁਰੱਖਿਅਤ ਰੱਖਦਾ ਹੈ:
dict.fromkeys(),sorted() - ਦੋ-ਅਯਾਮੀ ਐਰੇ (ਸੂਚੀਆਂ ਦੀ ਸੂਚੀ)
- ਅਸਲੀ ਸੂਚੀ ਦੇ ਕ੍ਰਮ ਨੂੰ ਸੁਰੱਖਿਅਤ ਨਾ ਕਰੋ:
- ਡੁਪਲੀਕੇਟ ਤੱਤ ਕੱਢੋ ਅਤੇ ਇੱਕ ਨਵੀਂ ਸੂਚੀ ਬਣਾਓ
- ਅਸਲੀ ਸੂਚੀ ਦੇ ਕ੍ਰਮ ਨੂੰ ਸੁਰੱਖਿਅਤ ਨਾ ਕਰੋ
- ਮੂਲ ਸੂਚੀਕਰਨ ਦੇ ਕ੍ਰਮ ਨੂੰ ਸੁਰੱਖਿਅਤ ਰੱਖਦਾ ਹੈ
- ਦੋ-ਅਯਾਮੀ ਐਰੇ (ਸੂਚੀਆਂ ਦੀ ਸੂਚੀ)
ਇਹੀ ਧਾਰਨਾ ਸੂਚੀਆਂ ਦੀ ਬਜਾਏ ਟੂਪਲਾਂ ‘ਤੇ ਲਾਗੂ ਕੀਤੀ ਜਾ ਸਕਦੀ ਹੈ।
ਲਈ ਅਗਲਾ ਲੇਖ ਦੇਖੋ
- ਜੇ ਤੁਸੀਂ ਇਹ ਨਿਰਧਾਰਤ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ ਕਿ ਕੀ ਸੂਚੀ ਜਾਂ ਟੂਪਲ ਵਿੱਚ ਡੁਪਲੀਕੇਟ ਤੱਤ ਹਨ
- ਜੇਕਰ ਤੁਸੀਂ ਉਹਨਾਂ ਤੱਤਾਂ ਨੂੰ ਐਕਸਟਰੈਕਟ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ ਜੋ ਇੱਕ ਸੂਚੀ ਦੀ ਬਜਾਏ ਕਈ ਸੂਚੀਆਂ ਵਿੱਚ ਆਮ ਜਾਂ ਆਮ ਨਹੀਂ ਹਨ
ਨੋਟ ਕਰੋ ਕਿ ਸੂਚੀਆਂ ਵੱਖ-ਵੱਖ ਕਿਸਮਾਂ ਦੇ ਡੇਟਾ ਨੂੰ ਸਟੋਰ ਕਰ ਸਕਦੀਆਂ ਹਨ ਅਤੇ ਐਰੇ ਤੋਂ ਬਿਲਕੁਲ ਵੱਖਰੀਆਂ ਹਨ। ਜੇ ਤੁਸੀਂ ਉਹਨਾਂ ਪ੍ਰਕਿਰਿਆਵਾਂ ਵਿੱਚ ਐਰੇ ਨੂੰ ਸੰਭਾਲਣਾ ਚਾਹੁੰਦੇ ਹੋ ਜਿਹਨਾਂ ਲਈ ਮੈਮੋਰੀ ਆਕਾਰ ਅਤੇ ਮੈਮੋਰੀ ਪਤੇ ਜਾਂ ਵੱਡੇ ਡੇਟਾ ਦੀ ਸੰਖਿਆਤਮਕ ਪ੍ਰਕਿਰਿਆ ਦੀ ਲੋੜ ਹੁੰਦੀ ਹੈ, ਤਾਂ ਐਰੇ (ਸਟੈਂਡਰਡ ਲਾਇਬ੍ਰੇਰੀ) ਜਾਂ NumPy ਦੀ ਵਰਤੋਂ ਕਰੋ।
ਡੁਪਲੀਕੇਟ ਤੱਤ ਹਟਾਓ ਅਤੇ ਨਵੀਂ ਸੂਚੀ ਬਣਾਓ
ਅਸਲੀ ਸੂਚੀ ਦੇ ਕ੍ਰਮ ਨੂੰ ਸੁਰੱਖਿਅਤ ਨਾ ਕਰੋ:set()
ਜੇਕਰ ਮੂਲ ਸੂਚੀ ਦੇ ਕ੍ਰਮ ਨੂੰ ਸੁਰੱਖਿਅਤ ਰੱਖਣ ਦੀ ਕੋਈ ਲੋੜ ਨਹੀਂ ਹੈ, ਤਾਂ ਸੈੱਟ() ਦੀ ਵਰਤੋਂ ਕਰੋ, ਜੋ ਇੱਕ ਸੈੱਟ ਕਿਸਮ ਦਾ ਸੈੱਟ ਤਿਆਰ ਕਰਦਾ ਹੈ।
ਸੈੱਟ ਕਿਸਮ ਇੱਕ ਡਾਟਾ ਕਿਸਮ ਹੈ ਜਿਸ ਵਿੱਚ ਕੋਈ ਡੁਪਲੀਕੇਟ ਤੱਤ ਨਹੀਂ ਹਨ। ਜਦੋਂ ਇੱਕ ਸੂਚੀ ਜਾਂ ਹੋਰ ਡੇਟਾ ਕਿਸਮ ਨੂੰ ਸੈੱਟ() ਵਿੱਚ ਪਾਸ ਕੀਤਾ ਜਾਂਦਾ ਹੈ, ਤਾਂ ਡੁਪਲੀਕੇਟ ਮੁੱਲਾਂ ਨੂੰ ਅਣਡਿੱਠ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਅਤੇ ਕਿਸਮ ਸੈੱਟ ਦੀ ਇੱਕ ਵਸਤੂ ਵਾਪਸ ਕੀਤੀ ਜਾਂਦੀ ਹੈ ਜਿਸ ਵਿੱਚ ਸਿਰਫ਼ ਵਿਲੱਖਣ ਮੁੱਲ ਤੱਤ ਹੁੰਦੇ ਹਨ।
ਜੇਕਰ ਤੁਸੀਂ ਇਸਨੂੰ ਟੂਪਲ ਬਣਾਉਣਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਟੂਪਲ () ਦੀ ਵਰਤੋਂ ਕਰੋ।
l = [3, 3, 2, 1, 5, 1, 4, 2, 3]
print(set(l))
# {1, 2, 3, 4, 5}
print(list(set(l)))
# [1, 2, 3, 4, 5]
ਬੇਸ਼ੱਕ, ਇਸ ਨੂੰ ਸੈੱਟ ਦੇ ਤੌਰ ਤੇ ਵੀ ਛੱਡਿਆ ਜਾ ਸਕਦਾ ਹੈ. ਸੈੱਟ ਕਿਸਮ ਦੇ ਸੈੱਟ ਬਾਰੇ ਹੋਰ ਜਾਣਕਾਰੀ ਲਈ ਹੇਠਾਂ ਦਿੱਤਾ ਲੇਖ ਦੇਖੋ।
ਮੂਲ ਸੂਚੀਕਰਨ ਦੇ ਕ੍ਰਮ ਨੂੰ ਸੁਰੱਖਿਅਤ ਰੱਖਦਾ ਹੈ:dict.fromkeys(),sorted()
ਜੇਕਰ ਤੁਸੀਂ ਮੂਲ ਸੂਚੀ ਦੇ ਕ੍ਰਮ ਨੂੰ ਸੁਰੱਖਿਅਤ ਰੱਖਣਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਸ਼ਬਦਕੋਸ਼ ਕਿਸਮ ਦੀ ਕੁੰਜੀ() ਕਲਾਸ ਵਿਧੀ ਜਾਂ ਬਿਲਟ-ਇਨ ਫੰਕਸ਼ਨ sorted() ਦੀ ਵਰਤੋਂ ਕਰੋ।
dict.fromkeys() ਇੱਕ ਨਵਾਂ ਡਿਕਸ਼ਨਰੀ ਆਬਜੈਕਟ ਬਣਾਉਂਦਾ ਹੈ ਜਿਸ ਦੀਆਂ ਕੁੰਜੀਆਂ ਸੂਚੀਆਂ, ਟੂਪਲਾਂ, ਆਦਿ ਹਨ ਜੋ ਆਰਗੂਮੈਂਟਾਂ ਵਿੱਚ ਦਰਸਾਏ ਗਏ ਹਨ। ਜੇਕਰ ਦੂਜੀ ਆਰਗੂਮੈਂਟ ਨੂੰ ਛੱਡ ਦਿੱਤਾ ਗਿਆ ਹੈ, ਤਾਂ ਮੁੱਲ ਕੋਈ ਨਹੀਂ ਹੈ।
ਕਿਉਂਕਿ ਡਿਕਸ਼ਨਰੀ ਕੁੰਜੀਆਂ ਵਿੱਚ ਡੁਪਲੀਕੇਟ ਤੱਤ ਨਹੀਂ ਹੁੰਦੇ ਹਨ, ਡੁਪਲੀਕੇਟ ਮੁੱਲਾਂ ਨੂੰ ਸੈੱਟ() ਦੇ ਰੂਪ ਵਿੱਚ ਅਣਡਿੱਠ ਕੀਤਾ ਜਾਂਦਾ ਹੈ। ਇਸ ਤੋਂ ਇਲਾਵਾ, ਇੱਕ ਡਿਕਸ਼ਨਰੀ ਵਸਤੂ ਨੂੰ ਇੱਕ ਸੂਚੀ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ list() ਨੂੰ ਇੱਕ ਦਲੀਲ ਵਜੋਂ ਪਾਸ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ ਜਿਸ ਦੇ ਤੱਤ ਸ਼ਬਦਕੋਸ਼ ਕੁੰਜੀਆਂ ਹਨ।
print(dict.fromkeys(l))
# {3: None, 2: None, 1: None, 5: None, 4: None}
print(list(dict.fromkeys(l)))
# [3, 2, 1, 5, 4]
ਪਾਈਥਨ 3.7 (CPython 3.6 ਹੈ) ਤੋਂ ਇਹ ਗਾਰੰਟੀ ਦਿੱਤੀ ਗਈ ਹੈ ਕਿ dict.fromkeys() ਆਰਗੂਮੈਂਟ ਕ੍ਰਮ ਦੇ ਕ੍ਰਮ ਨੂੰ ਸੁਰੱਖਿਅਤ ਰੱਖਦਾ ਹੈ। ਪਿਛਲੇ ਸੰਸਕਰਣਾਂ ਵਿੱਚ ਬਿਲਟ-ਇਨ ਫੰਕਸ਼ਨ sorted() ਨੂੰ ਹੇਠਾਂ ਦਿੱਤੇ ਅਨੁਸਾਰ ਵਰਤਦੇ ਹਨ।
ਕ੍ਰਮਬੱਧ ਦੀ ਆਰਗੂਮੈਂਟ ਕੁੰਜੀ ਲਈ ਸੂਚੀ ਟੂਪਲ ਵਿਧੀ ਸੂਚਕਾਂਕ() ਦਿਓ, ਜੋ ਤੱਤਾਂ ਦੀ ਕ੍ਰਮਬੱਧ ਸੂਚੀ ਵਾਪਸ ਕਰਦੀ ਹੈ।
index() ਇੱਕ ਢੰਗ ਹੈ ਜੋ ਮੁੱਲ ਦਾ ਸੂਚਕਾਂਕ (ਸੂਚੀ ਵਿੱਚ ਤੱਤ ਦੀ ਸੰਖਿਆ) ਵਾਪਸ ਕਰਦਾ ਹੈ, ਜਿਸ ਨੂੰ ਮੂਲ ਸੂਚੀ ਦੇ ਕ੍ਰਮ ਦੇ ਆਧਾਰ ‘ਤੇ ਸੂਚੀ ਨੂੰ ਛਾਂਟਣ ਲਈ sorted() ਦੀ ਕੁੰਜੀ ਵਜੋਂ ਨਿਰਧਾਰਤ ਕੀਤਾ ਜਾ ਸਕਦਾ ਹੈ। ਆਰਗੂਮੈਂਟ ਕੁੰਜੀ ਨੂੰ ਇੱਕ ਕਾਲ ਕਰਨ ਯੋਗ (ਕਾਲ ਕਰਨ ਯੋਗ) ਵਸਤੂ ਦੇ ਤੌਰ ਤੇ ਨਿਰਧਾਰਤ ਕੀਤਾ ਗਿਆ ਹੈ, ਇਸ ਲਈ () ਨਾ ਲਿਖੋ.
print(sorted(set(l), key=l.index))
# [3, 2, 1, 5, 4]
ਦੋ-ਅਯਾਮੀ ਐਰੇ (ਸੂਚੀਆਂ ਦੀ ਸੂਚੀ)
ਦੋ-ਅਯਾਮੀ ਐਰੇ (ਸੂਚੀਆਂ ਦੀਆਂ ਸੂਚੀਆਂ) ਲਈ, set() ਜਾਂ dict.fromkeys() ਦੀ ਵਰਤੋਂ ਕਰਨ ਵਾਲੀ ਵਿਧੀ TypeError ਵਿੱਚ ਨਤੀਜਾ ਦਿੰਦੀ ਹੈ।
l_2d = [[1, 1], [0, 1], [0, 1], [0, 0], [1, 0], [1, 1], [1, 1]]
# l_2d_unique = list(set(l_2d))
# TypeError: unhashable type: 'list'
# l_2d_unique_order = dict.fromkeys(l_2d)
# TypeError: unhashable type: 'list'
ਇਹ ਇਸ ਲਈ ਹੈ ਕਿਉਂਕਿ ਗੈਰ-ਹੈਸ਼ਯੋਗ ਵਸਤੂਆਂ ਜਿਵੇਂ ਕਿ ਸੂਚੀਆਂ ਟਾਈਪ ਸੈੱਟ ਜਾਂ ਟਾਈਪ ਡਿਕਟ ਦੀਆਂ ਕੁੰਜੀਆਂ ਨਹੀਂ ਹੋ ਸਕਦੀਆਂ।
ਹੇਠਾਂ ਦਿੱਤੇ ਫੰਕਸ਼ਨਾਂ ਨੂੰ ਪਰਿਭਾਸ਼ਿਤ ਕਰੋ ਮੂਲ ਸੂਚੀ ਦਾ ਕ੍ਰਮ ਸੁਰੱਖਿਅਤ ਹੈ ਅਤੇ ਇੱਕ-ਅਯਾਮੀ ਸੂਚੀਆਂ ਅਤੇ ਟੂਪਲਾਂ ਲਈ ਕੰਮ ਕਰਦਾ ਹੈ।
def get_unique_list(seq):
seen = []
return [x for x in seq if x not in seen and not seen.append(x)]
print(get_unique_list(l_2d))
# [[1, 1], [0, 1], [0, 0], [1, 0]]
print(get_unique_list(l))
# [3, 2, 1, 5, 4]
ਸੂਚੀ ਸਮਝ ਸੰਕੇਤਕ ਦੀ ਵਰਤੋਂ ਕੀਤੀ ਜਾਂਦੀ ਹੈ।
ਇੱਥੇ, ਅਸੀਂ ਹੇਠਾਂ ਦਿੱਤੇ ਦੀ ਵਰਤੋਂ ਕਰਦੇ ਹਾਂ
- ਜੇਕਰ “X ਅਤੇ Y” ਵਿੱਚ X ਅਤੇ ਓਪਰੇਟਰ ਦੇ ਸ਼ਾਰਟ-ਸਰਕਟ ਮੁਲਾਂਕਣ ਵਿੱਚ ਗਲਤ ਹੈ, ਤਾਂ Y ਦਾ ਮੁਲਾਂਕਣ ਨਹੀਂ ਕੀਤਾ ਜਾਂਦਾ (ਐਕਜ਼ੀਕਿਊਟ ਨਹੀਂ ਕੀਤਾ ਜਾਂਦਾ)।
- append() ਵਿਧੀ ਕੋਈ ਨਹੀਂ ਵਾਪਸ ਕਰਦੀ ਹੈ।
ਜੇਕਰ ਮੂਲ ਸੂਚੀ ਸੀਕ ਦੇ ਤੱਤ ਦੇਖੇ ਗਏ ਵਿੱਚ ਮੌਜੂਦ ਨਹੀਂ ਹਨ, ਤਾਂ ਅਤੇ ਬਾਅਦ ਵਿੱਚ ਮੁਲਾਂਕਣ ਕੀਤੇ ਜਾਂਦੇ ਹਨ।
see.append(x) ਨੂੰ ਐਗਜ਼ੀਕਿਊਟ ਕੀਤਾ ਜਾਂਦਾ ਹੈ ਅਤੇ ਐਲੀਮੈਂਟ ਨੂੰ ਦੇਖਿਆ ਜਾਂਦਾ ਹੈ।
ਕਿਉਂਕਿ append() ਵਿਧੀ None ਨੂੰ ਵਾਪਸ ਕਰਦੀ ਹੈ ਅਤੇ None is False, not seen.append(x) ਦਾ ਮੁਲਾਂਕਣ ਸਹੀ ਹੁੰਦਾ ਹੈ।
ਸੂਚੀ ਸਮਝ ਸੰਕੇਤ ਵਿੱਚ ਸ਼ਰਤੀਆ ਸਮੀਕਰਨ ਸਹੀ ਬਣ ਜਾਂਦਾ ਹੈ ਅਤੇ ਅੰਤਮ ਤਿਆਰ ਕੀਤੀ ਸੂਚੀ ਦੇ ਇੱਕ ਤੱਤ ਵਜੋਂ ਜੋੜਿਆ ਜਾਂਦਾ ਹੈ।
ਜੇਕਰ ਮੂਲ ਸੂਚੀ ਸੀਕ ਦੇ ਤੱਤ ਦੇਖੇ ਗਏ ਵਿੱਚ ਮੌਜੂਦ ਹਨ, ਤਾਂ x ਨਾ ਦੇਖਿਆ ਗਿਆ ਗਲਤ ਹੈ, ਅਤੇ ਸੂਚੀ ਸਮਝ ਸਮੀਕਰਨ ਲਈ ਕੰਡੀਸ਼ਨਲ ਸਮੀਕਰਨ ਗਲਤ ਹੈ।
ਇਸਲਈ, ਉਹਨਾਂ ਨੂੰ ਅੰਤਮ ਤਿਆਰ ਕੀਤੀ ਸੂਚੀ ਦੇ ਤੱਤ ਦੇ ਰੂਪ ਵਿੱਚ ਸ਼ਾਮਲ ਨਹੀਂ ਕੀਤਾ ਜਾਂਦਾ ਹੈ।
ਇੱਕ ਹੋਰ ਤਰੀਕਾ NumPy ਦੇ ਫੰਕਸ਼ਨ np.unique() ਵਿੱਚ ਆਰਗੂਮੈਂਟ ਧੁਰਾ ਸੈੱਟ ਕਰਨਾ ਹੈ, ਹਾਲਾਂਕਿ ਨਤੀਜਾ ਕ੍ਰਮਬੱਧ ਕੀਤਾ ਜਾਵੇਗਾ।
ਡੁਪਲੀਕੇਟ ਤੱਤ ਕੱਢੋ ਅਤੇ ਇੱਕ ਨਵੀਂ ਸੂਚੀ ਬਣਾਓ
ਅਸਲੀ ਸੂਚੀ ਦੇ ਕ੍ਰਮ ਨੂੰ ਸੁਰੱਖਿਅਤ ਨਾ ਕਰੋ
ਅਸਲ ਸੂਚੀ ਵਿੱਚੋਂ ਸਿਰਫ਼ ਡੁਪਲੀਕੇਟ ਐਲੀਮੈਂਟਸ ਨੂੰ ਐਕਸਟਰੈਕਟ ਕਰਨ ਲਈ, collections.Counter() ਦੀ ਵਰਤੋਂ ਕਰੋ।
ਕੁੰਜੀਆਂ ਦੇ ਰੂਪ ਵਿੱਚ ਤੱਤਾਂ ਅਤੇ ਮੁੱਲਾਂ ਦੇ ਰੂਪ ਵਿੱਚ ਤੱਤਾਂ ਦੀ ਸੰਖਿਆ ਦੇ ਨਾਲ ਇੱਕ ਸੰਗ੍ਰਹਿ।
import collections
l = [3, 3, 2, 1, 5, 1, 4, 2, 3]
print(collections.Counter(l))
# Counter({3: 3, 2: 2, 1: 2, 5: 1, 4: 1})
ਕਿਉਂਕਿ ਇਹ ਸ਼ਬਦਕੋਸ਼ ਦਾ ਇੱਕ ਉਪ-ਕਲਾਸ ਹੈ, ਇਸਲਈ ਆਈਟਮਾਂ() ਨੂੰ ਕੁੰਜੀਆਂ ਅਤੇ ਮੁੱਲਾਂ ਨੂੰ ਪ੍ਰਾਪਤ ਕਰਨ ਲਈ ਵਰਤਿਆ ਜਾ ਸਕਦਾ ਹੈ। ਇਹ ਉਹਨਾਂ ਕੁੰਜੀਆਂ ਨੂੰ ਕੱਢਣ ਲਈ ਕਾਫੀ ਹੈ ਜਿਨ੍ਹਾਂ ਦੀ ਸੰਖਿਆ ਦੋ ਜਾਂ ਵੱਧ ਹੈ।
print([k for k, v in collections.Counter(l).items() if v > 1])
# [3, 2, 1]
ਮੂਲ ਸੂਚੀਕਰਨ ਦੇ ਕ੍ਰਮ ਨੂੰ ਸੁਰੱਖਿਅਤ ਰੱਖਦਾ ਹੈ
ਜਿਵੇਂ ਕਿ ਉਪਰੋਕਤ ਉਦਾਹਰਨ ਵਿੱਚ ਦਿਖਾਇਆ ਗਿਆ ਹੈ, ਪਾਈਥਨ 3.7 ਤੋਂ, ਸੰਗ੍ਰਹਿ ਦੀਆਂ ਕੁੰਜੀਆਂ. ਕਾਊਂਟਰ ਅਸਲ ਸੂਚੀ ਦੇ ਕ੍ਰਮ ਨੂੰ ਬਰਕਰਾਰ ਰੱਖਦੀਆਂ ਹਨ ਅਤੇ ਹੋਰ ਵੀ।
ਪੁਰਾਣੇ ਸੰਸਕਰਣਾਂ ਵਿੱਚ, sorted() ਨਾਲ ਲੜੀਬੱਧ ਕਰਨਾ ਕਾਫ਼ੀ ਹੈ, ਜਿਵੇਂ ਕਿ ਡੁਪਲੀਕੇਟ ਤੱਤਾਂ ਨੂੰ ਮਿਟਾਉਣਾ ਹੈ।
print(sorted([k for k, v in collections.Counter(l).items() if v > 1], key=l.index))
# [3, 2, 1]
ਜੇਕਰ ਤੁਸੀਂ ਡੁਪਲੀਕੇਟ ਜਿਵੇਂ ਕਿ ਉਹ ਹਨ, ਨੂੰ ਐਕਸਟਰੈਕਟ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਬਸ ਦੋ ਜਾਂ ਵੱਧ ਦੀ ਸੰਖਿਆ ਦੇ ਨਾਲ ਅਸਲ ਸੂਚੀ ਵਿੱਚੋਂ ਤੱਤ ਛੱਡੋ। ਹੁਕਮ ਵੀ ਸਾਂਭਿਆ ਹੋਇਆ ਹੈ।
cc = collections.Counter(l)
print([x for x in l if cc[x] > 1])
# [3, 3, 2, 1, 1, 2, 3]
ਦੋ-ਅਯਾਮੀ ਐਰੇ (ਸੂਚੀਆਂ ਦੀ ਸੂਚੀ)
ਦੋ-ਅਯਾਮੀ ਐਰੇ (ਸੂਚੀਆਂ ਦੀਆਂ ਸੂਚੀਆਂ) ਲਈ, ਹੇਠਾਂ ਦਿੱਤੇ ਫੰਕਸ਼ਨ ਸੰਭਵ ਹੁੰਦੇ ਹਨ ਜਦੋਂ ਅਸਲ ਸੂਚੀ ਦਾ ਕ੍ਰਮ ਬਰਕਰਾਰ ਨਹੀਂ ਰੱਖਿਆ ਜਾਂਦਾ ਹੈ ਅਤੇ ਜਦੋਂ ਇਸਨੂੰ ਕ੍ਰਮਵਾਰ ਬਰਕਰਾਰ ਰੱਖਿਆ ਜਾਂਦਾ ਹੈ। ਇਹ ਇੱਕ-ਅਯਾਮੀ ਸੂਚੀਆਂ ਅਤੇ ਟੂਪਲਾਂ ਲਈ ਵੀ ਕੰਮ ਕਰਦਾ ਹੈ।
l_2d = [[1, 1], [0, 1], [0, 1], [0, 0], [1, 0], [1, 1], [1, 1]]
def get_duplicate_list(seq):
seen = []
return [x for x in seq if not seen.append(x) and seen.count(x) == 2]
def get_duplicate_list_order(seq):
seen = []
return [x for x in seq if seq.count(x) > 1 and not seen.append(x) and seen.count(x) == 1]
print(get_duplicate_list(l_2d))
# [[0, 1], [1, 1]]
print(get_duplicate_list_order(l_2d))
# [[1, 1], [0, 1]]
print(get_duplicate_list(l))
# [3, 1, 2]
print(get_duplicate_list_order(l))
# [3, 2, 1]
ਜੇਕਰ ਤੁਸੀਂ ਡੁਪਲੀਕੇਟ ਨਾਲ ਐਕਸਟਰੈਕਟ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਮੂਲ ਸੂਚੀ ਵਿੱਚੋਂ ਦੋ ਜਾਂ ਵੱਧ ਦੀ ਗਿਣਤੀ ਦੇ ਨਾਲ ਤੱਤ ਛੱਡੋ।
print([x for x in l_2d if l_2d.count(x) > 1])
# [[1, 1], [0, 1], [0, 1], [1, 1], [1, 1]]
ਨੋਟ ਕਰੋ ਕਿ ਕਿਉਂਕਿ ਕਾਉਂਟ() ਦੀ ਕੰਪਿਊਟੇਸ਼ਨਲ ਗੁੰਝਲਤਾ O(n) ਹੈ, ਉੱਪਰ ਦਿਖਾਇਆ ਗਿਆ ਫੰਕਸ਼ਨ ਜੋ ਵਾਰ-ਵਾਰ count() ਨੂੰ ਚਲਾਉਂਦਾ ਹੈ ਬਹੁਤ ਅਯੋਗ ਹੈ। ਕੋਈ ਚੁਸਤ ਤਰੀਕਾ ਹੋ ਸਕਦਾ ਹੈ।
ਕਾਊਂਟਰ ਸ਼ਬਦਕੋਸ਼ ਦਾ ਇੱਕ ਉਪ-ਕਲਾਸ ਹੈ, ਇਸਲਈ ਜੇਕਰ ਤੁਸੀਂ ਇੱਕ ਸੂਚੀ ਜਾਂ ਟੂਪਲ ਪਾਸ ਕਰਦੇ ਹੋ ਜਿਸ ਦੇ ਤੱਤ ਸੂਚੀਆਂ ਜਾਂ ਹੋਰ ਗੈਰ-ਹੈਸ਼ਯੋਗ ਵਸਤੂਆਂ ਹਨ ਸੰਗ੍ਰਹਿ. ਕਾਊਂਟਰ(), ਤਾਂ ਇੱਕ ਤਰੁੱਟੀ ਆਵੇਗੀ ਅਤੇ ਤੁਸੀਂ ਇਸਨੂੰ ਵਰਤਣ ਦੇ ਯੋਗ ਨਹੀਂ ਹੋਵੋਗੇ।
# print(collections.Counter(l_2d))
# TypeError: unhashable type: 'list'
