python पायथन में दो सूचियों को कैसे सम्मिलित करें?




list (20)

मैं पायथन में दो सूचियों को कैसे जोड़ूं?

उदाहरण:

listone = [1, 2, 3]
listtwo = [4, 5, 6]

अनुमानित परिणाम:

>>> joinedlist
[1, 2, 3, 4, 5, 6]

एक जनरेटर बनाना भी संभव है जो दोनों सूचियों में आइटमों पर आसानी से पुनरावृत्त हो। यह आपको एक नई सूची में आइटम कॉपी किए बिना प्रोसेसिंग के लिए चेन सूचियों (या किसी भी पुनरावर्तनीय) को एक साथ करने की अनुमति देता है:

import itertools
for item in itertools.chain(listone, listtwo):
   # do something with each list item

lst1 = [1,2]

lst2 = [3,4]

def list_combinationer(Bushisms, are_funny):

    for item in lst1:
        lst2.append(item)
        lst1n2 = sorted(lst2)
        print lst1n2

list_combinationer(lst1, lst2)

[1,2,3,4]

अधिक सूचियों के लिए एक सामान्य तरीका के रूप में आप उन्हें एक सूची में डाल सकते हैं और itertools.chain.from_iterable() 1 फ़ंक्शन का उपयोग कर सकते हैं जो THIS उत्तर पर आधारित है, नेस्टेड सूची को फ़्लैट करने का सबसे अच्छा तरीका है:

>>> l=[[1, 2, 3], [4, 5, 6], [7, 8, 9]]
>>> import itertools
>>> list(itertools.chain.from_iterable(l))
[1, 2, 3, 4, 5, 6, 7, 8, 9] 

1. ध्यान दें कि chain.from_iterable() python => 2.6 में उपलब्ध है। अन्य संस्करणों में chain(*l) उपयोग करें chain(*l)


आप अद्वितीय मानों की विलय सूची प्राप्त करने के लिए सेट का उपयोग कर सकते हैं

mergedlist = list(set(listone + listtwo))

पायथन >= 3.5 वैकल्पिक: [*l1, *l2]

हालांकि यह एक पुराना उत्तर है, PEP 448 की स्वीकृति के माध्यम से एक और विकल्प पेश किया गया है जो उल्लेख करने योग्य है।

अतिरिक्त अनपॅकिंग सामान्यीकरण नामक पीईपी, पाइथन में तारांकित * अभिव्यक्ति का उपयोग करते समय आम तौर पर कुछ वाक्य रचनात्मक प्रतिबंधों को कम करता है; इसके साथ, दो सूचियों में शामिल होना (किसी भी पुनरावर्तनीय पर लागू होता है) अब भी साथ किया जा सकता है:

>>> l1 = [1, 2, 3]
>>> l2 = [4, 5, 6]

#unpack both iterables in a list literal
>>> joinedList = [*l1, *l2]
>>> print(joinedList)
[1, 2, 3, 4, 5, 6]

यह कार्यक्षमता पायथन 3.5 लिए परिभाषित की गई थी, इसे 3.x परिवार में पिछले संस्करणों में वापस नहीं भेजा गया है। असमर्थित संस्करणों में एक SyntaxError उठाया जा रहा है।

अन्य दृष्टिकोणों के साथ, यह भी संबंधित सूचियों में तत्वों की उथली प्रति के रूप में बनाता है

इस दृष्टिकोण के ऊपर यह है कि आपको इसे करने के लिए वास्तव में सूचियों की आवश्यकता नहीं है, जो कुछ भी करने योग्य है, वह करेगा। पीईपी में कहा गया है:

यह एक सूची में my_list + list(my_tuple) + list(my_range) को my_list + list(my_tuple) + list(my_range) करने के एक और अधिक पठनीय तरीके के रूप में भी उपयोगी है, जैसे my_list + list(my_tuple) + list(my_range) जो अब [*my_list, *my_tuple, *my_range]

तो जब टाइप के साथ + टाइप TypeError कारण TypeError बढ़ाएगा:

l = [1, 2, 3]
r = range(4, 7)
res = l + r

निम्नलिखित नहीं होगा:

res = [*l, *r]

क्योंकि यह पहले पुनरावृत्तियों की सामग्री को अनपैक कर देगा और फिर सामग्री से केवल एक list बनाएं।


यदि आपको जटिल सॉर्टिंग नियमों के साथ दो आदेशित सूचियों को मर्ज करने की आवश्यकता है, तो आपको इसे निम्न कोड (जैसे पठनीयता :-) के लिए एक सरल सॉर्टिंग नियम का उपयोग करके) में स्वयं को रोल करना पड़ सकता है।

list1 = [1,2,5]
list2 = [2,3,4]
newlist = []

while list1 and list2:
    if list1[0] == list2[0]:
        newlist.append(list1.pop(0))
        list2.pop(0)
    elif list1[0] < list2[0]:
        newlist.append(list1.pop(0))
    else:
        newlist.append(list2.pop(0))

if list1:
    newlist.extend(list1)
if list2:
    newlist.extend(list2)

assert(newlist == [1, 2, 3, 4, 5])

list जोड़ने के लिए आप extend भी उपयोग कर सकते हैं दूसरे के अंत को जोड़ें:

listone = [1,2,3]
listtwo = [4,5,6]
mergedlist = []
mergedlist.extend(listone)
mergedlist.extend(listtwo)

आप list वस्तुओं पर परिभाषित append() विधि का उपयोग कर सकते हैं:

mergedlist =[]
for elem in listone:
    mergedlist.append(elem)
for elem in listtwo:
    mergedlist.append(elem)

यदि आप प्लस ऑपरेटर ( + ) का उपयोग नहीं कर सकते हैं, तो आप __add__ फ़ंक्शन का उपयोग कर सकते हैं:

listone = [1,2,3]
listtwo = [4,5,6]

result = list.__add__(listone, listtwo)
print(result)

>>> [1, 2, 3, 4, 5, 6]

वैकल्पिक रूप से, यदि आपको dunders के उपयोग को पसंद नहीं है तो आप operator आयात का उपयोग कर सकते हैं:

import operator

listone = [1,2,3]
listtwo = [4,5,6]

result = operator.add(listone, listtwo)
print(result)

>>> [1, 2, 3, 4, 5, 6]

कोई तर्क दे सकता है कि यह थोड़ा और पठनीय है।


आप extend समारोह के लिए जा सकते हैं।

l1 = [1,2,3]
l2 = [4,5,6]
l1.extend(l2)
print l1

आउटपुट: [1,2,3,4,5,6]


पायथन 3.3+ के साथ आप उपज का उपयोग कर सकते हैं:

listone = [1,2,3]
listtwo = [4,5,6]

def merge(l1, l2):
    yield from l1
    yield from l2

>>> list(merge(listone, listtwo))
[1, 2, 3, 4, 5, 6]

या, यदि आप पुनरावृत्तियों की मनमानी संख्या का समर्थन करना चाहते हैं:

def merge(*iters):
    for it in iters:
        yield from it

>>> list(merge(listone, listtwo, 'abcd', [20, 21, 22]))
[1, 2, 3, 4, 5, 6, 'a', 'b', 'c', 'd', 20, 21, 22]

यह काफी सरल है, मुझे लगता है कि यह tutorial में भी दिखाया गया था:

>>> listone = [1,2,3]
>>> listtwo = [4,5,6]
>>>
>>> listone + listtwo
[1, 2, 3, 4, 5, 6]

import itertools

A = list(zip([1,3,5,7,9],[2,4,6,8,10]))
B = [1,3,5,7,9]+[2,4,6,8,10]
C = list(set([1,3,5,7,9] + [2,4,6,8,10]))

D = [1,3,5,7,9]
D.append([2,4,6,8,10])

E = [1,3,5,7,9]
E.extend([2,4,6,8,10])

F = []
for a in itertools.chain([1,3,5,7,9], [2,4,6,8,10]):
    F.append(a)


print ("A: " + str(A))
print ("B: " + str(B))
print ("C: " + str(C))
print ("D: " + str(D))
print ("E: " + str(E))
print ("F: " + str(F))

आउटपुट:

A: [(1, 2), (3, 4), (5, 6), (7, 8), (9, 10)]
B: [1, 3, 5, 7, 9, 2, 4, 6, 8, 10]
C: [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
D: [1, 3, 5, 7, 9, [2, 4, 6, 8, 10]]
E: [1, 3, 5, 7, 9, 2, 4, 6, 8, 10]
F: [1, 3, 5, 7, 9, 2, 4, 6, 8, 10]

पायथन में दो सूचियों में शामिल होना:

>>> a = [1, 2, 3, 4]
>>> b = [1, 4, 6, 7]
>>> c = a + b
>>> c
[1, 2, 3, 4, 1, 4, 6, 7]

यदि आप कोई डुप्लिकेशन नहीं चाहते हैं:

>>> a = [1, 2, 3, 4, 5, 6]
>>> b = [5, 6, 7, 8]
>>> c = list(set(a + b))
>>> c
[1, 2, 3, 4, 5, 6, 7, 8]

यदि आप दो पुरानी सूचियां रखते हुए एक नई सूची चाहते थे:

joinedList = []
for i in listOne:
    joinedList.append(i)
for j in listTwo:
    joinedList.append(j)

sorted(joinedList)

return joinedList

आप निम्नानुसार + या += ऑपरेटर का उपयोग कर सकते हैं:

a = [1, 2, 3]
b = [4, 5, 6]

c = a + b

या:

c = []
a = [1, 2, 3]
b = [4, 5, 6]

c += (a + b)

साथ ही, यदि आप मर्ज किए गए सूची में मान अद्वितीय होना चाहते हैं तो आप यह कर सकते हैं:

c = list(set(a + b))

list(set(listone) | set(listtwo))

उपर्युक्त कोड, आदेश को संरक्षित नहीं करता है, प्रत्येक सूची से डुप्लिकेट हटा देता है (लेकिन समेकित सूची से नहीं)


यदि आप क्रमबद्ध रूप में दो सूचियों को मर्ज करना चाहते हैं, तो आप हेपैक लाइब्रेरी से मर्ज फ़ंक्शन का उपयोग कर सकते हैं।

from heapq import merge

a = [1,2,4]
b = [2,4,6,7]

print list(merge(a,b))

यह सवाल सीधे दो सूचियों में शामिल होने के बारे में पूछता है। हालांकि, जब आप कई सूचियों में शामिल होने का तरीका ढूंढ रहे हैं, तब भी यह खोज में बहुत अधिक है (जब आप शून्य सूचियों में शामिल होते हैं)। इस अधिक सामान्य दृष्टिकोण पर विचार करें:

a = [[1,2,3], [4,5,6], [7,8,9]]
reduce(lambda c, x: c + x, a, [])

आउटपुट होगा:

[1, 2, 3, 4, 5, 6, 7, 8, 9]

ध्यान दें, यह a [] या [[1,2,3]] होने पर भी सही तरीके से काम करता है।

हालांकि, इसे itertools साथ अधिक कुशलता से किया जा सकता है:

a = [[1,2,3], [4,5,6], [7,8,9]]
list(itertools.chain(*a))

यदि आपको किसी list आवश्यकता नहीं है, लेकिन केवल एक पुनरावृत्त है, तो list() छोड़ दें list()

अद्यतन करें

टिप्पणियों में पैट्रिक कॉलिन्स द्वारा सुझाए गए वैकल्पिक भी आपके लिए काम कर सकते हैं:

sum(a, [])

आप फ़ंक्शन का extends कर सकते हैं

listone.extends(listtwo)






list