Combina listas uniendo cadenas con valores de índice coincidentes

Tengo dos listas que me gustaría combinar, pero en lugar de boost el número de elementos de la lista, me gustaría unirme a los elementos que tienen un índice coincidente. Por ejemplo:

List1 = ['A', 'B', 'C'] List2 = ['1', '2', '3'] List3 = ['A1', 'B2', 'C3'] 

He visto algunas otras preguntas sobre la simple combinación de dos listas, pero me temo que no he encontrado nada que pueda lograr.

Cualquier ayuda sería muy apreciada. Aclamaciones.

 >>> List1 = ['A', 'B', 'C'] >>> List2 = ['1', '2', '3'] >>> map(lambda a, b: a + b, List1, List2) ['A1', 'B2', 'C3'] 
 >>> List1 = ['A', 'B', 'C'] >>> List2 = ['1', '2', '3'] >>> [x + y for x, y in zip(List1, List2)] ['A1', 'B2', 'C3'] 
 map(''.join,zip(List1,List2,List3)) >>> ['A1A1', 'B2B2', 'C3C3'] 

Explicación:

 zip(List1,List2,List3) 

Devoluciones

 [('A', '1', 'A1'), ('B', '2', 'B2'), ('C', '3', 'C3')] 

Cada tupla representa los elementos asociados con un índice N en las listas comprimidas. Queremos combinar los elementos de cada tupla en una sola cadena. Para una sola tupla podemos ir:

 >>> ''.join(('A', '1', 'A1')) 'A1A1' 

Para producir el resultado deseado, por lo tanto, para obtener una lista de todas las cadenas deseadas, asignamos esta función de join a todas las tuplas de la siguiente manera:

 map(''.join,zip(List1,List2,List3)) 

Resultando en

 ['A1A1', 'B2B2', 'C3C3'] 

Así que si quisieras agregar solo List1 y List2

 map(''.join,zip(List1,List2)) >>> ['A1', 'B2', 'C3'] 

Algunos tiempos:

 Microsoft Windows [Version 6.2.9200] (c) 2012 Microsoft Corporation. All rights reserved. C:\Users\Henry>python -m timeit -s "List1 = ['A', 'B', 'C']*10**5; List2 = ['1', '2','3']*10**5" "map(lambda x, y: x + y, List1, List2)" 10 loops, best of 3: 44 msec per loop C:\Users\Henry>python -m timeit -s "List1 = ['A', 'B', 'C']*10**5; List2 = ['1', '2', '3']*10**5" "[x + y for x, y in zip(List1, List2)]" 10 loops, best of 3: 44 msec per loop C:\Users\Henry>python -m timeit -s "List1 = ['A', 'B', 'C']*10**5; List2 = ['1', '2', '3']*10**5" "map(''.join,zip(List1,List2))" 10 loops, best of 3: 42.6 msec per loop C:\Users\Henry>python -m timeit -s "from operator import add" "List1 = ['A', 'B', 'C']*10**5; List2 = ['1', '2', '3']*10**5" "map(add, List1, List2)" 10 loops, best of 3: 28.6 msec per loop 

Y usando izip en lugar de zip.

 Microsoft Windows [Version 6.2.9200] (c) 2012 Microsoft Corporation. All rights reserved. C:\Users\Henry>python -m timeit -s "List1 = ['A', 'B', 'C']*10**5; List2 = ['1', '2','3']*10**5" "map(lambda x, y: x + y, List1, List2)" 10 loops, best of 3: 44.1 msec per loop C:\Users\Henry>python -m timeit -s "from itertools import izip" "List1 = ['A', 'B', 'C']*10**5; List2 = ['1', '2', '3']*10**5" "[x + y for x, y in izip(List1, List2)]" 10 loops, best of 3: 31.3 msec per loop C:\Users\Henry>python -m timeit -s "from itertools import izip" "List1 = ['A', 'B', 'C']*10**5; List2 = ['1', '2', '3']*10**5" "map(''.join,izip(List1,List2))" 10 loops, best of 3: 36.2 msec per loop C:\Users\Henry>python -m timeit -s "from operator import add" "List1 = ['A', 'B', 'C']*10**5; List2 = ['1', '2', '3']*10**5" "map(add, List1, List2)" 10 loops, best of 3: 28.6 msec per loop 

Añadir a la variedad (Python 2.7).

 List3 = ['{}{}'.format(x, y) for x, y in zip(List1, List2)] 

Como puede verse en las muchas otras respuestas, hay varias formas de resolver esto en Python. Aquí hay un ejemplo:

 >>> from operator import add >>> List1 = ['A', 'B', 'C'] >>> List2 = ['1', '2', '3'] >>> map(add, List1, List2) ['A1', 'B2', 'C3'] 

Sin embargo, lo que básicamente estás buscando es zipWith , me vinculo a hoogle solo porque se puede explicar fácilmente, y no hay una implementación estándar de zipWith en python. Lo que está diciendo es que usted proporciona zipWith una función binaria, por ejemplo, operator.add , y dos listas, y devuelve las listas zip ‘d junto con la función aplicada a cada par.

Puede abstraer esta idea para operar en más de dos listas con un operador binario.

 >>> def zipWith(f, *iterables): ... return map(f, *iterables) 

Aparte: esto puede parecer que no está haciendo mucho, pero proporciona semántica sobre lo que está sucediendo. Es zip los iterables con la función. Esto es más legible que simplemente usando la versión del mapa.

Luego puede usarlo con cualquier función siempre que haga coincidir el número de listas de entrada con la aridad de la función f . Por ejemplo:

 >>> zipWith(lambda a, b, c: a + b * c, [1, 2, 3], [1, 2, 3], [1, 2, 3]) [2, 6, 12] >>> zipWith(lambda a, b, c: (a + b) * c, List1, List2, [1, 2, 3]) ['A1', 'B2B2', 'C3C3C3'] >>> zipWith(lambda a, b: a + b, List1, List2) ['A1', 'B2', 'C3'] >>> zipWith(add, List1, List2) ['A1', 'B2', 'C3']