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

Question

मेरे पास दो सूचियां हैं जिन्हें मुझे संयोजित करने की आवश्यकता है जहां दूसरी सूची में पहली सूची के किसी भी डुप्लिकेट को अनदेखा किया गया है। .. समझाने में थोड़ा कठिन है, तो मुझे एक उदाहरण दिखाते हैं कि कोड क्या दिखता है, और परिणामस्वरूप मैं क्या चाहता हूं।

first_list = [1, 2, 2, 5]

second_list = [2, 5, 7, 9]

# The result of combining the two lists should result in this list:
resulting_list = [1, 2, 2, 5, 7, 9]

आप देखेंगे कि परिणाम में पहली सूची है, जिसमें इसके दो "2" मान शामिल हैं, लेकिन तथ्य यह है कि दूसरी_सूची में अतिरिक्त 2 और 5 मान भी हैं, पहली सूची में नहीं जोड़ा गया है।

आम तौर पर इस तरह से कुछ के लिए मैं सेट का उपयोग करता हूं, लेकिन First_list पर एक सेट डुप्लिकेट मानों को पहले से ही शुद्ध कर देगा। तो मैं बस सोच रहा हूँ कि इस वांछित संयोजन को प्राप्त करने का सबसे अच्छा / सबसे तेज़ तरीका क्या है।

धन्यवाद।

Comments

क्या होगा अगर वहाँ तीन 2s हैं second_list?

— बेलफा

@balpha: हाँ, मैंने पूरी तरह से तय नहीं किया है कि मैं अभी तक कैसे संभालना चाहता हूं। यह कुछ ऐसा है जिसके बारे में मैंने सोचा था, लेकिन इस मामले पर अपनी

— अनिच्छा

Answer 1

आपको दूसरी सूची के उन तत्वों को पहली सूची में संलग्न करना होगा जो पहले नहीं हैं - सेट यह निर्धारित करने का सबसे आसान तरीका है कि वे कौन से तत्व हैं:

first_list = [1, 2, 2, 5]
second_list = [2, 5, 7, 9]

in_first = set(first_list)
in_second = set(second_list)

in_second_but_not_in_first = in_second - in_first

result = first_list + list(in_second_but_not_in_first)
print(result)  # Prints [1, 2, 2, 5, 9, 7]

या यदि आप एक-लाइनर्स को पसंद करते हैं 8-)

print(first_list + list(set(second_list) - set(first_list)))

Comments

या अगर आपको इसकी आवश्यकता है तो छाँटें: प्रिंट पहले_सूची + क्रमबद्ध (सेट (दूसरी_सूची) - सेट (पहली_सूची))

— ह्यूग्डब्रोन

सूची (सेट (पहली_सूची) | सेट (दूसरी_सूची)) # | है सेट चौराहे देखने stackoverflow.com/questions/4674013/...

— staticd

@ स्टैटिक: हाँ, लेकिन यह गलत उत्तर देता है। 2आपके परिणाम में केवल एक ही है , जब उनमें से दो होने चाहिए।

— रिचीहिंडल

उफ़। आप सही हे। पूरी तरह से याद किया कि पहली सूची में डुप्लिकेट की अनुमति थी । : पी

— स्टेटिक

Answer 2

resulting_list = list(first_list)
resulting_list.extend(x for x in second_list if x not in resulting_list)

Comments

अंत में एक जवाब है कि सेट में कास्टिंग शामिल नहीं है! कुडोस।

— सुपरफैमग्यू

यह वास्तव में हे (n * m) है, लेकिन हो सकता है जब आपके पास गैर-धुली चीजों की सूची हो और प्रदर्शन चिंता का विषय न हो

— alcuadrado

क्या मैं न तो पहले से और न ही दूसरे से न तो कोई डुप्लिकेट चाहता हूं?

— देजेल

यह तकनीक सूची में विशेषताओं के क्रम को संरक्षित करती है, जो कि ऐसा नहीं है set। Sh

— सुभाष भूषण

Answer 3

आप सेट का उपयोग कर सकते हैं:

first_list = [1, 2, 2, 5]
second_list = [2, 5, 7, 9]

resultList= list(set(first_list) | set(second_list))

print(resultList)
# Results in : resultList = [1,2,5,7,9]

Comments

हाँ धन्यवाद मुझे मिल गया। यह ठीक काम करेगा। परिणाम सूची = पहली_सूची + सूची (सेट (दूसरी_सूची) -सेट (प्रथम_सूची))

— काठिरवन उम्मेदुरई

Answer 4

यदि आप संख्या का उपयोग करते हैं, तो आप इसे कोड की एक एकल पंक्ति में ला सकते हैं:

a = [1,2,3,4,5,6,7]
b = [2,4,7,8,9,10,11,12]

sorted(np.unique(a+b))

>>> [1,2,3,4,5,6,7,8,9,10,11,12]

Answer 5

first_list = [1, 2, 2, 5]
second_list = [2, 5, 7, 9]

print( set( first_list + second_list ) )

Answer 6

resulting_list = first_list + [i for i in second_list if i not in first_list]

Comments

पहली बार सेट करें और आप "सेट" कर रहे हैं

— u0b34a0f6ae

परिणामी सूची को क्रमबद्ध नहीं किया जाएगा।

— अवकर

क्या होगा अगर मैं भी नहीं चाहता कि किसी भी सूची में डुप्लिकेट हों? इस तरह यदि एक सूची में डुप्लिकेट हैं, तो वे वापस आ जाएंगे

— Dejell

Answer 7

मेरे लिए सबसे सरल है:

first_list = [1, 2, 2, 5]
second_list = [2, 5, 7, 9]

merged_list = list(set(first_list+second_list))
print(merged_list)

#prints [1, 2, 5, 7, 9]

Comments

यह एक महान समाधान है, लेकिन ध्यान रखें कि अगर हम शब्दकोशों के सरणी को एक सेट बनाने की कोशिश करेंगे तो यह काम नहीं करेगा (जैसे उठाएंगे TypeError: unhashable type: 'dict')

— lakesare

Answer 8

आप रिचीहिंडल और नेड बैचेलेडर की औसत- हे O (m + n) एल्गोरिदम के लिए प्रतिक्रियाओं को भी जोड़ सकते हैं जो ऑर्डर को संरक्षित करता है:

first_list = [1, 2, 2, 5]
second_list = [2, 5, 7, 9]

fs = set(first_list)
resulting_list = first_list + [x for x in second_list if x not in fs]

assert(resulting_list == [1, 2, 2, 5, 7, 9])

ध्यान दें कि x in sकी बुरी से बुरी हालत जटिलता है हे (एम) , तो बुरी से बुरी हालत के लिए इस कोड की जटिलता अब भी है हे (एम * एन) ।

Answer 9

यह मदद कर सकता है

def union(a,b):
    for e in b:
        if e not in a:
            a.append(e)

यदि यह पहले से ही में है, तो संघ कार्य दूसरी सूची को पहली बार में विलय कर देता है। सेट यूनियन ऑपरेटर के समान। यह फ़ंक्शन b नहीं बदलता है। यदि a = [1,2,3] b = [2,3,4]। संघ के बाद (ए, बी) एक = [1,2,3,4] और बी = [2,3,4] बनाता है

Answer 10

नुस्खा के आधार पर :

परिणामी_सूची = सूची (सेट)

Answer 11

    first_list = [1, 2, 2, 5]
    second_list = [2, 5, 7, 9]

    newList=[]
    for i in first_list:
        newList.append(i)
    for z in second_list:
        if z not in newList:
            newList.append(z)
    newList.sort()
    print newList

[१, २, २, ५, 2, ९]