 # Python | Concatenate two lists into a list of tuples

Examples :

`  Input:  list1 = [1, 2, 3] list2 = [`a`,` b`, `c `]  Output:  [(1,` a`), (2, `b`), (3,` c`)]  Input:  list1 = [1, 2, 3, 4] list2 = [1, 4, 9]  Output:  [(1, 1), (2, 4), (3, 9), (4, ``)] `

Approach # 1: Naive
Concatenate both lists into a list of tuples using a for loop. But the downside is that the two lists must be the same length.

 ` def ` ` merge (list1, list2) : `   ` merged_list ` ` = ` ` [(list1 [i], list2 [i]) ` ` for ` ` i ` ` in ` ` range ` ` (` ` 0 ` `, ` ` len ` ` (list1))] ` ` return ` ` merged_list `   ` # Driver code ```` l ist1 = [ 1 , 2 , 3 ] list2 = [ `a` , ` b` , `c` ] print (merge (list1, list2)) ```

Exit:

``` [(1, `a`), (2,` b`), (3, `c`)]    Approach # 2:  Naive but more effective  This method fixes the above drawback and works well with unequal lengths of two lists. This also provides a try catch error for the Index error.           ` def ` ` merge (list1, list2): `       ` merged_list ` ` = ` ` [] `   ` for ` ` i ` ` in ` ` range ` ` (` ` max ` ` ((` ` len ` ` (list1), ` ` len ` ` (list2)))) : `      ` while ` ` T rue ` `: `   ` try  : ``    tup   =   (list1 [i], list2 [i])     except   IndexError:     if   len   (list1) & gt;   len   (list2):     list2.append (``)     tup   =   (list1 [i], list2 [i])     elif   len   (list1) & lt;   len   (list2):     list1.append (``)     tup   =   (list1 [i], list2 [i])     continue         merged_list.append (tup)     break      return   merged_list      # Driver code     list1   =   [  1  ,   2  ,   3  ]    list2   =   [  `a`  ,  ` b`  ,   `c`  ]    print   (merge (list1, list2)) `    Exit:  [(1, `a`), (2,` b`), (3, `c`)]
Approach # 3  Using ` zip () `  using the zip () method to concatenate two list items and then inject them into a tuple.

` def ` ` merge (list1, list2): `

` merged_list ` ` = ` ` tuple   (  zip   (list1, list2))  ````
return   merged_list
# Driver code
list1   =   [  1  ,   2  ,   3  ]
list2   =   [  `a`  ,  ` b`  ,   `c`  ]
print   (merge (list1, list2))   ```

Exit:
((1, `a`), (2, `b`), (3,` c`))
Approach # 4:  Using enumerate (), an alternative to zip ().
This method uses two for loops to iterate through lists and concatenate the two lists.

` def ` ` merge (list1 , list2): `

` merged_list ` ` = ` ` [(p1, p2) ` ` for ` ` idx1, p1 ` ` in ` ` enumerate ` ` (list1) `
`   for   idx2, p2   in   enumerate   (list2)   if   idx1   =   =   idx2] ````
return   merged_list
# Driver code
list1   =   [  1  ,   2  ,   3  ]
list2   =   [  `a`  ,  ` b`  ,   `c`  ]
print   (merge (list1, list2))
```

Exit:
[(1, `a`), (2,` b`) , (3, `c`)]
Approach # 5  Using ` map () ` and ` lambda `.

` # Using map () and lambda `
` def ` ` listOfTuples (l1, l2): `
` return ` ` list ` ` (` ` map ` ` (  lambda   x, y: (x, y), l1, l2)) ````
Driver code
list1   =   [  1  ,   2  ,   3  ]
list2   =   [  `a`  ,   `b`  ,  ` c`  ]

print   (listOfTuples (list1, list2))
```

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

```