Python | Concatenar dos listas en una lista de tuplas

| | | | | | |

Ejemplos:

Entrada:  lista1 = [1, 2, 3] lista2 = [`a`, `b`, `c `] Salida:  [(1,` a`), (2, `b`), (3,` c`)] Entrada:  lista1 = [1, 2, 3, 4] lista2 = [1, 4, 9] Salida:  [(1, 1), (2, 4), (3, 9), (4, ``)] 

Enfoque # 1: Ingenuo
Concatenar ambas listas en una lista de tuplas usando un bucle for. Pero la desventaja es que las dos listas deben tener la misma longitud.


def merge (lista1, lista2):


merged_list = [(lista1 [i], lista2 [i]) para i en rango ( 0 , len (lista1))]

return merged_list


# Código del controlador

l ist1 = [ 1 , 2 , 3 ]

lista2 = [ `a` , ` b` , `c` < /código> ]

imprimir (combinar (lista1, lista2 ))

Salir:

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

Enfoque # 2: Ingenuo pero más efectivo
Este El método corrige el inconveniente anterior y funciona bien con longitudes desiguales de dos listas. Esto también proporciona un error de captura de prueba para el error de índice.


def fusionar (lista1, lista2):


merged_list = []

para i en rango < código clase = "simple"> ( max (( len (lista1), len (lista2)))):


while T rue :

prueba :

tup = (lista1 [i], lista2 [i])

excepto IndexError:

si len (lista1) > len (lista2):

lista2. agregar (``)

tup = (lista1 [i], lista2 [i])

elif len (lista1) " len (lista2):

lista1. agregar (``)

tup = (lista1 [i], lista2 [i])

continuar


merged_list.append (tup)

break

return merged_list


# Código del controlador

lista1 = [ 1 , 2 , 3 ]

lista2 = [ `a` , ` b` , `c` ]

imprimir < /código> (combinar (lista1, lista2))

Salir:

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

Enfoque # 3 Usando zip ()
utilizando el método zip () para concatenar dos elementos de la lista y luego inyectarlos en una tupla.

def fusionar (lista1, lista2):


merged_list = < /código> tupla ( zip (lista1, li st2))

return merged_list


# código del controlador

lista1 = [ 1 , 2 , 3 ]

lista2 = [ `a` , ` b` , ` c` ]

print (merge (list1, list2))

Salir:

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

Enfoque # 4: Usando enumerate (), una alternativa a zip ().

Este método usa dos bucles for para iterar a través de listas y concatenar los dos listas.


def merge (list1 , list2):


merged_list = [(p1, p2) < /código> para idx1, p1 en enumerar (lista1)

para idx2, p2 en enumerar ate (lista2) if idx1 = = idx2]

volver merged_list


# Código del controlador

list1 = [< /código> 1 , 2 , 3 ]

lista2 = [ `a` , ` b` , `c` < /código> ]

imprimir (combinar (lista1, lista2 ))

Salir:

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

Enfoque # 5 Usando mapa () y lambda .


# Usando map() y lambda

def < /código> listOfTuples (l1, l2):

return lista ( mapa ( lambda x, y: (x, y), l1, l2))


Código del controlador

list1 = [ 1 , 2 , 3 ]

lista2 = [ `a` , `b` , ` c` ]


imprimir (listOfTuples (list1, list2))

Salir:

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