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

उदाहरण:

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

अपेक्षित परिणाम:

>>> joinedlist
[1, 2, 3, 4, 5, 6]
3172
y2k 12 नवम्बर 2009, 10:04
11
क्या आप केवल संलग्न करना चाहते हैं, या आप दो सूचियों को क्रमबद्ध क्रम में मर्ज करना चाहते हैं? [1,3,6] और [2,4,5] के लिए आप किस आउटपुट की अपेक्षा करते हैं? क्या हम मान सकते हैं कि दोनों उपन्यासकार पहले से ही क्रमबद्ध हैं (जैसा कि आपके उदाहरण में है)?
 – 
smci
12 सितंबर 2015, 10:51
2
... क्या होगा यदि सूचियों में डुप्लीकेट हैं उदा। [1,2,5] and [2,4,5,6]? क्या आप चाहते हैं कि डुप्लीकेट शामिल हों, बहिष्कृत हों, या परवाह न करें?
 – 
smci
12 जिंदा 2020, 23:15
8
अगर किसी को यह उपयोगी लगे तो मैंने सूचियों को जोड़ने के 6 तरीकों पर एक यूट्यूब ट्यूटोरियल बनाया youtube.com/watch? v=O5kJ1v9XrDw
 – 
Brendan Metcalfe
25 जून 2020, 21:48

29 जवाब

सबसे बढ़िया उत्तर

आप उन्हें संयोजित करने के लिए + ऑपरेटर का उपयोग कर सकते हैं:

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

joinedlist = listone + listtwo

आउटपुट:

>>> joinedlist
[1, 2, 3, 4, 5, 6]
4750
Boris 21 सितंबर 2021, 09:19
140
क्या यह लिस्टोन की एक गहरी प्रति बनाता है और सूची दो को जोड़ता है?
 – 
Daniel F
19 अप्रैल 2012, 16:34
189
यह पहली सूची में वस्तुओं की उथली प्रतिलिपि के साथ एक नई सूची बनाएगा, उसके बाद दूसरी सूची में वस्तुओं की उथली प्रति। सूचियों की गहरी प्रतियां प्राप्त करने के लिए copy.deepcopy का प्रयोग करें।
 – 
Daniel G
19 अप्रैल 2012, 18:51
271
यहां एक और उपयोगी विवरण: listone += listtwo परिणाम listone == [1, 2, 3, 4, 5, 6]
 – 
rickcnagy
29 जिंदा 2014, 20:14
19
क्या वह बदल जाएगा जो लिस्टोन इंगित कर रहा है? तो:list3 = listone listone+=listtwo क्या सूची3 भी बदल गई है?
 – 
MikeH
19 फरवरी 2014, 09:01
13
यह सूची 3 बदलता है। हालांकि, अगर यह कोई समस्या नहीं है, तो नई सूचियां बनाने के बजाय दो सूचियां जोड़ना अधिक आसान है।
 – 
rickcnagy
20 फरवरी 2014, 22:55

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

mergedlist = list(set(listone + listtwo))
247
thefourtheye 2 अप्रैल 2014, 11:28
59
सच है, हालांकि, यह डुप्लिकेट को भी हटा देगा, यदि आप इसमें रुचि रखते हैं। साथ में सूची जोड़ने से ऐसा नहीं होगा।
 – 
metasoarous
21 अगस्त 2012, 04:28
2
ऐसा करने और आदेश देने की जानकारी रखने का तरीका क्या है?
 – 
Natim
29 जिंदा 2013, 17:12
14
listone + [x for x in listtwo if x not in listone] से बेहतर
 – 
Natim
29 जिंदा 2013, 17:13
9
+1 आईएमएचओ यह "मर्ज" (संघ) सूचियों का सही तरीका है जबकि "स्वीकृत" उत्तर बताता है कि सूचियों को कैसे जोड़ना/जोड़ना है (मल्टीसेट)
 – 
Nir Alfasi
27 अप्रैल 2014, 08:07
3
यदि आप इनपुट ऑर्डर बनाए रखने की परवाह करते हैं, तो import collections; mergedlist = list(collections.OrderedDict.fromkeys(listone + listtwo)) चाल चल जाएगी।
 – 
SethMMorton
15 पद 2016, 23:11

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

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

listone.extend(listtwo)

यदि आप मूल सूची को बरकरार रखना चाहते हैं, तो आप एक नया list ऑब्जेक्ट और extend दोनों सूचियां बना सकते हैं:

mergedlist = []
mergedlist.extend(listone)
mergedlist.extend(listtwo)
252
4 revs, 3 users 57% 30 मई 2020, 21:02
2
मेरे मामले में यह विधि None क्यों लौटाती है?
 – 
Ayush
15 जुलाई 2021, 12:10
1
listone = [1,2,3]; listtwo = [4,5,6]; listone.extend(listtwo) यह मुझे लौटाता है None
 – 
Ayush
15 जुलाई 2021, 12:15
1
यह listone में यथास्थान अद्यतन करता है। तो जांचें कि वह सूची में है listone
 – 
Gourneau
16 जुलाई 2021, 20:33
वास्तव में मैं एक अभिव्यक्ति लौटा रहा हूँ जहाँ मैं आपके द्वारा बताई गई विधि का उपयोग करके एक सूची का विस्तार कर रहा हूँ। जैसा कि इस पोस्ट में कहा गया है, मैं सूची को दोबारा असाइन नहीं कर रहा हूं। मेरी अभिव्यक्ति कुछ इस तरह है return list1.extend(list2) और यह अभिव्यक्ति मेरे पास None लौटाती है।
 – 
Ayush
17 जुलाई 2021, 20:45

यह काफी सरल है, और मुझे लगता है कि इसे ट्यूटोरियल में भी दिखाया गया था:

>>> listone = [1,2,3]
>>> listtwo = [4,5,6]
>>>
>>> listone + listtwo
[1, 2, 3, 4, 5, 6]
89
Peter Mortensen 17 मार्च 2019, 12:15

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

3.9 तक, ये अजगर में दो (या अधिक) सूचियों को जोड़ने के लिए सबसे लोकप्रिय stdlib तरीके हैं।

enter image description here

फुटनोट

  1. इसकी संक्षिप्तता के कारण यह एक स्लीक सॉल्यूशन है। लेकिन sum जोड़-तोड़ रूप में संयोजन करता है, जिसका अर्थ है कि यह एक है स्मृति के रूप में द्विघात संचालन को प्रत्येक चरण के लिए आवंटित किया जाना है। करना यदि आपकी सूचियां बड़ी हैं तो उपयोग न करें।

  2. देखें chain तथा chain.from_iterable डॉक्स से। आपको पहले import itertools करना होगा। स्मृति में संयोजन रैखिक है, इसलिए यह के संदर्भ में सबसे अच्छा है प्रदर्शन और संस्करण संगतता। chain.from_iterable को 2.6 में पेश किया गया था।

  3. यह विधि अतिरिक्त अनपैकिंग सामान्यीकरण (PEP 448) का उपयोग करती है, लेकिन नहीं कर सकती N सूचियों को तब तक सामान्यीकृत करें जब तक कि आप प्रत्येक को स्वयं मैन्युअल रूप से अनपैक न करें।

  4. a += b और a.extend(b) कमोबेश सभी व्यावहारिक उद्देश्यों के समकक्ष हैं। += किसी सूची में बुलाए जाने पर आंतरिक रूप से कॉल करेगा list.__iadd__, जो पहली सूची को दूसरी तक बढ़ा देता है।


प्रदर्शन

2-सूची संयोजन1

enter image description here

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

एन-सूची संयोजन

enter image description here

perfplot मॉड्यूल का उपयोग करके प्लॉट तैयार किए गए हैं। कोड, आपके संदर्भ के लिए।

1. iadd (+=) और extend विधियां जगह-जगह काम करती हैं, इसलिए परीक्षण से पहले हर बार एक कॉपी तैयार करनी पड़ती है। चीजों को निष्पक्ष रखने के लिए, सभी विधियों में बाएं हाथ की सूची के लिए एक पूर्व-प्रतिलिपि चरण होता है जिसे अनदेखा किया जा सकता है।


अन्य समाधान पर टिप्पणियाँ

  • डंडर विधि list.__add__ का सीधे किसी भी रूप, आकार या रूप में उपयोग न करें। वास्तव में, डंडर विधियों से दूर रहें, और ऑपरेटरों और operator फ़ंक्शंस का उपयोग करें जैसे वे डिज़ाइन किए गए थे। पायथन के पास सावधानीपूर्वक शब्दार्थ हैं, जो सीधे डंडर को कॉल करने की तुलना में अधिक जटिल हैं। यह रहा एक उदाहरण। तो, संक्षेप में, a.__add__(b) => खराब; a + b => अच्छा।

  • यहाँ कुछ उत्तर जोड़ीवार संयोजन के लिए reduce(operator.add, [a, b]) प्रदान करते हैं -- यह sum([a, b], []) के समान ही अधिक चिंताजनक है।

  • कोई भी विधि जो set का उपयोग करती है, डुप्लीकेट छोड़ देगी और ऑर्डर देना खो देगी। सावधानी से प्रयोग करें।

  • for i in b: a.append(i), a.extend(b) की तुलना में अधिक चिंताजनक और धीमा है, जो कि सिंगल फंक्शन कॉल और अधिक मुहावरेदार है। append शब्दार्थ के कारण धीमा है जिसके साथ स्मृति आवंटित की जाती है और सूचियों के लिए विकसित की जाती है। इसी तरह की चर्चा के लिए यहां देखें।

  • heapq.merge काम करेगा, लेकिन इसका उपयोग मामला रैखिक समय में क्रमबद्ध सूचियों को मर्ज करने के लिए है। किसी अन्य स्थिति में इसका उपयोग करना एक विरोधी पैटर्न है।

  • yieldकिसी फ़ंक्शन से सूची तत्वों को शामिल करना एक स्वीकार्य तरीका है, लेकिन chain इसे तेज़ और बेहतर तरीके से करता है (इसमें C में एक कोड पथ है, इसलिए यह तेज़ है)।

  • operator.add(a, b) a + b के बराबर एक स्वीकार्य कार्यात्मक है। इसका उपयोग के मामले मुख्य रूप से गतिशील विधि प्रेषण के लिए हैं। अन्यथा, a + b को प्राथमिकता दें जो छोटा और अधिक पठनीय हो, मेरी राय में। वाईएमएमवी।

205
cs95 25 जुलाई 2020, 09:36
stackoverflow.com/q/36863404/125507 के उत्तर एक परफप्लॉट प्लॉट (सुंबा समाधान सहित) का उपयोग कर सकते हैं।
 – 
endolith
21 अगस्त 2019, 04:31
थोड़ा काम के साथ बह गया, लेकिन मैं देख लूंगा और देख सकता हूं कि क्या मैं चिप कर सकता हूं। Ty।
 – 
cs95
21 अगस्त 2019, 20:52
प्रदर्शन के अनुसार सबसे अच्छा तरीका कौन सा है, तेज़? बता।
 – 
GD- Ganesh Deshmukh
19 मई 2020, 08:06
1
टीएल; डीआर वे सभी अच्छे हैं और आप जो चुनते हैं वह ज्यादातर शैली का मामला है। "There's not much difference between these methods but that makes sense given they all have the same order of complexity (linear). There's no particular reason to prefer one over the other except as a matter of style." समाधान मेरे उत्तर में सूचीबद्ध नहीं हैं, या "टिप्पणियां" में आलोचना की गई है, मैं अनुशंसा करता हूं कि इसका उपयोग न करें।
 – 
cs95
19 मई 2020, 23:21

यह प्रश्न सीधे दो सूचियों में शामिल होने के बारे में पूछता है। हालाँकि, यह खोज में बहुत अधिक है, तब भी जब आप कई सूचियों में शामिल होने का तरीका खोज रहे हैं (उस मामले सहित जब आप शून्य सूचियों में शामिल होते हैं)।

मुझे लगता है कि सूची समझ का उपयोग करने का सबसे अच्छा विकल्प है:

>>> a = [[1,2,3], [4,5,6], [7,8,9]]
>>> [x for xs in a for x in xs]
[1, 2, 3, 4, 5, 6, 7, 8, 9]

आप जनरेटर भी बना सकते हैं:

>>> map(str, (x for xs in a for x in xs))
['1', '2', '3', '4', '5', '6', '7', '8', '9']

पुराना उत्तर

इस अधिक सामान्य दृष्टिकोण पर विचार करें:

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() को छोड़ दें।

अपडेट करें

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

sum(a, [])
62
wonder.mice 4 सितंबर 2018, 21:15
6
पायथन 3 नोट: reduce अब functools में है, इसलिए आपको इसे पहले आयात करना होगा।
 – 
Dimitris Fasarakis Hilliard
24 जुलाई 2017, 21:00

आप बस + या += ऑपरेटर का उपयोग इस प्रकार कर सकते हैं:

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))
47
Peter Mortensen 22 पद 2013, 13:21
2
अंतिम भाग वस्तुओं को मनमाने ढंग से पुन: क्रमित कर सकता है। यदि आप ऑर्डर सुरक्षित रखना चाहते हैं, तो CPython 3.6+ पर आप list(dict.fromkeys(a + b)) कर सकते हैं
 – 
Boris
24 नवम्बर 2019, 05:29

यह ध्यान देने योग्य है कि itertools.chain फ़ंक्शन तर्कों की चर संख्या को स्वीकार करता है:

>>> l1 = ['a']; l2 = ['b', 'c']; l3 = ['d', 'e', 'f']
>>> [i for i in itertools.chain(l1, l2)]
['a', 'b', 'c']
>>> [i for i in itertools.chain(l1, l2, l3)]
['a', 'b', 'c', 'd', 'e', 'f']

यदि एक पुनरावर्तनीय (टपल, सूची, जनरेटर, आदि) इनपुट है, तो from_iterable वर्ग विधि का उपयोग किया जा सकता है:

>>> il = [['a'], ['b', 'c'], ['d', 'e', 'f']]
>>> [i for i in itertools.chain.from_iterable(il)]
['a', 'b', 'c', 'd', 'e', 'f']
33
Dariusz Walczak 5 फरवरी 2013, 09:01

Python 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]
30
user688635user688635 21 जुलाई 2014, 04:53
1
आप इसके बजाय itertools.chain (जो समतुल्य है) का उपयोग कर सकते हैं अपने स्वयं के कार्य को परिभाषित करने के लिए।
 – 
Boris
22 नवम्बर 2019, 15:49

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

from heapq import merge

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

print list(merge(a, b))
25
Peter Mortensen 17 मार्च 2019, 12:19

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

import operator

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

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

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

वैकल्पिक रूप से, आप __add__ dunder फ़ंक्शन का भी उपयोग कर सकते हैं:

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

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

>>> [1, 2, 3, 4, 5, 6]
18
jpihl 4 जून 2019, 10:09
4
डंडर्स को हथियाना आम तौर पर सबसे अच्छा तरीका नहीं है। अगर + टेबल से बाहर है, तो operator.add का इस्तेमाल करें।
 – 
Dimitris Fasarakis Hilliard
4 जुलाई 2017, 15:00
2
प्लस ऑपरेटर अनुपलब्ध क्यों होगा?
 – 
cs01
25 जून 2018, 22:36
2
आम तौर पर यह नहीं होगा :) लेकिन यदि आप मानचित्र फ़ंक्शन के साथ सूची संयोजन कर रहे हैं या ऐड फ़ंक्शन को एक चर में संग्रहीत करना चाहते हैं, तो आप + का उपयोग नहीं कर सकते।
 – 
jpihl
26 जून 2018, 07:30

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

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])
13
Peter Mortensen 22 पद 2013, 13:23
या बस heapq.merge का उपयोग करें।
 – 
cs95
4 जून 2019, 07:21

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

mergedlist =[]
for elem in listone:
    mergedlist.append(elem)
for elem in listtwo:
    mergedlist.append(elem)
7
Dimitris Fasarakis Hilliard 5 मई 2016, 12:05
9
जैसा कि आप जानते हैं, यदि आप अभ्यास में यही कर रहे हैं, तो यह अन्य प्रस्तावित विधियों की तुलना में बहुत धीमा है। देखें ए>
 – 
Ryan Haining
16 जुलाई 2013, 06:10
list(set(listone) | set(listtwo))

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

7
SuperNova 7 जुलाई 2016, 10:42

जैसा कि पहले ही कई लोगों ने बताया है, itertools.chain() अगर दोनों सूचियों में बिल्कुल एक जैसे व्यवहार को लागू करने की आवश्यकता है तो जाने का रास्ता है। मेरे मामले में, मेरे पास एक लेबल और एक झंडा था जो एक सूची से दूसरी सूची में भिन्न था, इसलिए मुझे कुछ और जटिल चाहिए। जैसा कि यह पता चला है, पर्दे के पीछे itertools.chain() बस निम्न कार्य करता है:

for it in iterables:
    for element in it:
        yield element

(देखें https://docs.python.org/2/library/itertools.html), इसलिए मैंने यहाँ से प्रेरणा ली और इन पंक्तियों के साथ कुछ लिखा:

for iterable, header, flag in ( (newList, 'New', ''), (modList, 'Modified', '-f')):
    print header + ':'
    for path in iterable:
        [...]
        command = 'cp -r' if os.path.isdir(srcPath) else 'cp'
        print >> SCRIPT , command, flag, srcPath, mergedDirPath
        [...]

यहां समझने के लिए मुख्य बिंदु यह हैं कि सूचियां केवल चलने योग्य का एक विशेष मामला है, जो किसी अन्य की तरह वस्तुएं हैं; और वह for ... in अजगर में लूप टपल चर के साथ काम कर सकता है, इसलिए एक ही समय में कई चर पर लूप करना आसान है।

6
Francesco Marchetti-Stasi 2 नवम्बर 2015, 21:59

एक साधारण सूची समझ का प्रयोग करें:

joined_list = [item for list_ in [list_one, list_two] for item in list_]

इसमें अतिरिक्त अनपैकिंग सामान्यीकरण का उपयोग करने के नवीनतम दृष्टिकोण के सभी लाभ हैं - अर्थात आप इस तरह से अलग-अलग पुनरावृत्तियों (उदाहरण के लिए, सूचियाँ, टुपल्स, रेंज और जनरेटर) की एक मनमानी संख्या को जोड़ सकते हैं - और यह पायथन 3.5 या बाद के संस्करण तक सीमित नहीं है।

8
z33k 23 अप्रैल 2019, 23:39

सूचियों की सूची को संयोजित करने का एक बहुत ही संक्षिप्त तरीका है

list_of_lists = [[1,2,3], [4,5,6], [7,8,9]]
reduce(list.__add__, list_of_lists)

जो हमें देता है

[1, 2, 3, 4, 5, 6, 7, 8, 9]
5
Akash Singh 29 जून 2018, 15:16
1
कृपया list.__add__ का उपयोग न करें, इसके बजाय operator.add का उपयोग करें। यह sum(list_of_lists, []) का अधिक चिंताजनक समकक्ष है जो उतना ही बुरा है। उपयोग नहीं करो!
 – 
cs95
4 जून 2019, 05:38
क्या आप सूची का उपयोग करके समझा सकते हैं कि समस्या क्या है।__ जोड़ें__
 – 
Akash Singh
7 जून 2019, 01:31
1
डंडर विधियां "निजी तरीके" हैं और आमतौर पर सीधे उपयोग नहीं की जानी चाहिए (उन्हें अन्य कार्यों द्वारा बुलाया जाता है)। अपवाद obj.__class__ और obj.__dict__ हैं।
 – 
cs95
7 जून 2019, 01:33
और अगर __add__ बहुत निम्न-स्तर और अस्थिर (परिवर्तन की संभावना) लगता है, तो आप इसके बजाय np.union1d का उपयोग कर सकते हैं।
 – 
mirekphd
24 सितंबर 2021, 16:02

यदि आप NumPy का उपयोग कर रहे हैं, तो आप इस कमांड के साथ संगत आयामों के दो सरणियों को जोड़ सकते हैं:

numpy.concatenate([a,b])
10
Cody Gray 26 जुलाई 2020, 20:00
1
यह numpy के लिए भी 'नहीं पूछता' है। मुझे कहना चाहिए कि इससे वास्तव में मुझे मदद मिली क्योंकि प्लस ऑपरेटर मेरे आवेदन के लिए काम नहीं कर रहा था
 – 
Aaron John Sabu
4 फरवरी 2021, 00:30

तो दो आसान तरीके हैं।

  1. + का उपयोग करना: यह प्रदान की गई सूचियों से एक नई सूची बनाता है

उदाहरण:

In [1]: a = [1, 2, 3]

In [2]: b = [4, 5, 6]

In [3]: a + b
Out[3]: [1, 2, 3, 4, 5, 6]

In [4]: %timeit a + b
10000000 loops, best of 3: 126 ns per loop
  1. विस्तार का उपयोग करना: यह नई सूची को मौजूदा सूची में जोड़ता है। इसका मतलब है कि यह एक अलग सूची नहीं बनाता है।

उदाहरण:

In [1]: a = [1, 2, 3]

In [2]: b = [4, 5, 6]

In [3]: %timeit a.extend(b)
10000000 loops, best of 3: 91.1 ns per loop

इस प्रकार हम देखते हैं कि दो सबसे लोकप्रिय विधियों में से extend कुशल है।

3
Peter Mortensen 17 मार्च 2019, 12:22
2
क्या होगा यदि मुझे a+b+c+d+e जैसी अनेक सूचियाँ जोड़ने की आवश्यकता है?
 – 
Tweakimp
12 मार्च 2019, 00:49
2
देखें यह उत्तर जिसमें कुछ विकल्प हैं (मैं chain.from_iterable का सुझाव देता हूं)।
 – 
cs95
4 जून 2019, 06:53
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]
-1
JamesVeug 16 फरवरी 2018, 06:46

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

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

    sorted(joinedList)

    return joinedList
-1
Ukendar Vadivel 31 जुलाई 2018, 12:35
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]
-2
Dimitris Fasarakis Hilliard 4 जुलाई 2017, 15:00
3
अच्छा, कृपया कुछ स्पष्टीकरण करें
 – 
U10-Forward
5 अक्टूबर 2018, 06:54
नहीं, कृपया नहीं, क्या भयानक "उत्तर" है।
 – 
Bart
13 फरवरी 2020, 14:08

आप पाइथन में यूनियन() फ़ंक्शन का उपयोग कर सकते हैं।

joinedlist = union(listone, listtwo)
print(joinedlist)

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

0
mr potato head 17 जिंदा 2021, 03:30

मुझे लगता है कि आप दो तरीकों में से एक चाहते हैं:

डुप्लिकेट तत्व रखें

यह बहुत आसान है, बस स्ट्रिंग की तरह संयोजित करें:

def concat_list(l1,l2):
    l3 = l1+l2
    return l3

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

def concat_list(l1,l2):
   l3 = []
   for i in [l1,l2]:
     for j in i:   
       if j not in l3:   
         #Check if element exists in final list, if no then add element to list
         l3.append(j)
   return l3
0
Dharman 14 नवम्बर 2020, 05:20

दूसरा तरीका:

>>> listone = [1, 2, 3]
>>> listtwo = [4, 5, 6]
>>> joinedlist = [*listone, *listtwo]
>>> joinedlist
[1, 2, 3, 4, 5, 6]
>>> 
7
surya 2 जून 2021, 13:04

मैं सूची को संयोजित करने के लिए तीन विधियों की अनुशंसा करता हूं लेकिन पहली विधि की सबसे अधिक अनुशंसा की जाती है,

# easiest and least complexity method <= recommended

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

newlist = listone + listtwo
print(newlist)

# 2nd easiest method
newlist = listone.copy()
newlist.extend(listtwo)
print(newlist)

दूसरी विधि में, मैं newlist को listone की एक प्रति सौंपता हूं क्योंकि मैं listone को बदलना नहीं चाहता।

# 3rd method
newlist = listone.copy()
for j in listtwo:
    newlist.append(j)

print(newlist)

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

5
Wouter 4 अक्टूबर 2021, 16:18

आप केवल sum का उपयोग भी कर सकते हैं।

>>> a = [1, 2, 3]
>>> b = [4, 5, 6]
>>> sum([a, b], [])
[1, 2, 3, 4, 5, 6]
>>> 

यह किसी भी लंबाई और किसी भी तत्व प्रकार की सूची के लिए काम करता है:

>>> a = ['a', 'b', 'c', 'd']
>>> b = [1, 2, 3, 4]
>>> c = [1, 2]
>>> sum([a, b, c], [])
['a', 'b', 'c', 'd', 1, 2, 3, 4, 1, 2]
>>> 

मेरे द्वारा [] जोड़ने का कारण यह है कि start तर्क डिफ़ॉल्ट रूप से 0 पर सेट है, इसलिए यह सूची के माध्यम से लूप करता है और start में जुड़ जाता है, लेकिन 0 + [1, 2, 3] एक त्रुटि देगा, इसलिए यदि हम start को [] पर सेट करते हैं, तो यह [] में जुड़ जाएगा, [] + [1, 2, 3] अपेक्षा के अनुरूप काम करेगा।

1
U12-F̉͋̅̾̇orward 12 सितंबर 2021, 04:48

बस इन दो सूची को जोड़ें //

अंतिम सूची = सूची 1 + सूची 2

0
Haris ramzan 10 अगस्त 2021, 20:50
1
हालांकि यह उनके प्रश्न का उत्तर दे सकता है, इसे थोड़ा और समझाना बेहतर होगा। जी। इसमें कुछ कोड जोड़ें।
 – 
Dominik
18 मई 2021, 00:19

प्रदान किए गए समाधान एकल सूची के लिए हैं। यदि किसी सूची में सूचियाँ हैं और संबंधित सूचियों का विलय आवश्यक है। लूप के लिए "+" ऑपरेशन काम करता है।

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

b=[[0,1,2],[7,8,9]]

for i in range(len(a)):
    cc.append(a[i]+b[i])

आउटपुट: [[1, 2, 3, 0, 1, 2], [4, 5, 6, 7, 8, 9]]

0
Khan 2 नवम्बर 2021, 12:54