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

Question

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

उदाहरण:

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

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

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

Comments

क्या आप केवल अपील करना चाहते हैं , या क्या आप दो सूचियों को क्रमबद्ध क्रम में मर्ज करना चाहते हैं ? [1,3,6] और [2,4,5] के लिए आप क्या आउटपुट की उम्मीद करते हैं? क्या हम मान सकते हैं कि दोनों उपठेका पहले से ही छंटे हुए हैं (जैसा कि आपके उदाहरण में है)?

— smci

... क्या होगा अगर सूचियों में डुप्लिकेट हैं जैसे [1,2,5] and [2,4,5,6]? क्या आप डुप्लिकेट को शामिल, बहिष्कृत, या देखभाल नहीं करना चाहते हैं?

— एसएमसीआई

Answer 1

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

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

joinedlist = listone + listtwo

आउटपुट:

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

Comments

यह listone की एक गहरी प्रतिलिपि बनाता है और listtwo को जोड़ता है?

— डैनियल एफ

@ डैनियल यह पहली सूची में वस्तुओं की एक उथली प्रतिलिपि के साथ एक नई सूची बनाएगा, इसके बाद दूसरी सूची में मदों की एक उथली प्रति होगी। सूचियों की गहरी प्रतियां प्राप्त करने के लिए copy.deepcopy का उपयोग करें।

— डैनियल जी

यहाँ एक और उपयोगी विवरण: listone += listtwoपरिणामlistone == [1, 2, 3, 4, 5, 6]

— rickcnagy

@ br1ckb0t क्या लिस्टऑन को इंगित कर रहा है जो बदल जाएगा? तो: list3 = listone listone+=listtwo क्या सूची 3 को भी बदल दिया गया है?

— मिकह

यह सूची 3 बदलता है। हालाँकि, यदि यह कोई समस्या नहीं है, तो नया बनाने के बजाय दो सूचियों को जोड़ना अधिक सरल है।

— rickcnagy

Answer 2

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

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

Comments

chainदो सूचियों के लिए धीमी गति से (लेकिन बहुत अधिक नहीं) है, लेकिन कई सूचियों (n >> 2) का पीछा करने के लिए सबसे तेज़ समाधान है।

— cs95

@ cs95 क्या की तुलना में धीमी गति से?

— Moberg

@Moberg सूचियों के अन्य तरीकों की तुलना में, संदर्भ के लिए कृपया यहां मेरे बेंचमार्क देखें ।

— cs95

Answer 3

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

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

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

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

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

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

---

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

यह सूची में पुनरावृत्तियों के अधिक पठनीय तरीके के रूप में भी उपयोगी है, जैसे कि my_list + list(my_tuple) + list(my_range)यह अब सिर्फ इसके बराबर है [*my_list, *my_tuple, *my_range]।

तो इसके साथ +ही TypeErrorटाइप मिसमैच के कारण बढ़ जाएगा :

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

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

res = [*l, *r]

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

Comments

पुनरावृत्त प्रकारों पर काम करने वाले अनपैकिंग दृष्टिकोण का एक अच्छा उदाहरण वह फ़ंक्शन है जो आपके द्वारा संक्षिप्त किए जा रहे सूचियों में से एक पुनरावर्तक को लौटाता है। उदाहरण के लिए, आप उन सूचियों में से एक को उलट सकते हैं जिन्हें आप संक्षिप्त कर रहे हैं res = [*l1, *reversed(l2)]:। चूंकि reversedएक पुनरावृत्तिकर्ता रिटर्न करता है, इसलिए res = l1 + reversed(l2)एक त्रुटि होगी।

— एलन

यह ध्यान देने योग्य है कि यह अजगर में शब्दकोश के संयोजन के अनुरूप है। dict3 = {** dict1, ** dict2}। ध्यान दें कि हम डिक्शनरी को अनपैक करने के लिए ** का उपयोग करते हैं जबकि सूचियों के साथ हम अनपैक करने के लिए * का उपयोग करते हैं।

— केविन एस

Answer 4

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

mergedlist = list(set(listone + listtwo))

Comments

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

— metasoarous

ऐसा करने का तरीका क्या है और आदेश की जानकारी रखना?

— नटिम

इससे बेहतरlistone + [x for x in listtwo if x not in listone]

— नटिम

+1 IMHO यह "मर्ज" (संघ) सूचियों का सही तरीका है जबकि "स्वीकृत" उत्तर बताता है कि सूचियों को कैसे जोड़ा / जोड़ा जाए (मल्टीसेट)

— अल्फासिन

यदि आप इनपुट ऑर्डर बनाए रखने की परवाह करते हैं, तो import collections; mergedlist = list(collections.OrderedDict.fromkeys(listone + listtwo))यह ट्रिक करेगा।

— सेठमोर्टन

Answer 5

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

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

listone.extend(listtwo)

यदि आप मूल सूची को अक्षुण्ण रखना चाहते हैं, तो आप एक नई listवस्तु बना सकते हैं , और extendदोनों सूचियाँ:

mergedlist = []
mergedlist.extend(listone)
mergedlist.extend(listtwo)

Answer 6

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

3.7 के रूप में, ये अजगर में दो (या अधिक) सूचियों को समेटने के लिए सबसे लोकप्रिय stdlib विधियाँ हैं।

फुटनोट

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

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

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

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

---

प्रदर्शन

2-सूची सम्‍मिलन ¹

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

एन-लिस्ट कॉनटेनेशन

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

_{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 , जो छोटा और अधिक पठनीय है , पसंद करें । YMMV।

Comments

stackoverflow.com/q/36863404/125507 के उत्तर एक परप्लॉट प्लॉट (सुंबा समाधान सहित) का उपयोग कर सकते हैं

— एंडोलिथ

@endolith बिट काम के साथ बह गया, लेकिन मैं देख लेता हूं और देख सकता हूं कि क्या मैं चीप कर सकता हूं।

— सीएस 95

जो सबसे अच्छा तरीका है, फिर प्रदर्शन बुद्धिमान, तेज़? कृपया बताओ।

— गणेशदेशमुख

@ganeshdeshmukh टीएल; DR वे सभी अच्छे हैं और जो आप चुनते हैं वह ज्यादातर शैली का विषय है। "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

Answer 7

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

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

Answer 8

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

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

>>> 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, [])

Comments

पायथन 3 नोट: reduceअब functoolsऐसा है इसलिए आपको इसे पहले आयात करना होगा।

— दिमित्री फासरकिस हिलियार्ड

Answer 9

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

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))

Comments

अंतिम भाग वस्तुओं को फिर से ऑर्डर कर सकते हैं। यदि आप ऑर्डर को संरक्षित करना चाहते हैं, तो सीपीथॉन 3.6+ पर आप कर सकते हैंlist(dict.fromkeys(a + b))

— बोरिस

Answer 10

यह ध्यान देने योग्य है कि 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']

Answer 11

पायथन 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]

Comments

आप itertools.chainअपने स्वयं के कार्य को परिभाषित करने के बजाय (जो समकक्ष है) का उपयोग कर सकते हैं ।

— बोरिस

Answer 12

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

from heapq import merge

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

print list(merge(a, b))

Answer 13

यदि आप प्लस ऑपरेटर ( +) का उपयोग नहीं कर सकते हैं, तो आप 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]

Comments

डंडर्स हथियाने आमतौर पर सबसे अच्छा तरीका नहीं है। यदि +तालिका बंद है, तो उपयोग करें operator.add।

— दिमित्री फासरकिस हिलियार्ड

प्लस ऑपरेटर अनुपलब्ध क्यों होगा?

— cs01

आम तौर पर यह नहीं होता है :) लेकिन अगर आप नक्शे के कार्य के साथ सूची बनाने का काम कर रहे हैं या किसी फ़ंक्शन को चर में जोड़ना चाहते हैं, तो आप + का उपयोग नहीं कर सकते।

— jpihl

Answer 14

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

>>> 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()पाइथन 2.6 और बाद में उपलब्ध है। अन्य संस्करणों में, उपयोग करें chain(*l)।}

Answer 15

यदि आपको जटिल क्रमबद्ध नियमों के साथ दो क्रमबद्ध सूचियों को मर्ज करने की आवश्यकता है, तो आपको इसे निम्नलिखित कोड की तरह खुद को रोल करना होगा (पठनीयता के लिए एक सरल छँटाई नियम का उपयोग करके)।

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])

Comments

या सिर्फ उपयोग करें heapq.merge।

— cs95

Answer 16

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

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

Comments

बस इतना आप जानते हैं, अगर यह वही है जो आप अभ्यास में कर रहे हैं, तो यह अन्य प्रस्तावित विधियों की तुलना में बहुत धीमा है। देखें stackoverflow.com/questions/17479361/…

— रयान हेनिंग

Answer 17

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

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

Answer 18

जैसा कि पहले ही कई लोगों ने बताया है, 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अजगर में लूप टपल चर के साथ काम कर सकता है, इसलिए एक ही समय में कई चर पर लूप करना सरल है।

Answer 19

एक सरल सूची समझ का उपयोग करें:

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

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

Answer 20

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

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]

Comments

कृपया उपयोग न करें list.__add__, operator.addइसके बजाय उपयोग करें । यह उतना sum(list_of_lists, [])ही बुरा है जितना कि इसके बराबर है । प्रयोग नहीं करें!

— CS95

@ सीएस 95 आप बता सकते हैं कि सूची का उपयोग करके क्या समस्या है ।__ add__

— आकाश सिंह

डंडर तरीके "निजी तरीके" हैं और आमतौर पर सीधे इस्तेमाल नहीं किए जाने चाहिए (उन्हें अन्य कार्यों द्वारा बुलाया जाता है)। अपवाद हैं obj.__class__और obj.__dict__।

— cs95

Answer 21

पायथन में आप इस कमांड के साथ संगत आयामों के दो सरणियों को समेट सकते हैं

numpy.concatenate([a,b])

Comments

प्रश्न सुन्न के लिए नहीं पूछता है।

— cs95

Answer 22

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

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

2. विस्तार का उपयोग करना : यह मौजूदा सूची में नई सूची जोड़ता है। इसका मतलब है कि यह एक अलग सूची नहीं बनाता है।

उदाहरण:

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कुशल है।

Comments

क्या होगा अगर मुझे एक + b + c + d + e की तरह कई सूचियाँ जोड़ने की आवश्यकता है?

— Tweakimp

@Tweakimp इस उत्तर को देखें जिसमें कुछ विकल्प हैं (मैं सुझाता हूं chain.from_iterable)।

— cs95

Answer 23

अजगर में सूचियों को समाप्‍त करने के कई तरीके हैं।

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

1. new_list = l1.extend(l2)
2. new_list = l1 + l2
3. new_list = [*l1, *l2]

Comments

क्या आप बता सकते हैं कि यह उत्तर दूसरों को कौन सी नई जानकारी प्रदान करता है?

— cs95

अजगर में सूचियों को समेटने के कई तरीके हैं - जो अन्य बहुत पुराने उत्तरों में बड़े पैमाने पर शामिल हैं। यह क्या नई जानकारी प्रदान करता है ??

— टोमेरिकू

Answer 24

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]

Answer 25

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

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

    sorted(joinedList)

    return joinedList

Comments

यह कैसे mingxiao द्वारा इस जवाब से अलग है ?

— टोमेरिकू

Answer 26

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]

Comments

खैर, कृपया कुछ स्पष्टीकरण करें

— U10- फॉरवर्ड

यदि आप इसके अंदर वैश्विक नामों का उपयोग कर रहे हैं, तो फ़ंक्शन के तर्कों का क्या मतलब है?

— टोमेरिकू

Answer 27

आप कोड का पालन कर सकते हैं

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

for i in listone:
    listtwo.append(i)
print(listtwo)

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