Python: एक सूची से डुप्लिकेट हटाएँ (पाँच समाधान)

Python में list एक क्रमबद्ध अनुक्रम होती है जो डुप्लिकेट मान रख सकती है। कुछ Python एप्लिकेशन में ऐसी सूची की आवश्यकता हो सकती है जिसमें केवल अद्वितीय तत्व हों। Python में सूची से डुप्लिकेट हटाने के कई तरीके हैं।

सही समाधान इस पर निर्भर करता है कि क्या एप्लिकेशन को डुप्लिकेट हटाने के बाद सूची के आइटमों का क्रम बनाए रखना है। इस ट्यूटोरियल में दिए गए समाधान पठनीयता और जटिलता में भिन्न हैं, और कुछ थर्ड-पार्टी मॉड्यूल के फ़ंक्शनों पर निर्भर करते हैं।

डुप्लिकेट मान क्या होता है?

किसी सूची से डुप्लिकेट हटाने के समाधान देने से पहले यह स्पष्ट करना उपयोगी है कि डुप्लिकेट मान से हमारा क्या आशय है। आम तौर पर दो ऑब्जेक्ट्स को डुप्लिकेट माना जाता है जब उनके मान समान हों। Python में, समानता ऑपरेटर == तब True लौटाता है जब दो ऑब्जेक्ट्स का मान समान हो। अलग-अलग डेटा टाइप्स के ऑब्जेक्ट्स भी समान हो सकते हैं:

print(10.0 == 10)
print(1 == True)संचालित द्वारा

True
Trueसंचालित द्वारा

फ्लोट 10.0 और इन्टीजर 10 समान हैं, और इन्टीजर 1 और Boolean True भी समान हैं। अधिकांश परिदृश्यों में, ये मान डुप्लिकेट माने जाते हैं।

कुछ Python डेटा संरचनाएँ अद्वितीय मान लागू कराती हैं। एक set ऐसी कलेक्शन है जिसमें केवल अद्वितीय तत्व होते हैं:

print({10, 10.0})
print({10.0, 10})
print({1, True, 1.0})संचालित द्वारा

{10}
{10.0}
{1}संचालित द्वारा

यह कोड ब्रेसेस नोटेशन {} का उपयोग कर तीन सेट बनाता है। प्रत्येक सेट में एक-दूसरे के बराबर ऑब्जेक्ट्स होते हैं। यदि अलग डेटा प्रकारों के समान ऑब्जेक्ट्स को सेट में जोड़ा जाए, तो केवल पहला ऑब्जेक्ट शामिल होता है।

Python में dictionary की keys का अद्वितीय होना भी आवश्यक है:

print({10: "Integer 10", 10.0: "Float 10"})
print({True: "Boolean True", 1: "Integer 1"})संचालित द्वारा

{10: 'Float 10'}
{True: 'Integer 1'}संचालित द्वारा

इस कोड में dictionaries में समान keys हैं। केवल पहली key रखी जाती है। हालाँकि, उससे संबद्ध मान को बाद में समान key के साथ जोड़े गए अंतिम मान से बदल दिया जाता है। इसलिए, पहले उदाहरण में, रखी गई key इन्टीजर 10 है, पर उसका मान स्ट्रिंग "Float 10" है। दूसरे उदाहरण में, key True, जो 1 के बराबर है, के साथ मान "Integer 1" जुड़ा है।

अद्वितीय तत्वों या keys की आवश्यकता के कारण, इस ट्यूटोरियल के कई समाधानों में sets और dictionaries की भूमिका है।

Set का उपयोग करके सूची से डुप्लिकेट हटाएँ

सूची से डुप्लिकेट हटाने का सबसे सरल तरीका यह है कि सूची को set में कास्ट करें और फिर वापस सूची में। set में केवल अद्वितीय मान हो सकते हैं। इसलिए, set में जोड़ते समय डुप्लिकेट हट जाते हैं:

names = ["James", "Bob", "James", "Mark", "Kate", "Sarah", "Kate"]
print(list(set(names)))संचालित द्वारा

['Mark', 'Bob', 'Kate', 'James', 'Sarah']संचालित द्वारा

इस तकनीक से डुप्लिकेट हटाने के लिए आवश्यक चरण देखें:

1. सूची को set में कास्ट किया जाता है, जिससे सभी डुप्लिकेट हट जाते हैं
2. set को वापस नई सूची में कास्ट किया जाता है, जिसमें केवल अद्वितीय मान होते हैं

मूल सूची में James और Kate दो बार आते हैं, लेकिन अंतिम सूची में केवल एक बार।

हालाँकि, sets अनक्रमबद्ध कलेक्शन हैं। set में आइटमों का क्रम बना नहीं रहता। ध्यान दें कि अंतिम सूची में नाम मूल सूची के क्रम में नहीं हैं। क्योंकि set में तत्वों के क्रम की कोई गारंटी नहीं है, वही कोड दोबारा चलाने पर या किसी और Python इंटरप्रेटर पर अलग क्रम दे सकता है।

यह समाधान तब आदर्श है जब सूची के आइटमों के क्रम की जानकारी खोना स्वीकार्य हो। लेकिन यदि तत्वों का क्रम बनाए रखना आवश्यक हो, तो हमें अन्य समाधान चाहिए।

सूची से डुप्लिकेट हटाएँ और क्रम बनाए रखें

Dictionary की keys sets के समान हैं क्योंकि उन्हें अद्वितीय होना होता है। किसी dictionary में डुप्लिकेट values हो सकती हैं, लेकिन डुप्लिकेट keys नहीं।

Python 3.6 से पहले, dictionaries अपने तत्वों का क्रम नहीं बनाए रखती थीं। लेकिन Python 3.6 में dictionaries के इम्प्लीमेंटेशन में किए गए बदलावों के एक साइड इफेक्ट के रूप में, अब dictionaries आइटम जोड़ने के क्रम को बनाए रखती हैं। Python 3.6 में यह केवल इम्प्लीमेंटेशन डिटेल था, पर Python 3.7 में यह भाषा का औपचारिक हिस्सा बन गया।

फ़ंक्शन dict.fromkeys() किसी iterable से dictionary बनाता है। iterable के तत्व नई dictionary की keys बन जाते हैं:

names = ["James", "Bob", "James", "Mark", "Kate", "Sarah", "Kate"]
print(dict.fromkeys(names))संचालित द्वारा

{'James': None, 'Bob': None, 'Mark': None, 'Kate': None, 'Sarah': None}संचालित द्वारा

चूँकि dictionary की keys अद्वितीय होती हैं, dictionary बनाते समय डुप्लिकेट मान हट जाते हैं। यदि आप Python 3.7 या बाद का संस्करण उपयोग कर रहे हैं तो keys का क्रम सूची के आइटमों के क्रम जैसा ही होने की गारंटी है। सभी keys का डिफ़ॉल्ट मान None होता है। हालाँकि, मानों की आवश्यकता नहीं है क्योंकि इस dictionary को वापस सूची में कास्ट किया जा सकता है:

names = ["James", "Bob", "James", "Mark", "Kate", "Sarah", "Kate"]
print(list(dict.fromkeys(names)))संचालित द्वारा

['James', 'Bob', 'Mark', 'Kate', 'Sarah']संचालित द्वारा

किसी dictionary को सूची में कास्ट करते समय केवल keys का उपयोग होता है। यह तकनीक मूल सूची को ऐसी नई सूची में बदल देती है जिसमें डुप्लिकेट नहीं होते और आइटमों का मूल क्रम बना रहता है।

सूची से डुप्लिकेट हटाने के अन्य विकल्प

इस ट्यूटोरियल के पहले भाग में दिए गए विकल्प उन दो परिदृश्यों को कवर करते हैं जब सूची से डुप्लिकेट हटाने होते हैं:

1. जब आइटमों का क्रम आवश्यक न हो तो set का उपयोग करें।
2. आइटमों का क्रम बनाए रखने के लिए dict.fromkeys() का उपयोग करें।

अधिकांश स्थितियों में ये दोनों विकल्प संभवतः सर्वोत्तम समाधान हैं। हालाँकि, सूची से डुप्लिकेट हटाने की अन्य तकनीकें भी हैं।

लूप का उपयोग करके नई सूची बनाना

एक सीधा विकल्प यह है कि मूल सूची पर इटरेट करें और नए आइटमों को नई सूची में जोड़ते जाएँ:

names = ["James", "Bob", "James", "Mark", "Kate", "Sarah", "Kate"]
unique_names = []
for name in names:
    if name not in unique_names:
        unique_names.append(name)
print(unique_names)संचालित द्वारा

['James', 'Bob', 'Mark', 'Kate', 'Sarah']संचालित द्वारा

नई सूची unique_names को for लूप से पहले खाली सूची के रूप में आरंभ किया जाता है। यदि कोई आइटम पहले से इसमें नहीं है तो उसे नई सूची में जोड़ा जाता है। यह संस्करण मूल सूची के आइटमों का क्रम बनाए रखता है क्योंकि for लूप सूची में क्रम से इटरेट करता है।

बड़ी सूचियों के लिए यह समाधान अक्षम हो सकता है। मान लें कि एक लंबी सूची यादृच्छिक संख्याओं से बनी है। हम इस समाधान के प्रदर्शन की तुलना dict.fromkeys() वाले संस्करण से कर सकते हैं:

import random
import timeit
data = [random.randint(0, 100) for _ in range(100)]
use_fromkeys = "unique_data = list(dict.fromkeys(data))"
use_for_loop = """unique_data = []
for item in data:
    if item not in unique_data:
        unique_data.append(item)"""
from_keys_time = timeit.timeit(use_fromkeys, globals=globals())
for_loop_time = timeit.timeit(use_for_loop, globals=globals())
print(f"Time for 'dict.fromkeys()' version: {from_keys_time:0.2f}s")
print(f"Time for loop version: {for_loop_time:0.2f}s")संचालित द्वारा

Time for 'dict.fromkeys()' version: 2.26s
Time for loop version: 17.88sसंचालित द्वारा

timeit() फ़ंक्शन, इसी नाम के मॉड्यूल में, किसी स्टेटमेंट के निष्पादन का समय मापता है। स्टेटमेंट्स को स्ट्रिंग के रूप में timeit.timeit() को पास किया जाता है। आउटपुट दर्शाता है कि for लूप वाला संस्करण dict.fromkeys() का उपयोग करने की तुलना में काफी धीमा है। विभिन्न कंप्यूटरों और सेटअप्स पर निष्पादन समय अलग होगा, पर dict.fromkeys() विकल्प हमेशा उल्लेखनीय रूप से तेज़ रहेगा।

set के साथ सूची समेकन (list comprehension) का उपयोग

पिछले सेक्शन के for लूप को list comprehension में बदला नहीं जा सकता क्योंकि if स्टेटमेंट जाँचता है कि कोई आइटम नई सूची में पहले से जोड़ा जा चुका है या नहीं। list comprehension उपयोग करने के लिए एक अलग डेटा संरचना की आवश्यकता है। एक set का उपयोग उन आइटमों का ट्रैक रखने के लिए किया जा सकता है जो सूची में पहले से जोड़े जा चुके हैं:

names = ["James", "Bob", "James", "Mark", "Kate", "Sarah", "Kate"]
items = set()
unique_names = [name for name in names if not (name in items or items.add(name))]
print(unique_names)संचालित द्वारा

['James', 'Bob', 'Mark', 'Kate', 'Sarah']संचालित द्वारा

यह ट्यूटोरियल पूर्णता के लिए इस समाधान को दिखाता है, लेकिन यह विकल्प पठनीयता में कमी रखता है और dict.fromkeys() के मुकाबले कोई प्रदर्शन सुधार नहीं देता।

यदि नाम पहले से set items में है, तो list comprehension में कोष्ठक के भीतर का अभिव्यक्ति True होती है। or कीवर्ड के बाद वाली अभिव्यक्ति का मूल्यांकन नहीं होता जब पहला ऑपरेण्ड True हो, क्योंकि or शॉर्ट-सर्किट करता है। चूँकि कोष्ठक के भीतर की अभिव्यक्ति True है, if क्लॉज False हो जाता है और नाम unique_names में नहीं जोड़ा जाता।

जब नाम set items में नहीं होता, तो or के बाद की अभिव्यक्ति का मूल्यांकन होता है और वह नाम को set में जोड़ देती है। हालाँकि, .add() मेथड None लौटाता है, जो falsy होता है। अब if क्लॉज True होता है और नाम सूची unique_names में भी जोड़ दिया जाता है।

थर्ड-पार्टी लाइब्रेरीज़ का उपयोग

कई थर्ड-पार्टी मॉड्यूल्स में डुप्लिकेट हटाने के टूल होते हैं। more_itertools थर्ड-पार्टी लाइब्रेरी में unique_everseen() शामिल है, जो एक iterator लौटाता है जो क्रम बनाए रखते हुए अद्वितीय तत्व देता है।

टर्मिनल में pip या अन्य पैकेज मैनेजर से more_itertools इंस्टॉल किया जा सकता है:

$ pip install more_itertoolsसंचालित द्वारा

अब हम सूची से डुप्लिकेट हटाने के लिए more_itertools.unique_everseen() का उपयोग कर सकते हैं:

import more_itertools
names = ["James", "Bob", "James", "Mark", "Kate", "Sarah", "Kate"]
unique_names = list(more_itertools.unique_everseen(names))
print(unique_names)संचालित द्वारा

['James', 'Bob', 'Mark', 'Kate', 'Sarah']संचालित द्वारा

चूँकि unique_everseen() एक iterator लौटाता है, उसके आउटपुट को सूची में कास्ट किया गया है।

एक और लोकप्रिय थर्ड-पार्टी लाइब्रेरी है NumPy, जो डुप्लिकेट हटाने का समाधान भी देती है। NumPy को pip या अन्य पैकेज मैनेजर से इंस्टॉल किया जा सकता है:

$ pip install numpyसंचालित द्वारा

NumPy का unique() फ़ंक्शन अपने आर्ग्युमेंट से अद्वितीय तत्वों वाला एक NumPy array लौटाता है। इस NumPy array को NumPy के .tolist() से सूची में बदला जा सकता है:

import numpy as np
names = ["James", "Bob", "James", "Mark", "Kate", "Sarah", "Kate"]
unique_names = np.unique(names).tolist()
print(unique_names)संचालित द्वारा

['Bob', 'James', 'Kate', 'Mark', 'Sarah']संचालित द्वारा

हालाँकि, ध्यान दें कि NumPy का unique() आइटमों का क्रम नहीं बनाए रखता। इसके बजाय, यह क्रमबद्ध आइटम लौटाता है। एक और लोकप्रिय थर्ड-पार्टी लाइब्रेरी, Pandas, का unique() फ़ंक्शन भी इसी तरह काम करता है लेकिन आइटमों का क्रम बनाए रखता है। NumPy और Pandas के समाधान तब आदर्श होते हैं जब ये लाइब्रेरीज़ पहले से कोडबेस में उपयोग हो रही हों और केवल सूची से डुप्लिकेट हटाने के लिए इन्हें अलग से इंस्टॉल और इम्पोर्ट न करना पड़े।

क्या dict.fromkeys() set के उपयोग से बेहतर है?

अधिकांश मामलों में, इस ट्यूटोरियल में दिए गए पहले दो विकल्प ही सर्वोत्तम होते हैं:

1. सूची को set में कास्ट करें, और set को वापस सूची में कास्ट करें।
2. सूची से dict.fromkeys() द्वारा dictionary बनाएँ और उसे वापस सूची में कास्ट करें।

Dictionary का उपयोग आइटमों का क्रम बनाए रखता है। हालाँकि, यदि आइटमों के क्रम की आवश्यकता नहीं है, तो set का उपयोग अधिक कुशल है और बेहतर प्रदर्शन दे सकता है।

प्रदर्शन सुधार को timeit से परिमाणित किया जा सकता है:

import random
import timeit
data = [random.randint(0, 100) for _ in range(100)]
use_fromkeys = "unique_data = list(dict.fromkeys(data))"
use_set = "unique_data = list(set(data))"
from_keys_time = timeit.timeit(use_fromkeys, globals=globals())
set_time = timeit.timeit(use_set, globals=globals())
print(f"Time for 'dict.fromkeys()' version: {from_keys_time:0.2f}s")
print(f"Time for set version: {set_time:0.2f}s")संचालित द्वारा

Time for 'dict.fromkeys()' version: 2.08s
Time for set version: 1.05sसंचालित द्वारा

set का उपयोग करके सूची से डुप्लिकेट हटाना, dictionary के उपयोग की तुलना में लगभग दोगुना तेज़ है।

निष्कर्ष

Python और इसकी थर्ड-पार्टी लाइब्रेरीज़ सूची से डुप्लिकेट हटाने के कई विकल्प देती हैं।

आप इन ब्लॉग पोस्ट्स से Python सीखना जारी रख सकते हैं:

• Python में स्ट्रिंग को बाइट्स में कैसे कनवर्ट करें
• Python का yield कीवर्ड: यह क्या है और इसका उपयोग कैसे करें?