¿Cómo concateno dos listas en Python?

3043

¿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]
3
  • 11
    ¿Desea simplemente agregar o 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)? smci 12 de septiembre de 2015 a las 7:51
  • 1
    ... también, ¿qué pasa si las listas tienen duplicados, por ejemplo [1,2,5] and [2,4,5,6]? ¿Quiere que los duplicados se incluyan, excluyan o no les importe? smci 12/01/20 a las 20:15
  • 6
    Hice un tutorial de youtube sobre 6 formas de concatenar listas si alguien lo encuentra útil youtube.com/watch?v=O5kJ1v9XrDwBrendan Metcalfe 25/06/20 a las 18:48
4617

Puede utilizar el +operador para combinarlos:

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

joinedlist = listone + listtwo

Producción:

>>> joinedlist
[1,2,3,4,5,6]
10
  • 135
    ¿Esto crea una copia profunda de listone y agrega listtwo? Daniel F 19/04/12 a las 12:34
  • 183
    @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 19/04/12 a las 14:51
  • 264
    otro detalle útil aquí: listone += listtworesulta enlistone == [1, 2, 3, 4, 5, 6]rickcnagy 29 de enero de 2014 a las 16:14
  • 18
    @ br1ckb0t, ¿cambiará eso a qué listone apunta? Entonces: list3 = listone listone+=listtwo ¿List3 también ha cambiado? MikeH 19/0214 a las 5:01
  • 12
    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 20 feb 2014 a las 18:55
422

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

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

El PEP, titulado Generalizaciones adicionales de desempaquetado , generalmente redujo algunas restricciones sintácticas al usar 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 y no se ha actualizado a versiones anteriores de la 3.xfamilia. En las 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 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, si bien la suma con +generaría una TypeErrorfalta de coincidencia 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 a listpartir de los contenidos.

3
  • 9
    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, se podría revertir una de las listas que estés concatenación: res = [*l1, *reversed(l2)]. Dado que reverseddevuelve un iterador, res = l1 + reversed(l2)arrojaría un error. alan 9/04/19 a las 16:15
  • 4
    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 8 de mayo de 2019 a las 18:16
  • 1
    La gramática nazy en mí tiene que señalar: * diccionariosMarcello Romani 25 de febrero a las 10:39
367

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
  • 9
    chainestá 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 4 de junio de 2019 a las 14:10
  • @ cs95 lento en comparación con qué? Moberg 10 abr.20 a las 17:09
  • 1
    @Moberg En comparación con otras formas de concatenación de listas, como referencia, consulte mis puntos de referencia aquí . cs95 7 de mayo de 2020 a las 21 h.
246

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

mergedlist = list(set(listone + listtwo))
6
  • 59
    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 21/08/12 a las 0:28
  • 2
    ¿Cuál es la forma de hacerlo y conservar la información de pedido? Natim 29/01/2013 a las 13:12
  • 14
    Mejor quelistone + [x for x in listtwo if x not in listone] ... Natim 29/01/2013 a las 13:13
  • 9
    +1 En mi humilde opinión, esta es la forma correcta de "fusionar" (unión) listas, mientras que la respuesta "aprobada" describe cómo combinar / agregar listas (multiset)Nir Alfasi 27 abr '14 a las 4:07
  • 3
    Si le importa mantener el orden de entrada, entonces import collections; mergedlist = list(collections.OrderedDict.fromkeys(listone + listtwo))será suficiente. SethMMorton 15/12/2016 a las 20:11
244

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 en él:

mergedlist = []
mergedlist.extend(listone)
mergedlist.extend(listtwo)
4
  • 1
    ¿Por qué este método regresa Noneen mi caso? Ayush 15 de julio a las 9:10
  • listone = [1,2,3]; listtwo = [4,5,6]; listone.extend(listtwo)esto me devuelveNoneAyush 15 de julio a las 9:15
  • Hace una actualización in situ a listone. Así que compruebe que está en la listalistoneGourneau 16 de julio a las 17:33
  • de hecho, estoy devolviendo una expresión en la que estoy ampliando una lista utilizando el método que ha mencionado. No voy a reasignar la lista como se dijo en esta publicación. Mi expresión es algo así como return list1.extend(list2)y esta expresión vuelve Nonea mí. Ayush 17 de julio a las 17:45
196

How do I concatenate two lists in Python?

A partir de 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.


Rendimiento

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

Concatenación de N-List

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 extendoperan en el lugar, por lo que se debe generar una copia cada vez antes de realizar 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 más dunder y utilice los operadores y las operatorfunciones para los que fueron diseñados. Python tiene una semántica cuidadosa incorporada en estos que son más complicados que simplemente llamar al dunder directamente. He aquí 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 con más palabras.

  • Cualquier método que utilice seteliminará los duplicados y perderá el orden. Ú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ático. appendes más lento debido a la semántica con la que se asigna y se hace crecer la memoria para las listas. Vea 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 anti-patró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 de 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.

4
  • las respuestas a stackoverflow.com/q/36863404/125507 podrían usar una gráfica perfplot (incluida la solución numba)endolith 21/08/19 a las 1:31
  • @endolith está un poco abrumado por el trabajo, pero echaré un vistazo y veré si puedo contribuir. Ty. cs95 21/08/19 a las 17:52
  • ¿Cuál es el mejor método que el rendimiento y el más rápido? informe a. GD- Ganesh Deshmukh 19 de mayo de 2020 a las 5:06
  • 1
    @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 19 de mayo de 2020 y 20:21
88

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

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 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 un iterable, omita list().

Actualizar

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

sum(a, [])
1
  • 5
    Nota de Python 3: reduceahora está disponible, functoolspor lo que primero deberá importarlo. Dimitris Fasarakis Hilliard 24 jul 2017 a las 18:00
46

Simplemente puede usar el operador +or 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))
1
  • 2
    La última parte puede reordenar arbitrariamente los artículos. Si desea mantener el orden, en CPython 3.6+ puede hacerlist(dict.fromkeys(a + b))Boris 24 nov 2019 a las 2:29
32

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

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]
1
  • 1
    Puede usar itertools.chain(que es equivalente) en lugar de definir su propia función. Boris 22/11/19 a las 12:49
24

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))
0
19

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 función del itertooldmódulo. Además, según esta respuesta, 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)`.
17

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]
3
  • 4
    agarrar dunders generalmente no es el mejor enfoque. Si +está fuera de la mesa, use operator.add. Dimitris Fasarakis Hilliard 4 jul 2017 a las 12:00
  • 2
    ¿Por qué no estaría disponible el operador plus? cs01 25/06/18 a las 19:36
  • 2
    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 26 de junio de 2018 a las 4:30
12

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 mejorar la 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])
1
9

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

numpy.concatenate([a,b])
2
  • 9
    La pregunta no pide numpy. cs95 4 de junio de 2019 a las 2:37
  • @ cs95 tampoco 'no pide' numpy. Debo decir que esto realmente me ayudó, ya que el operador plus no funcionaba para mi aplicaciónAaron John Sabu 3 de feb a las 21:30
8

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 de desempaquetado adicionales , es decir, puede concatenar una cantidad arbitraria de iterables diferentes (por ejemplo, listas, tuplas, rangos y generadores) de esa manera, y no se limita a Python 3.5 o posterior. .

7

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

mergedlist =[]
for elem in listone:
    mergedlist.append(elem)
for elem in listtwo:
    mergedlist.append(elem)
1
7
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)

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

(ver 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 iterables, que son objetos como cualquier otro; y que los for ... inbucles en Python pueden funcionar con variables de tupla, por lo que es sencillo realizar un bucle en varias variables al mismo tiempo.

4

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)

que nos da

[1, 2, 3, 4, 5, 6, 7, 8, 9]
3
  • 1
    Por favor, no lo use list.__add__, use operator.adden su lugar. Este es el equivalente más prolijo de lo sum(list_of_lists, [])que es igual de malo. ¡NO UTILICE! cs95 4 de junio de 2019 a las 2:38
  • @ cs95 ¿puede explicar cuál es el problema usando list .__ add__Akash Singh 6/06/19 a las 22:31
  • 1
    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 6/06/19 a las 22:33
4

De otra manera:

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

Así que hay dos formas sencillas.

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

2
  • 2
    ¿Qué sucede si necesito agregar varias listas, como a + b + c + d + e? Tweakimp 11/03/19 a las 21:49
  • 2
    @Tweakimp Vea esta respuesta que tiene un par de opciones (recomiendo chain.from_iterable). cs95 4 de junio de 2019 a las 3:53
1
 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]
0

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
0

solo agrega estas dos listas //

finallist = list1 + list2

1
  • Si bien esto puede responder a su pregunta, sería mejor explicarlo un poco más, por ejemplo, agregarle algo de código. Dominik 17 de mayo a las 21:19
-1
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))

Producción:

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

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.

2
  • 1
    unionno funciona con listas, puede usarlo con conjuntos o dictmaczos 22 de enero a las 13:05
  • 1
    oh sí lo siento, no lo he usado en mucho tiempo mi malmr potato head 23 de enero a las 0:58