¿Cómo concateno dos listas en Python?

Ejemplo:

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

Gastos esperados:

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

Puede usar el +operador para combinarlos:

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

joinedlist = listone + listtwo

Salida:

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

También es posible crear un generador que simplemente itera sobre los elementos en ambas listas usando itertools.chain(). 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

>= 3.5Alternativa a Python :[*l1, *l2]

Se ha introducido otra alternativa a través de la aceptación de la PEP 448cual merece mencionarse.

El PEP, titulado Generalizaciones adicionales de desempaque , generalmente redujo algunas restricciones sintácticas cuando se usa la *expresión con estrella 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]
>>> joined_list = [*l1, *l2]  # unpack both iterables in a list literal
>>> print(joined_list)
[1, 2, 3, 4, 5, 6]

Esta funcionalidad se definió para Python3.5 , no se ha respaldado a versiones anteriores de la 3.xfamilia. En versiones no compatibles, se generará 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 necesita listas para realizarlo, cualquier cosa que sea iterable servirá. Como se indica en la PEP:

Esto también es útil como una forma más legible de sumar iterables en una lista, como lo 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 +aumentaría una TypeErrorfalta de coincidencia debido al tipo:

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

Lo siguiente no lo hará:

res = [*l, *r]

porque primero descomprimirá el contenido de los iterables y luego simplemente creará a listpartir de los contenidos.

Puede usar conjuntos para obtener una lista fusionada de valores únicos

mergedlist = list(set(listone + listtwo))

También puede usar el list.extend()método para agregar un listal final de otro:

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

listone.extend(listtwo)

Si desea mantener intacta la lista original, puede crear un nuevo listobjeto y extendambas listas:

mergedlist = []
mergedlist.extend(listone)
mergedlist.extend(listtwo)

¿Cómo concateno dos listas en Python?

A partir de 3.7, estos son los métodos stdlib más populares para concatenar dos (o más) listas en python.

Notas al pie

1. Esta es una solución resbaladiza debido a su brevedad. Pero sumrealiza la concatenación en forma de pares, lo que significa que esta es una operación cuadrática ya que la memoria debe asignarse para cada paso. NO USE si sus listas son grandes.

2. Ver chain y chain.from_iterable de los documentos. Necesitarás import itertoolsprimero. La concatenación es lineal en la memoria, por lo que es la mejor en términos de rendimiento y compatibilidad de versiones. chain.from_iterablefue introducido en 2.6.

3. Este método utiliza Generalizaciones de desempaquetado adicionales (PEP 448) , pero no puede generalizar a N listas a menos que desembale manualmente cada una.

4. a += by a.extend(b)son más o menos equivalentes para todos los fines prácticos. +=cuando se llama en una lista, llamará internamente list.__iadd__, lo que extiende la primera lista por la segunda.

Actuación

Concatenación de ² listas ¹

No hay mucha diferencia entre estos métodos, pero eso tiene sentido dado que todos tienen el mismo orden de complejidad (lineal). No hay una razón particular para preferir uno sobre el otro, excepto por cuestiones de estilo.

Concatenación de la lista N

Las parcelas se han generado utilizando el módulo perfplot . Código, para su referencia.

_{1. Los métodos iadd( +=) y extendfuncionan en el lugar, por lo que se debe generar una copia cada vez antes de la prueba. Para mantener las cosas justas, todos los métodos tienen un paso previo a la copia para la lista de la izquierda que puede ignorarse.}

Comentarios sobre otras soluciones

• NO UTILICE EL MÉTODO DUNDER list.__add__directamente de ninguna manera o forma. De hecho, manténgase alejado de los métodos dunder y use los operadores y las operatorfunciones para los que fueron diseñados. Python tiene una semántica cuidadosa que es más complicada que simplemente llamar directamente al dunder. Aquí hay un ejemplo . Entonces, para resumir, a.__add__(b)=> MALO; a + b=> BUENO.

• Algunas respuestas aquí ofrecen reduce(operator.add, [a, b])una concatenación por pares: esto es lo mismo que sum([a, b], [])solo más palabras.

• Cualquier método que use seteliminará duplicados y perderá el pedido. Usar con precaución.

• for i in b: a.append(i)es más prolijo y más lento que a.extend(b), que es una función de llamada única y más idiomático. appendes más lento debido a la semántica con la que se asigna y crece la memoria para las listas. Ver aquí para una discusión similar.

• heapq.mergefuncionará, pero su caso de uso es para fusionar listas ordenadas en tiempo lineal. Usarlo en cualquier otra situación es un antipatrón.

• yieldLa lista de elementos de una función es un método aceptable, pero lo chainhace más rápido y mejor (tiene una ruta de código en C, por lo que es rápido).

• operator.add(a, b)es un equivalente funcional aceptable para a + b. Sus casos de uso son principalmente para el envío de métodos dinámicos. De lo contrario, prefiero a + bque sea más corto y más legible, en mi opinión . YMMV.

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 sobre unir 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 listas cero).

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

Vieja respuesta

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 aes []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 un list, pero solo un iterable, omita list().

Actualizar

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

sum(a, [])

Simplemente puede usar el operador +o de la +=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 combinada sean únicos, puede hacer lo siguiente:

c = list(set(a + b))

Vale la pena señalar que la itertools.chainfunción 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 la entrada es un iterable (tupla, lista, generador, etc.), from_iterablese puede usar el método de clase:

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

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 fusionar las dos listas en forma ordenada, puede usar la mergefunción de la heapqbiblioteca.

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 operatorimportación:

import operator

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

result = operator.add(listone, listtwo)
print(result)

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

Alternativamente, también puede usar la función __add__ dunder :

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

result = list.__add__(listone, listtwo)
print(result)

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

Como una forma más general de obtener más listas, puede colocarlas dentro de una lista y usar la función itertools.chain.from_iterable()¹ , que según esta respuesta es la mejor manera de aplanar 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, use chain(*l).}

Si necesita fusionar dos listas ordenadas con reglas de clasificación complicadas, es posible que tenga que pasarlo usted mismo como en el siguiente código (usando 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])

Puede usar el append()método definido en los listobjetos:

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

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

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

Como ya señalaron muchos, itertools.chain()es el camino a seguir si uno 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 otra, por lo que necesitaba algo un poco más complejo. Como resultado, detrás de escena 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 que los for ... inbucles en python pueden funcionar con variables de tupla, por lo que es simple recorrer múltiples variables al mismo tiempo.

Use una simple lista de comprensión:

joined_list = [item for list_ in [list_one, list_two] for item in list_]

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

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]

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

numpy.concatenate([a,b])

Entonces hay dos formas fáciles.

1. Uso+ : crea una nueva lista a partir de las 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

2. Usando extender : 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

Por lo tanto, vemos que de dos de los métodos más populares, extendes eficiente.

Hay varias formas de concatenar listas en Python.

l1 = [1,2,3,4]
l2 = [3,4,5,6]

 1. new_list = l1.copy()
    new_list = new_list.extend(l2)
 2. new_list = l1 + l2
 3. new_list = [*l1, *l2]

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]

Si desea una nueva lista mientras mantiene las dos listas anteriores:

def concatenate_list(listOne, listTwo):
    joinedList = []
    for i in listOne:
        joinedList.append(i)
    for j in listTwo:
        joinedList.append(j)

    sorted(joinedList)

    return joinedList

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]

Puedes seguir el código

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

for i in listone:
    listtwo.append(i)
print(listtwo)

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