अजगर | दो सूचियों को टुपल्स की सूची में संयोजित करें

| | | | | | |

उदाहरण:

इनपुट:  list1 = [1, 2, 3] list2 = [`a`,` b`, `c `] आउटपुट:  [(1,` a`), (2, `b`), (3,` c`)] इनपुट:  list1 = [1, 2, 3, 4] सूची 2 = [1, 4, 9] आउटपुट:  [(1, 1), (2, 4), (3, 9), (4, ``)] 

दृष्टिकोण # 1: Naive
फॉर लूप का उपयोग करके दोनों सूचियों को टुपल्स की सूची में संयोजित करें। लेकिन नकारात्मक पक्ष यह है कि दोनों सूचियों की लंबाई समान होनी चाहिए।


def merge (सूची 1, सूची 2):


"सादा"> [(सूची 1 [i], सूची 2 [i]) <कोड वर्ग =" कीवर्ड "> के लिए <कोड वर्ग =" सादा "> मैं <कोड वर्ग = "कीवर्ड"> इन <कोड क्लास = "फ़ंक्शंस"> रेंज <कोड क्लास = "प्लेन"> ( <कोड क्लास = "वैल्यू"> 0 <कोड वर्ग = "सादा">, <कोड वर्ग = "कार्य"> लेन <कोड वर्ग = "सादा"> (सूची 1))]

<कोड क्लास = "कीवर्ड"> रिटर्न <कोड क्लास = "प्लेन"> मर्ज किए गए_लिस्ट


<कोड क्लास = "टिप्पणियां"> # ड्राइवर कोड /p>

<कोड वर्ग = "सादा"> l ist1 <कोड वर्ग = "कीवर्ड"> = <कोड वर्ग = "सादा"> [ <कोड वर्ग = "मान"> 1 <कोड वर्ग = "सादा">, <कोड वर्ग = "मान"> 2 <कोड वर्ग ="सादा ">, <कोड वर्ग =" मान "> 3 <कोड वर्ग = "सादा">]

<कोड वर्ग = "सादा" > सूची 2 <कोड वर्ग = "कीवर्ड"> = <कोड वर्ग = "सादा"> [ <कोड वर्ग = "स्ट्रिंग"> `ए` <कोड वर्ग ="सादा ">, <कोड वर्ग =" स्ट्रिंग ">` बी ` <कोड वर्ग = "सादा">, <कोड वर्ग = "स्ट्रिंग"> `सी` ]

Print (मर्ज (list1, list2) ))

बाहर निकलें:

[ (1, `ए`), (2,` बी`), (3, `सी`)] 

दृष्टिकोण # 2: सरल लेकिन अधिक प्रभावी
यह विधि उपरोक्त दोष को ठीक करती है और दो सूचियों की असमान लंबाई के साथ अच्छी तरह से काम करती है। यह इंडेक्स एरर के लिए ट्राइ कैच एरर भी प्रदान करता है।


<टेबल बॉर्डर = "0" सेलपैडिंग = "0" सेलस्पेसिंग = " 0 ">

def merge (list1, list2):


<कोड वर्ग = "सादा"> मर्ज किए गए_सूची <कोड वर्ग = "कीवर्ड"> = <कोड वर्ग = "सादा"> []

<कोड वर्ग = "कीवर्ड"> के लिए कोड वर्ग = "सादा"> ( <कोड वर्ग = "कार्य"> अधिकतम <कोड वर्ग = "सादा"> (( <कोड वर्ग = "कार्य"> लेन <कोड वर्ग = "सादा"> (सूची 1), <कोड वर्ग = "कार्य"> लेन <कोड वर्ग = "सादा"> (सूची 2))):


जबकि T rue :

<कोड वर्ग = "कीवर्ड"> प्रयास करें <कोड वर्ग = "सादा">:

टप <कोड क्लास = "कीवर्ड"> = <कोड क्लास = "प्लेन"> (लिस्ट 1 [i], लिस्ट 2 [i])

<कोड वर्ग = "कीवर्ड"> सिवाय <कोड वर्ग = "सादा"> अनुक्रमणिका त्रुटि:

<कोड वर्ग = "कीवर्ड"> यदि कोड> <कोड वर्ग = "कार्य"> लेन <कोड वर्ग = "सादा"> (सूची 1) > len (list2):

list2. परिशिष्ट (``)

<कोड वर्ग = "सादा"> टप <कोड वर्ग = "कीवर्ड"> = <कोड वर्ग = "सादा"> (सूची 1 [i], सूची 2 [i])

<कोड वर्ग = "कीवर्ड"> एलिफ <कोड वर्ग = "कार्य"> लेन <कोड वर्ग = "सादा"> (सूची 1) और लेफ्टिनेंट; len (list2):

list1. परिशिष्ट (``)

<कोड वर्ग = "सादा"> टप <कोड वर्ग = "कीवर्ड"> = <कोड वर्ग = "सादा"> (सूची 1 [i], सूची 2 [i])

<कोड वर्ग = "कीवर्ड"> जारी रखें


<पी> <कोड वर्ग = " प्लेन"> मर्जर_लिस्ट.एपेंड (tup)

<कोड क्लास = "कीवर्ड"> ब्रेक

<कोड क्लास = "कीवर्ड"> रिटर्न < /कोड> <कोड वर्ग = "सादा"> मर्ज किए गए_सूची


वर्ग = "सादा"> सूची 1 <कोड वर्ग = "कीवर्ड"> = <कोड वर्ग = "सादा"> [ <कोड वर्ग = "मान"> 1 <कोड वर्ग = "सादा">, <कोड वर्ग = "मान"> 2 <कोड वर्ग = "सादा">, <कोड वर्ग = "मान"> 3 कोड> <कोड वर्ग = "सादा">]

कोड वर्ग = "सादा"> सूची 2 <कोड वर्ग = "कीवर्ड"> = <कोड वर्ग = "सादा"> [ <कोड ई क्लास = "स्ट्रिंग"> `ए` <कोड क्लास = "सादा">, <कोड क्लास = "स्ट्रिंग"> `बी` <कोड क्लास = "सादा"> , `c` ]

Print < /कोड> <कोड वर्ग = "सादा"> (मर्ज (सूची 1, सूची 2))

<कोड> बाहर निकलें: [(1, `ए`), (2,` बी`), (3, `सी`)]

दृष्टिकोण # 3 zip () < का उपयोग करना /code>
ज़िप () पद्धति का उपयोग करके दो सूची आइटम्स को संयोजित करें और फिर उन्हें एक टपल में इंजेक्ट करें।

<टेबल बॉर्डर = "0" सेलपैडिंग = "0" सेलस्पेसिंग = "0">

def मर्ज (list1, list2):


merged_list = < / कोड> <कोड वर्ग = "कार्य"> टपल <कोड वर्ग = "सादा"> ( <कोड वर्ग = "कार्य"> ज़िप <कोड वर्ग = "सादा"> (सूची1, ली st2))

return merged_list


# ड्राइवर कोड

list1 = [ <कोड वर्ग = "मान"> 1 <कोड वर्ग = "सादा">, <कोड वर्ग = "मान"> 2 <कोड वर्ग = "सादा">, <कोड वर्ग = "मान"> 3 <कोड वर्ग = "सादा">]

<कोड वर्ग = "सादा"> सूची 2 <कोड वर्ग = "कीवर्ड"> = <कोड वर्ग = "सादा"> [ <कोड वर्ग = "स्ट्रिंग"> `ए` <कोड वर्ग = "सादा">, <कोड वर्ग = "स्ट्रिंग"> `बी` <कोड वर्ग = "सादा">, <कोड वर्ग = "स्ट्रिंग"> ` c` <कोड वर्ग ="p lain ">]

Print (मर्ज (list1, list2)) p>

बाहर निकलें:

((1, `a`), (2, `b`), (3,` c`)) 

दृष्टिकोण # 4: zip () के विकल्प के रूप में एन्यूमरेट () का उपयोग करना।

यह विधि सूचियों के माध्यम से पुनरावृति करने के लिए दो लूप का उपयोग करती है और उन्हें संयोजित करती है। दो सूचियाँ।


def merge (list1, list2):


<कोड वर्ग = "सादा"> विलय_सूची <कोड वर्ग = "कीवर्ड"> = <कोड वर्ग = "सादा"> [(p1, p2) < /कोड> <कोड वर्ग = "कीवर्ड"> के लिए "> गणना करें <कोड वर्ग = "सादा"> (सूची 1)

<कोड वर्ग = "अपरिभाषित रिक्त स्थान"> <कोड वर्ग = "कीवर्ड" > के लिए खाया <कोड वर्ग = "सादा"> (सूची 2) <कोड वर्ग = "कीवर्ड"> अगर <कोड वर्ग = "सादा"> idx1 <कोड वर्ग = "कीवर्ड"> = <कोड वर्ग = "कीवर्ड"> = <कोड वर्ग = "सादा"> idx2]

कोड वर्ग = "कीवर्ड" > वापसी <कोड वर्ग = "सादा"> मर्ज किए गए_सूची

<कोड वर्ग =" अपरिभाषित रिक्त स्थान ">
# ड्राइवर कोड

list1 = [< /कोड> <कोड वर्ग = "मान"> 1 <कोड वर्ग = "सादा">, <कोड वर्ग = "मान"> 2 <कोड वर्ग = "सादा"> , 3 ]

list2 <कोड वर्ग = "कीवर्ड"> = <कोड वर्ग = "सादा"> [ <कोड वर्ग = "स्ट्रिंग"> `ए` <कोड वर्ग = "सादा"> , ` b` , `c` ]

Print (मर्ज (list1, list2) ))

बाहर निकलें:

[ (1, `a`), (2,` b`) , (3, `c`)] 

दृष्टिकोण # 5 map () और <कोड> लैम्ब्डा ।


# मैप () और लैम्ब्डा का इस्तेमाल करना

def < / कोड> <कोड वर्ग = "सादा"> सूचीऑफ टुपल्स (एल 1, एल 2):

<कोड वर्ग = "कीवर्ड"> वापसी <कोड वर्ग = "कार्य"> सूची <कोड वर्ग = "सादा"> ( <कोड वर्ग = "कार्य"> नक्शा <कोड वर्ग = "सादा"> ( <कोड वर्ग = "कीवर्ड" "> लैम्ब्डा <कोड वर्ग = "सादा"> x, y: (x, y), l1, l2))


<कोड वर्ग s = " टिप्पणियाँ"> ड्राइवर कोड

कोड वर्ग = "सादा"> सूची 1 <कोड वर्ग = "कीवर्ड"> = <कोड वर्ग = "सादा"> [ 1 , 2 , <कोड वर्ग = "मान"> 3 <कोड वर्ग = "सादा">]

<कोड वर्ग = "सादा" > सूची 2 < /कोड> <कोड वर्ग = "कीवर्ड"> = <कोड वर्ग = "सादा"> [ <कोड वर्ग = "स्ट्रिंग"> `ए` <कोड वर्ग = "सादा" ">, <कोड ई क्लास = "स्ट्रिंग"> `बी` <कोड क्लास = "सादा">, <कोड क्लास = "स्ट्रिंग"> `सी` <कोड क्लास = "सादा"> ]


Print (listOfTuples (list1, list2))

बाहर निकलें:

[(1, `a`), (2,` b`), (3, `c`)]