¿Cómo concatenar dos listas en Python?

¿Cómo concatenar dos listas en Python?

Ejemplo:

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

Gastos esperados:

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

Puedes usar el operador + para combinarlos:

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

Salida:

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

También es posible crear un generador que simplemente itere sobre los elementos en ambas listas. Esto le permite encadenar listas (o cualquier iterable) para procesarlas sin copiar los elementos a una nueva lista:

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

Puede utilizar conjuntos para obtener una lista combinada de valores únicos

 mergedlist = list(set(listone + listtwo)) 

Python >= 3.5 alternativa: [*l1, *l2]

Aunque esta es una respuesta antigua, se ha introducido otra alternativa a través de la aceptación de la PEP 448 que merece ser mencionada.

El PEP, titulado Generalizaciones de desempaquetado adicionales , generalmente redujo algunas restricciones sintácticas al usar la expresión * destacada en Python; Con él, unir dos listas (se aplica a cualquier iterable) ahora también se puede hacer con:

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

Esta funcionalidad se definió para Python 3.5 pero no se ha vuelto a la versión anterior de la familia 3.x En versiones no compatibles, se SyntaxError un SyntaxError .

Al igual que con los otros enfoques, esto también crea una copia superficial de los elementos en las listas correspondientes.


La ventaja de este enfoque es que realmente no necesitas listas para realizarlo, cualquier cosa que sea iterable hará. Como se indica en el PEP:

Esto también es útil como una forma más legible de sumr iterables en una lista, como my_list + list(my_tuple) + list(my_range) que ahora es equivalente a solo [*my_list, *my_tuple, *my_range] .

Entonces, mientras que la adición con + elevaría un TypeError debido a la falta de coincidencia de tipo:

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

Lo siguiente no:

 res = [*l, *r] 

porque primero desempaquetará los contenidos de los iterables y luego simplemente creará una list partir de los contenidos.

También puede usar la extend para agregar una list agregar el final de otra:

 listone = [1,2,3] listtwo = [4,5,6] mergedlist = [] mergedlist.extend(listone) mergedlist.extend(listtwo) 

Esto es bastante simple, y creo que incluso se mostró en el tutorial :

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

Esta pregunta pregunta directamente acerca de unirse a dos listas. Sin embargo, es bastante alto en la búsqueda, incluso cuando está buscando una forma de unirse a muchas listas (incluido el caso cuando se une a cero listas).

Creo que la mejor opción es usar listas de comprensión:

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

También puedes crear generadores:

 >>> map(str, (x for xs in a for x in xs)) ['1', '2', '3', '4', '5', '6', '7', '8', '9'] 

Respuesta antigua

Considere este enfoque más genérico:

 a = [[1,2,3], [4,5,6], [7,8,9]] reduce(lambda c, x: c + x, a, []) 

Saldrá:

 [1, 2, 3, 4, 5, 6, 7, 8, 9] 

Tenga en cuenta que esto también funciona correctamente cuando a es [] o [[1,2,3]] .

Sin embargo, esto se puede hacer de manera más eficiente con itertools :

 a = [[1,2,3], [4,5,6], [7,8,9]] list(itertools.chain(*a)) 

Si no necesita una list , sino solo una iterable, omita la list() .

Actualizar

La alternativa sugerida por Patrick Collins en los comentarios también podría funcionar para usted:

 sum(a, []) 

Simplemente puede utilizar el operador + o += siguiente manera:

 a = [1, 2, 3] b = [4, 5, 6] c = a + b 

O:

 c = [] a = [1, 2, 3] b = [4, 5, 6] c += (a + b) 

Además, si desea que los valores de la lista fusionada sean únicos, puede hacerlo:

 c = list(set(a + b)) 

Vale la pena señalar que la función itertools.chain acepta un número variable de argumentos:

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

Si se ingresa un iterable (tupla, lista, generador, etc.), se puede usar el método de clase from_iterable :

 >>> il = [['a'], ['b', 'c'], ['d', 'e', 'f']] >>> [i for i in itertools.chain.from_iterable(il)] ['a', 'b', 'c', 'd', 'e', 'f'] 

Usted puede ir para la función list.extend .

 l1 = [1,2,3] l2 = [4,5,6] l1.extend(l2) print l1 

Salida:

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

Con Python 3.3+ puedes usar el rendimiento de :

 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] 

O, si desea admitir un número arbitrario de iteradores:

 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] 

Si desea combinar las dos listas en forma ordenada, puede usar la función de merge de la biblioteca heapq .

 from heapq import merge a = [1, 2, 4] b = [2, 4, 6, 7] print list(merge(a, b)) 

Si no puede usar el operador más ( + ), puede usar la función __add__ :

 listone = [1,2,3] listtwo = [4,5,6] result = list.__add__(listone, listtwo) print(result) >>> [1, 2, 3, 4, 5, 6] 

Alternativamente, si no le gusta el uso de dunders puede usar la importación del operator :

 import operator listone = [1,2,3] listtwo = [4,5,6] result = operator.add(listone, listtwo) print(result) >>> [1, 2, 3, 4, 5, 6] 

Se podría argumentar que esto es un poco más legible.

Como una forma más general para más listas, puede colocarlas dentro de una lista y usar la función itertools.chain.from_iterable() 1 que, según esta respuesta, es la mejor manera de acoplar una lista anidada:

 >>> 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. Tenga en cuenta que chain.from_iterable() está disponible en Python 2.6 y versiones posteriores. En otras versiones, usar chain(*l) .

Uniendo dos listas en Python:

 >>> a = [1, 2, 3, 4] >>> b = [1, 4, 6, 7] >>> c = a + b >>> c [1, 2, 3, 4, 1, 4, 6, 7] 

Si no quieres ninguna duplicación:

 >>> a = [1, 2, 3, 4, 5, 6] >>> b = [5, 6, 7, 8] >>> c = list(set(a + b)) >>> c [1, 2, 3, 4, 5, 6, 7, 8] 

Si necesita combinar dos listas ordenadas con reglas de clasificación complicadas, es posible que deba rodarlas usted mismo como en el siguiente código (utilizando una regla de clasificación simple para facilitar la lectura :-)).

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

Como ya lo señalaron muchos, itertools.chain() es el camino a seguir si se necesita aplicar exactamente el mismo tratamiento a ambas listas. En mi caso, tenía una etiqueta y una bandera que eran diferentes de una lista a la otra, por lo que necesitaba algo un poco más complejo. Resulta que, detrás de las escenas, itertools.chain() simplemente hace lo siguiente:

 for it in iterables: for element in it: yield element 

(vea https://docs.python.org/2/library/itertools.html ), así que me inspiré aquí y escribí algo en este sentido:

 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 [...] 

Los puntos principales a entender aquí son que las listas son solo un caso especial de iterable, que son objetos como cualquier otro; y eso for ... in loops en python puede trabajar con variables de tupla, por lo que es simple hacer un loop en múltiples variables al mismo tiempo.

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

El código anterior, no conserva el orden, elimina el duplicado de cada lista (pero no de la lista concatenada)

Podría usar el método append() definido en los objetos de la list :

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

En Python puedes concatenar dos matrices de dimensiones compatibles con este comando

 numpy.concatenate([a,b]) 

Para ampliar una lista con otra hay varios métodos como a continuación:

 >>> listone = [1,2,3] >>> listome = [4,5,6] >>> >>> listone+listome # adding 2 list is actually extending the list [1, 2, 3, 4, 5, 6] >>> >>> listone.extend(listome) >>> listone [1, 2, 3, 4, 5, 6] >>> >>> listone = [1,2,3] >>> >>> listone.__add__(listome) [1, 2, 3, 4, 5, 6] 

Además, for loop también se puede utilizar:

 >>> for i in listome: ... listone.append(i) ... >>> listone [1, 2, 3, 4, 5, 6] >>> 

Una forma realmente concisa de combinar una lista de listas es

 list_of_lists = [[1,2,3], [4,5,6], [7,8,9]] reduce(list.__add__, list_of_lists) 

lo que nos da

 [1, 2, 3, 4, 5, 6, 7, 8, 9] 
 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] 
 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)) 

Salida:

 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] 

Use una lista de comprensión simple:

 joined_list = [y for x in [list_one, list_two] for y in x] 

Tiene todas las ventajas del nuevo enfoque de usar Generalizaciones de desempaquetado adicionales , es decir, puede concatenar un número arbitrario de diferentes iterables (por ejemplo, listas, tuplas, rangos y generadores) de esa manera, y no se limita a Python 3.5 o posterior. .

Puede utilizar la función de extends

 listone.extends(listtwo) 

Si desea una nueva lista manteniendo las dos listas antiguas:

 def concatenate_list(listOne, listTwo): joinedList = [] for i in listOne: joinedList.append(i) for j in listTwo: joinedList.append(j) sorted(joinedList) return joinedList 
 a = [1,2,3,4,5,6] b = [7,8,9,10] c = a.extend(b) 

imprimir (c) da

 [1,2,3,4,5,6,7,8,9,10] 

Así que hay dos formas fáciles.

  1. Usando + : Crea una nueva lista a partir de listas proporcionadas

Ejemplo:

 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 
  1. Usando extend : Agrega una nueva lista a la lista existente. Eso significa que no crea una lista separada.

Ejemplo:

 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 

Así vemos que de los dos métodos más populares, extend es eficiente.

Puede usar el operador ‘+’ para concatenar dos listas en Python:

 >>> listone = [1,2,3] >>> listtwo = [4,5,6] >>> >>> listSum = [] >>> listSum = listone + listtwo >>> print(listSum) [1, 2, 3, 4, 5, 6]