निम्नलिखित उदाहरण:

string1 = "calvin klein design dress calvin klein"

मैं दूसरे दो डुप्लिकेट "calvin" और "klein" को कैसे हटा सकता हूं?

परिणाम इसकी तरह दिखना चाहिए

string2 = "calvin klein design dress"

केवल दूसरे डुप्लिकेट को हटा दिया जाना चाहिए और शब्दों का क्रम नहीं बदला जाना चाहिए!

32
burner007 17 अक्टूबर 2011, 17:08

14 जवाब

सबसे बढ़िया उत्तर
def unique_list(l):
    ulist = []
    [ulist.append(x) for x in l if x not in ulist]
    return ulist

a="calvin klein design dress calvin klein"
a=' '.join(unique_list(a.split()))
24
spicavigo 17 अक्टूबर 2011, 17:12
10
दुर्भाग्य से यह O(N²) है - in हर बार पूरे ulist से होकर गुजरता है। लंबी सूचियों के लिए इसका इस्तेमाल न करें।
 – 
Petr Viktorin
17 अक्टूबर 2011, 17:18
धन्यवाद पाब्लो। मैंने उस सूची समझ भाग को लगभग 2 साल पहले SO पर ही पाया था। तब से इसका इस्तेमाल कर रहे हैं।
 – 
spicavigo
17 अक्टूबर 2011, 17:18
@ पेट्र। यह सच है। मैंने इसे यहां इस धारणा के तहत प्रदान किया है कि सूची बहुत लंबी नहीं होने वाली है।
 – 
spicavigo
17 अक्टूबर 2011, 17:20
12
मुझे सूची समझ में परेशान करने वाली सूची में संलग्न करने का आपका उपयोग मिलता है।
 – 
Markus
17 अक्टूबर 2011, 18:17
2
एक सूची समझ अनुपयुक्त है और इसका उपयोग तब तक नहीं किया जाना चाहिए जब तक कि आप आउटपुट का उपयोग नहीं कर रहे हों। उचित for x in l: if x not in ulist: ulist.append(x) का प्रयोग करें।
 – 
Chris Morgan
18 अक्टूबर 2011, 02:47
string1 = "calvin klein design dress calvin klein"
words = string1.split()
print (" ".join(sorted(set(words), key=words.index)))

यह शब्दों की मूल सूची में शब्द की अनुक्रमणिका द्वारा आपकी स्ट्रिंग में सभी (अद्वितीय) शब्दों का सेट सॉर्ट करता है।

42
Markus 2 जिंदा 2019, 14:57

पायथन 2.7+ में, आप collections.OrderedDict का उपयोग कर सकते हैं इसके लिए:

from collections import OrderedDict
s = "calvin klein design dress calvin klein"
print ' '.join(OrderedDict((w,w) for w in s.split()).keys())
12
NPE 17 अक्टूबर 2011, 17:27
4
' '.join(OrderedDict.fromkeys(s.split())).
 – 
ekhumoro
16 फरवरी 2017, 03:44

itertools व्यंजनों से कट और पेस्ट करें

from itertools import ifilterfalse

def unique_everseen(iterable, key=None):
    "List unique elements, preserving order. Remember all elements ever seen."
    # unique_everseen('AAAABBBCCDAABBB') --> A B C D
    # unique_everseen('ABBCcAD', str.lower) --> A B C D
    seen = set()
    seen_add = seen.add
    if key is None:
        for element in ifilterfalse(seen.__contains__, iterable):
            seen_add(element)
            yield element
    else:
        for element in iterable:
            k = key(element)
            if k not in seen:
                seen_add(k)
                yield element

मैं वास्तव में चाहता हूं कि वे आगे बढ़ सकें और जल्द ही उन व्यंजनों का एक मॉड्यूल बना सकें। जब भी मुझे कुछ चाहिए, मैं कट-एंड-पेस्ट का उपयोग करने के बजाय from itertools_recipes import unique_everseen करने में सक्षम होना चाहता हूं।

ऐसे करें इस्तेमाल:

def unique_words(string, ignore_case=False):
    key = None
    if ignore_case:
        key = str.lower
    return " ".join(unique_everseen(string.split(), key=key))

string2 = unique_words(string1)
7
Lauritz V. Thaulow 17 अक्टूबर 2011, 17:44
मैंने इनमें से कुछ को समय दिया... यह बहुत तेज़ है, यहाँ तक कि लंबी सूचियों के लिए भी।
 – 
Markus
17 अक्टूबर 2011, 18:41
1
@lazyr: आपकी इच्छा के लिए, यह पता चला है कि आप बिल्कुल ऐसा कर सकते हैं। PyPI से बस पैकेज इंस्टॉल करें।
 – 
Petr Viktorin
18 अक्टूबर 2011, 02:20
यह खबर मुझे जरा भी चौंकाती नहीं है। मुझे आश्चर्य होगा अगर इसके लिए कोई PyPI पैकेज नहीं होता। मेरा मतलब यह था कि यह अजगर में शामिल बैटरी का हिस्सा होना चाहिए, क्योंकि इनका उपयोग इतनी बार किया जाता है। मैं बल्कि हैरान हूं कि वे क्यों नहीं हैं।
 – 
Lauritz V. Thaulow
19 अक्टूबर 2011, 01:38
string = 'calvin klein design dress calvin klein'

def uniquify(string):
    output = []
    seen = set()
    for word in string.split():
        if word not in seen:
            output.append(word)
            seen.add(word)
    return ' '.join(output)

print uniquify(string)
5
ekhumoro 17 अक्टूबर 2011, 17:27

आप पहले से संसाधित शब्दों का ट्रैक रखने के लिए एक सेट का उपयोग कर सकते हैं।

words = set()
result = ''
for word in string1.split():
    if word not in words:
        result = result + word + ' '
        words.add(word)
print result
2
Pablo Santa Cruz 17 अक्टूबर 2011, 17:17
2
ध्यान दें कि set एक अंतर्निर्मित प्रकार है। इसे आयात करने की कोई आवश्यकता नहीं है (जब तक कि आप पायथन के प्राचीन संस्करण का उपयोग नहीं करते हैं)।
 – 
Petr Viktorin
17 अक्टूबर 2011, 17:15
1
आपको result एक सूची बनानी चाहिए, append उसके लिए शब्द, और फिर return " ".join(result) अंत में। यह अधिक कुशल है।
 – 
Lauritz V. Thaulow
17 अक्टूबर 2011, 18:44
string2 = ' '.join(set(string1.split()))

स्पष्टीकरण:

.split() - यह स्ट्रिंग को सूची में विभाजित करने की एक विधि है (बिना पैरा के यह रिक्त स्थान से विभाजित है)
set() - यह एक प्रकार का अनियंत्रित संग्रह है जो डुप्लिकेट को बाहर करता है
'separator'.join(list) - इसका मतलब है कि आप तत्वों के बीच 'सेपरेटर' के साथ पैरा से स्ट्रिंग में सूची में शामिल होना चाहते हैं

4
Andrey Topoleov 9 नवम्बर 2018, 13:02
हालांकि यह लेखकों के प्रश्न का उत्तर दे सकता है, लेकिन इसमें कुछ व्याख्यात्मक शब्दों और/या दस्तावेज़ीकरण के लिंक का अभाव है। रॉ कोड स्निपेट उनके आस-पास के कुछ वाक्यांशों के बिना बहुत उपयोगी नहीं होते हैं। आपको एक अच्छा उत्तर कैसे लिखें बहुत उपयोगी भी मिल सकता है। कृपया अपना उत्तर संपादित करें।
 – 
hellow
9 नवम्बर 2018, 12:46
यह संभावित रूप से स्ट्रिंग में शब्दों के क्रम को बदल देता है।
 – 
parvus
8 अक्टूबर 2020, 08:39
यदि आप अंतरिक्ष के अलावा अन्य तत्वों पर विभाजित करना चाहते हैं तो यह डुप्लिकेट को नहीं हटाएगा। fe: "cisco, cisco systems, cisco".join(set(a.split())) आउटपुट करेगा: 'cisco, systems, cisco'
 – 
Tomas Pytel
12 अक्टूबर 2021, 15:34

कई उत्तर इसके बहुत करीब हैं लेकिन मैंने जहां किया है वहां काफी समाप्त नहीं हुआ है:

def uniques( your_string ):    
    seen = set()
    return ' '.join( seen.add(i) or i for i in your_string.split() if i not in seen )

बेशक, यदि आप इसे थोड़ा साफ या तेज चाहते हैं, तो हम थोड़ा सा रिफैक्टर कर सकते हैं:

def uniques( your_string ):    
    words = your_string.split()

    seen = set()
    seen_add = seen.add

    def add(x):
        seen_add(x)  
        return x

    return ' '.join( add(i) for i in words if i not in seen )

मुझे लगता है कि दूसरा संस्करण उतना ही निष्पादक है जितना आप कोड की एक छोटी राशि में प्राप्त कर सकते हैं। (इनपुट स्ट्रिंग में एक ही स्कैन में सभी कार्य करने के लिए अधिक कोड का उपयोग किया जा सकता है, लेकिन अधिकांश कार्यभार के लिए, यह पर्याप्त होना चाहिए।)

1
Chris Phillips 18 अक्टूबर 2011, 02:13

11 और 2 पूरी तरह से काम करते हैं:

    s="the sky is blue very blue"
    s=s.lower()
    slist = s.split()
    print " ".join(sorted(set(slist), key=slist.index))

और 2

    s="the sky is blue very blue"
    s=s.lower()
    slist = s.split()
    print " ".join(sorted(set(slist), key=slist.index))
0
the chib 17 अप्रैल 2016, 19:38
यह key तर्क कैसे काम करता है? मैं इसे दस्तावेज़ीकरण में नहीं ढूंढ सका।
 – 
xuanyue
19 अगस्त 2016, 23:49

प्रश्न: एक स्ट्रिंग में डुप्लिकेट निकालें

 from _collections import OrderedDict

    a = "Gina Gini Gini Protijayi"

    aa = OrderedDict().fromkeys(a.split())
    print(' '.join(aa))
   # output => Gina Gini Protijayi
0
Soudipta Dutta 17 जून 2018, 02:44

आप निम्नलिखित कोड का उपयोग करके टेक्स्ट फ़ाइल या स्ट्रिंग से डुप्लिकेट या दोहराए गए शब्दों को हटा सकते हैं -

from collections import Counter
for lines in all_words:

    line=''.join(lines.lower())
    new_data1=' '.join(lemmatize_sentence(line))
    new_data2 = word_tokenize(new_data1)
    new_data3=nltk.pos_tag(new_data2)

    # below code is for removal of repeated words

    for i in range(0, len(new_data3)):
        new_data3[i] = "".join(new_data3[i])
    UniqW = Counter(new_data3)
    new_data5 = " ".join(UniqW.keys())
    print (new_data5)


    new_data.append(new_data5)


print (new_data)

पी.एस. -आवश्यकता के अनुसार पहचान करें। उम्मीद है की यह मदद करेगा!!!

0
rahul ranjan 25 जून 2018, 10:22

आप ऐसा केवल स्ट्रिंग से जुड़े सेट को प्राप्त करके कर सकते हैं, जो एक गणितीय वस्तु है जिसमें परिभाषा के अनुसार कोई दोहराए गए तत्व नहीं हैं। यह सेट में शब्दों को वापस एक स्ट्रिंग में जोड़ने के लिए पर्याप्त है:

def remove_duplicate_words(string):
        x = string.split()
        x = sorted(set(x), key = x.index)
        return ' '.join(x)
-1
Mffd4n1 9 अक्टूबर 2020, 12:36
हालांकि यह लेखकों के प्रश्न का उत्तर दे सकता है, लेकिन इसमें कुछ व्याख्यात्मक शब्दों और/या दस्तावेज़ीकरण के लिंक का अभाव है। रॉ कोड स्निपेट उनके आस-पास के कुछ वाक्यांशों के बिना बहुत उपयोगी नहीं होते हैं। आपको एक अच्छा उत्तर कैसे लिखें बहुत उपयोगी भी मिल सकता है। कृपया अपना उत्तर संपादित करें।
 – 
hellow
9 नवम्बर 2018, 12:46
यह संभावित रूप से स्ट्रिंग में शब्दों के क्रम को बदल देता है।
 – 
parvus
8 अक्टूबर 2020, 08:38
धन्यवाद @parvus मैंने अपना उत्तर संशोधित कर दिया है
 – 
Mffd4n1
9 अक्टूबर 2020, 12:37

स्प्लिट फ़ंक्शन का उपयोग किए बिना (साक्षात्कार में मदद करेगा)

def unique_words2(a):
    words = []
    spaces = ' '
    length = len(a)
    i = 0
    while i < length:
        if a[i] not in spaces:
            word_start = i
            while i < length and a[i] not in spaces:
                i += 1
            words.append(a[word_start:i])
        i += 1
    words_stack = []
    for val in words:  #
        if val not in words_stack:  # We can replace these three lines with this one -> [words_stack.append(val) for val in words if val not in words_stack]
            words_stack.append(val)  #
    print(' '.join(words_stack))  # or return, your choice


unique_words2('calvin klein design dress calvin klein') 
0
Taazar 6 मार्च 2020, 16:45

Numpy फ़ंक्शन का उपयोग करें आयात के लिए उपनाम रखने के लिए आयात को बेहतर बनाएं (एनपी के रूप में)

import numpy as np

और फिर आप सरणी से डुप्लीकेट हटाने के लिए इसे इस तरह बिंग कर सकते हैं, आप इसे इस तरह से उपयोग कर सकते हैं

no_duplicates_array = np.unique(your_array)

आपके मामले के लिए यदि आप स्ट्रिंग में परिणाम चाहते हैं तो आप इसका उपयोग कर सकते हैं

no_duplicates_string = ' '.join(np.unique(your_string.split()))
1
Sulman Malik 8 जून 2020, 15:04