¿Cómo concateno dos listas en Python?

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

preguntado el 12 de noviembre de 09 a las 07:11

Quieres simplemente anexaro quieres fusionar las dos listas en orden ordenado? ¿Qué resultado espera para [1,3,6] y [2,4,5]? ¿Podemos asumir que ambas sublistas ya están ordenadas (como en su ejemplo)? -

... también, ¿qué pasa si las listas tienen duplicados, p. ej. [1,2,5] and [2,4,5,6]? ¿Quiere que los duplicados se incluyan, excluyan o no les importe? -

Hice un tutorial de youtube sobre 6 formas de concatenar listas si alguien lo encuentra útil youtube.com/watch?v=O5kJ1v9XrDw -

26 Respuestas

Puede utilizar el + operador para combinarlos:

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

joinedlist = listone + listtwo

Salida:

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

Respondido el 07 de junio de 19 a las 09:06

¿Esto crea una copia profunda de listone y agrega listtwo? - Daniel F

@Daniel creará una nueva lista con una copia superficial de los elementos de la primera lista, seguida de una copia superficial de los elementos de la segunda lista. Utilice copy.deepcopy para obtener copias en profundidad de las listas. - Daniel G

otro detalle útil aquí: listone += listtwo resultados en listone == [1, 2, 3, 4, 5, 6] - Rickcnagy

@ br1ckb0t, ¿cambiará eso a qué listone apunta? Entonces:list3 = listone listone+=listtwo ¿List3 también ha cambiado? - MikeH

sí cambia list3. Sin embargo, si eso no es un problema, es más sencillo y más legible agregar las dos listas en lugar de crear una nueva. - Rickcnagy

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

Se ha introducido otra alternativa mediante la aceptación de PEP 448 que merece ser mencionado.

El PEP, titulado Generalizaciones adicionales de desembalaje, generalmente redujo algunas restricciones sintácticas al usar las estrellas * expresión 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 fue definido para Python 3.5 no se ha actualizado a versiones anteriores en el 3.x familia. En versiones no compatibles un SyntaxError se va a levantar.

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


La al revés a este enfoque es que realmente no necesita listas para realizarlo, cualquier cosa que sea iterable servirá. Como se indica en el PEP:

Esto también es útil como una forma más legible de sumar 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 suma con + levantaría un TypeError debido a la falta de coincidencia de tipos:

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á un list del contenido.

respondido 22 nov., 19:15

Un buen ejemplo del enfoque de desempaquetado que funciona con tipos iterables son las funciones que devuelven un iterador sobre una de las listas que está concatenando. Por ejemplo, puede invertir una de las listas que está concatenando: res = [*l1, *reversed(l2)]. Desde reversed devuelve un iterador, res = l1 + reversed(l2) arrojaría un error. - alan

Vale la pena señalar que esto es análogo a combinar diccionarios en Python. dict3 = {** dict1, ** dict2}. Observe que usamos ** para descomprimir el diccionario, mientras que con las listas usamos * para descomprimir. - Kevin S

La gramática nazy en mí tiene que señalar: * diccionarios - Marcello Romani

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

respondido 22 nov., 19:15

chain está en el lado más lento (pero no mucho) para dos listas, pero es la solución más rápida para encadenar múltiples listas (n >> 2). - cs95

@ cs95 lento en comparación con qué? - Moberg

@Moberg En comparación con otras formas de concatenación de listas, como referencia, consulte mis puntos de referencia acá. - cs95

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

mergedlist = list(set(listone + listtwo))

Respondido 02 Abr '14, 11:04

Sin embargo, es cierto que también eliminará los duplicados, si eso es lo que le interesa. La adición de listas no haría eso. - metasoarous

¿Cuál es la forma de hacerlo y conservar la información de pedido? - Natim

Mejor que listone + [x for x in listtwo if x not in listone] - Natim

+1 en mi humilde opinión, esta es la forma correcta de "fusionar" (unir) listas, mientras que la respuesta "aprobada" describe cómo combinar / agregar listas (multiset) - Nir Alfasi

Si le interesa mantener el orden de entrada, entonces import collections; mergedlist = list(collections.OrderedDict.fromkeys(listone + listtwo)) hará el truco. - SethMMorton

También podrías usar el list.extend() método para agregar un list hasta el final de otro:

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

listone.extend(listtwo)

Si desea mantener intacta la lista original, puede crear una nueva list objeto, y extend ambas listas a él:

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

contestado el 30 de mayo de 20 a las 21:05

¿Cómo concateno dos listas en Python?

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

enter image description here

Notas a pie de página

  1. Esta es una solución ingeniosa debido a su brevedad. Pero sum realiza la concatenación por pares, lo que significa que se trata de una operación cuadrática ya que se debe asignar memoria para cada paso. NO USE si sus listas son grandes.

  2. Vea chain y chain.from_iterable de los docs. Necesitaras import itertools primero. 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_iterable fue introducido en 2.6.

  3. Este método usa Generalizaciones adicionales de desembalaje (PEP 448), pero no se puede generalizar a N listas a menos que desempaquete manualmente cada una usted mismo.

  4. a += b y a.extend(b) son más o menos equivalentes a todos los efectos prácticos. += cuando sea llamado en una lista, llamará internamente list.__iadd__, que amplía la primera lista por la segunda.


Rendimiento

Concatenación de 2 listas1

enter image description here

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 en particular para preferir uno sobre el otro, excepto por una cuestión de estilo.

Concatenación de N-List

enter image description here

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

1. los iadd (+=) y extend Los métodos operan 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 cualquier manera, forma o forma. De hecho, manténgase alejado de los métodos dunder y utilice los operadores y operator funciones para las que fueron diseñadas. Python tiene una semántica cuidadosa incorporada en estos que son más complicados que simplemente llamar al dunder directamente. Aquí está un ejemplo. Entonces, para resumir, a.__add__(b) => MALO; a + b => BUENO.

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

  • Cualquier método que utilice set dejará duplicados y perderá el pedido. Úselo 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. append es más lento debido a la semántica con la que se asigna y se hace crecer la memoria para las listas. Ver acá para una discusión similar.

  • heapq.merge funcionará, pero su caso de uso es para fusionar listas ordenadas en tiempo lineal. Usarlo en cualquier otra situación es un anti-patrón.

  • yieldLa lista de elementos de una función es un método aceptable, pero chain hace esto 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 a a + b. Sus casos de uso son principalmente para el envío de métodos dinámicos. De lo contrario, prefiera a + b que es más corto y más legible, en mi opinión. YMMV.

Respondido 25 Jul 20, 09:07

las respuestas a stackoverflow.com/q/36863404/125507 podría usar una gráfica perfplot (incluida la solución numba) - endolito

@endolith un poco abrumado por el trabajo, pero echaré un vistazo y veré si puedo contribuir. Ty. - cs95

¿Cuál es el mejor método y el más rápido en cuanto al rendimiento? informe a. - Ganeshdeshmukh

@ganeshdeshmukh El TL; DR es que todos son buenos y cuál eliges es principalmente una cuestión de estilo. "There's not much difference between these methods but that makes sense given they all have the same order of complexity (linear). There's no particular reason to prefer one over the other except as a matter of style."Soluciones que no figuran en mi respuesta, o criticadas en" Comentarios ", recomiendo no usar. - cs95

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]

respondido 17 mar '19, 12:03

Esta pregunta se refiere directamente a 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 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 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 a is [] or [[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 necesitas un list, pero solo iterable, omite list().

Noticias

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

sum(a, [])

Respondido el 04 de Septiembre de 18 a las 21:09

Nota de Python 3: reduce ahora está en functools por lo que primero deberá importarlo. - Dimitris Fasarakis Hilliard

Podrías simplemente usar el + or += operador 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))

Respondido el 22 de diciembre de 13 a las 13:12

La última parte puede reordenar arbitrariamente los artículos. Si desea mantener el orden, en CPython 3.6+ puede hacerlo list(dict.fromkeys(a + b)) - Boris

Vale la pena señalar que el itertools.chain La funció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 un iterable (tupla, lista, generador, etc.) es la entrada, el from_iterable se puede utilizar 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']

Respondido 05 Feb 13, 09:02

Con Python 3.3+ puedes usar 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]

Respondido 21 Jul 14, 04:07

Puedes usar itertools.chain (que es equivalente) en lugar de definir su propia función. - Boris

Si desea fusionar las dos listas en forma ordenada, puede utilizar el merge funcionar desde el heapq biblioteca.

from heapq import merge

a = [1, 2, 4]
b = [2, 4, 6, 7]

print list(merge(a, b))

respondido 17 mar '19, 12:03

Para los casos con un número bajo de listas, simplemente puede agregar las listas juntas 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 forma más general para casos con más listas, como enfoque pitónico, puede usar chain.from_iterable()1 funcionar desde itertoold módulo. Además, basado en este https://www.youtube.com/watch?v=xB-eutXNUMXJtA&feature=youtu.be esta función es la mejor; o al menos una forma muy gastronómica 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 posteriores. En otras versiones, use `chain (* l)`.

Respondido 16 Jul 20, 22:07

Si no puede usar el operador más (+), puede utilizar el operator importe:

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 utilizar el __add__ dunder función:

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

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

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

Respondido el 04 de junio de 19 a las 10:06

agarrar dunders generalmente no es el mejor enfoque. Si + está fuera de la mesa, usa operator.add. - Dimitris Fasarakis Hilliard

¿Por qué no estaría disponible el operador plus? - cs01

Normalmente no lo haría :) pero si está haciendo una concatenación de listas con la función de mapa o desea almacenar la función de agregar en una variable, no puede usar +. - jpihl

Si necesita fusionar dos listas ordenadas con reglas de ordenación complicadas, es posible que tenga que enrollarlas usted mismo como en el siguiente código (usando una regla de ordenación simple para legibilidad :-)).

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

Respondido el 22 de diciembre de 13 a las 13:12

O simplemente usa heapq.merge. - cs95

Podrías usar el append() método definido en list objetos:

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

contestado el 05 de mayo de 16 a las 12:05

para que lo sepas, si esto es lo que estás haciendo en la práctica, es mucho, mucho más lento que los otros métodos propuestos. ver stackoverflow.com/questions/17479361/… - Ryan Haining

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)

Respondido 07 Jul 16, 10:07

Como ya han señalado muchos, itertools.chain() es el camino a seguir si uno necesita postularse exactamente el mismo trato a ambas listas. En mi caso, tenía una etiqueta y una bandera que eran diferentes de una lista a otra, así 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

(consulte https://docs.python.org/2/library/itertools.html), así que me inspiré aquí y escribí algo como 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 eso for ... in Los bucles en Python pueden funcionar con variables de tupla, por lo que es sencillo realizar un bucle en varias variables al mismo tiempo.

respondido 02 nov., 15:21

Utilice 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 adicionales de desembalaje - 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.

Respondido 23 Abr '19, 23:04

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

numpy.concatenate([a,b])

Respondido 26 Jul 20, 20:07

La pregunta no pide numpy. - cs95

@ cs95 tampoco 'no pide' numpy. Debo decir que esto realmente me ayudó, ya que el operador plus no funcionaba para mi aplicación. Aaron John Sabu

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]

Respondido el 29 de junio de 18 a las 15:06

Por favor, no use list.__add__, Utilizar operator.add en lugar de. Este es el equivalente más prolijo de sum(list_of_lists, []) que es igual de malo. ¡NO UTILICE! - cs95

@ cs95 ¿puede explicar cuál es el problema usando list .__ add__ - Akash Singh

Los métodos dunder son "métodos privados" y normalmente no deben usarse directamente (son llamados por otras funciones). Las excepciones son obj.__class__ y obj.__dict__. - cs95

Así que hay dos formas sencillas.

  1. Usar +: 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 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, extend es eficiente.

respondido 17 mar '19, 12:03

¿Qué sucede si necesito agregar varias listas, como a + b + c + d + e? - Tweakimp

@Tweakimp Ver esta respuesta que tiene un par de opciones (recomiendo chain.from_iterable). - cs95

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

 c=a+b
 print(c)

SALIDA:

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

En el código anterior, el operador "+" se usa para concatenar las 2 listas en una sola lista.

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)

SALIDA:

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

Respondido 07 Jul 20, 18:07

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]

Respondido 16 Feb 18, 06:02

Supongo que desea uno de los dos métodos:

Mantener elementos duplicados

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

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

Siguiente si desea 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

respondido 14 nov., 20:05

Puede usar la función union () en Python.

joinedlist = union(listone, listtwo)
print(joinedlist)

Básicamente, lo que está haciendo es eliminar uno de cada duplicado en las dos listas. Dado que sus listas no tienen ningún duplicado, solo devuelve la versión concatenada de las dos listas.

Respondido el 17 de enero de 21 a las 03:01

union no funciona con listas, puede usarlo con conjuntos o dict - maczos

oh sí lo siento, no lo he usado en mucho tiempo mi mal - señor Cara de Papa

No es la respuesta que estás buscando? Examinar otras preguntas etiquetadas or haz tu propia pregunta.