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

Puedes usar el +operador para combinarlos:

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

joinedlist = listone + listtwo

Producción:

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

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

Se ha introducido otra alternativa PEP 448cuya aceptación merece mención.

El PEP, titulado Additional Unpacking Generalizations , 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]
>>> 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 adaptado a versiones anteriores de la 3.xfamilia. En versiones no compatibles, SyntaxErrorse generará una.

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 el PEP:

This is also useful as a more readable way of summing iterables into a list, such as my_list + list(my_tuple) + list(my_range) which is now equivalent to just [*my_list, *my_tuple, *my_range].

Entonces, mientras que la suma con +generaría una TypeErrorfalta de coincidencia de tipos:

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

Lo siguiente no:

res = [*l, *r]

porque primero desempaquetará el contenido de los iterables y luego simplemente creará un lista partir del contenido.

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

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

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)

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

mergedlist = list(set(listone + listtwo))

How do I concatenate two lists in Python?

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

ingrese la descripción de la imagen aquí

Footnotes

  1. This is a slick solution because of its succinctness. But sum performs concatenation in a pairwise fashion, which means this is a quadratic operation as memory has to be allocated for each step. DO NOT USE if your lists are large.

  2. See chain and chain.from_iterable from the docs. You will need to import itertools first. Concatenation is linear in memory, so this is the best in terms of performance and version compatibility. chain.from_iterable was introduced in 2.6.

  3. This method uses Additional Unpacking Generalizations (PEP 448), but cannot generalize to N lists unless you manually unpack each one yourself.

  4. a += b and a.extend(b) are more or less equivalent for all practical purposes. += when called on a list will internally call list.__iadd__, which extends the first list by the second.


Actuación

Concatenación de 2 listas 1

ingrese la descripción de la imagen aquí

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

Concatenación de lista N

ingrese la descripción de la imagen aquí

Los gráficos 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 de copia previa para la lista de la izquierda que se puede ignorar.


Comentarios sobre otras soluciones

  • NO USE 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 operatorfunciones como fueron diseñados. Python tiene una semántica cuidadosa integrada en estos que son más complicados que simplemente llamar al dunder directamente. Aquí hay un ejemplo . Entonces, para resumir, a.__add__(b)=> MAL; a + b=> BUENO.

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

  • Cualquier método que use seteliminará los duplicados y perderá el orden. Utilizar 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 llamada de función única y más idiomática. appendes más lento debido a la semántica con la que se asigna y aumenta 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.

  • yielding elementos de la lista de una función es un método aceptable, pero chainlo hace 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 de a + b. Sus casos de uso son principalmente para el envío de métodos dinámicos. De lo contrario, prefiera a + bel que 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 acerca de 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 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 puede 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 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, sino 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 podría 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 en la lista fusionada 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 iterable (tupla, lista, generador, etc.), se from_iterablepuede 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+ puede 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]

Para casos con una cantidad baja de listas, simplemente puede agregar las listas o usar el desempaquetado en el lugar (disponible en Python-3.5+):

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

In [2]: listone + listtwo                                                                                                                                                                                   
Out[2]: [1, 2, 3, 4, 5, 6]
                                                                                                                                                                                     
In [3]: [*listone, *listtwo]                                                                                                                                                                                
Out[3]: [1, 2, 3, 4, 5, 6]

Como una forma más general para casos con más listas, puede usar chain.from_iterable()1 función del itertoolsmódulo. Además, según esta respuesta , esta función es la mejor; o al menos una muy buena manera de aplanar una lista anidada también.

>>> 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, usa `chain(*l)`.

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 podría 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]

Si necesita fusionar dos listas ordenadas con reglas de clasificación complicadas, es posible que deba hacerlo 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])

Si está utilizando NumPy, puede concatenar dos matrices de dimensiones compatibles con este comando:

numpy.concatenate([a,b])

Use una lista simple 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 adicionales de desempaquetado , es decir, puede concatenar un número arbitrario de iterables diferentes (por ejemplo, listas, tuplas, rangos y generadores) de esa manera, y no está limitado a Python 3.5 o posterior. .

Podrías 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 el duplicado de cada lista (pero no de la lista concatenada)

De otra manera:

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

Como ya han señalado 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 otra, por lo que necesitaba algo un poco más complejo. Resulta que detrás de escena itertools.chain()simplemente hace lo siguiente:

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

(consulte https://docs.python.org/2/library/itertools.html ), así que me inspiré aquí y escribí algo similar a esto:

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 iterables, que son objetos como cualquier otro; y que for ... inlos bucles en python pueden funcionar con variables de tupla, por lo que es sencillo hacer un bucle en varias variables al mismo tiempo.

Una forma muy 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)

que nos da

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

Recomiendo tres métodos para concatenar la lista, pero el primer método es el más recomendado,

# easiest and least complexity method <= recommended

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

newlist = listone + listtwo
print(newlist)

# 2nd easiest method
newlist = listone.copy()
newlist.extend(listtwo)
print(newlist)

En el segundo método, asigno newlista una copia de listoneporque no quiero cambiar listone.

# 3rd method
newlist = listone.copy()
for j in listtwo:
    newlist.append(j)

print(newlist)

Esta no es una buena manera de concatenar listas porque usamos for loop para concatenar las listas. Entonces la complejidad del tiempo es mucho mayor que con los otros dos métodos.

Así que hay dos maneras 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
  1. 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

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

También podría simplemente usar sum.

>>> a = [1, 2, 3]
>>> b = [4, 5, 6]
>>> sum([a, b], [])
[1, 2, 3, 4, 5, 6]
>>> 

Esto funciona para cualquier longitud y cualquier tipo de elemento de lista:

>>> a = ['a', 'b', 'c', 'd']
>>> b = [1, 2, 3, 4]
>>> c = [1, 2]
>>> sum([a, b, c], [])
['a', 'b', 'c', 'd', 1, 2, 3, 4, 1, 2]
>>> 

La razón por la que agrego [], es porque el startargumento está configurado 0de forma predeterminada, por lo que recorre la lista y se agrega a start, pero 0 + [1, 2, 3]daría un error, por lo que si configuramos starta [], se agregaría a [], [] + [1, 2, 3]funcionaría como se esperaba.

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

 c=a+b
 print(c)

PRODUCCIÓN:

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

In the above code "+" operator is used to concatenate the 2 lists into a single list.

OTRA SOLUCIÓN:

 a=[1,2,3]
 b=[4,5,6]
 c=[] #Empty list in which we are going to append the values of list (a) and (b)

 for i in a:
     c.append(i)
 for j in b:
     c.append(j)

 print(c)

PRODUCCIÓN:

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

Supongo que desea uno de los dos métodos:

Mantener elementos duplicados

Es muy fácil, simplemente concatene como una cadena:

def concat_list(l1,l2):
    l3 = l1+l2
    return l3

Siguiente si quieres eliminar elementos duplicados

def concat_list(l1,l2):
   l3 = []
   for i in [l1,l2]:
     for j in i:   
       if j not in l3:   
         #Check if element exists in final list, if no then add element to list
         l3.append(j)
   return l3

Las soluciones proporcionadas son para lista única. En caso de que haya listas dentro de una lista y se requiera la fusión de las listas correspondientes. La operación "+" a través del bucle for hace el trabajo.

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

b=[[0,1,2],[7,8,9]]

for i in range(len(a)):
    cc.append(a[i]+b[i])

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

El método más común utilizado para concatenar listas es el operador más y el método integrado append , por ejemplo:

list = [1,2]

list = list + [3]
# list = [1,2,3]

list.append(3) 
# list = [1,2,3]

list.append([3,4]) 
# list = [1,2,[3,4]]

Para la mayoría de los casos, esto funcionará, pero la función de agregar no extenderá una lista si se agregó una. Debido a que eso no se espera, puede usar otro método llamado extender que debería funcionar con estructuras:

list = [1,2]
list.extend([3,4]) 
# list = [1,2,3,4]

Esta es otra solución

list1 =[1,2,3,4]
list2 =['a','b']
for item in list2:
    list1.append(item)
list1